26534 lines
1.1 MiB
26534 lines
1.1 MiB
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 __esm = (fn, res) => function __init() {
|
|
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
|
};
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
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
|
|
));
|
|
|
|
// node_modules/@actions/core/lib/utils.js
|
|
var require_utils = __commonJS({
|
|
"node_modules/@actions/core/lib/utils.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.toCommandProperties = exports2.toCommandValue = void 0;
|
|
function toCommandValue(input) {
|
|
if (input === null || input === void 0) {
|
|
return "";
|
|
} else if (typeof input === "string" || input instanceof String) {
|
|
return input;
|
|
}
|
|
return JSON.stringify(input);
|
|
}
|
|
exports2.toCommandValue = toCommandValue;
|
|
function toCommandProperties(annotationProperties) {
|
|
if (!Object.keys(annotationProperties).length) {
|
|
return {};
|
|
}
|
|
return {
|
|
title: annotationProperties.title,
|
|
file: annotationProperties.file,
|
|
line: annotationProperties.startLine,
|
|
endLine: annotationProperties.endLine,
|
|
col: annotationProperties.startColumn,
|
|
endColumn: annotationProperties.endColumn
|
|
};
|
|
}
|
|
exports2.toCommandProperties = toCommandProperties;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/command.js
|
|
var require_command = __commonJS({
|
|
"node_modules/@actions/core/lib/command.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
|
|
exports2.issue = exports2.issueCommand = void 0;
|
|
var os3 = __importStar(require("os"));
|
|
var utils_1 = require_utils();
|
|
function issueCommand(command, properties, message) {
|
|
const cmd = new Command(command, properties, message);
|
|
process.stdout.write(cmd.toString() + os3.EOL);
|
|
}
|
|
exports2.issueCommand = issueCommand;
|
|
function issue(name, message = "") {
|
|
issueCommand(name, {}, message);
|
|
}
|
|
exports2.issue = issue;
|
|
var CMD_STRING = "::";
|
|
var Command = class {
|
|
constructor(command, properties, message) {
|
|
if (!command) {
|
|
command = "missing.command";
|
|
}
|
|
this.command = command;
|
|
this.properties = properties;
|
|
this.message = message;
|
|
}
|
|
toString() {
|
|
let cmdStr = CMD_STRING + this.command;
|
|
if (this.properties && Object.keys(this.properties).length > 0) {
|
|
cmdStr += " ";
|
|
let first = true;
|
|
for (const key in this.properties) {
|
|
if (this.properties.hasOwnProperty(key)) {
|
|
const val = this.properties[key];
|
|
if (val) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
cmdStr += ",";
|
|
}
|
|
cmdStr += `${key}=${escapeProperty(val)}`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
|
return cmdStr;
|
|
}
|
|
};
|
|
function escapeData(s2) {
|
|
return (0, utils_1.toCommandValue)(s2).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
|
|
}
|
|
function escapeProperty(s2) {
|
|
return (0, utils_1.toCommandValue)(s2).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/file-command.js
|
|
var require_file_command = __commonJS({
|
|
"node_modules/@actions/core/lib/file-command.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
|
|
exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0;
|
|
var crypto = __importStar(require("crypto"));
|
|
var fs6 = __importStar(require("fs"));
|
|
var os3 = __importStar(require("os"));
|
|
var utils_1 = require_utils();
|
|
function issueFileCommand(command, message) {
|
|
const filePath = process.env[`GITHUB_${command}`];
|
|
if (!filePath) {
|
|
throw new Error(`Unable to find environment variable for file command ${command}`);
|
|
}
|
|
if (!fs6.existsSync(filePath)) {
|
|
throw new Error(`Missing file at path: ${filePath}`);
|
|
}
|
|
fs6.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os3.EOL}`, {
|
|
encoding: "utf8"
|
|
});
|
|
}
|
|
exports2.issueFileCommand = issueFileCommand;
|
|
function prepareKeyValueMessage(key, value) {
|
|
const delimiter = `ghadelimiter_${crypto.randomUUID()}`;
|
|
const convertedValue = (0, utils_1.toCommandValue)(value);
|
|
if (key.includes(delimiter)) {
|
|
throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
|
|
}
|
|
if (convertedValue.includes(delimiter)) {
|
|
throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
|
|
}
|
|
return `${key}<<${delimiter}${os3.EOL}${convertedValue}${os3.EOL}${delimiter}`;
|
|
}
|
|
exports2.prepareKeyValueMessage = prepareKeyValueMessage;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/proxy.js
|
|
var require_proxy = __commonJS({
|
|
"node_modules/@actions/http-client/lib/proxy.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.checkBypass = exports2.getProxyUrl = void 0;
|
|
function getProxyUrl(reqUrl) {
|
|
const usingSsl = reqUrl.protocol === "https:";
|
|
if (checkBypass(reqUrl)) {
|
|
return void 0;
|
|
}
|
|
const proxyVar = (() => {
|
|
if (usingSsl) {
|
|
return process.env["https_proxy"] || process.env["HTTPS_PROXY"];
|
|
} else {
|
|
return process.env["http_proxy"] || process.env["HTTP_PROXY"];
|
|
}
|
|
})();
|
|
if (proxyVar) {
|
|
try {
|
|
return new DecodedURL(proxyVar);
|
|
} catch (_a) {
|
|
if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://"))
|
|
return new DecodedURL(`http://${proxyVar}`);
|
|
}
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
exports2.getProxyUrl = getProxyUrl;
|
|
function checkBypass(reqUrl) {
|
|
if (!reqUrl.hostname) {
|
|
return false;
|
|
}
|
|
const reqHost = reqUrl.hostname;
|
|
if (isLoopbackAddress(reqHost)) {
|
|
return true;
|
|
}
|
|
const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || "";
|
|
if (!noProxy) {
|
|
return false;
|
|
}
|
|
let reqPort;
|
|
if (reqUrl.port) {
|
|
reqPort = Number(reqUrl.port);
|
|
} else if (reqUrl.protocol === "http:") {
|
|
reqPort = 80;
|
|
} else if (reqUrl.protocol === "https:") {
|
|
reqPort = 443;
|
|
}
|
|
const upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
|
if (typeof reqPort === "number") {
|
|
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
|
}
|
|
for (const upperNoProxyItem of noProxy.split(",").map((x2) => x2.trim().toUpperCase()).filter((x2) => x2)) {
|
|
if (upperNoProxyItem === "*" || upperReqHosts.some((x2) => x2 === upperNoProxyItem || x2.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x2.endsWith(`${upperNoProxyItem}`))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
exports2.checkBypass = checkBypass;
|
|
function isLoopbackAddress(host) {
|
|
const hostLower = host.toLowerCase();
|
|
return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]");
|
|
}
|
|
var DecodedURL = class extends URL {
|
|
constructor(url, base) {
|
|
super(url, base);
|
|
this._decodedUsername = decodeURIComponent(super.username);
|
|
this._decodedPassword = decodeURIComponent(super.password);
|
|
}
|
|
get username() {
|
|
return this._decodedUsername;
|
|
}
|
|
get password() {
|
|
return this._decodedPassword;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/tunnel/lib/tunnel.js
|
|
var require_tunnel = __commonJS({
|
|
"node_modules/tunnel/lib/tunnel.js"(exports2) {
|
|
"use strict";
|
|
var net = require("net");
|
|
var tls = require("tls");
|
|
var http3 = require("http");
|
|
var https2 = require("https");
|
|
var events = require("events");
|
|
var assert = require("assert");
|
|
var util = require("util");
|
|
exports2.httpOverHttp = httpOverHttp;
|
|
exports2.httpsOverHttp = httpsOverHttp;
|
|
exports2.httpOverHttps = httpOverHttps;
|
|
exports2.httpsOverHttps = httpsOverHttps;
|
|
function httpOverHttp(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http3.request;
|
|
return agent;
|
|
}
|
|
function httpsOverHttp(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http3.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
}
|
|
function httpOverHttps(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https2.request;
|
|
return agent;
|
|
}
|
|
function httpsOverHttps(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https2.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
}
|
|
function TunnelingAgent(options) {
|
|
var self2 = this;
|
|
self2.options = options || {};
|
|
self2.proxyOptions = self2.options.proxy || {};
|
|
self2.maxSockets = self2.options.maxSockets || http3.Agent.defaultMaxSockets;
|
|
self2.requests = [];
|
|
self2.sockets = [];
|
|
self2.on("free", function onFree(socket, host, port, localAddress) {
|
|
var options2 = toOptions(host, port, localAddress);
|
|
for (var i2 = 0, len = self2.requests.length; i2 < len; ++i2) {
|
|
var pending = self2.requests[i2];
|
|
if (pending.host === options2.host && pending.port === options2.port) {
|
|
self2.requests.splice(i2, 1);
|
|
pending.request.onSocket(socket);
|
|
return;
|
|
}
|
|
}
|
|
socket.destroy();
|
|
self2.removeSocket(socket);
|
|
});
|
|
}
|
|
util.inherits(TunnelingAgent, events.EventEmitter);
|
|
TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
|
|
var self2 = this;
|
|
var options = mergeOptions({ request: req }, self2.options, toOptions(host, port, localAddress));
|
|
if (self2.sockets.length >= this.maxSockets) {
|
|
self2.requests.push(options);
|
|
return;
|
|
}
|
|
self2.createSocket(options, function(socket) {
|
|
socket.on("free", onFree);
|
|
socket.on("close", onCloseOrRemove);
|
|
socket.on("agentRemove", onCloseOrRemove);
|
|
req.onSocket(socket);
|
|
function onFree() {
|
|
self2.emit("free", socket, options);
|
|
}
|
|
function onCloseOrRemove(err) {
|
|
self2.removeSocket(socket);
|
|
socket.removeListener("free", onFree);
|
|
socket.removeListener("close", onCloseOrRemove);
|
|
socket.removeListener("agentRemove", onCloseOrRemove);
|
|
}
|
|
});
|
|
};
|
|
TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
|
|
var self2 = this;
|
|
var placeholder = {};
|
|
self2.sockets.push(placeholder);
|
|
var connectOptions = mergeOptions({}, self2.proxyOptions, {
|
|
method: "CONNECT",
|
|
path: options.host + ":" + options.port,
|
|
agent: false,
|
|
headers: {
|
|
host: options.host + ":" + options.port
|
|
}
|
|
});
|
|
if (options.localAddress) {
|
|
connectOptions.localAddress = options.localAddress;
|
|
}
|
|
if (connectOptions.proxyAuth) {
|
|
connectOptions.headers = connectOptions.headers || {};
|
|
connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64");
|
|
}
|
|
debug("making CONNECT request");
|
|
var connectReq = self2.request(connectOptions);
|
|
connectReq.useChunkedEncodingByDefault = false;
|
|
connectReq.once("response", onResponse);
|
|
connectReq.once("upgrade", onUpgrade);
|
|
connectReq.once("connect", onConnect);
|
|
connectReq.once("error", onError);
|
|
connectReq.end();
|
|
function onResponse(res) {
|
|
res.upgrade = true;
|
|
}
|
|
function onUpgrade(res, socket, head) {
|
|
process.nextTick(function() {
|
|
onConnect(res, socket, head);
|
|
});
|
|
}
|
|
function onConnect(res, socket, head) {
|
|
connectReq.removeAllListeners();
|
|
socket.removeAllListeners();
|
|
if (res.statusCode !== 200) {
|
|
debug(
|
|
"tunneling socket could not be established, statusCode=%d",
|
|
res.statusCode
|
|
);
|
|
socket.destroy();
|
|
var error = new Error("tunneling socket could not be established, statusCode=" + res.statusCode);
|
|
error.code = "ECONNRESET";
|
|
options.request.emit("error", error);
|
|
self2.removeSocket(placeholder);
|
|
return;
|
|
}
|
|
if (head.length > 0) {
|
|
debug("got illegal response body from proxy");
|
|
socket.destroy();
|
|
var error = new Error("got illegal response body from proxy");
|
|
error.code = "ECONNRESET";
|
|
options.request.emit("error", error);
|
|
self2.removeSocket(placeholder);
|
|
return;
|
|
}
|
|
debug("tunneling connection has established");
|
|
self2.sockets[self2.sockets.indexOf(placeholder)] = socket;
|
|
return cb(socket);
|
|
}
|
|
function onError(cause) {
|
|
connectReq.removeAllListeners();
|
|
debug(
|
|
"tunneling socket could not be established, cause=%s\n",
|
|
cause.message,
|
|
cause.stack
|
|
);
|
|
var error = new Error("tunneling socket could not be established, cause=" + cause.message);
|
|
error.code = "ECONNRESET";
|
|
options.request.emit("error", error);
|
|
self2.removeSocket(placeholder);
|
|
}
|
|
};
|
|
TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
|
|
var pos = this.sockets.indexOf(socket);
|
|
if (pos === -1) {
|
|
return;
|
|
}
|
|
this.sockets.splice(pos, 1);
|
|
var pending = this.requests.shift();
|
|
if (pending) {
|
|
this.createSocket(pending, function(socket2) {
|
|
pending.request.onSocket(socket2);
|
|
});
|
|
}
|
|
};
|
|
function createSecureSocket(options, cb) {
|
|
var self2 = this;
|
|
TunnelingAgent.prototype.createSocket.call(self2, options, function(socket) {
|
|
var hostHeader = options.request.getHeader("host");
|
|
var tlsOptions = mergeOptions({}, self2.options, {
|
|
socket,
|
|
servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host
|
|
});
|
|
var secureSocket = tls.connect(0, tlsOptions);
|
|
self2.sockets[self2.sockets.indexOf(socket)] = secureSocket;
|
|
cb(secureSocket);
|
|
});
|
|
}
|
|
function toOptions(host, port, localAddress) {
|
|
if (typeof host === "string") {
|
|
return {
|
|
host,
|
|
port,
|
|
localAddress
|
|
};
|
|
}
|
|
return host;
|
|
}
|
|
function mergeOptions(target) {
|
|
for (var i2 = 1, len = arguments.length; i2 < len; ++i2) {
|
|
var overrides = arguments[i2];
|
|
if (typeof overrides === "object") {
|
|
var keys = Object.keys(overrides);
|
|
for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
|
|
var k = keys[j];
|
|
if (overrides[k] !== void 0) {
|
|
target[k] = overrides[k];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
var debug;
|
|
if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
|
|
debug = function() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
if (typeof args[0] === "string") {
|
|
args[0] = "TUNNEL: " + args[0];
|
|
} else {
|
|
args.unshift("TUNNEL:");
|
|
}
|
|
console.error.apply(console, args);
|
|
};
|
|
} else {
|
|
debug = function() {
|
|
};
|
|
}
|
|
exports2.debug = debug;
|
|
}
|
|
});
|
|
|
|
// node_modules/tunnel/index.js
|
|
var require_tunnel2 = __commonJS({
|
|
"node_modules/tunnel/index.js"(exports2, module2) {
|
|
module2.exports = require_tunnel();
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/symbols.js
|
|
var require_symbols = __commonJS({
|
|
"node_modules/undici/lib/core/symbols.js"(exports2, module2) {
|
|
module2.exports = {
|
|
kClose: Symbol("close"),
|
|
kDestroy: Symbol("destroy"),
|
|
kDispatch: Symbol("dispatch"),
|
|
kUrl: Symbol("url"),
|
|
kWriting: Symbol("writing"),
|
|
kResuming: Symbol("resuming"),
|
|
kQueue: Symbol("queue"),
|
|
kConnect: Symbol("connect"),
|
|
kConnecting: Symbol("connecting"),
|
|
kHeadersList: Symbol("headers list"),
|
|
kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
|
|
kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
|
|
kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
|
|
kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
|
|
kKeepAlive: Symbol("keep alive"),
|
|
kHeadersTimeout: Symbol("headers timeout"),
|
|
kBodyTimeout: Symbol("body timeout"),
|
|
kServerName: Symbol("server name"),
|
|
kLocalAddress: Symbol("local address"),
|
|
kHost: Symbol("host"),
|
|
kNoRef: Symbol("no ref"),
|
|
kBodyUsed: Symbol("used"),
|
|
kRunning: Symbol("running"),
|
|
kBlocking: Symbol("blocking"),
|
|
kPending: Symbol("pending"),
|
|
kSize: Symbol("size"),
|
|
kBusy: Symbol("busy"),
|
|
kQueued: Symbol("queued"),
|
|
kFree: Symbol("free"),
|
|
kConnected: Symbol("connected"),
|
|
kClosed: Symbol("closed"),
|
|
kNeedDrain: Symbol("need drain"),
|
|
kReset: Symbol("reset"),
|
|
kDestroyed: Symbol.for("nodejs.stream.destroyed"),
|
|
kMaxHeadersSize: Symbol("max headers size"),
|
|
kRunningIdx: Symbol("running index"),
|
|
kPendingIdx: Symbol("pending index"),
|
|
kError: Symbol("error"),
|
|
kClients: Symbol("clients"),
|
|
kClient: Symbol("client"),
|
|
kParser: Symbol("parser"),
|
|
kOnDestroyed: Symbol("destroy callbacks"),
|
|
kPipelining: Symbol("pipelining"),
|
|
kSocket: Symbol("socket"),
|
|
kHostHeader: Symbol("host header"),
|
|
kConnector: Symbol("connector"),
|
|
kStrictContentLength: Symbol("strict content length"),
|
|
kMaxRedirections: Symbol("maxRedirections"),
|
|
kMaxRequests: Symbol("maxRequestsPerClient"),
|
|
kProxy: Symbol("proxy agent options"),
|
|
kCounter: Symbol("socket request counter"),
|
|
kInterceptors: Symbol("dispatch interceptors"),
|
|
kMaxResponseSize: Symbol("max response size"),
|
|
kHTTP2Session: Symbol("http2Session"),
|
|
kHTTP2SessionState: Symbol("http2Session state"),
|
|
kHTTP2BuildRequest: Symbol("http2 build request"),
|
|
kHTTP1BuildRequest: Symbol("http1 build request"),
|
|
kHTTP2CopyHeaders: Symbol("http2 copy headers"),
|
|
kHTTPConnVersion: Symbol("http connection version"),
|
|
kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
|
|
kConstruct: Symbol("constructable")
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/errors.js
|
|
var require_errors = __commonJS({
|
|
"node_modules/undici/lib/core/errors.js"(exports2, module2) {
|
|
"use strict";
|
|
var UndiciError = class extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "UndiciError";
|
|
this.code = "UND_ERR";
|
|
}
|
|
};
|
|
var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ConnectTimeoutError);
|
|
this.name = "ConnectTimeoutError";
|
|
this.message = message || "Connect Timeout Error";
|
|
this.code = "UND_ERR_CONNECT_TIMEOUT";
|
|
}
|
|
};
|
|
var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _HeadersTimeoutError);
|
|
this.name = "HeadersTimeoutError";
|
|
this.message = message || "Headers Timeout Error";
|
|
this.code = "UND_ERR_HEADERS_TIMEOUT";
|
|
}
|
|
};
|
|
var HeadersOverflowError = class _HeadersOverflowError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _HeadersOverflowError);
|
|
this.name = "HeadersOverflowError";
|
|
this.message = message || "Headers Overflow Error";
|
|
this.code = "UND_ERR_HEADERS_OVERFLOW";
|
|
}
|
|
};
|
|
var BodyTimeoutError = class _BodyTimeoutError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _BodyTimeoutError);
|
|
this.name = "BodyTimeoutError";
|
|
this.message = message || "Body Timeout Error";
|
|
this.code = "UND_ERR_BODY_TIMEOUT";
|
|
}
|
|
};
|
|
var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError {
|
|
constructor(message, statusCode, headers, body) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ResponseStatusCodeError);
|
|
this.name = "ResponseStatusCodeError";
|
|
this.message = message || "Response Status Code Error";
|
|
this.code = "UND_ERR_RESPONSE_STATUS_CODE";
|
|
this.body = body;
|
|
this.status = statusCode;
|
|
this.statusCode = statusCode;
|
|
this.headers = headers;
|
|
}
|
|
};
|
|
var InvalidArgumentError = class _InvalidArgumentError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _InvalidArgumentError);
|
|
this.name = "InvalidArgumentError";
|
|
this.message = message || "Invalid Argument Error";
|
|
this.code = "UND_ERR_INVALID_ARG";
|
|
}
|
|
};
|
|
var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _InvalidReturnValueError);
|
|
this.name = "InvalidReturnValueError";
|
|
this.message = message || "Invalid Return Value Error";
|
|
this.code = "UND_ERR_INVALID_RETURN_VALUE";
|
|
}
|
|
};
|
|
var RequestAbortedError = class _RequestAbortedError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _RequestAbortedError);
|
|
this.name = "AbortError";
|
|
this.message = message || "Request aborted";
|
|
this.code = "UND_ERR_ABORTED";
|
|
}
|
|
};
|
|
var InformationalError = class _InformationalError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _InformationalError);
|
|
this.name = "InformationalError";
|
|
this.message = message || "Request information";
|
|
this.code = "UND_ERR_INFO";
|
|
}
|
|
};
|
|
var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _RequestContentLengthMismatchError);
|
|
this.name = "RequestContentLengthMismatchError";
|
|
this.message = message || "Request body length does not match content-length header";
|
|
this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
|
|
}
|
|
};
|
|
var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ResponseContentLengthMismatchError);
|
|
this.name = "ResponseContentLengthMismatchError";
|
|
this.message = message || "Response body length does not match content-length header";
|
|
this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
|
|
}
|
|
};
|
|
var ClientDestroyedError = class _ClientDestroyedError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ClientDestroyedError);
|
|
this.name = "ClientDestroyedError";
|
|
this.message = message || "The client is destroyed";
|
|
this.code = "UND_ERR_DESTROYED";
|
|
}
|
|
};
|
|
var ClientClosedError = class _ClientClosedError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ClientClosedError);
|
|
this.name = "ClientClosedError";
|
|
this.message = message || "The client is closed";
|
|
this.code = "UND_ERR_CLOSED";
|
|
}
|
|
};
|
|
var SocketError = class _SocketError extends UndiciError {
|
|
constructor(message, socket) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _SocketError);
|
|
this.name = "SocketError";
|
|
this.message = message || "Socket error";
|
|
this.code = "UND_ERR_SOCKET";
|
|
this.socket = socket;
|
|
}
|
|
};
|
|
var NotSupportedError = class _NotSupportedError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _NotSupportedError);
|
|
this.name = "NotSupportedError";
|
|
this.message = message || "Not supported error";
|
|
this.code = "UND_ERR_NOT_SUPPORTED";
|
|
}
|
|
};
|
|
var BalancedPoolMissingUpstreamError = class extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, NotSupportedError);
|
|
this.name = "MissingUpstreamError";
|
|
this.message = message || "No upstream has been added to the BalancedPool";
|
|
this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
|
|
}
|
|
};
|
|
var HTTPParserError = class _HTTPParserError extends Error {
|
|
constructor(message, code, data) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _HTTPParserError);
|
|
this.name = "HTTPParserError";
|
|
this.code = code ? `HPE_${code}` : void 0;
|
|
this.data = data ? data.toString() : void 0;
|
|
}
|
|
};
|
|
var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _ResponseExceededMaxSizeError);
|
|
this.name = "ResponseExceededMaxSizeError";
|
|
this.message = message || "Response content exceeded max size";
|
|
this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
|
|
}
|
|
};
|
|
var RequestRetryError = class _RequestRetryError extends UndiciError {
|
|
constructor(message, code, { headers, data }) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _RequestRetryError);
|
|
this.name = "RequestRetryError";
|
|
this.message = message || "Request retry error";
|
|
this.code = "UND_ERR_REQ_RETRY";
|
|
this.statusCode = code;
|
|
this.data = data;
|
|
this.headers = headers;
|
|
}
|
|
};
|
|
module2.exports = {
|
|
HTTPParserError,
|
|
UndiciError,
|
|
HeadersTimeoutError,
|
|
HeadersOverflowError,
|
|
BodyTimeoutError,
|
|
RequestContentLengthMismatchError,
|
|
ConnectTimeoutError,
|
|
ResponseStatusCodeError,
|
|
InvalidArgumentError,
|
|
InvalidReturnValueError,
|
|
RequestAbortedError,
|
|
ClientDestroyedError,
|
|
ClientClosedError,
|
|
InformationalError,
|
|
SocketError,
|
|
NotSupportedError,
|
|
ResponseContentLengthMismatchError,
|
|
BalancedPoolMissingUpstreamError,
|
|
ResponseExceededMaxSizeError,
|
|
RequestRetryError
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/constants.js
|
|
var require_constants = __commonJS({
|
|
"node_modules/undici/lib/core/constants.js"(exports2, module2) {
|
|
"use strict";
|
|
var headerNameLowerCasedRecord = {};
|
|
var wellknownHeaderNames = [
|
|
"Accept",
|
|
"Accept-Encoding",
|
|
"Accept-Language",
|
|
"Accept-Ranges",
|
|
"Access-Control-Allow-Credentials",
|
|
"Access-Control-Allow-Headers",
|
|
"Access-Control-Allow-Methods",
|
|
"Access-Control-Allow-Origin",
|
|
"Access-Control-Expose-Headers",
|
|
"Access-Control-Max-Age",
|
|
"Access-Control-Request-Headers",
|
|
"Access-Control-Request-Method",
|
|
"Age",
|
|
"Allow",
|
|
"Alt-Svc",
|
|
"Alt-Used",
|
|
"Authorization",
|
|
"Cache-Control",
|
|
"Clear-Site-Data",
|
|
"Connection",
|
|
"Content-Disposition",
|
|
"Content-Encoding",
|
|
"Content-Language",
|
|
"Content-Length",
|
|
"Content-Location",
|
|
"Content-Range",
|
|
"Content-Security-Policy",
|
|
"Content-Security-Policy-Report-Only",
|
|
"Content-Type",
|
|
"Cookie",
|
|
"Cross-Origin-Embedder-Policy",
|
|
"Cross-Origin-Opener-Policy",
|
|
"Cross-Origin-Resource-Policy",
|
|
"Date",
|
|
"Device-Memory",
|
|
"Downlink",
|
|
"ECT",
|
|
"ETag",
|
|
"Expect",
|
|
"Expect-CT",
|
|
"Expires",
|
|
"Forwarded",
|
|
"From",
|
|
"Host",
|
|
"If-Match",
|
|
"If-Modified-Since",
|
|
"If-None-Match",
|
|
"If-Range",
|
|
"If-Unmodified-Since",
|
|
"Keep-Alive",
|
|
"Last-Modified",
|
|
"Link",
|
|
"Location",
|
|
"Max-Forwards",
|
|
"Origin",
|
|
"Permissions-Policy",
|
|
"Pragma",
|
|
"Proxy-Authenticate",
|
|
"Proxy-Authorization",
|
|
"RTT",
|
|
"Range",
|
|
"Referer",
|
|
"Referrer-Policy",
|
|
"Refresh",
|
|
"Retry-After",
|
|
"Sec-WebSocket-Accept",
|
|
"Sec-WebSocket-Extensions",
|
|
"Sec-WebSocket-Key",
|
|
"Sec-WebSocket-Protocol",
|
|
"Sec-WebSocket-Version",
|
|
"Server",
|
|
"Server-Timing",
|
|
"Service-Worker-Allowed",
|
|
"Service-Worker-Navigation-Preload",
|
|
"Set-Cookie",
|
|
"SourceMap",
|
|
"Strict-Transport-Security",
|
|
"Supports-Loading-Mode",
|
|
"TE",
|
|
"Timing-Allow-Origin",
|
|
"Trailer",
|
|
"Transfer-Encoding",
|
|
"Upgrade",
|
|
"Upgrade-Insecure-Requests",
|
|
"User-Agent",
|
|
"Vary",
|
|
"Via",
|
|
"WWW-Authenticate",
|
|
"X-Content-Type-Options",
|
|
"X-DNS-Prefetch-Control",
|
|
"X-Frame-Options",
|
|
"X-Permitted-Cross-Domain-Policies",
|
|
"X-Powered-By",
|
|
"X-Requested-With",
|
|
"X-XSS-Protection"
|
|
];
|
|
for (let i2 = 0; i2 < wellknownHeaderNames.length; ++i2) {
|
|
const key = wellknownHeaderNames[i2];
|
|
const lowerCasedKey = key.toLowerCase();
|
|
headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
|
|
}
|
|
Object.setPrototypeOf(headerNameLowerCasedRecord, null);
|
|
module2.exports = {
|
|
wellknownHeaderNames,
|
|
headerNameLowerCasedRecord
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/util.js
|
|
var require_util = __commonJS({
|
|
"node_modules/undici/lib/core/util.js"(exports2, module2) {
|
|
"use strict";
|
|
var assert = require("assert");
|
|
var { kDestroyed, kBodyUsed } = require_symbols();
|
|
var { IncomingMessage } = require("http");
|
|
var stream = require("stream");
|
|
var net = require("net");
|
|
var { InvalidArgumentError } = require_errors();
|
|
var { Blob: Blob4 } = require("buffer");
|
|
var nodeUtil = require("util");
|
|
var { stringify } = require("querystring");
|
|
var { headerNameLowerCasedRecord } = require_constants();
|
|
var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
|
|
function nop() {
|
|
}
|
|
function isStream(obj) {
|
|
return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
|
|
}
|
|
function isBlobLike(object) {
|
|
return Blob4 && object instanceof Blob4 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
|
|
}
|
|
function buildURL(url, queryParams) {
|
|
if (url.includes("?") || url.includes("#")) {
|
|
throw new Error('Query params cannot be passed when url already contains "?" or "#".');
|
|
}
|
|
const stringified = stringify(queryParams);
|
|
if (stringified) {
|
|
url += "?" + stringified;
|
|
}
|
|
return url;
|
|
}
|
|
function parseURL(url) {
|
|
if (typeof url === "string") {
|
|
url = new URL(url);
|
|
if (!/^https?:/.test(url.origin || url.protocol)) {
|
|
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
|
|
}
|
|
return url;
|
|
}
|
|
if (!url || typeof url !== "object") {
|
|
throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
|
|
}
|
|
if (!/^https?:/.test(url.origin || url.protocol)) {
|
|
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
|
|
}
|
|
if (!(url instanceof URL)) {
|
|
if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) {
|
|
throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
|
|
}
|
|
if (url.path != null && typeof url.path !== "string") {
|
|
throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
|
|
}
|
|
if (url.pathname != null && typeof url.pathname !== "string") {
|
|
throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
|
|
}
|
|
if (url.hostname != null && typeof url.hostname !== "string") {
|
|
throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
|
|
}
|
|
if (url.origin != null && typeof url.origin !== "string") {
|
|
throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
|
|
}
|
|
const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
|
|
let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
|
|
let path3 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
|
|
if (origin.endsWith("/")) {
|
|
origin = origin.substring(0, origin.length - 1);
|
|
}
|
|
if (path3 && !path3.startsWith("/")) {
|
|
path3 = `/${path3}`;
|
|
}
|
|
url = new URL(origin + path3);
|
|
}
|
|
return url;
|
|
}
|
|
function parseOrigin(url) {
|
|
url = parseURL(url);
|
|
if (url.pathname !== "/" || url.search || url.hash) {
|
|
throw new InvalidArgumentError("invalid url");
|
|
}
|
|
return url;
|
|
}
|
|
function getHostname(host) {
|
|
if (host[0] === "[") {
|
|
const idx2 = host.indexOf("]");
|
|
assert(idx2 !== -1);
|
|
return host.substring(1, idx2);
|
|
}
|
|
const idx = host.indexOf(":");
|
|
if (idx === -1) return host;
|
|
return host.substring(0, idx);
|
|
}
|
|
function getServerName(host) {
|
|
if (!host) {
|
|
return null;
|
|
}
|
|
assert.strictEqual(typeof host, "string");
|
|
const servername = getHostname(host);
|
|
if (net.isIP(servername)) {
|
|
return "";
|
|
}
|
|
return servername;
|
|
}
|
|
function deepClone(obj) {
|
|
return JSON.parse(JSON.stringify(obj));
|
|
}
|
|
function isAsyncIterable(obj) {
|
|
return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
|
|
}
|
|
function isIterable(obj) {
|
|
return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
|
|
}
|
|
function bodyLength(body) {
|
|
if (body == null) {
|
|
return 0;
|
|
} else if (isStream(body)) {
|
|
const state = body._readableState;
|
|
return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
|
|
} else if (isBlobLike(body)) {
|
|
return body.size != null ? body.size : null;
|
|
} else if (isBuffer(body)) {
|
|
return body.byteLength;
|
|
}
|
|
return null;
|
|
}
|
|
function isDestroyed(stream2) {
|
|
return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]);
|
|
}
|
|
function isReadableAborted(stream2) {
|
|
const state = stream2 && stream2._readableState;
|
|
return isDestroyed(stream2) && state && !state.endEmitted;
|
|
}
|
|
function destroy(stream2, err) {
|
|
if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) {
|
|
return;
|
|
}
|
|
if (typeof stream2.destroy === "function") {
|
|
if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) {
|
|
stream2.socket = null;
|
|
}
|
|
stream2.destroy(err);
|
|
} else if (err) {
|
|
process.nextTick((stream3, err2) => {
|
|
stream3.emit("error", err2);
|
|
}, stream2, err);
|
|
}
|
|
if (stream2.destroyed !== true) {
|
|
stream2[kDestroyed] = true;
|
|
}
|
|
}
|
|
var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
|
|
function parseKeepAliveTimeout(val) {
|
|
const m2 = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
|
|
return m2 ? parseInt(m2[1], 10) * 1e3 : null;
|
|
}
|
|
function headerNameToString(value) {
|
|
return headerNameLowerCasedRecord[value] || value.toLowerCase();
|
|
}
|
|
function parseHeaders(headers, obj = {}) {
|
|
if (!Array.isArray(headers)) return headers;
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
const key = headers[i2].toString().toLowerCase();
|
|
let val = obj[key];
|
|
if (!val) {
|
|
if (Array.isArray(headers[i2 + 1])) {
|
|
obj[key] = headers[i2 + 1].map((x2) => x2.toString("utf8"));
|
|
} else {
|
|
obj[key] = headers[i2 + 1].toString("utf8");
|
|
}
|
|
} else {
|
|
if (!Array.isArray(val)) {
|
|
val = [val];
|
|
obj[key] = val;
|
|
}
|
|
val.push(headers[i2 + 1].toString("utf8"));
|
|
}
|
|
}
|
|
if ("content-length" in obj && "content-disposition" in obj) {
|
|
obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
|
|
}
|
|
return obj;
|
|
}
|
|
function parseRawHeaders(headers) {
|
|
const ret = [];
|
|
let hasContentLength = false;
|
|
let contentDispositionIdx = -1;
|
|
for (let n = 0; n < headers.length; n += 2) {
|
|
const key = headers[n + 0].toString();
|
|
const val = headers[n + 1].toString("utf8");
|
|
if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
|
|
ret.push(key, val);
|
|
hasContentLength = true;
|
|
} else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
|
|
contentDispositionIdx = ret.push(key, val) - 1;
|
|
} else {
|
|
ret.push(key, val);
|
|
}
|
|
}
|
|
if (hasContentLength && contentDispositionIdx !== -1) {
|
|
ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
|
|
}
|
|
return ret;
|
|
}
|
|
function isBuffer(buffer) {
|
|
return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
|
|
}
|
|
function validateHandler(handler, method, upgrade) {
|
|
if (!handler || typeof handler !== "object") {
|
|
throw new InvalidArgumentError("handler must be an object");
|
|
}
|
|
if (typeof handler.onConnect !== "function") {
|
|
throw new InvalidArgumentError("invalid onConnect method");
|
|
}
|
|
if (typeof handler.onError !== "function") {
|
|
throw new InvalidArgumentError("invalid onError method");
|
|
}
|
|
if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) {
|
|
throw new InvalidArgumentError("invalid onBodySent method");
|
|
}
|
|
if (upgrade || method === "CONNECT") {
|
|
if (typeof handler.onUpgrade !== "function") {
|
|
throw new InvalidArgumentError("invalid onUpgrade method");
|
|
}
|
|
} else {
|
|
if (typeof handler.onHeaders !== "function") {
|
|
throw new InvalidArgumentError("invalid onHeaders method");
|
|
}
|
|
if (typeof handler.onData !== "function") {
|
|
throw new InvalidArgumentError("invalid onData method");
|
|
}
|
|
if (typeof handler.onComplete !== "function") {
|
|
throw new InvalidArgumentError("invalid onComplete method");
|
|
}
|
|
}
|
|
}
|
|
function isDisturbed(body) {
|
|
return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
|
|
}
|
|
function isErrored(body) {
|
|
return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test(
|
|
nodeUtil.inspect(body)
|
|
)));
|
|
}
|
|
function isReadable(body) {
|
|
return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test(
|
|
nodeUtil.inspect(body)
|
|
)));
|
|
}
|
|
function getSocketInfo(socket) {
|
|
return {
|
|
localAddress: socket.localAddress,
|
|
localPort: socket.localPort,
|
|
remoteAddress: socket.remoteAddress,
|
|
remotePort: socket.remotePort,
|
|
remoteFamily: socket.remoteFamily,
|
|
timeout: socket.timeout,
|
|
bytesWritten: socket.bytesWritten,
|
|
bytesRead: socket.bytesRead
|
|
};
|
|
}
|
|
async function* convertIterableToBuffer(iterable) {
|
|
for await (const chunk of iterable) {
|
|
yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
|
|
}
|
|
}
|
|
var ReadableStream2;
|
|
function ReadableStreamFrom(iterable) {
|
|
if (!ReadableStream2) {
|
|
ReadableStream2 = require("stream/web").ReadableStream;
|
|
}
|
|
if (ReadableStream2.from) {
|
|
return ReadableStream2.from(convertIterableToBuffer(iterable));
|
|
}
|
|
let iterator;
|
|
return new ReadableStream2(
|
|
{
|
|
async start() {
|
|
iterator = iterable[Symbol.asyncIterator]();
|
|
},
|
|
async pull(controller) {
|
|
const { done, value } = await iterator.next();
|
|
if (done) {
|
|
queueMicrotask(() => {
|
|
controller.close();
|
|
});
|
|
} else {
|
|
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
|
|
controller.enqueue(new Uint8Array(buf));
|
|
}
|
|
return controller.desiredSize > 0;
|
|
},
|
|
async cancel(reason) {
|
|
await iterator.return();
|
|
}
|
|
},
|
|
0
|
|
);
|
|
}
|
|
function isFormDataLike(object) {
|
|
return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
|
|
}
|
|
function throwIfAborted(signal) {
|
|
if (!signal) {
|
|
return;
|
|
}
|
|
if (typeof signal.throwIfAborted === "function") {
|
|
signal.throwIfAborted();
|
|
} else {
|
|
if (signal.aborted) {
|
|
const err = new Error("The operation was aborted");
|
|
err.name = "AbortError";
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
function addAbortListener(signal, listener) {
|
|
if ("addEventListener" in signal) {
|
|
signal.addEventListener("abort", listener, { once: true });
|
|
return () => signal.removeEventListener("abort", listener);
|
|
}
|
|
signal.addListener("abort", listener);
|
|
return () => signal.removeListener("abort", listener);
|
|
}
|
|
var hasToWellFormed = !!String.prototype.toWellFormed;
|
|
function toUSVString(val) {
|
|
if (hasToWellFormed) {
|
|
return `${val}`.toWellFormed();
|
|
} else if (nodeUtil.toUSVString) {
|
|
return nodeUtil.toUSVString(val);
|
|
}
|
|
return `${val}`;
|
|
}
|
|
function parseRangeHeader(range) {
|
|
if (range == null || range === "") return { start: 0, end: null, size: null };
|
|
const m2 = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
|
|
return m2 ? {
|
|
start: parseInt(m2[1]),
|
|
end: m2[2] ? parseInt(m2[2]) : null,
|
|
size: m2[3] ? parseInt(m2[3]) : null
|
|
} : null;
|
|
}
|
|
var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
|
|
kEnumerableProperty.enumerable = true;
|
|
module2.exports = {
|
|
kEnumerableProperty,
|
|
nop,
|
|
isDisturbed,
|
|
isErrored,
|
|
isReadable,
|
|
toUSVString,
|
|
isReadableAborted,
|
|
isBlobLike,
|
|
parseOrigin,
|
|
parseURL,
|
|
getServerName,
|
|
isStream,
|
|
isIterable,
|
|
isAsyncIterable,
|
|
isDestroyed,
|
|
headerNameToString,
|
|
parseRawHeaders,
|
|
parseHeaders,
|
|
parseKeepAliveTimeout,
|
|
destroy,
|
|
bodyLength,
|
|
deepClone,
|
|
ReadableStreamFrom,
|
|
isBuffer,
|
|
validateHandler,
|
|
getSocketInfo,
|
|
isFormDataLike,
|
|
buildURL,
|
|
throwIfAborted,
|
|
addAbortListener,
|
|
parseRangeHeader,
|
|
nodeMajor,
|
|
nodeMinor,
|
|
nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
|
|
safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/timers.js
|
|
var require_timers = __commonJS({
|
|
"node_modules/undici/lib/timers.js"(exports2, module2) {
|
|
"use strict";
|
|
var fastNow = Date.now();
|
|
var fastNowTimeout;
|
|
var fastTimers = [];
|
|
function onTimeout() {
|
|
fastNow = Date.now();
|
|
let len = fastTimers.length;
|
|
let idx = 0;
|
|
while (idx < len) {
|
|
const timer = fastTimers[idx];
|
|
if (timer.state === 0) {
|
|
timer.state = fastNow + timer.delay;
|
|
} else if (timer.state > 0 && fastNow >= timer.state) {
|
|
timer.state = -1;
|
|
timer.callback(timer.opaque);
|
|
}
|
|
if (timer.state === -1) {
|
|
timer.state = -2;
|
|
if (idx !== len - 1) {
|
|
fastTimers[idx] = fastTimers.pop();
|
|
} else {
|
|
fastTimers.pop();
|
|
}
|
|
len -= 1;
|
|
} else {
|
|
idx += 1;
|
|
}
|
|
}
|
|
if (fastTimers.length > 0) {
|
|
refreshTimeout();
|
|
}
|
|
}
|
|
function refreshTimeout() {
|
|
if (fastNowTimeout && fastNowTimeout.refresh) {
|
|
fastNowTimeout.refresh();
|
|
} else {
|
|
clearTimeout(fastNowTimeout);
|
|
fastNowTimeout = setTimeout(onTimeout, 1e3);
|
|
if (fastNowTimeout.unref) {
|
|
fastNowTimeout.unref();
|
|
}
|
|
}
|
|
}
|
|
var Timeout = class {
|
|
constructor(callback, delay, opaque) {
|
|
this.callback = callback;
|
|
this.delay = delay;
|
|
this.opaque = opaque;
|
|
this.state = -2;
|
|
this.refresh();
|
|
}
|
|
refresh() {
|
|
if (this.state === -2) {
|
|
fastTimers.push(this);
|
|
if (!fastNowTimeout || fastTimers.length === 1) {
|
|
refreshTimeout();
|
|
}
|
|
}
|
|
this.state = 0;
|
|
}
|
|
clear() {
|
|
this.state = -1;
|
|
}
|
|
};
|
|
module2.exports = {
|
|
setTimeout(callback, delay, opaque) {
|
|
return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque);
|
|
},
|
|
clearTimeout(timeout) {
|
|
if (timeout instanceof Timeout) {
|
|
timeout.clear();
|
|
} else {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
|
|
var require_sbmh = __commonJS({
|
|
"node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) {
|
|
"use strict";
|
|
var EventEmitter = require("node:events").EventEmitter;
|
|
var inherits = require("node:util").inherits;
|
|
function SBMH(needle) {
|
|
if (typeof needle === "string") {
|
|
needle = Buffer.from(needle);
|
|
}
|
|
if (!Buffer.isBuffer(needle)) {
|
|
throw new TypeError("The needle has to be a String or a Buffer.");
|
|
}
|
|
const needleLength = needle.length;
|
|
if (needleLength === 0) {
|
|
throw new Error("The needle cannot be an empty String/Buffer.");
|
|
}
|
|
if (needleLength > 256) {
|
|
throw new Error("The needle cannot have a length bigger than 256.");
|
|
}
|
|
this.maxMatches = Infinity;
|
|
this.matches = 0;
|
|
this._occ = new Array(256).fill(needleLength);
|
|
this._lookbehind_size = 0;
|
|
this._needle = needle;
|
|
this._bufpos = 0;
|
|
this._lookbehind = Buffer.alloc(needleLength);
|
|
for (var i2 = 0; i2 < needleLength - 1; ++i2) {
|
|
this._occ[needle[i2]] = needleLength - 1 - i2;
|
|
}
|
|
}
|
|
inherits(SBMH, EventEmitter);
|
|
SBMH.prototype.reset = function() {
|
|
this._lookbehind_size = 0;
|
|
this.matches = 0;
|
|
this._bufpos = 0;
|
|
};
|
|
SBMH.prototype.push = function(chunk, pos) {
|
|
if (!Buffer.isBuffer(chunk)) {
|
|
chunk = Buffer.from(chunk, "binary");
|
|
}
|
|
const chlen = chunk.length;
|
|
this._bufpos = pos || 0;
|
|
let r2;
|
|
while (r2 !== chlen && this.matches < this.maxMatches) {
|
|
r2 = this._sbmh_feed(chunk);
|
|
}
|
|
return r2;
|
|
};
|
|
SBMH.prototype._sbmh_feed = function(data) {
|
|
const len = data.length;
|
|
const needle = this._needle;
|
|
const needleLength = needle.length;
|
|
const lastNeedleChar = needle[needleLength - 1];
|
|
let pos = -this._lookbehind_size;
|
|
let ch;
|
|
if (pos < 0) {
|
|
while (pos < 0 && pos <= len - needleLength) {
|
|
ch = this._sbmh_lookup_char(data, pos + needleLength - 1);
|
|
if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) {
|
|
this._lookbehind_size = 0;
|
|
++this.matches;
|
|
this.emit("info", true);
|
|
return this._bufpos = pos + needleLength;
|
|
}
|
|
pos += this._occ[ch];
|
|
}
|
|
if (pos < 0) {
|
|
while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
|
|
++pos;
|
|
}
|
|
}
|
|
if (pos >= 0) {
|
|
this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
|
|
this._lookbehind_size = 0;
|
|
} else {
|
|
const bytesToCutOff = this._lookbehind_size + pos;
|
|
if (bytesToCutOff > 0) {
|
|
this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
|
|
}
|
|
this._lookbehind.copy(
|
|
this._lookbehind,
|
|
0,
|
|
bytesToCutOff,
|
|
this._lookbehind_size - bytesToCutOff
|
|
);
|
|
this._lookbehind_size -= bytesToCutOff;
|
|
data.copy(this._lookbehind, this._lookbehind_size);
|
|
this._lookbehind_size += len;
|
|
this._bufpos = len;
|
|
return len;
|
|
}
|
|
}
|
|
pos += (pos >= 0) * this._bufpos;
|
|
if (data.indexOf(needle, pos) !== -1) {
|
|
pos = data.indexOf(needle, pos);
|
|
++this.matches;
|
|
if (pos > 0) {
|
|
this.emit("info", true, data, this._bufpos, pos);
|
|
} else {
|
|
this.emit("info", true);
|
|
}
|
|
return this._bufpos = pos + needleLength;
|
|
} else {
|
|
pos = len - needleLength;
|
|
}
|
|
while (pos < len && (data[pos] !== needle[0] || Buffer.compare(
|
|
data.subarray(pos, pos + len - pos),
|
|
needle.subarray(0, len - pos)
|
|
) !== 0)) {
|
|
++pos;
|
|
}
|
|
if (pos < len) {
|
|
data.copy(this._lookbehind, 0, pos, pos + (len - pos));
|
|
this._lookbehind_size = len - pos;
|
|
}
|
|
if (pos > 0) {
|
|
this.emit("info", false, data, this._bufpos, pos < len ? pos : len);
|
|
}
|
|
this._bufpos = len;
|
|
return len;
|
|
};
|
|
SBMH.prototype._sbmh_lookup_char = function(data, pos) {
|
|
return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
|
|
};
|
|
SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
|
|
for (var i2 = 0; i2 < len; ++i2) {
|
|
if (this._sbmh_lookup_char(data, pos + i2) !== this._needle[i2]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
module2.exports = SBMH;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
|
|
var require_PartStream = __commonJS({
|
|
"node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) {
|
|
"use strict";
|
|
var inherits = require("node:util").inherits;
|
|
var ReadableStream2 = require("node:stream").Readable;
|
|
function PartStream(opts) {
|
|
ReadableStream2.call(this, opts);
|
|
}
|
|
inherits(PartStream, ReadableStream2);
|
|
PartStream.prototype._read = function(n) {
|
|
};
|
|
module2.exports = PartStream;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/utils/getLimit.js
|
|
var require_getLimit = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function getLimit(limits, name, defaultLimit) {
|
|
if (!limits || limits[name] === void 0 || limits[name] === null) {
|
|
return defaultLimit;
|
|
}
|
|
if (typeof limits[name] !== "number" || isNaN(limits[name])) {
|
|
throw new TypeError("Limit " + name + " is not a valid number");
|
|
}
|
|
return limits[name];
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
|
|
var require_HeaderParser = __commonJS({
|
|
"node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) {
|
|
"use strict";
|
|
var EventEmitter = require("node:events").EventEmitter;
|
|
var inherits = require("node:util").inherits;
|
|
var getLimit = require_getLimit();
|
|
var StreamSearch = require_sbmh();
|
|
var B_DCRLF = Buffer.from("\r\n\r\n");
|
|
var RE_CRLF = /\r\n/g;
|
|
var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
|
|
function HeaderParser(cfg) {
|
|
EventEmitter.call(this);
|
|
cfg = cfg || {};
|
|
const self2 = this;
|
|
this.nread = 0;
|
|
this.maxed = false;
|
|
this.npairs = 0;
|
|
this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
|
|
this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
|
|
this.buffer = "";
|
|
this.header = {};
|
|
this.finished = false;
|
|
this.ss = new StreamSearch(B_DCRLF);
|
|
this.ss.on("info", function(isMatch, data, start, end) {
|
|
if (data && !self2.maxed) {
|
|
if (self2.nread + end - start >= self2.maxHeaderSize) {
|
|
end = self2.maxHeaderSize - self2.nread + start;
|
|
self2.nread = self2.maxHeaderSize;
|
|
self2.maxed = true;
|
|
} else {
|
|
self2.nread += end - start;
|
|
}
|
|
self2.buffer += data.toString("binary", start, end);
|
|
}
|
|
if (isMatch) {
|
|
self2._finish();
|
|
}
|
|
});
|
|
}
|
|
inherits(HeaderParser, EventEmitter);
|
|
HeaderParser.prototype.push = function(data) {
|
|
const r2 = this.ss.push(data);
|
|
if (this.finished) {
|
|
return r2;
|
|
}
|
|
};
|
|
HeaderParser.prototype.reset = function() {
|
|
this.finished = false;
|
|
this.buffer = "";
|
|
this.header = {};
|
|
this.ss.reset();
|
|
};
|
|
HeaderParser.prototype._finish = function() {
|
|
if (this.buffer) {
|
|
this._parseHeader();
|
|
}
|
|
this.ss.matches = this.ss.maxMatches;
|
|
const header = this.header;
|
|
this.header = {};
|
|
this.buffer = "";
|
|
this.finished = true;
|
|
this.nread = this.npairs = 0;
|
|
this.maxed = false;
|
|
this.emit("header", header);
|
|
};
|
|
HeaderParser.prototype._parseHeader = function() {
|
|
if (this.npairs === this.maxHeaderPairs) {
|
|
return;
|
|
}
|
|
const lines = this.buffer.split(RE_CRLF);
|
|
const len = lines.length;
|
|
let m2, h2;
|
|
for (var i2 = 0; i2 < len; ++i2) {
|
|
if (lines[i2].length === 0) {
|
|
continue;
|
|
}
|
|
if (lines[i2][0] === " " || lines[i2][0] === " ") {
|
|
if (h2) {
|
|
this.header[h2][this.header[h2].length - 1] += lines[i2];
|
|
continue;
|
|
}
|
|
}
|
|
const posColon = lines[i2].indexOf(":");
|
|
if (posColon === -1 || posColon === 0) {
|
|
return;
|
|
}
|
|
m2 = RE_HDR.exec(lines[i2]);
|
|
h2 = m2[1].toLowerCase();
|
|
this.header[h2] = this.header[h2] || [];
|
|
this.header[h2].push(m2[2] || "");
|
|
if (++this.npairs === this.maxHeaderPairs) {
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
module2.exports = HeaderParser;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
|
|
var require_Dicer = __commonJS({
|
|
"node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) {
|
|
"use strict";
|
|
var WritableStream = require("node:stream").Writable;
|
|
var inherits = require("node:util").inherits;
|
|
var StreamSearch = require_sbmh();
|
|
var PartStream = require_PartStream();
|
|
var HeaderParser = require_HeaderParser();
|
|
var DASH = 45;
|
|
var B_ONEDASH = Buffer.from("-");
|
|
var B_CRLF = Buffer.from("\r\n");
|
|
var EMPTY_FN = function() {
|
|
};
|
|
function Dicer(cfg) {
|
|
if (!(this instanceof Dicer)) {
|
|
return new Dicer(cfg);
|
|
}
|
|
WritableStream.call(this, cfg);
|
|
if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") {
|
|
throw new TypeError("Boundary required");
|
|
}
|
|
if (typeof cfg.boundary === "string") {
|
|
this.setBoundary(cfg.boundary);
|
|
} else {
|
|
this._bparser = void 0;
|
|
}
|
|
this._headerFirst = cfg.headerFirst;
|
|
this._dashes = 0;
|
|
this._parts = 0;
|
|
this._finished = false;
|
|
this._realFinish = false;
|
|
this._isPreamble = true;
|
|
this._justMatched = false;
|
|
this._firstWrite = true;
|
|
this._inHeader = true;
|
|
this._part = void 0;
|
|
this._cb = void 0;
|
|
this._ignoreData = false;
|
|
this._partOpts = { highWaterMark: cfg.partHwm };
|
|
this._pause = false;
|
|
const self2 = this;
|
|
this._hparser = new HeaderParser(cfg);
|
|
this._hparser.on("header", function(header) {
|
|
self2._inHeader = false;
|
|
self2._part.emit("header", header);
|
|
});
|
|
}
|
|
inherits(Dicer, WritableStream);
|
|
Dicer.prototype.emit = function(ev) {
|
|
if (ev === "finish" && !this._realFinish) {
|
|
if (!this._finished) {
|
|
const self2 = this;
|
|
process.nextTick(function() {
|
|
self2.emit("error", new Error("Unexpected end of multipart data"));
|
|
if (self2._part && !self2._ignoreData) {
|
|
const type = self2._isPreamble ? "Preamble" : "Part";
|
|
self2._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data"));
|
|
self2._part.push(null);
|
|
process.nextTick(function() {
|
|
self2._realFinish = true;
|
|
self2.emit("finish");
|
|
self2._realFinish = false;
|
|
});
|
|
return;
|
|
}
|
|
self2._realFinish = true;
|
|
self2.emit("finish");
|
|
self2._realFinish = false;
|
|
});
|
|
}
|
|
} else {
|
|
WritableStream.prototype.emit.apply(this, arguments);
|
|
}
|
|
};
|
|
Dicer.prototype._write = function(data, encoding, cb) {
|
|
if (!this._hparser && !this._bparser) {
|
|
return cb();
|
|
}
|
|
if (this._headerFirst && this._isPreamble) {
|
|
if (!this._part) {
|
|
this._part = new PartStream(this._partOpts);
|
|
if (this.listenerCount("preamble") !== 0) {
|
|
this.emit("preamble", this._part);
|
|
} else {
|
|
this._ignore();
|
|
}
|
|
}
|
|
const r2 = this._hparser.push(data);
|
|
if (!this._inHeader && r2 !== void 0 && r2 < data.length) {
|
|
data = data.slice(r2);
|
|
} else {
|
|
return cb();
|
|
}
|
|
}
|
|
if (this._firstWrite) {
|
|
this._bparser.push(B_CRLF);
|
|
this._firstWrite = false;
|
|
}
|
|
this._bparser.push(data);
|
|
if (this._pause) {
|
|
this._cb = cb;
|
|
} else {
|
|
cb();
|
|
}
|
|
};
|
|
Dicer.prototype.reset = function() {
|
|
this._part = void 0;
|
|
this._bparser = void 0;
|
|
this._hparser = void 0;
|
|
};
|
|
Dicer.prototype.setBoundary = function(boundary) {
|
|
const self2 = this;
|
|
this._bparser = new StreamSearch("\r\n--" + boundary);
|
|
this._bparser.on("info", function(isMatch, data, start, end) {
|
|
self2._oninfo(isMatch, data, start, end);
|
|
});
|
|
};
|
|
Dicer.prototype._ignore = function() {
|
|
if (this._part && !this._ignoreData) {
|
|
this._ignoreData = true;
|
|
this._part.on("error", EMPTY_FN);
|
|
this._part.resume();
|
|
}
|
|
};
|
|
Dicer.prototype._oninfo = function(isMatch, data, start, end) {
|
|
let buf;
|
|
const self2 = this;
|
|
let i2 = 0;
|
|
let r2;
|
|
let shouldWriteMore = true;
|
|
if (!this._part && this._justMatched && data) {
|
|
while (this._dashes < 2 && start + i2 < end) {
|
|
if (data[start + i2] === DASH) {
|
|
++i2;
|
|
++this._dashes;
|
|
} else {
|
|
if (this._dashes) {
|
|
buf = B_ONEDASH;
|
|
}
|
|
this._dashes = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (this._dashes === 2) {
|
|
if (start + i2 < end && this.listenerCount("trailer") !== 0) {
|
|
this.emit("trailer", data.slice(start + i2, end));
|
|
}
|
|
this.reset();
|
|
this._finished = true;
|
|
if (self2._parts === 0) {
|
|
self2._realFinish = true;
|
|
self2.emit("finish");
|
|
self2._realFinish = false;
|
|
}
|
|
}
|
|
if (this._dashes) {
|
|
return;
|
|
}
|
|
}
|
|
if (this._justMatched) {
|
|
this._justMatched = false;
|
|
}
|
|
if (!this._part) {
|
|
this._part = new PartStream(this._partOpts);
|
|
this._part._read = function(n) {
|
|
self2._unpause();
|
|
};
|
|
if (this._isPreamble && this.listenerCount("preamble") !== 0) {
|
|
this.emit("preamble", this._part);
|
|
} else if (this._isPreamble !== true && this.listenerCount("part") !== 0) {
|
|
this.emit("part", this._part);
|
|
} else {
|
|
this._ignore();
|
|
}
|
|
if (!this._isPreamble) {
|
|
this._inHeader = true;
|
|
}
|
|
}
|
|
if (data && start < end && !this._ignoreData) {
|
|
if (this._isPreamble || !this._inHeader) {
|
|
if (buf) {
|
|
shouldWriteMore = this._part.push(buf);
|
|
}
|
|
shouldWriteMore = this._part.push(data.slice(start, end));
|
|
if (!shouldWriteMore) {
|
|
this._pause = true;
|
|
}
|
|
} else if (!this._isPreamble && this._inHeader) {
|
|
if (buf) {
|
|
this._hparser.push(buf);
|
|
}
|
|
r2 = this._hparser.push(data.slice(start, end));
|
|
if (!this._inHeader && r2 !== void 0 && r2 < end) {
|
|
this._oninfo(false, data, start + r2, end);
|
|
}
|
|
}
|
|
}
|
|
if (isMatch) {
|
|
this._hparser.reset();
|
|
if (this._isPreamble) {
|
|
this._isPreamble = false;
|
|
} else {
|
|
if (start !== end) {
|
|
++this._parts;
|
|
this._part.on("end", function() {
|
|
if (--self2._parts === 0) {
|
|
if (self2._finished) {
|
|
self2._realFinish = true;
|
|
self2.emit("finish");
|
|
self2._realFinish = false;
|
|
} else {
|
|
self2._unpause();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
this._part.push(null);
|
|
this._part = void 0;
|
|
this._ignoreData = false;
|
|
this._justMatched = true;
|
|
this._dashes = 0;
|
|
}
|
|
};
|
|
Dicer.prototype._unpause = function() {
|
|
if (!this._pause) {
|
|
return;
|
|
}
|
|
this._pause = false;
|
|
if (this._cb) {
|
|
const cb = this._cb;
|
|
this._cb = void 0;
|
|
cb();
|
|
}
|
|
};
|
|
module2.exports = Dicer;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/utils/decodeText.js
|
|
var require_decodeText = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) {
|
|
"use strict";
|
|
var utf8Decoder = new TextDecoder("utf-8");
|
|
var textDecoders = /* @__PURE__ */ new Map([
|
|
["utf-8", utf8Decoder],
|
|
["utf8", utf8Decoder]
|
|
]);
|
|
function getDecoder(charset) {
|
|
let lc;
|
|
while (true) {
|
|
switch (charset) {
|
|
case "utf-8":
|
|
case "utf8":
|
|
return decoders.utf8;
|
|
case "latin1":
|
|
case "ascii":
|
|
// TODO: Make these a separate, strict decoder?
|
|
case "us-ascii":
|
|
case "iso-8859-1":
|
|
case "iso8859-1":
|
|
case "iso88591":
|
|
case "iso_8859-1":
|
|
case "windows-1252":
|
|
case "iso_8859-1:1987":
|
|
case "cp1252":
|
|
case "x-cp1252":
|
|
return decoders.latin1;
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
return decoders.utf16le;
|
|
case "base64":
|
|
return decoders.base64;
|
|
default:
|
|
if (lc === void 0) {
|
|
lc = true;
|
|
charset = charset.toLowerCase();
|
|
continue;
|
|
}
|
|
return decoders.other.bind(charset);
|
|
}
|
|
}
|
|
}
|
|
var decoders = {
|
|
utf8: (data, sourceEncoding) => {
|
|
if (data.length === 0) {
|
|
return "";
|
|
}
|
|
if (typeof data === "string") {
|
|
data = Buffer.from(data, sourceEncoding);
|
|
}
|
|
return data.utf8Slice(0, data.length);
|
|
},
|
|
latin1: (data, sourceEncoding) => {
|
|
if (data.length === 0) {
|
|
return "";
|
|
}
|
|
if (typeof data === "string") {
|
|
return data;
|
|
}
|
|
return data.latin1Slice(0, data.length);
|
|
},
|
|
utf16le: (data, sourceEncoding) => {
|
|
if (data.length === 0) {
|
|
return "";
|
|
}
|
|
if (typeof data === "string") {
|
|
data = Buffer.from(data, sourceEncoding);
|
|
}
|
|
return data.ucs2Slice(0, data.length);
|
|
},
|
|
base64: (data, sourceEncoding) => {
|
|
if (data.length === 0) {
|
|
return "";
|
|
}
|
|
if (typeof data === "string") {
|
|
data = Buffer.from(data, sourceEncoding);
|
|
}
|
|
return data.base64Slice(0, data.length);
|
|
},
|
|
other: (data, sourceEncoding) => {
|
|
if (data.length === 0) {
|
|
return "";
|
|
}
|
|
if (typeof data === "string") {
|
|
data = Buffer.from(data, sourceEncoding);
|
|
}
|
|
if (textDecoders.has(exports2.toString())) {
|
|
try {
|
|
return textDecoders.get(exports2).decode(data);
|
|
} catch {
|
|
}
|
|
}
|
|
return typeof data === "string" ? data : data.toString();
|
|
}
|
|
};
|
|
function decodeText(text, sourceEncoding, destEncoding) {
|
|
if (text) {
|
|
return getDecoder(destEncoding)(text, sourceEncoding);
|
|
}
|
|
return text;
|
|
}
|
|
module2.exports = decodeText;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/utils/parseParams.js
|
|
var require_parseParams = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) {
|
|
"use strict";
|
|
var decodeText = require_decodeText();
|
|
var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
|
|
var EncodedLookup = {
|
|
"%00": "\0",
|
|
"%01": "",
|
|
"%02": "",
|
|
"%03": "",
|
|
"%04": "",
|
|
"%05": "",
|
|
"%06": "",
|
|
"%07": "\x07",
|
|
"%08": "\b",
|
|
"%09": " ",
|
|
"%0a": "\n",
|
|
"%0A": "\n",
|
|
"%0b": "\v",
|
|
"%0B": "\v",
|
|
"%0c": "\f",
|
|
"%0C": "\f",
|
|
"%0d": "\r",
|
|
"%0D": "\r",
|
|
"%0e": "",
|
|
"%0E": "",
|
|
"%0f": "",
|
|
"%0F": "",
|
|
"%10": "",
|
|
"%11": "",
|
|
"%12": "",
|
|
"%13": "",
|
|
"%14": "",
|
|
"%15": "",
|
|
"%16": "",
|
|
"%17": "",
|
|
"%18": "",
|
|
"%19": "",
|
|
"%1a": "",
|
|
"%1A": "",
|
|
"%1b": "\x1B",
|
|
"%1B": "\x1B",
|
|
"%1c": " ",
|
|
"%1C": " ",
|
|
"%1d": " ",
|
|
"%1D": " ",
|
|
"%1e": " ",
|
|
"%1E": " ",
|
|
"%1f": " ",
|
|
"%1F": " ",
|
|
"%20": " ",
|
|
"%21": "!",
|
|
"%22": '"',
|
|
"%23": "#",
|
|
"%24": "$",
|
|
"%25": "%",
|
|
"%26": "&",
|
|
"%27": "'",
|
|
"%28": "(",
|
|
"%29": ")",
|
|
"%2a": "*",
|
|
"%2A": "*",
|
|
"%2b": "+",
|
|
"%2B": "+",
|
|
"%2c": ",",
|
|
"%2C": ",",
|
|
"%2d": "-",
|
|
"%2D": "-",
|
|
"%2e": ".",
|
|
"%2E": ".",
|
|
"%2f": "/",
|
|
"%2F": "/",
|
|
"%30": "0",
|
|
"%31": "1",
|
|
"%32": "2",
|
|
"%33": "3",
|
|
"%34": "4",
|
|
"%35": "5",
|
|
"%36": "6",
|
|
"%37": "7",
|
|
"%38": "8",
|
|
"%39": "9",
|
|
"%3a": ":",
|
|
"%3A": ":",
|
|
"%3b": ";",
|
|
"%3B": ";",
|
|
"%3c": "<",
|
|
"%3C": "<",
|
|
"%3d": "=",
|
|
"%3D": "=",
|
|
"%3e": ">",
|
|
"%3E": ">",
|
|
"%3f": "?",
|
|
"%3F": "?",
|
|
"%40": "@",
|
|
"%41": "A",
|
|
"%42": "B",
|
|
"%43": "C",
|
|
"%44": "D",
|
|
"%45": "E",
|
|
"%46": "F",
|
|
"%47": "G",
|
|
"%48": "H",
|
|
"%49": "I",
|
|
"%4a": "J",
|
|
"%4A": "J",
|
|
"%4b": "K",
|
|
"%4B": "K",
|
|
"%4c": "L",
|
|
"%4C": "L",
|
|
"%4d": "M",
|
|
"%4D": "M",
|
|
"%4e": "N",
|
|
"%4E": "N",
|
|
"%4f": "O",
|
|
"%4F": "O",
|
|
"%50": "P",
|
|
"%51": "Q",
|
|
"%52": "R",
|
|
"%53": "S",
|
|
"%54": "T",
|
|
"%55": "U",
|
|
"%56": "V",
|
|
"%57": "W",
|
|
"%58": "X",
|
|
"%59": "Y",
|
|
"%5a": "Z",
|
|
"%5A": "Z",
|
|
"%5b": "[",
|
|
"%5B": "[",
|
|
"%5c": "\\",
|
|
"%5C": "\\",
|
|
"%5d": "]",
|
|
"%5D": "]",
|
|
"%5e": "^",
|
|
"%5E": "^",
|
|
"%5f": "_",
|
|
"%5F": "_",
|
|
"%60": "`",
|
|
"%61": "a",
|
|
"%62": "b",
|
|
"%63": "c",
|
|
"%64": "d",
|
|
"%65": "e",
|
|
"%66": "f",
|
|
"%67": "g",
|
|
"%68": "h",
|
|
"%69": "i",
|
|
"%6a": "j",
|
|
"%6A": "j",
|
|
"%6b": "k",
|
|
"%6B": "k",
|
|
"%6c": "l",
|
|
"%6C": "l",
|
|
"%6d": "m",
|
|
"%6D": "m",
|
|
"%6e": "n",
|
|
"%6E": "n",
|
|
"%6f": "o",
|
|
"%6F": "o",
|
|
"%70": "p",
|
|
"%71": "q",
|
|
"%72": "r",
|
|
"%73": "s",
|
|
"%74": "t",
|
|
"%75": "u",
|
|
"%76": "v",
|
|
"%77": "w",
|
|
"%78": "x",
|
|
"%79": "y",
|
|
"%7a": "z",
|
|
"%7A": "z",
|
|
"%7b": "{",
|
|
"%7B": "{",
|
|
"%7c": "|",
|
|
"%7C": "|",
|
|
"%7d": "}",
|
|
"%7D": "}",
|
|
"%7e": "~",
|
|
"%7E": "~",
|
|
"%7f": "\x7F",
|
|
"%7F": "\x7F",
|
|
"%80": "\x80",
|
|
"%81": "\x81",
|
|
"%82": "\x82",
|
|
"%83": "\x83",
|
|
"%84": "\x84",
|
|
"%85": "\x85",
|
|
"%86": "\x86",
|
|
"%87": "\x87",
|
|
"%88": "\x88",
|
|
"%89": "\x89",
|
|
"%8a": "\x8A",
|
|
"%8A": "\x8A",
|
|
"%8b": "\x8B",
|
|
"%8B": "\x8B",
|
|
"%8c": "\x8C",
|
|
"%8C": "\x8C",
|
|
"%8d": "\x8D",
|
|
"%8D": "\x8D",
|
|
"%8e": "\x8E",
|
|
"%8E": "\x8E",
|
|
"%8f": "\x8F",
|
|
"%8F": "\x8F",
|
|
"%90": "\x90",
|
|
"%91": "\x91",
|
|
"%92": "\x92",
|
|
"%93": "\x93",
|
|
"%94": "\x94",
|
|
"%95": "\x95",
|
|
"%96": "\x96",
|
|
"%97": "\x97",
|
|
"%98": "\x98",
|
|
"%99": "\x99",
|
|
"%9a": "\x9A",
|
|
"%9A": "\x9A",
|
|
"%9b": "\x9B",
|
|
"%9B": "\x9B",
|
|
"%9c": "\x9C",
|
|
"%9C": "\x9C",
|
|
"%9d": "\x9D",
|
|
"%9D": "\x9D",
|
|
"%9e": "\x9E",
|
|
"%9E": "\x9E",
|
|
"%9f": "\x9F",
|
|
"%9F": "\x9F",
|
|
"%a0": "\xA0",
|
|
"%A0": "\xA0",
|
|
"%a1": "\xA1",
|
|
"%A1": "\xA1",
|
|
"%a2": "\xA2",
|
|
"%A2": "\xA2",
|
|
"%a3": "\xA3",
|
|
"%A3": "\xA3",
|
|
"%a4": "\xA4",
|
|
"%A4": "\xA4",
|
|
"%a5": "\xA5",
|
|
"%A5": "\xA5",
|
|
"%a6": "\xA6",
|
|
"%A6": "\xA6",
|
|
"%a7": "\xA7",
|
|
"%A7": "\xA7",
|
|
"%a8": "\xA8",
|
|
"%A8": "\xA8",
|
|
"%a9": "\xA9",
|
|
"%A9": "\xA9",
|
|
"%aa": "\xAA",
|
|
"%Aa": "\xAA",
|
|
"%aA": "\xAA",
|
|
"%AA": "\xAA",
|
|
"%ab": "\xAB",
|
|
"%Ab": "\xAB",
|
|
"%aB": "\xAB",
|
|
"%AB": "\xAB",
|
|
"%ac": "\xAC",
|
|
"%Ac": "\xAC",
|
|
"%aC": "\xAC",
|
|
"%AC": "\xAC",
|
|
"%ad": "\xAD",
|
|
"%Ad": "\xAD",
|
|
"%aD": "\xAD",
|
|
"%AD": "\xAD",
|
|
"%ae": "\xAE",
|
|
"%Ae": "\xAE",
|
|
"%aE": "\xAE",
|
|
"%AE": "\xAE",
|
|
"%af": "\xAF",
|
|
"%Af": "\xAF",
|
|
"%aF": "\xAF",
|
|
"%AF": "\xAF",
|
|
"%b0": "\xB0",
|
|
"%B0": "\xB0",
|
|
"%b1": "\xB1",
|
|
"%B1": "\xB1",
|
|
"%b2": "\xB2",
|
|
"%B2": "\xB2",
|
|
"%b3": "\xB3",
|
|
"%B3": "\xB3",
|
|
"%b4": "\xB4",
|
|
"%B4": "\xB4",
|
|
"%b5": "\xB5",
|
|
"%B5": "\xB5",
|
|
"%b6": "\xB6",
|
|
"%B6": "\xB6",
|
|
"%b7": "\xB7",
|
|
"%B7": "\xB7",
|
|
"%b8": "\xB8",
|
|
"%B8": "\xB8",
|
|
"%b9": "\xB9",
|
|
"%B9": "\xB9",
|
|
"%ba": "\xBA",
|
|
"%Ba": "\xBA",
|
|
"%bA": "\xBA",
|
|
"%BA": "\xBA",
|
|
"%bb": "\xBB",
|
|
"%Bb": "\xBB",
|
|
"%bB": "\xBB",
|
|
"%BB": "\xBB",
|
|
"%bc": "\xBC",
|
|
"%Bc": "\xBC",
|
|
"%bC": "\xBC",
|
|
"%BC": "\xBC",
|
|
"%bd": "\xBD",
|
|
"%Bd": "\xBD",
|
|
"%bD": "\xBD",
|
|
"%BD": "\xBD",
|
|
"%be": "\xBE",
|
|
"%Be": "\xBE",
|
|
"%bE": "\xBE",
|
|
"%BE": "\xBE",
|
|
"%bf": "\xBF",
|
|
"%Bf": "\xBF",
|
|
"%bF": "\xBF",
|
|
"%BF": "\xBF",
|
|
"%c0": "\xC0",
|
|
"%C0": "\xC0",
|
|
"%c1": "\xC1",
|
|
"%C1": "\xC1",
|
|
"%c2": "\xC2",
|
|
"%C2": "\xC2",
|
|
"%c3": "\xC3",
|
|
"%C3": "\xC3",
|
|
"%c4": "\xC4",
|
|
"%C4": "\xC4",
|
|
"%c5": "\xC5",
|
|
"%C5": "\xC5",
|
|
"%c6": "\xC6",
|
|
"%C6": "\xC6",
|
|
"%c7": "\xC7",
|
|
"%C7": "\xC7",
|
|
"%c8": "\xC8",
|
|
"%C8": "\xC8",
|
|
"%c9": "\xC9",
|
|
"%C9": "\xC9",
|
|
"%ca": "\xCA",
|
|
"%Ca": "\xCA",
|
|
"%cA": "\xCA",
|
|
"%CA": "\xCA",
|
|
"%cb": "\xCB",
|
|
"%Cb": "\xCB",
|
|
"%cB": "\xCB",
|
|
"%CB": "\xCB",
|
|
"%cc": "\xCC",
|
|
"%Cc": "\xCC",
|
|
"%cC": "\xCC",
|
|
"%CC": "\xCC",
|
|
"%cd": "\xCD",
|
|
"%Cd": "\xCD",
|
|
"%cD": "\xCD",
|
|
"%CD": "\xCD",
|
|
"%ce": "\xCE",
|
|
"%Ce": "\xCE",
|
|
"%cE": "\xCE",
|
|
"%CE": "\xCE",
|
|
"%cf": "\xCF",
|
|
"%Cf": "\xCF",
|
|
"%cF": "\xCF",
|
|
"%CF": "\xCF",
|
|
"%d0": "\xD0",
|
|
"%D0": "\xD0",
|
|
"%d1": "\xD1",
|
|
"%D1": "\xD1",
|
|
"%d2": "\xD2",
|
|
"%D2": "\xD2",
|
|
"%d3": "\xD3",
|
|
"%D3": "\xD3",
|
|
"%d4": "\xD4",
|
|
"%D4": "\xD4",
|
|
"%d5": "\xD5",
|
|
"%D5": "\xD5",
|
|
"%d6": "\xD6",
|
|
"%D6": "\xD6",
|
|
"%d7": "\xD7",
|
|
"%D7": "\xD7",
|
|
"%d8": "\xD8",
|
|
"%D8": "\xD8",
|
|
"%d9": "\xD9",
|
|
"%D9": "\xD9",
|
|
"%da": "\xDA",
|
|
"%Da": "\xDA",
|
|
"%dA": "\xDA",
|
|
"%DA": "\xDA",
|
|
"%db": "\xDB",
|
|
"%Db": "\xDB",
|
|
"%dB": "\xDB",
|
|
"%DB": "\xDB",
|
|
"%dc": "\xDC",
|
|
"%Dc": "\xDC",
|
|
"%dC": "\xDC",
|
|
"%DC": "\xDC",
|
|
"%dd": "\xDD",
|
|
"%Dd": "\xDD",
|
|
"%dD": "\xDD",
|
|
"%DD": "\xDD",
|
|
"%de": "\xDE",
|
|
"%De": "\xDE",
|
|
"%dE": "\xDE",
|
|
"%DE": "\xDE",
|
|
"%df": "\xDF",
|
|
"%Df": "\xDF",
|
|
"%dF": "\xDF",
|
|
"%DF": "\xDF",
|
|
"%e0": "\xE0",
|
|
"%E0": "\xE0",
|
|
"%e1": "\xE1",
|
|
"%E1": "\xE1",
|
|
"%e2": "\xE2",
|
|
"%E2": "\xE2",
|
|
"%e3": "\xE3",
|
|
"%E3": "\xE3",
|
|
"%e4": "\xE4",
|
|
"%E4": "\xE4",
|
|
"%e5": "\xE5",
|
|
"%E5": "\xE5",
|
|
"%e6": "\xE6",
|
|
"%E6": "\xE6",
|
|
"%e7": "\xE7",
|
|
"%E7": "\xE7",
|
|
"%e8": "\xE8",
|
|
"%E8": "\xE8",
|
|
"%e9": "\xE9",
|
|
"%E9": "\xE9",
|
|
"%ea": "\xEA",
|
|
"%Ea": "\xEA",
|
|
"%eA": "\xEA",
|
|
"%EA": "\xEA",
|
|
"%eb": "\xEB",
|
|
"%Eb": "\xEB",
|
|
"%eB": "\xEB",
|
|
"%EB": "\xEB",
|
|
"%ec": "\xEC",
|
|
"%Ec": "\xEC",
|
|
"%eC": "\xEC",
|
|
"%EC": "\xEC",
|
|
"%ed": "\xED",
|
|
"%Ed": "\xED",
|
|
"%eD": "\xED",
|
|
"%ED": "\xED",
|
|
"%ee": "\xEE",
|
|
"%Ee": "\xEE",
|
|
"%eE": "\xEE",
|
|
"%EE": "\xEE",
|
|
"%ef": "\xEF",
|
|
"%Ef": "\xEF",
|
|
"%eF": "\xEF",
|
|
"%EF": "\xEF",
|
|
"%f0": "\xF0",
|
|
"%F0": "\xF0",
|
|
"%f1": "\xF1",
|
|
"%F1": "\xF1",
|
|
"%f2": "\xF2",
|
|
"%F2": "\xF2",
|
|
"%f3": "\xF3",
|
|
"%F3": "\xF3",
|
|
"%f4": "\xF4",
|
|
"%F4": "\xF4",
|
|
"%f5": "\xF5",
|
|
"%F5": "\xF5",
|
|
"%f6": "\xF6",
|
|
"%F6": "\xF6",
|
|
"%f7": "\xF7",
|
|
"%F7": "\xF7",
|
|
"%f8": "\xF8",
|
|
"%F8": "\xF8",
|
|
"%f9": "\xF9",
|
|
"%F9": "\xF9",
|
|
"%fa": "\xFA",
|
|
"%Fa": "\xFA",
|
|
"%fA": "\xFA",
|
|
"%FA": "\xFA",
|
|
"%fb": "\xFB",
|
|
"%Fb": "\xFB",
|
|
"%fB": "\xFB",
|
|
"%FB": "\xFB",
|
|
"%fc": "\xFC",
|
|
"%Fc": "\xFC",
|
|
"%fC": "\xFC",
|
|
"%FC": "\xFC",
|
|
"%fd": "\xFD",
|
|
"%Fd": "\xFD",
|
|
"%fD": "\xFD",
|
|
"%FD": "\xFD",
|
|
"%fe": "\xFE",
|
|
"%Fe": "\xFE",
|
|
"%fE": "\xFE",
|
|
"%FE": "\xFE",
|
|
"%ff": "\xFF",
|
|
"%Ff": "\xFF",
|
|
"%fF": "\xFF",
|
|
"%FF": "\xFF"
|
|
};
|
|
function encodedReplacer(match) {
|
|
return EncodedLookup[match];
|
|
}
|
|
var STATE_KEY = 0;
|
|
var STATE_VALUE = 1;
|
|
var STATE_CHARSET = 2;
|
|
var STATE_LANG = 3;
|
|
function parseParams(str) {
|
|
const res = [];
|
|
let state = STATE_KEY;
|
|
let charset = "";
|
|
let inquote = false;
|
|
let escaping = false;
|
|
let p = 0;
|
|
let tmp = "";
|
|
const len = str.length;
|
|
for (var i2 = 0; i2 < len; ++i2) {
|
|
const char = str[i2];
|
|
if (char === "\\" && inquote) {
|
|
if (escaping) {
|
|
escaping = false;
|
|
} else {
|
|
escaping = true;
|
|
continue;
|
|
}
|
|
} else if (char === '"') {
|
|
if (!escaping) {
|
|
if (inquote) {
|
|
inquote = false;
|
|
state = STATE_KEY;
|
|
} else {
|
|
inquote = true;
|
|
}
|
|
continue;
|
|
} else {
|
|
escaping = false;
|
|
}
|
|
} else {
|
|
if (escaping && inquote) {
|
|
tmp += "\\";
|
|
}
|
|
escaping = false;
|
|
if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
|
|
if (state === STATE_CHARSET) {
|
|
state = STATE_LANG;
|
|
charset = tmp.substring(1);
|
|
} else {
|
|
state = STATE_VALUE;
|
|
}
|
|
tmp = "";
|
|
continue;
|
|
} else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
|
|
state = char === "*" ? STATE_CHARSET : STATE_VALUE;
|
|
res[p] = [tmp, void 0];
|
|
tmp = "";
|
|
continue;
|
|
} else if (!inquote && char === ";") {
|
|
state = STATE_KEY;
|
|
if (charset) {
|
|
if (tmp.length) {
|
|
tmp = decodeText(
|
|
tmp.replace(RE_ENCODED, encodedReplacer),
|
|
"binary",
|
|
charset
|
|
);
|
|
}
|
|
charset = "";
|
|
} else if (tmp.length) {
|
|
tmp = decodeText(tmp, "binary", "utf8");
|
|
}
|
|
if (res[p] === void 0) {
|
|
res[p] = tmp;
|
|
} else {
|
|
res[p][1] = tmp;
|
|
}
|
|
tmp = "";
|
|
++p;
|
|
continue;
|
|
} else if (!inquote && (char === " " || char === " ")) {
|
|
continue;
|
|
}
|
|
}
|
|
tmp += char;
|
|
}
|
|
if (charset && tmp.length) {
|
|
tmp = decodeText(
|
|
tmp.replace(RE_ENCODED, encodedReplacer),
|
|
"binary",
|
|
charset
|
|
);
|
|
} else if (tmp) {
|
|
tmp = decodeText(tmp, "binary", "utf8");
|
|
}
|
|
if (res[p] === void 0) {
|
|
if (tmp) {
|
|
res[p] = tmp;
|
|
}
|
|
} else {
|
|
res[p][1] = tmp;
|
|
}
|
|
return res;
|
|
}
|
|
module2.exports = parseParams;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/utils/basename.js
|
|
var require_basename = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function basename(path3) {
|
|
if (typeof path3 !== "string") {
|
|
return "";
|
|
}
|
|
for (var i2 = path3.length - 1; i2 >= 0; --i2) {
|
|
switch (path3.charCodeAt(i2)) {
|
|
case 47:
|
|
// '/'
|
|
case 92:
|
|
path3 = path3.slice(i2 + 1);
|
|
return path3 === ".." || path3 === "." ? "" : path3;
|
|
}
|
|
}
|
|
return path3 === ".." || path3 === "." ? "" : path3;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/types/multipart.js
|
|
var require_multipart = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Readable } = require("node:stream");
|
|
var { inherits } = require("node:util");
|
|
var Dicer = require_Dicer();
|
|
var parseParams = require_parseParams();
|
|
var decodeText = require_decodeText();
|
|
var basename = require_basename();
|
|
var getLimit = require_getLimit();
|
|
var RE_BOUNDARY = /^boundary$/i;
|
|
var RE_FIELD = /^form-data$/i;
|
|
var RE_CHARSET = /^charset$/i;
|
|
var RE_FILENAME = /^filename$/i;
|
|
var RE_NAME = /^name$/i;
|
|
Multipart.detect = /^multipart\/form-data/i;
|
|
function Multipart(boy, cfg) {
|
|
let i2;
|
|
let len;
|
|
const self2 = this;
|
|
let boundary;
|
|
const limits = cfg.limits;
|
|
const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
|
|
const parsedConType = cfg.parsedConType || [];
|
|
const defCharset = cfg.defCharset || "utf8";
|
|
const preservePath = cfg.preservePath;
|
|
const fileOpts = { highWaterMark: cfg.fileHwm };
|
|
for (i2 = 0, len = parsedConType.length; i2 < len; ++i2) {
|
|
if (Array.isArray(parsedConType[i2]) && RE_BOUNDARY.test(parsedConType[i2][0])) {
|
|
boundary = parsedConType[i2][1];
|
|
break;
|
|
}
|
|
}
|
|
function checkFinished() {
|
|
if (nends === 0 && finished && !boy._done) {
|
|
finished = false;
|
|
self2.end();
|
|
}
|
|
}
|
|
if (typeof boundary !== "string") {
|
|
throw new Error("Multipart: Boundary not found");
|
|
}
|
|
const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
|
|
const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
|
|
const filesLimit = getLimit(limits, "files", Infinity);
|
|
const fieldsLimit = getLimit(limits, "fields", Infinity);
|
|
const partsLimit = getLimit(limits, "parts", Infinity);
|
|
const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
|
|
const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
|
|
let nfiles = 0;
|
|
let nfields = 0;
|
|
let nends = 0;
|
|
let curFile;
|
|
let curField;
|
|
let finished = false;
|
|
this._needDrain = false;
|
|
this._pause = false;
|
|
this._cb = void 0;
|
|
this._nparts = 0;
|
|
this._boy = boy;
|
|
const parserCfg = {
|
|
boundary,
|
|
maxHeaderPairs: headerPairsLimit,
|
|
maxHeaderSize: headerSizeLimit,
|
|
partHwm: fileOpts.highWaterMark,
|
|
highWaterMark: cfg.highWaterMark
|
|
};
|
|
this.parser = new Dicer(parserCfg);
|
|
this.parser.on("drain", function() {
|
|
self2._needDrain = false;
|
|
if (self2._cb && !self2._pause) {
|
|
const cb = self2._cb;
|
|
self2._cb = void 0;
|
|
cb();
|
|
}
|
|
}).on("part", function onPart(part) {
|
|
if (++self2._nparts > partsLimit) {
|
|
self2.parser.removeListener("part", onPart);
|
|
self2.parser.on("part", skipPart);
|
|
boy.hitPartsLimit = true;
|
|
boy.emit("partsLimit");
|
|
return skipPart(part);
|
|
}
|
|
if (curField) {
|
|
const field = curField;
|
|
field.emit("end");
|
|
field.removeAllListeners("end");
|
|
}
|
|
part.on("header", function(header) {
|
|
let contype;
|
|
let fieldname;
|
|
let parsed;
|
|
let charset;
|
|
let encoding;
|
|
let filename;
|
|
let nsize = 0;
|
|
if (header["content-type"]) {
|
|
parsed = parseParams(header["content-type"][0]);
|
|
if (parsed[0]) {
|
|
contype = parsed[0].toLowerCase();
|
|
for (i2 = 0, len = parsed.length; i2 < len; ++i2) {
|
|
if (RE_CHARSET.test(parsed[i2][0])) {
|
|
charset = parsed[i2][1].toLowerCase();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (contype === void 0) {
|
|
contype = "text/plain";
|
|
}
|
|
if (charset === void 0) {
|
|
charset = defCharset;
|
|
}
|
|
if (header["content-disposition"]) {
|
|
parsed = parseParams(header["content-disposition"][0]);
|
|
if (!RE_FIELD.test(parsed[0])) {
|
|
return skipPart(part);
|
|
}
|
|
for (i2 = 0, len = parsed.length; i2 < len; ++i2) {
|
|
if (RE_NAME.test(parsed[i2][0])) {
|
|
fieldname = parsed[i2][1];
|
|
} else if (RE_FILENAME.test(parsed[i2][0])) {
|
|
filename = parsed[i2][1];
|
|
if (!preservePath) {
|
|
filename = basename(filename);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
return skipPart(part);
|
|
}
|
|
if (header["content-transfer-encoding"]) {
|
|
encoding = header["content-transfer-encoding"][0].toLowerCase();
|
|
} else {
|
|
encoding = "7bit";
|
|
}
|
|
let onData, onEnd;
|
|
if (isPartAFile(fieldname, contype, filename)) {
|
|
if (nfiles === filesLimit) {
|
|
if (!boy.hitFilesLimit) {
|
|
boy.hitFilesLimit = true;
|
|
boy.emit("filesLimit");
|
|
}
|
|
return skipPart(part);
|
|
}
|
|
++nfiles;
|
|
if (boy.listenerCount("file") === 0) {
|
|
self2.parser._ignore();
|
|
return;
|
|
}
|
|
++nends;
|
|
const file = new FileStream(fileOpts);
|
|
curFile = file;
|
|
file.on("end", function() {
|
|
--nends;
|
|
self2._pause = false;
|
|
checkFinished();
|
|
if (self2._cb && !self2._needDrain) {
|
|
const cb = self2._cb;
|
|
self2._cb = void 0;
|
|
cb();
|
|
}
|
|
});
|
|
file._read = function(n) {
|
|
if (!self2._pause) {
|
|
return;
|
|
}
|
|
self2._pause = false;
|
|
if (self2._cb && !self2._needDrain) {
|
|
const cb = self2._cb;
|
|
self2._cb = void 0;
|
|
cb();
|
|
}
|
|
};
|
|
boy.emit("file", fieldname, file, filename, encoding, contype);
|
|
onData = function(data) {
|
|
if ((nsize += data.length) > fileSizeLimit) {
|
|
const extralen = fileSizeLimit - nsize + data.length;
|
|
if (extralen > 0) {
|
|
file.push(data.slice(0, extralen));
|
|
}
|
|
file.truncated = true;
|
|
file.bytesRead = fileSizeLimit;
|
|
part.removeAllListeners("data");
|
|
file.emit("limit");
|
|
return;
|
|
} else if (!file.push(data)) {
|
|
self2._pause = true;
|
|
}
|
|
file.bytesRead = nsize;
|
|
};
|
|
onEnd = function() {
|
|
curFile = void 0;
|
|
file.push(null);
|
|
};
|
|
} else {
|
|
if (nfields === fieldsLimit) {
|
|
if (!boy.hitFieldsLimit) {
|
|
boy.hitFieldsLimit = true;
|
|
boy.emit("fieldsLimit");
|
|
}
|
|
return skipPart(part);
|
|
}
|
|
++nfields;
|
|
++nends;
|
|
let buffer = "";
|
|
let truncated = false;
|
|
curField = part;
|
|
onData = function(data) {
|
|
if ((nsize += data.length) > fieldSizeLimit) {
|
|
const extralen = fieldSizeLimit - (nsize - data.length);
|
|
buffer += data.toString("binary", 0, extralen);
|
|
truncated = true;
|
|
part.removeAllListeners("data");
|
|
} else {
|
|
buffer += data.toString("binary");
|
|
}
|
|
};
|
|
onEnd = function() {
|
|
curField = void 0;
|
|
if (buffer.length) {
|
|
buffer = decodeText(buffer, "binary", charset);
|
|
}
|
|
boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
|
|
--nends;
|
|
checkFinished();
|
|
};
|
|
}
|
|
part._readableState.sync = false;
|
|
part.on("data", onData);
|
|
part.on("end", onEnd);
|
|
}).on("error", function(err) {
|
|
if (curFile) {
|
|
curFile.emit("error", err);
|
|
}
|
|
});
|
|
}).on("error", function(err) {
|
|
boy.emit("error", err);
|
|
}).on("finish", function() {
|
|
finished = true;
|
|
checkFinished();
|
|
});
|
|
}
|
|
Multipart.prototype.write = function(chunk, cb) {
|
|
const r2 = this.parser.write(chunk);
|
|
if (r2 && !this._pause) {
|
|
cb();
|
|
} else {
|
|
this._needDrain = !r2;
|
|
this._cb = cb;
|
|
}
|
|
};
|
|
Multipart.prototype.end = function() {
|
|
const self2 = this;
|
|
if (self2.parser.writable) {
|
|
self2.parser.end();
|
|
} else if (!self2._boy._done) {
|
|
process.nextTick(function() {
|
|
self2._boy._done = true;
|
|
self2._boy.emit("finish");
|
|
});
|
|
}
|
|
};
|
|
function skipPart(part) {
|
|
part.resume();
|
|
}
|
|
function FileStream(opts) {
|
|
Readable.call(this, opts);
|
|
this.bytesRead = 0;
|
|
this.truncated = false;
|
|
}
|
|
inherits(FileStream, Readable);
|
|
FileStream.prototype._read = function(n) {
|
|
};
|
|
module2.exports = Multipart;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/utils/Decoder.js
|
|
var require_Decoder = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) {
|
|
"use strict";
|
|
var RE_PLUS = /\+/g;
|
|
var HEX = [
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
];
|
|
function Decoder() {
|
|
this.buffer = void 0;
|
|
}
|
|
Decoder.prototype.write = function(str) {
|
|
str = str.replace(RE_PLUS, " ");
|
|
let res = "";
|
|
let i2 = 0;
|
|
let p = 0;
|
|
const len = str.length;
|
|
for (; i2 < len; ++i2) {
|
|
if (this.buffer !== void 0) {
|
|
if (!HEX[str.charCodeAt(i2)]) {
|
|
res += "%" + this.buffer;
|
|
this.buffer = void 0;
|
|
--i2;
|
|
} else {
|
|
this.buffer += str[i2];
|
|
++p;
|
|
if (this.buffer.length === 2) {
|
|
res += String.fromCharCode(parseInt(this.buffer, 16));
|
|
this.buffer = void 0;
|
|
}
|
|
}
|
|
} else if (str[i2] === "%") {
|
|
if (i2 > p) {
|
|
res += str.substring(p, i2);
|
|
p = i2;
|
|
}
|
|
this.buffer = "";
|
|
++p;
|
|
}
|
|
}
|
|
if (p < len && this.buffer === void 0) {
|
|
res += str.substring(p);
|
|
}
|
|
return res;
|
|
};
|
|
Decoder.prototype.reset = function() {
|
|
this.buffer = void 0;
|
|
};
|
|
module2.exports = Decoder;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/types/urlencoded.js
|
|
var require_urlencoded = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) {
|
|
"use strict";
|
|
var Decoder = require_Decoder();
|
|
var decodeText = require_decodeText();
|
|
var getLimit = require_getLimit();
|
|
var RE_CHARSET = /^charset$/i;
|
|
UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
|
|
function UrlEncoded(boy, cfg) {
|
|
const limits = cfg.limits;
|
|
const parsedConType = cfg.parsedConType;
|
|
this.boy = boy;
|
|
this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
|
|
this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
|
|
this.fieldsLimit = getLimit(limits, "fields", Infinity);
|
|
let charset;
|
|
for (var i2 = 0, len = parsedConType.length; i2 < len; ++i2) {
|
|
if (Array.isArray(parsedConType[i2]) && RE_CHARSET.test(parsedConType[i2][0])) {
|
|
charset = parsedConType[i2][1].toLowerCase();
|
|
break;
|
|
}
|
|
}
|
|
if (charset === void 0) {
|
|
charset = cfg.defCharset || "utf8";
|
|
}
|
|
this.decoder = new Decoder();
|
|
this.charset = charset;
|
|
this._fields = 0;
|
|
this._state = "key";
|
|
this._checkingBytes = true;
|
|
this._bytesKey = 0;
|
|
this._bytesVal = 0;
|
|
this._key = "";
|
|
this._val = "";
|
|
this._keyTrunc = false;
|
|
this._valTrunc = false;
|
|
this._hitLimit = false;
|
|
}
|
|
UrlEncoded.prototype.write = function(data, cb) {
|
|
if (this._fields === this.fieldsLimit) {
|
|
if (!this.boy.hitFieldsLimit) {
|
|
this.boy.hitFieldsLimit = true;
|
|
this.boy.emit("fieldsLimit");
|
|
}
|
|
return cb();
|
|
}
|
|
let idxeq;
|
|
let idxamp;
|
|
let i2;
|
|
let p = 0;
|
|
const len = data.length;
|
|
while (p < len) {
|
|
if (this._state === "key") {
|
|
idxeq = idxamp = void 0;
|
|
for (i2 = p; i2 < len; ++i2) {
|
|
if (!this._checkingBytes) {
|
|
++p;
|
|
}
|
|
if (data[i2] === 61) {
|
|
idxeq = i2;
|
|
break;
|
|
} else if (data[i2] === 38) {
|
|
idxamp = i2;
|
|
break;
|
|
}
|
|
if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
|
|
this._hitLimit = true;
|
|
break;
|
|
} else if (this._checkingBytes) {
|
|
++this._bytesKey;
|
|
}
|
|
}
|
|
if (idxeq !== void 0) {
|
|
if (idxeq > p) {
|
|
this._key += this.decoder.write(data.toString("binary", p, idxeq));
|
|
}
|
|
this._state = "val";
|
|
this._hitLimit = false;
|
|
this._checkingBytes = true;
|
|
this._val = "";
|
|
this._bytesVal = 0;
|
|
this._valTrunc = false;
|
|
this.decoder.reset();
|
|
p = idxeq + 1;
|
|
} else if (idxamp !== void 0) {
|
|
++this._fields;
|
|
let key;
|
|
const keyTrunc = this._keyTrunc;
|
|
if (idxamp > p) {
|
|
key = this._key += this.decoder.write(data.toString("binary", p, idxamp));
|
|
} else {
|
|
key = this._key;
|
|
}
|
|
this._hitLimit = false;
|
|
this._checkingBytes = true;
|
|
this._key = "";
|
|
this._bytesKey = 0;
|
|
this._keyTrunc = false;
|
|
this.decoder.reset();
|
|
if (key.length) {
|
|
this.boy.emit(
|
|
"field",
|
|
decodeText(key, "binary", this.charset),
|
|
"",
|
|
keyTrunc,
|
|
false
|
|
);
|
|
}
|
|
p = idxamp + 1;
|
|
if (this._fields === this.fieldsLimit) {
|
|
return cb();
|
|
}
|
|
} else if (this._hitLimit) {
|
|
if (i2 > p) {
|
|
this._key += this.decoder.write(data.toString("binary", p, i2));
|
|
}
|
|
p = i2;
|
|
if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
|
|
this._checkingBytes = false;
|
|
this._keyTrunc = true;
|
|
}
|
|
} else {
|
|
if (p < len) {
|
|
this._key += this.decoder.write(data.toString("binary", p));
|
|
}
|
|
p = len;
|
|
}
|
|
} else {
|
|
idxamp = void 0;
|
|
for (i2 = p; i2 < len; ++i2) {
|
|
if (!this._checkingBytes) {
|
|
++p;
|
|
}
|
|
if (data[i2] === 38) {
|
|
idxamp = i2;
|
|
break;
|
|
}
|
|
if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
|
|
this._hitLimit = true;
|
|
break;
|
|
} else if (this._checkingBytes) {
|
|
++this._bytesVal;
|
|
}
|
|
}
|
|
if (idxamp !== void 0) {
|
|
++this._fields;
|
|
if (idxamp > p) {
|
|
this._val += this.decoder.write(data.toString("binary", p, idxamp));
|
|
}
|
|
this.boy.emit(
|
|
"field",
|
|
decodeText(this._key, "binary", this.charset),
|
|
decodeText(this._val, "binary", this.charset),
|
|
this._keyTrunc,
|
|
this._valTrunc
|
|
);
|
|
this._state = "key";
|
|
this._hitLimit = false;
|
|
this._checkingBytes = true;
|
|
this._key = "";
|
|
this._bytesKey = 0;
|
|
this._keyTrunc = false;
|
|
this.decoder.reset();
|
|
p = idxamp + 1;
|
|
if (this._fields === this.fieldsLimit) {
|
|
return cb();
|
|
}
|
|
} else if (this._hitLimit) {
|
|
if (i2 > p) {
|
|
this._val += this.decoder.write(data.toString("binary", p, i2));
|
|
}
|
|
p = i2;
|
|
if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
|
|
this._checkingBytes = false;
|
|
this._valTrunc = true;
|
|
}
|
|
} else {
|
|
if (p < len) {
|
|
this._val += this.decoder.write(data.toString("binary", p));
|
|
}
|
|
p = len;
|
|
}
|
|
}
|
|
}
|
|
cb();
|
|
};
|
|
UrlEncoded.prototype.end = function() {
|
|
if (this.boy._done) {
|
|
return;
|
|
}
|
|
if (this._state === "key" && this._key.length > 0) {
|
|
this.boy.emit(
|
|
"field",
|
|
decodeText(this._key, "binary", this.charset),
|
|
"",
|
|
this._keyTrunc,
|
|
false
|
|
);
|
|
} else if (this._state === "val") {
|
|
this.boy.emit(
|
|
"field",
|
|
decodeText(this._key, "binary", this.charset),
|
|
decodeText(this._val, "binary", this.charset),
|
|
this._keyTrunc,
|
|
this._valTrunc
|
|
);
|
|
}
|
|
this.boy._done = true;
|
|
this.boy.emit("finish");
|
|
};
|
|
module2.exports = UrlEncoded;
|
|
}
|
|
});
|
|
|
|
// node_modules/@fastify/busboy/lib/main.js
|
|
var require_main = __commonJS({
|
|
"node_modules/@fastify/busboy/lib/main.js"(exports2, module2) {
|
|
"use strict";
|
|
var WritableStream = require("node:stream").Writable;
|
|
var { inherits } = require("node:util");
|
|
var Dicer = require_Dicer();
|
|
var MultipartParser2 = require_multipart();
|
|
var UrlencodedParser = require_urlencoded();
|
|
var parseParams = require_parseParams();
|
|
function Busboy(opts) {
|
|
if (!(this instanceof Busboy)) {
|
|
return new Busboy(opts);
|
|
}
|
|
if (typeof opts !== "object") {
|
|
throw new TypeError("Busboy expected an options-Object.");
|
|
}
|
|
if (typeof opts.headers !== "object") {
|
|
throw new TypeError("Busboy expected an options-Object with headers-attribute.");
|
|
}
|
|
if (typeof opts.headers["content-type"] !== "string") {
|
|
throw new TypeError("Missing Content-Type-header.");
|
|
}
|
|
const {
|
|
headers,
|
|
...streamOptions
|
|
} = opts;
|
|
this.opts = {
|
|
autoDestroy: false,
|
|
...streamOptions
|
|
};
|
|
WritableStream.call(this, this.opts);
|
|
this._done = false;
|
|
this._parser = this.getParserByHeaders(headers);
|
|
this._finished = false;
|
|
}
|
|
inherits(Busboy, WritableStream);
|
|
Busboy.prototype.emit = function(ev) {
|
|
if (ev === "finish") {
|
|
if (!this._done) {
|
|
this._parser?.end();
|
|
return;
|
|
} else if (this._finished) {
|
|
return;
|
|
}
|
|
this._finished = true;
|
|
}
|
|
WritableStream.prototype.emit.apply(this, arguments);
|
|
};
|
|
Busboy.prototype.getParserByHeaders = function(headers) {
|
|
const parsed = parseParams(headers["content-type"]);
|
|
const cfg = {
|
|
defCharset: this.opts.defCharset,
|
|
fileHwm: this.opts.fileHwm,
|
|
headers,
|
|
highWaterMark: this.opts.highWaterMark,
|
|
isPartAFile: this.opts.isPartAFile,
|
|
limits: this.opts.limits,
|
|
parsedConType: parsed,
|
|
preservePath: this.opts.preservePath
|
|
};
|
|
if (MultipartParser2.detect.test(parsed[0])) {
|
|
return new MultipartParser2(this, cfg);
|
|
}
|
|
if (UrlencodedParser.detect.test(parsed[0])) {
|
|
return new UrlencodedParser(this, cfg);
|
|
}
|
|
throw new Error("Unsupported Content-Type.");
|
|
};
|
|
Busboy.prototype._write = function(chunk, encoding, cb) {
|
|
this._parser.write(chunk, cb);
|
|
};
|
|
module2.exports = Busboy;
|
|
module2.exports.default = Busboy;
|
|
module2.exports.Busboy = Busboy;
|
|
module2.exports.Dicer = Dicer;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/constants.js
|
|
var require_constants2 = __commonJS({
|
|
"node_modules/undici/lib/fetch/constants.js"(exports2, module2) {
|
|
"use strict";
|
|
var { MessageChannel, receiveMessageOnPort } = require("worker_threads");
|
|
var corsSafeListedMethods = ["GET", "HEAD", "POST"];
|
|
var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
|
|
var nullBodyStatus = [101, 204, 205, 304];
|
|
var redirectStatus2 = [301, 302, 303, 307, 308];
|
|
var redirectStatusSet = new Set(redirectStatus2);
|
|
var badPorts = [
|
|
"1",
|
|
"7",
|
|
"9",
|
|
"11",
|
|
"13",
|
|
"15",
|
|
"17",
|
|
"19",
|
|
"20",
|
|
"21",
|
|
"22",
|
|
"23",
|
|
"25",
|
|
"37",
|
|
"42",
|
|
"43",
|
|
"53",
|
|
"69",
|
|
"77",
|
|
"79",
|
|
"87",
|
|
"95",
|
|
"101",
|
|
"102",
|
|
"103",
|
|
"104",
|
|
"109",
|
|
"110",
|
|
"111",
|
|
"113",
|
|
"115",
|
|
"117",
|
|
"119",
|
|
"123",
|
|
"135",
|
|
"137",
|
|
"139",
|
|
"143",
|
|
"161",
|
|
"179",
|
|
"389",
|
|
"427",
|
|
"465",
|
|
"512",
|
|
"513",
|
|
"514",
|
|
"515",
|
|
"526",
|
|
"530",
|
|
"531",
|
|
"532",
|
|
"540",
|
|
"548",
|
|
"554",
|
|
"556",
|
|
"563",
|
|
"587",
|
|
"601",
|
|
"636",
|
|
"989",
|
|
"990",
|
|
"993",
|
|
"995",
|
|
"1719",
|
|
"1720",
|
|
"1723",
|
|
"2049",
|
|
"3659",
|
|
"4045",
|
|
"5060",
|
|
"5061",
|
|
"6000",
|
|
"6566",
|
|
"6665",
|
|
"6666",
|
|
"6667",
|
|
"6668",
|
|
"6669",
|
|
"6697",
|
|
"10080"
|
|
];
|
|
var badPortsSet = new Set(badPorts);
|
|
var referrerPolicy = [
|
|
"",
|
|
"no-referrer",
|
|
"no-referrer-when-downgrade",
|
|
"same-origin",
|
|
"origin",
|
|
"strict-origin",
|
|
"origin-when-cross-origin",
|
|
"strict-origin-when-cross-origin",
|
|
"unsafe-url"
|
|
];
|
|
var referrerPolicySet = new Set(referrerPolicy);
|
|
var requestRedirect = ["follow", "manual", "error"];
|
|
var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
|
|
var safeMethodsSet = new Set(safeMethods);
|
|
var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
|
|
var requestCredentials = ["omit", "same-origin", "include"];
|
|
var requestCache = [
|
|
"default",
|
|
"no-store",
|
|
"reload",
|
|
"no-cache",
|
|
"force-cache",
|
|
"only-if-cached"
|
|
];
|
|
var requestBodyHeader = [
|
|
"content-encoding",
|
|
"content-language",
|
|
"content-location",
|
|
"content-type",
|
|
// See https://github.com/nodejs/undici/issues/2021
|
|
// 'Content-Length' is a forbidden header name, which is typically
|
|
// removed in the Headers implementation. However, undici doesn't
|
|
// filter out headers, so we add it here.
|
|
"content-length"
|
|
];
|
|
var requestDuplex = [
|
|
"half"
|
|
];
|
|
var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
|
|
var forbiddenMethodsSet = new Set(forbiddenMethods);
|
|
var subresource = [
|
|
"audio",
|
|
"audioworklet",
|
|
"font",
|
|
"image",
|
|
"manifest",
|
|
"paintworklet",
|
|
"script",
|
|
"style",
|
|
"track",
|
|
"video",
|
|
"xslt",
|
|
""
|
|
];
|
|
var subresourceSet = new Set(subresource);
|
|
var DOMException3 = globalThis.DOMException ?? (() => {
|
|
try {
|
|
atob("~");
|
|
} catch (err) {
|
|
return Object.getPrototypeOf(err).constructor;
|
|
}
|
|
})();
|
|
var channel;
|
|
var structuredClone2 = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
|
|
// structuredClone was added in v17.0.0, but fetch supports v16.8
|
|
function structuredClone3(value, options = void 0) {
|
|
if (arguments.length === 0) {
|
|
throw new TypeError("missing argument");
|
|
}
|
|
if (!channel) {
|
|
channel = new MessageChannel();
|
|
}
|
|
channel.port1.unref();
|
|
channel.port2.unref();
|
|
channel.port1.postMessage(value, options?.transfer);
|
|
return receiveMessageOnPort(channel.port2).message;
|
|
};
|
|
module2.exports = {
|
|
DOMException: DOMException3,
|
|
structuredClone: structuredClone2,
|
|
subresource,
|
|
forbiddenMethods,
|
|
requestBodyHeader,
|
|
referrerPolicy,
|
|
requestRedirect,
|
|
requestMode,
|
|
requestCredentials,
|
|
requestCache,
|
|
redirectStatus: redirectStatus2,
|
|
corsSafeListedMethods,
|
|
nullBodyStatus,
|
|
safeMethods,
|
|
badPorts,
|
|
requestDuplex,
|
|
subresourceSet,
|
|
badPortsSet,
|
|
redirectStatusSet,
|
|
corsSafeListedMethodsSet,
|
|
safeMethodsSet,
|
|
forbiddenMethodsSet,
|
|
referrerPolicySet
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/global.js
|
|
var require_global = __commonJS({
|
|
"node_modules/undici/lib/fetch/global.js"(exports2, module2) {
|
|
"use strict";
|
|
var globalOrigin = Symbol.for("undici.globalOrigin.1");
|
|
function getGlobalOrigin() {
|
|
return globalThis[globalOrigin];
|
|
}
|
|
function setGlobalOrigin(newOrigin) {
|
|
if (newOrigin === void 0) {
|
|
Object.defineProperty(globalThis, globalOrigin, {
|
|
value: void 0,
|
|
writable: true,
|
|
enumerable: false,
|
|
configurable: false
|
|
});
|
|
return;
|
|
}
|
|
const parsedURL = new URL(newOrigin);
|
|
if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
|
|
throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
|
|
}
|
|
Object.defineProperty(globalThis, globalOrigin, {
|
|
value: parsedURL,
|
|
writable: true,
|
|
enumerable: false,
|
|
configurable: false
|
|
});
|
|
}
|
|
module2.exports = {
|
|
getGlobalOrigin,
|
|
setGlobalOrigin
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/util.js
|
|
var require_util2 = __commonJS({
|
|
"node_modules/undici/lib/fetch/util.js"(exports2, module2) {
|
|
"use strict";
|
|
var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2();
|
|
var { getGlobalOrigin } = require_global();
|
|
var { performance: performance2 } = require("perf_hooks");
|
|
var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
|
|
var assert = require("assert");
|
|
var { isUint8Array } = require("util/types");
|
|
var supportedHashes = [];
|
|
var crypto;
|
|
try {
|
|
crypto = require("crypto");
|
|
const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
|
|
supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
|
|
} catch {
|
|
}
|
|
function responseURL(response) {
|
|
const urlList = response.urlList;
|
|
const length = urlList.length;
|
|
return length === 0 ? null : urlList[length - 1].toString();
|
|
}
|
|
function responseLocationURL(response, requestFragment) {
|
|
if (!redirectStatusSet.has(response.status)) {
|
|
return null;
|
|
}
|
|
let location = response.headersList.get("location");
|
|
if (location !== null && isValidHeaderValue(location)) {
|
|
location = new URL(location, responseURL(response));
|
|
}
|
|
if (location && !location.hash) {
|
|
location.hash = requestFragment;
|
|
}
|
|
return location;
|
|
}
|
|
function requestCurrentURL(request) {
|
|
return request.urlList[request.urlList.length - 1];
|
|
}
|
|
function requestBadPort(request) {
|
|
const url = requestCurrentURL(request);
|
|
if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
|
|
return "blocked";
|
|
}
|
|
return "allowed";
|
|
}
|
|
function isErrorLike(object) {
|
|
return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
|
|
}
|
|
function isValidReasonPhrase(statusText) {
|
|
for (let i2 = 0; i2 < statusText.length; ++i2) {
|
|
const c = statusText.charCodeAt(i2);
|
|
if (!(c === 9 || // HTAB
|
|
c >= 32 && c <= 126 || // SP / VCHAR
|
|
c >= 128 && c <= 255)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isTokenCharCode(c) {
|
|
switch (c) {
|
|
case 34:
|
|
case 40:
|
|
case 41:
|
|
case 44:
|
|
case 47:
|
|
case 58:
|
|
case 59:
|
|
case 60:
|
|
case 61:
|
|
case 62:
|
|
case 63:
|
|
case 64:
|
|
case 91:
|
|
case 92:
|
|
case 93:
|
|
case 123:
|
|
case 125:
|
|
return false;
|
|
default:
|
|
return c >= 33 && c <= 126;
|
|
}
|
|
}
|
|
function isValidHTTPToken(characters) {
|
|
if (characters.length === 0) {
|
|
return false;
|
|
}
|
|
for (let i2 = 0; i2 < characters.length; ++i2) {
|
|
if (!isTokenCharCode(characters.charCodeAt(i2))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isValidHeaderName(potentialValue) {
|
|
return isValidHTTPToken(potentialValue);
|
|
}
|
|
function isValidHeaderValue(potentialValue) {
|
|
if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) {
|
|
return false;
|
|
}
|
|
if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
|
|
const { headersList } = actualResponse;
|
|
const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
|
|
let policy = "";
|
|
if (policyHeader.length > 0) {
|
|
for (let i2 = policyHeader.length; i2 !== 0; i2--) {
|
|
const token = policyHeader[i2 - 1].trim();
|
|
if (referrerPolicyTokens.has(token)) {
|
|
policy = token;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (policy !== "") {
|
|
request.referrerPolicy = policy;
|
|
}
|
|
}
|
|
function crossOriginResourcePolicyCheck() {
|
|
return "allowed";
|
|
}
|
|
function corsCheck() {
|
|
return "success";
|
|
}
|
|
function TAOCheck() {
|
|
return "success";
|
|
}
|
|
function appendFetchMetadata(httpRequest) {
|
|
let header = null;
|
|
header = httpRequest.mode;
|
|
httpRequest.headersList.set("sec-fetch-mode", header);
|
|
}
|
|
function appendRequestOriginHeader(request) {
|
|
let serializedOrigin = request.origin;
|
|
if (request.responseTainting === "cors" || request.mode === "websocket") {
|
|
if (serializedOrigin) {
|
|
request.headersList.append("origin", serializedOrigin);
|
|
}
|
|
} else if (request.method !== "GET" && request.method !== "HEAD") {
|
|
switch (request.referrerPolicy) {
|
|
case "no-referrer":
|
|
serializedOrigin = null;
|
|
break;
|
|
case "no-referrer-when-downgrade":
|
|
case "strict-origin":
|
|
case "strict-origin-when-cross-origin":
|
|
if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
|
|
serializedOrigin = null;
|
|
}
|
|
break;
|
|
case "same-origin":
|
|
if (!sameOrigin(request, requestCurrentURL(request))) {
|
|
serializedOrigin = null;
|
|
}
|
|
break;
|
|
default:
|
|
}
|
|
if (serializedOrigin) {
|
|
request.headersList.append("origin", serializedOrigin);
|
|
}
|
|
}
|
|
}
|
|
function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
|
|
return performance2.now();
|
|
}
|
|
function createOpaqueTimingInfo(timingInfo) {
|
|
return {
|
|
startTime: timingInfo.startTime ?? 0,
|
|
redirectStartTime: 0,
|
|
redirectEndTime: 0,
|
|
postRedirectStartTime: timingInfo.startTime ?? 0,
|
|
finalServiceWorkerStartTime: 0,
|
|
finalNetworkResponseStartTime: 0,
|
|
finalNetworkRequestStartTime: 0,
|
|
endTime: 0,
|
|
encodedBodySize: 0,
|
|
decodedBodySize: 0,
|
|
finalConnectionTimingInfo: null
|
|
};
|
|
}
|
|
function makePolicyContainer() {
|
|
return {
|
|
referrerPolicy: "strict-origin-when-cross-origin"
|
|
};
|
|
}
|
|
function clonePolicyContainer(policyContainer) {
|
|
return {
|
|
referrerPolicy: policyContainer.referrerPolicy
|
|
};
|
|
}
|
|
function determineRequestsReferrer2(request) {
|
|
const policy = request.referrerPolicy;
|
|
assert(policy);
|
|
let referrerSource = null;
|
|
if (request.referrer === "client") {
|
|
const globalOrigin = getGlobalOrigin();
|
|
if (!globalOrigin || globalOrigin.origin === "null") {
|
|
return "no-referrer";
|
|
}
|
|
referrerSource = new URL(globalOrigin);
|
|
} else if (request.referrer instanceof URL) {
|
|
referrerSource = request.referrer;
|
|
}
|
|
let referrerURL = stripURLForReferrer(referrerSource);
|
|
const referrerOrigin = stripURLForReferrer(referrerSource, true);
|
|
if (referrerURL.toString().length > 4096) {
|
|
referrerURL = referrerOrigin;
|
|
}
|
|
const areSameOrigin = sameOrigin(request, referrerURL);
|
|
const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url);
|
|
switch (policy) {
|
|
case "origin":
|
|
return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
|
|
case "unsafe-url":
|
|
return referrerURL;
|
|
case "same-origin":
|
|
return areSameOrigin ? referrerOrigin : "no-referrer";
|
|
case "origin-when-cross-origin":
|
|
return areSameOrigin ? referrerURL : referrerOrigin;
|
|
case "strict-origin-when-cross-origin": {
|
|
const currentURL = requestCurrentURL(request);
|
|
if (sameOrigin(referrerURL, currentURL)) {
|
|
return referrerURL;
|
|
}
|
|
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
|
|
return "no-referrer";
|
|
}
|
|
return referrerOrigin;
|
|
}
|
|
case "strict-origin":
|
|
// eslint-disable-line
|
|
/**
|
|
* 1. If referrerURL is a potentially trustworthy URL and
|
|
* request’s current URL is not a potentially trustworthy URL,
|
|
* then return no referrer.
|
|
* 2. Return referrerOrigin
|
|
*/
|
|
case "no-referrer-when-downgrade":
|
|
// eslint-disable-line
|
|
/**
|
|
* 1. If referrerURL is a potentially trustworthy URL and
|
|
* request’s current URL is not a potentially trustworthy URL,
|
|
* then return no referrer.
|
|
* 2. Return referrerOrigin
|
|
*/
|
|
default:
|
|
return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
|
|
}
|
|
}
|
|
function stripURLForReferrer(url, originOnly) {
|
|
assert(url instanceof URL);
|
|
if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") {
|
|
return "no-referrer";
|
|
}
|
|
url.username = "";
|
|
url.password = "";
|
|
url.hash = "";
|
|
if (originOnly) {
|
|
url.pathname = "";
|
|
url.search = "";
|
|
}
|
|
return url;
|
|
}
|
|
function isURLPotentiallyTrustworthy(url) {
|
|
if (!(url instanceof URL)) {
|
|
return false;
|
|
}
|
|
if (url.href === "about:blank" || url.href === "about:srcdoc") {
|
|
return true;
|
|
}
|
|
if (url.protocol === "data:") return true;
|
|
if (url.protocol === "file:") return true;
|
|
return isOriginPotentiallyTrustworthy2(url.origin);
|
|
function isOriginPotentiallyTrustworthy2(origin) {
|
|
if (origin == null || origin === "null") return false;
|
|
const originAsURL = new URL(origin);
|
|
if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
|
|
return true;
|
|
}
|
|
if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function bytesMatch(bytes, metadataList) {
|
|
if (crypto === void 0) {
|
|
return true;
|
|
}
|
|
const parsedMetadata = parseMetadata(metadataList);
|
|
if (parsedMetadata === "no metadata") {
|
|
return true;
|
|
}
|
|
if (parsedMetadata.length === 0) {
|
|
return true;
|
|
}
|
|
const strongest = getStrongestMetadata(parsedMetadata);
|
|
const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest);
|
|
for (const item of metadata) {
|
|
const algorithm = item.algo;
|
|
const expectedValue = item.hash;
|
|
let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
|
|
if (actualValue[actualValue.length - 1] === "=") {
|
|
if (actualValue[actualValue.length - 2] === "=") {
|
|
actualValue = actualValue.slice(0, -2);
|
|
} else {
|
|
actualValue = actualValue.slice(0, -1);
|
|
}
|
|
}
|
|
if (compareBase64Mixed(actualValue, expectedValue)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;
|
|
function parseMetadata(metadata) {
|
|
const result = [];
|
|
let empty = true;
|
|
for (const token of metadata.split(" ")) {
|
|
empty = false;
|
|
const parsedToken = parseHashWithOptions.exec(token);
|
|
if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) {
|
|
continue;
|
|
}
|
|
const algorithm = parsedToken.groups.algo.toLowerCase();
|
|
if (supportedHashes.includes(algorithm)) {
|
|
result.push(parsedToken.groups);
|
|
}
|
|
}
|
|
if (empty === true) {
|
|
return "no metadata";
|
|
}
|
|
return result;
|
|
}
|
|
function getStrongestMetadata(metadataList) {
|
|
let algorithm = metadataList[0].algo;
|
|
if (algorithm[3] === "5") {
|
|
return algorithm;
|
|
}
|
|
for (let i2 = 1; i2 < metadataList.length; ++i2) {
|
|
const metadata = metadataList[i2];
|
|
if (metadata.algo[3] === "5") {
|
|
algorithm = "sha512";
|
|
break;
|
|
} else if (algorithm[3] === "3") {
|
|
continue;
|
|
} else if (metadata.algo[3] === "3") {
|
|
algorithm = "sha384";
|
|
}
|
|
}
|
|
return algorithm;
|
|
}
|
|
function filterMetadataListByAlgorithm(metadataList, algorithm) {
|
|
if (metadataList.length === 1) {
|
|
return metadataList;
|
|
}
|
|
let pos = 0;
|
|
for (let i2 = 0; i2 < metadataList.length; ++i2) {
|
|
if (metadataList[i2].algo === algorithm) {
|
|
metadataList[pos++] = metadataList[i2];
|
|
}
|
|
}
|
|
metadataList.length = pos;
|
|
return metadataList;
|
|
}
|
|
function compareBase64Mixed(actualValue, expectedValue) {
|
|
if (actualValue.length !== expectedValue.length) {
|
|
return false;
|
|
}
|
|
for (let i2 = 0; i2 < actualValue.length; ++i2) {
|
|
if (actualValue[i2] !== expectedValue[i2]) {
|
|
if (actualValue[i2] === "+" && expectedValue[i2] === "-" || actualValue[i2] === "/" && expectedValue[i2] === "_") {
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
|
|
}
|
|
function sameOrigin(A2, B) {
|
|
if (A2.origin === B.origin && A2.origin === "null") {
|
|
return true;
|
|
}
|
|
if (A2.protocol === B.protocol && A2.hostname === B.hostname && A2.port === B.port) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function createDeferredPromise() {
|
|
let res;
|
|
let rej;
|
|
const promise = new Promise((resolve, reject) => {
|
|
res = resolve;
|
|
rej = reject;
|
|
});
|
|
return { promise, resolve: res, reject: rej };
|
|
}
|
|
function isAborted(fetchParams) {
|
|
return fetchParams.controller.state === "aborted";
|
|
}
|
|
function isCancelled(fetchParams) {
|
|
return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
|
|
}
|
|
var normalizeMethodRecord = {
|
|
delete: "DELETE",
|
|
DELETE: "DELETE",
|
|
get: "GET",
|
|
GET: "GET",
|
|
head: "HEAD",
|
|
HEAD: "HEAD",
|
|
options: "OPTIONS",
|
|
OPTIONS: "OPTIONS",
|
|
post: "POST",
|
|
POST: "POST",
|
|
put: "PUT",
|
|
PUT: "PUT"
|
|
};
|
|
Object.setPrototypeOf(normalizeMethodRecord, null);
|
|
function normalizeMethod(method) {
|
|
return normalizeMethodRecord[method.toLowerCase()] ?? method;
|
|
}
|
|
function serializeJavascriptValueToJSONString(value) {
|
|
const result = JSON.stringify(value);
|
|
if (result === void 0) {
|
|
throw new TypeError("Value is not JSON serializable");
|
|
}
|
|
assert(typeof result === "string");
|
|
return result;
|
|
}
|
|
var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
|
|
function makeIterator(iterator, name, kind) {
|
|
const object = {
|
|
index: 0,
|
|
kind,
|
|
target: iterator
|
|
};
|
|
const i2 = {
|
|
next() {
|
|
if (Object.getPrototypeOf(this) !== i2) {
|
|
throw new TypeError(
|
|
`'next' called on an object that does not implement interface ${name} Iterator.`
|
|
);
|
|
}
|
|
const { index, kind: kind2, target } = object;
|
|
const values = target();
|
|
const len = values.length;
|
|
if (index >= len) {
|
|
return { value: void 0, done: true };
|
|
}
|
|
const pair = values[index];
|
|
object.index = index + 1;
|
|
return iteratorResult(pair, kind2);
|
|
},
|
|
// The class string of an iterator prototype object for a given interface is the
|
|
// result of concatenating the identifier of the interface and the string " Iterator".
|
|
[Symbol.toStringTag]: `${name} Iterator`
|
|
};
|
|
Object.setPrototypeOf(i2, esIteratorPrototype);
|
|
return Object.setPrototypeOf({}, i2);
|
|
}
|
|
function iteratorResult(pair, kind) {
|
|
let result;
|
|
switch (kind) {
|
|
case "key": {
|
|
result = pair[0];
|
|
break;
|
|
}
|
|
case "value": {
|
|
result = pair[1];
|
|
break;
|
|
}
|
|
case "key+value": {
|
|
result = pair;
|
|
break;
|
|
}
|
|
}
|
|
return { value: result, done: false };
|
|
}
|
|
async function fullyReadBody(body, processBody, processBodyError) {
|
|
const successSteps = processBody;
|
|
const errorSteps = processBodyError;
|
|
let reader;
|
|
try {
|
|
reader = body.stream.getReader();
|
|
} catch (e2) {
|
|
errorSteps(e2);
|
|
return;
|
|
}
|
|
try {
|
|
const result = await readAllBytes(reader);
|
|
successSteps(result);
|
|
} catch (e2) {
|
|
errorSteps(e2);
|
|
}
|
|
}
|
|
var ReadableStream2 = globalThis.ReadableStream;
|
|
function isReadableStreamLike(stream) {
|
|
if (!ReadableStream2) {
|
|
ReadableStream2 = require("stream/web").ReadableStream;
|
|
}
|
|
return stream instanceof ReadableStream2 || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
|
|
}
|
|
var MAXIMUM_ARGUMENT_LENGTH = 65535;
|
|
function isomorphicDecode(input) {
|
|
if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
|
|
return String.fromCharCode(...input);
|
|
}
|
|
return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
|
|
}
|
|
function readableStreamClose(controller) {
|
|
try {
|
|
controller.close();
|
|
} catch (err) {
|
|
if (!err.message.includes("Controller is already closed")) {
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
function isomorphicEncode(input) {
|
|
for (let i2 = 0; i2 < input.length; i2++) {
|
|
assert(input.charCodeAt(i2) <= 255);
|
|
}
|
|
return input;
|
|
}
|
|
async function readAllBytes(reader) {
|
|
const bytes = [];
|
|
let byteLength = 0;
|
|
while (true) {
|
|
const { done, value: chunk } = await reader.read();
|
|
if (done) {
|
|
return Buffer.concat(bytes, byteLength);
|
|
}
|
|
if (!isUint8Array(chunk)) {
|
|
throw new TypeError("Received non-Uint8Array chunk");
|
|
}
|
|
bytes.push(chunk);
|
|
byteLength += chunk.length;
|
|
}
|
|
}
|
|
function urlIsLocal(url) {
|
|
assert("protocol" in url);
|
|
const protocol = url.protocol;
|
|
return protocol === "about:" || protocol === "blob:" || protocol === "data:";
|
|
}
|
|
function urlHasHttpsScheme(url) {
|
|
if (typeof url === "string") {
|
|
return url.startsWith("https:");
|
|
}
|
|
return url.protocol === "https:";
|
|
}
|
|
function urlIsHttpHttpsScheme(url) {
|
|
assert("protocol" in url);
|
|
const protocol = url.protocol;
|
|
return protocol === "http:" || protocol === "https:";
|
|
}
|
|
var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
|
|
module2.exports = {
|
|
isAborted,
|
|
isCancelled,
|
|
createDeferredPromise,
|
|
ReadableStreamFrom,
|
|
toUSVString,
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL,
|
|
coarsenedSharedCurrentTime,
|
|
determineRequestsReferrer: determineRequestsReferrer2,
|
|
makePolicyContainer,
|
|
clonePolicyContainer,
|
|
appendFetchMetadata,
|
|
appendRequestOriginHeader,
|
|
TAOCheck,
|
|
corsCheck,
|
|
crossOriginResourcePolicyCheck,
|
|
createOpaqueTimingInfo,
|
|
setRequestReferrerPolicyOnRedirect,
|
|
isValidHTTPToken,
|
|
requestBadPort,
|
|
requestCurrentURL,
|
|
responseURL,
|
|
responseLocationURL,
|
|
isBlobLike,
|
|
isURLPotentiallyTrustworthy,
|
|
isValidReasonPhrase,
|
|
sameOrigin,
|
|
normalizeMethod,
|
|
serializeJavascriptValueToJSONString,
|
|
makeIterator,
|
|
isValidHeaderName,
|
|
isValidHeaderValue,
|
|
hasOwn,
|
|
isErrorLike,
|
|
fullyReadBody,
|
|
bytesMatch,
|
|
isReadableStreamLike,
|
|
readableStreamClose,
|
|
isomorphicEncode,
|
|
isomorphicDecode,
|
|
urlIsLocal,
|
|
urlHasHttpsScheme,
|
|
urlIsHttpHttpsScheme,
|
|
readAllBytes,
|
|
normalizeMethodRecord,
|
|
parseMetadata
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/symbols.js
|
|
var require_symbols2 = __commonJS({
|
|
"node_modules/undici/lib/fetch/symbols.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = {
|
|
kUrl: Symbol("url"),
|
|
kHeaders: Symbol("headers"),
|
|
kSignal: Symbol("signal"),
|
|
kState: Symbol("state"),
|
|
kGuard: Symbol("guard"),
|
|
kRealm: Symbol("realm")
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/webidl.js
|
|
var require_webidl = __commonJS({
|
|
"node_modules/undici/lib/fetch/webidl.js"(exports2, module2) {
|
|
"use strict";
|
|
var { types: types3 } = require("util");
|
|
var { hasOwn, toUSVString } = require_util2();
|
|
var webidl = {};
|
|
webidl.converters = {};
|
|
webidl.util = {};
|
|
webidl.errors = {};
|
|
webidl.errors.exception = function(message) {
|
|
return new TypeError(`${message.header}: ${message.message}`);
|
|
};
|
|
webidl.errors.conversionFailed = function(context) {
|
|
const plural = context.types.length === 1 ? "" : " one of";
|
|
const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`;
|
|
return webidl.errors.exception({
|
|
header: context.prefix,
|
|
message
|
|
});
|
|
};
|
|
webidl.errors.invalidArgument = function(context) {
|
|
return webidl.errors.exception({
|
|
header: context.prefix,
|
|
message: `"${context.value}" is an invalid ${context.type}.`
|
|
});
|
|
};
|
|
webidl.brandCheck = function(V, I, opts = void 0) {
|
|
if (opts?.strict !== false && !(V instanceof I)) {
|
|
throw new TypeError("Illegal invocation");
|
|
} else {
|
|
return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag];
|
|
}
|
|
};
|
|
webidl.argumentLengthCheck = function({ length }, min, ctx) {
|
|
if (length < min) {
|
|
throw webidl.errors.exception({
|
|
message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
|
|
...ctx
|
|
});
|
|
}
|
|
};
|
|
webidl.illegalConstructor = function() {
|
|
throw webidl.errors.exception({
|
|
header: "TypeError",
|
|
message: "Illegal constructor"
|
|
});
|
|
};
|
|
webidl.util.Type = function(V) {
|
|
switch (typeof V) {
|
|
case "undefined":
|
|
return "Undefined";
|
|
case "boolean":
|
|
return "Boolean";
|
|
case "string":
|
|
return "String";
|
|
case "symbol":
|
|
return "Symbol";
|
|
case "number":
|
|
return "Number";
|
|
case "bigint":
|
|
return "BigInt";
|
|
case "function":
|
|
case "object": {
|
|
if (V === null) {
|
|
return "Null";
|
|
}
|
|
return "Object";
|
|
}
|
|
}
|
|
};
|
|
webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) {
|
|
let upperBound;
|
|
let lowerBound;
|
|
if (bitLength === 64) {
|
|
upperBound = Math.pow(2, 53) - 1;
|
|
if (signedness === "unsigned") {
|
|
lowerBound = 0;
|
|
} else {
|
|
lowerBound = Math.pow(-2, 53) + 1;
|
|
}
|
|
} else if (signedness === "unsigned") {
|
|
lowerBound = 0;
|
|
upperBound = Math.pow(2, bitLength) - 1;
|
|
} else {
|
|
lowerBound = Math.pow(-2, bitLength) - 1;
|
|
upperBound = Math.pow(2, bitLength - 1) - 1;
|
|
}
|
|
let x2 = Number(V);
|
|
if (x2 === 0) {
|
|
x2 = 0;
|
|
}
|
|
if (opts.enforceRange === true) {
|
|
if (Number.isNaN(x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
|
|
throw webidl.errors.exception({
|
|
header: "Integer conversion",
|
|
message: `Could not convert ${V} to an integer.`
|
|
});
|
|
}
|
|
x2 = webidl.util.IntegerPart(x2);
|
|
if (x2 < lowerBound || x2 > upperBound) {
|
|
throw webidl.errors.exception({
|
|
header: "Integer conversion",
|
|
message: `Value must be between ${lowerBound}-${upperBound}, got ${x2}.`
|
|
});
|
|
}
|
|
return x2;
|
|
}
|
|
if (!Number.isNaN(x2) && opts.clamp === true) {
|
|
x2 = Math.min(Math.max(x2, lowerBound), upperBound);
|
|
if (Math.floor(x2) % 2 === 0) {
|
|
x2 = Math.floor(x2);
|
|
} else {
|
|
x2 = Math.ceil(x2);
|
|
}
|
|
return x2;
|
|
}
|
|
if (Number.isNaN(x2) || x2 === 0 && Object.is(0, x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
|
|
return 0;
|
|
}
|
|
x2 = webidl.util.IntegerPart(x2);
|
|
x2 = x2 % Math.pow(2, bitLength);
|
|
if (signedness === "signed" && x2 >= Math.pow(2, bitLength) - 1) {
|
|
return x2 - Math.pow(2, bitLength);
|
|
}
|
|
return x2;
|
|
};
|
|
webidl.util.IntegerPart = function(n) {
|
|
const r2 = Math.floor(Math.abs(n));
|
|
if (n < 0) {
|
|
return -1 * r2;
|
|
}
|
|
return r2;
|
|
};
|
|
webidl.sequenceConverter = function(converter) {
|
|
return (V) => {
|
|
if (webidl.util.Type(V) !== "Object") {
|
|
throw webidl.errors.exception({
|
|
header: "Sequence",
|
|
message: `Value of type ${webidl.util.Type(V)} is not an Object.`
|
|
});
|
|
}
|
|
const method = V?.[Symbol.iterator]?.();
|
|
const seq = [];
|
|
if (method === void 0 || typeof method.next !== "function") {
|
|
throw webidl.errors.exception({
|
|
header: "Sequence",
|
|
message: "Object is not an iterator."
|
|
});
|
|
}
|
|
while (true) {
|
|
const { done, value } = method.next();
|
|
if (done) {
|
|
break;
|
|
}
|
|
seq.push(converter(value));
|
|
}
|
|
return seq;
|
|
};
|
|
};
|
|
webidl.recordConverter = function(keyConverter, valueConverter) {
|
|
return (O) => {
|
|
if (webidl.util.Type(O) !== "Object") {
|
|
throw webidl.errors.exception({
|
|
header: "Record",
|
|
message: `Value of type ${webidl.util.Type(O)} is not an Object.`
|
|
});
|
|
}
|
|
const result = {};
|
|
if (!types3.isProxy(O)) {
|
|
const keys2 = Object.keys(O);
|
|
for (const key of keys2) {
|
|
const typedKey = keyConverter(key);
|
|
const typedValue = valueConverter(O[key]);
|
|
result[typedKey] = typedValue;
|
|
}
|
|
return result;
|
|
}
|
|
const keys = Reflect.ownKeys(O);
|
|
for (const key of keys) {
|
|
const desc = Reflect.getOwnPropertyDescriptor(O, key);
|
|
if (desc?.enumerable) {
|
|
const typedKey = keyConverter(key);
|
|
const typedValue = valueConverter(O[key]);
|
|
result[typedKey] = typedValue;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
webidl.interfaceConverter = function(i2) {
|
|
return (V, opts = {}) => {
|
|
if (opts.strict !== false && !(V instanceof i2)) {
|
|
throw webidl.errors.exception({
|
|
header: i2.name,
|
|
message: `Expected ${V} to be an instance of ${i2.name}.`
|
|
});
|
|
}
|
|
return V;
|
|
};
|
|
};
|
|
webidl.dictionaryConverter = function(converters) {
|
|
return (dictionary) => {
|
|
const type = webidl.util.Type(dictionary);
|
|
const dict = {};
|
|
if (type === "Null" || type === "Undefined") {
|
|
return dict;
|
|
} else if (type !== "Object") {
|
|
throw webidl.errors.exception({
|
|
header: "Dictionary",
|
|
message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
|
|
});
|
|
}
|
|
for (const options of converters) {
|
|
const { key, defaultValue, required, converter } = options;
|
|
if (required === true) {
|
|
if (!hasOwn(dictionary, key)) {
|
|
throw webidl.errors.exception({
|
|
header: "Dictionary",
|
|
message: `Missing required key "${key}".`
|
|
});
|
|
}
|
|
}
|
|
let value = dictionary[key];
|
|
const hasDefault = hasOwn(options, "defaultValue");
|
|
if (hasDefault && value !== null) {
|
|
value = value ?? defaultValue;
|
|
}
|
|
if (required || hasDefault || value !== void 0) {
|
|
value = converter(value);
|
|
if (options.allowedValues && !options.allowedValues.includes(value)) {
|
|
throw webidl.errors.exception({
|
|
header: "Dictionary",
|
|
message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
|
|
});
|
|
}
|
|
dict[key] = value;
|
|
}
|
|
}
|
|
return dict;
|
|
};
|
|
};
|
|
webidl.nullableConverter = function(converter) {
|
|
return (V) => {
|
|
if (V === null) {
|
|
return V;
|
|
}
|
|
return converter(V);
|
|
};
|
|
};
|
|
webidl.converters.DOMString = function(V, opts = {}) {
|
|
if (V === null && opts.legacyNullToEmptyString) {
|
|
return "";
|
|
}
|
|
if (typeof V === "symbol") {
|
|
throw new TypeError("Could not convert argument of type symbol to string.");
|
|
}
|
|
return String(V);
|
|
};
|
|
webidl.converters.ByteString = function(V) {
|
|
const x2 = webidl.converters.DOMString(V);
|
|
for (let index = 0; index < x2.length; index++) {
|
|
if (x2.charCodeAt(index) > 255) {
|
|
throw new TypeError(
|
|
`Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x2.charCodeAt(index)} which is greater than 255.`
|
|
);
|
|
}
|
|
}
|
|
return x2;
|
|
};
|
|
webidl.converters.USVString = toUSVString;
|
|
webidl.converters.boolean = function(V) {
|
|
const x2 = Boolean(V);
|
|
return x2;
|
|
};
|
|
webidl.converters.any = function(V) {
|
|
return V;
|
|
};
|
|
webidl.converters["long long"] = function(V) {
|
|
const x2 = webidl.util.ConvertToInt(V, 64, "signed");
|
|
return x2;
|
|
};
|
|
webidl.converters["unsigned long long"] = function(V) {
|
|
const x2 = webidl.util.ConvertToInt(V, 64, "unsigned");
|
|
return x2;
|
|
};
|
|
webidl.converters["unsigned long"] = function(V) {
|
|
const x2 = webidl.util.ConvertToInt(V, 32, "unsigned");
|
|
return x2;
|
|
};
|
|
webidl.converters["unsigned short"] = function(V, opts) {
|
|
const x2 = webidl.util.ConvertToInt(V, 16, "unsigned", opts);
|
|
return x2;
|
|
};
|
|
webidl.converters.ArrayBuffer = function(V, opts = {}) {
|
|
if (webidl.util.Type(V) !== "Object" || !types3.isAnyArrayBuffer(V)) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: `${V}`,
|
|
argument: `${V}`,
|
|
types: ["ArrayBuffer"]
|
|
});
|
|
}
|
|
if (opts.allowShared === false && types3.isSharedArrayBuffer(V)) {
|
|
throw webidl.errors.exception({
|
|
header: "ArrayBuffer",
|
|
message: "SharedArrayBuffer is not allowed."
|
|
});
|
|
}
|
|
return V;
|
|
};
|
|
webidl.converters.TypedArray = function(V, T, opts = {}) {
|
|
if (webidl.util.Type(V) !== "Object" || !types3.isTypedArray(V) || V.constructor.name !== T.name) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: `${T.name}`,
|
|
argument: `${V}`,
|
|
types: [T.name]
|
|
});
|
|
}
|
|
if (opts.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
|
|
throw webidl.errors.exception({
|
|
header: "ArrayBuffer",
|
|
message: "SharedArrayBuffer is not allowed."
|
|
});
|
|
}
|
|
return V;
|
|
};
|
|
webidl.converters.DataView = function(V, opts = {}) {
|
|
if (webidl.util.Type(V) !== "Object" || !types3.isDataView(V)) {
|
|
throw webidl.errors.exception({
|
|
header: "DataView",
|
|
message: "Object is not a DataView."
|
|
});
|
|
}
|
|
if (opts.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
|
|
throw webidl.errors.exception({
|
|
header: "ArrayBuffer",
|
|
message: "SharedArrayBuffer is not allowed."
|
|
});
|
|
}
|
|
return V;
|
|
};
|
|
webidl.converters.BufferSource = function(V, opts = {}) {
|
|
if (types3.isAnyArrayBuffer(V)) {
|
|
return webidl.converters.ArrayBuffer(V, opts);
|
|
}
|
|
if (types3.isTypedArray(V)) {
|
|
return webidl.converters.TypedArray(V, V.constructor);
|
|
}
|
|
if (types3.isDataView(V)) {
|
|
return webidl.converters.DataView(V, opts);
|
|
}
|
|
throw new TypeError(`Could not convert ${V} to a BufferSource.`);
|
|
};
|
|
webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
|
|
webidl.converters.ByteString
|
|
);
|
|
webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
|
|
webidl.converters["sequence<ByteString>"]
|
|
);
|
|
webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
|
|
webidl.converters.ByteString,
|
|
webidl.converters.ByteString
|
|
);
|
|
module2.exports = {
|
|
webidl
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/dataURL.js
|
|
var require_dataURL = __commonJS({
|
|
"node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) {
|
|
var assert = require("assert");
|
|
var { atob: atob2 } = require("buffer");
|
|
var { isomorphicDecode } = require_util2();
|
|
var encoder = new TextEncoder();
|
|
var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/;
|
|
var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
|
|
var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
|
|
function dataURLProcessor(dataURL) {
|
|
assert(dataURL.protocol === "data:");
|
|
let input = URLSerializer(dataURL, true);
|
|
input = input.slice(5);
|
|
const position = { position: 0 };
|
|
let mimeType = collectASequenceOfCodePointsFast(
|
|
",",
|
|
input,
|
|
position
|
|
);
|
|
const mimeTypeLength = mimeType.length;
|
|
mimeType = removeASCIIWhitespace(mimeType, true, true);
|
|
if (position.position >= input.length) {
|
|
return "failure";
|
|
}
|
|
position.position++;
|
|
const encodedBody = input.slice(mimeTypeLength + 1);
|
|
let body = stringPercentDecode(encodedBody);
|
|
if (/;(\u0020){0,}base64$/i.test(mimeType)) {
|
|
const stringBody = isomorphicDecode(body);
|
|
body = forgivingBase64(stringBody);
|
|
if (body === "failure") {
|
|
return "failure";
|
|
}
|
|
mimeType = mimeType.slice(0, -6);
|
|
mimeType = mimeType.replace(/(\u0020)+$/, "");
|
|
mimeType = mimeType.slice(0, -1);
|
|
}
|
|
if (mimeType.startsWith(";")) {
|
|
mimeType = "text/plain" + mimeType;
|
|
}
|
|
let mimeTypeRecord = parseMIMEType(mimeType);
|
|
if (mimeTypeRecord === "failure") {
|
|
mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
|
|
}
|
|
return { mimeType: mimeTypeRecord, body };
|
|
}
|
|
function URLSerializer(url, excludeFragment = false) {
|
|
if (!excludeFragment) {
|
|
return url.href;
|
|
}
|
|
const href = url.href;
|
|
const hashLength = url.hash.length;
|
|
return hashLength === 0 ? href : href.substring(0, href.length - hashLength);
|
|
}
|
|
function collectASequenceOfCodePoints(condition, input, position) {
|
|
let result = "";
|
|
while (position.position < input.length && condition(input[position.position])) {
|
|
result += input[position.position];
|
|
position.position++;
|
|
}
|
|
return result;
|
|
}
|
|
function collectASequenceOfCodePointsFast(char, input, position) {
|
|
const idx = input.indexOf(char, position.position);
|
|
const start = position.position;
|
|
if (idx === -1) {
|
|
position.position = input.length;
|
|
return input.slice(start);
|
|
}
|
|
position.position = idx;
|
|
return input.slice(start, position.position);
|
|
}
|
|
function stringPercentDecode(input) {
|
|
const bytes = encoder.encode(input);
|
|
return percentDecode(bytes);
|
|
}
|
|
function percentDecode(input) {
|
|
const output = [];
|
|
for (let i2 = 0; i2 < input.length; i2++) {
|
|
const byte = input[i2];
|
|
if (byte !== 37) {
|
|
output.push(byte);
|
|
} else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i2 + 1], input[i2 + 2]))) {
|
|
output.push(37);
|
|
} else {
|
|
const nextTwoBytes = String.fromCharCode(input[i2 + 1], input[i2 + 2]);
|
|
const bytePoint = Number.parseInt(nextTwoBytes, 16);
|
|
output.push(bytePoint);
|
|
i2 += 2;
|
|
}
|
|
}
|
|
return Uint8Array.from(output);
|
|
}
|
|
function parseMIMEType(input) {
|
|
input = removeHTTPWhitespace(input, true, true);
|
|
const position = { position: 0 };
|
|
const type = collectASequenceOfCodePointsFast(
|
|
"/",
|
|
input,
|
|
position
|
|
);
|
|
if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
|
|
return "failure";
|
|
}
|
|
if (position.position > input.length) {
|
|
return "failure";
|
|
}
|
|
position.position++;
|
|
let subtype = collectASequenceOfCodePointsFast(
|
|
";",
|
|
input,
|
|
position
|
|
);
|
|
subtype = removeHTTPWhitespace(subtype, false, true);
|
|
if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
|
|
return "failure";
|
|
}
|
|
const typeLowercase = type.toLowerCase();
|
|
const subtypeLowercase = subtype.toLowerCase();
|
|
const mimeType = {
|
|
type: typeLowercase,
|
|
subtype: subtypeLowercase,
|
|
/** @type {Map<string, string>} */
|
|
parameters: /* @__PURE__ */ new Map(),
|
|
// https://mimesniff.spec.whatwg.org/#mime-type-essence
|
|
essence: `${typeLowercase}/${subtypeLowercase}`
|
|
};
|
|
while (position.position < input.length) {
|
|
position.position++;
|
|
collectASequenceOfCodePoints(
|
|
// https://fetch.spec.whatwg.org/#http-whitespace
|
|
(char) => HTTP_WHITESPACE_REGEX.test(char),
|
|
input,
|
|
position
|
|
);
|
|
let parameterName = collectASequenceOfCodePoints(
|
|
(char) => char !== ";" && char !== "=",
|
|
input,
|
|
position
|
|
);
|
|
parameterName = parameterName.toLowerCase();
|
|
if (position.position < input.length) {
|
|
if (input[position.position] === ";") {
|
|
continue;
|
|
}
|
|
position.position++;
|
|
}
|
|
if (position.position > input.length) {
|
|
break;
|
|
}
|
|
let parameterValue = null;
|
|
if (input[position.position] === '"') {
|
|
parameterValue = collectAnHTTPQuotedString(input, position, true);
|
|
collectASequenceOfCodePointsFast(
|
|
";",
|
|
input,
|
|
position
|
|
);
|
|
} else {
|
|
parameterValue = collectASequenceOfCodePointsFast(
|
|
";",
|
|
input,
|
|
position
|
|
);
|
|
parameterValue = removeHTTPWhitespace(parameterValue, false, true);
|
|
if (parameterValue.length === 0) {
|
|
continue;
|
|
}
|
|
}
|
|
if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
|
|
mimeType.parameters.set(parameterName, parameterValue);
|
|
}
|
|
}
|
|
return mimeType;
|
|
}
|
|
function forgivingBase64(data) {
|
|
data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
|
|
if (data.length % 4 === 0) {
|
|
data = data.replace(/=?=$/, "");
|
|
}
|
|
if (data.length % 4 === 1) {
|
|
return "failure";
|
|
}
|
|
if (/[^+/0-9A-Za-z]/.test(data)) {
|
|
return "failure";
|
|
}
|
|
const binary = atob2(data);
|
|
const bytes = new Uint8Array(binary.length);
|
|
for (let byte = 0; byte < binary.length; byte++) {
|
|
bytes[byte] = binary.charCodeAt(byte);
|
|
}
|
|
return bytes;
|
|
}
|
|
function collectAnHTTPQuotedString(input, position, extractValue) {
|
|
const positionStart = position.position;
|
|
let value = "";
|
|
assert(input[position.position] === '"');
|
|
position.position++;
|
|
while (true) {
|
|
value += collectASequenceOfCodePoints(
|
|
(char) => char !== '"' && char !== "\\",
|
|
input,
|
|
position
|
|
);
|
|
if (position.position >= input.length) {
|
|
break;
|
|
}
|
|
const quoteOrBackslash = input[position.position];
|
|
position.position++;
|
|
if (quoteOrBackslash === "\\") {
|
|
if (position.position >= input.length) {
|
|
value += "\\";
|
|
break;
|
|
}
|
|
value += input[position.position];
|
|
position.position++;
|
|
} else {
|
|
assert(quoteOrBackslash === '"');
|
|
break;
|
|
}
|
|
}
|
|
if (extractValue) {
|
|
return value;
|
|
}
|
|
return input.slice(positionStart, position.position);
|
|
}
|
|
function serializeAMimeType(mimeType) {
|
|
assert(mimeType !== "failure");
|
|
const { parameters, essence } = mimeType;
|
|
let serialization = essence;
|
|
for (let [name, value] of parameters.entries()) {
|
|
serialization += ";";
|
|
serialization += name;
|
|
serialization += "=";
|
|
if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
|
|
value = value.replace(/(\\|")/g, "\\$1");
|
|
value = '"' + value;
|
|
value += '"';
|
|
}
|
|
serialization += value;
|
|
}
|
|
return serialization;
|
|
}
|
|
function isHTTPWhiteSpace(char) {
|
|
return char === "\r" || char === "\n" || char === " " || char === " ";
|
|
}
|
|
function removeHTTPWhitespace(str, leading = true, trailing = true) {
|
|
let lead = 0;
|
|
let trail = str.length - 1;
|
|
if (leading) {
|
|
for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ;
|
|
}
|
|
if (trailing) {
|
|
for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ;
|
|
}
|
|
return str.slice(lead, trail + 1);
|
|
}
|
|
function isASCIIWhitespace(char) {
|
|
return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " ";
|
|
}
|
|
function removeASCIIWhitespace(str, leading = true, trailing = true) {
|
|
let lead = 0;
|
|
let trail = str.length - 1;
|
|
if (leading) {
|
|
for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ;
|
|
}
|
|
if (trailing) {
|
|
for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ;
|
|
}
|
|
return str.slice(lead, trail + 1);
|
|
}
|
|
module2.exports = {
|
|
dataURLProcessor,
|
|
URLSerializer,
|
|
collectASequenceOfCodePoints,
|
|
collectASequenceOfCodePointsFast,
|
|
stringPercentDecode,
|
|
parseMIMEType,
|
|
collectAnHTTPQuotedString,
|
|
serializeAMimeType
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/file.js
|
|
var require_file = __commonJS({
|
|
"node_modules/undici/lib/fetch/file.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Blob: Blob4, File: NativeFile } = require("buffer");
|
|
var { types: types3 } = require("util");
|
|
var { kState } = require_symbols2();
|
|
var { isBlobLike } = require_util2();
|
|
var { webidl } = require_webidl();
|
|
var { parseMIMEType, serializeAMimeType } = require_dataURL();
|
|
var { kEnumerableProperty } = require_util();
|
|
var encoder = new TextEncoder();
|
|
var File3 = class _File2 extends Blob4 {
|
|
constructor(fileBits, fileName, options = {}) {
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
|
|
fileBits = webidl.converters["sequence<BlobPart>"](fileBits);
|
|
fileName = webidl.converters.USVString(fileName);
|
|
options = webidl.converters.FilePropertyBag(options);
|
|
const n = fileName;
|
|
let t2 = options.type;
|
|
let d;
|
|
substep: {
|
|
if (t2) {
|
|
t2 = parseMIMEType(t2);
|
|
if (t2 === "failure") {
|
|
t2 = "";
|
|
break substep;
|
|
}
|
|
t2 = serializeAMimeType(t2).toLowerCase();
|
|
}
|
|
d = options.lastModified;
|
|
}
|
|
super(processBlobParts(fileBits, options), { type: t2 });
|
|
this[kState] = {
|
|
name: n,
|
|
lastModified: d,
|
|
type: t2
|
|
};
|
|
}
|
|
get name() {
|
|
webidl.brandCheck(this, _File2);
|
|
return this[kState].name;
|
|
}
|
|
get lastModified() {
|
|
webidl.brandCheck(this, _File2);
|
|
return this[kState].lastModified;
|
|
}
|
|
get type() {
|
|
webidl.brandCheck(this, _File2);
|
|
return this[kState].type;
|
|
}
|
|
};
|
|
var FileLike = class _FileLike {
|
|
constructor(blobLike, fileName, options = {}) {
|
|
const n = fileName;
|
|
const t2 = options.type;
|
|
const d = options.lastModified ?? Date.now();
|
|
this[kState] = {
|
|
blobLike,
|
|
name: n,
|
|
type: t2,
|
|
lastModified: d
|
|
};
|
|
}
|
|
stream(...args) {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.stream(...args);
|
|
}
|
|
arrayBuffer(...args) {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.arrayBuffer(...args);
|
|
}
|
|
slice(...args) {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.slice(...args);
|
|
}
|
|
text(...args) {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.text(...args);
|
|
}
|
|
get size() {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.size;
|
|
}
|
|
get type() {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].blobLike.type;
|
|
}
|
|
get name() {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].name;
|
|
}
|
|
get lastModified() {
|
|
webidl.brandCheck(this, _FileLike);
|
|
return this[kState].lastModified;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "File";
|
|
}
|
|
};
|
|
Object.defineProperties(File3.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "File",
|
|
configurable: true
|
|
},
|
|
name: kEnumerableProperty,
|
|
lastModified: kEnumerableProperty
|
|
});
|
|
webidl.converters.Blob = webidl.interfaceConverter(Blob4);
|
|
webidl.converters.BlobPart = function(V, opts) {
|
|
if (webidl.util.Type(V) === "Object") {
|
|
if (isBlobLike(V)) {
|
|
return webidl.converters.Blob(V, { strict: false });
|
|
}
|
|
if (ArrayBuffer.isView(V) || types3.isAnyArrayBuffer(V)) {
|
|
return webidl.converters.BufferSource(V, opts);
|
|
}
|
|
}
|
|
return webidl.converters.USVString(V, opts);
|
|
};
|
|
webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter(
|
|
webidl.converters.BlobPart
|
|
);
|
|
webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
|
|
{
|
|
key: "lastModified",
|
|
converter: webidl.converters["long long"],
|
|
get defaultValue() {
|
|
return Date.now();
|
|
}
|
|
},
|
|
{
|
|
key: "type",
|
|
converter: webidl.converters.DOMString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "endings",
|
|
converter: (value) => {
|
|
value = webidl.converters.DOMString(value);
|
|
value = value.toLowerCase();
|
|
if (value !== "native") {
|
|
value = "transparent";
|
|
}
|
|
return value;
|
|
},
|
|
defaultValue: "transparent"
|
|
}
|
|
]);
|
|
function processBlobParts(parts, options) {
|
|
const bytes = [];
|
|
for (const element of parts) {
|
|
if (typeof element === "string") {
|
|
let s2 = element;
|
|
if (options.endings === "native") {
|
|
s2 = convertLineEndingsNative(s2);
|
|
}
|
|
bytes.push(encoder.encode(s2));
|
|
} else if (types3.isAnyArrayBuffer(element) || types3.isTypedArray(element)) {
|
|
if (!element.buffer) {
|
|
bytes.push(new Uint8Array(element));
|
|
} else {
|
|
bytes.push(
|
|
new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
|
|
);
|
|
}
|
|
} else if (isBlobLike(element)) {
|
|
bytes.push(element);
|
|
}
|
|
}
|
|
return bytes;
|
|
}
|
|
function convertLineEndingsNative(s2) {
|
|
let nativeLineEnding = "\n";
|
|
if (process.platform === "win32") {
|
|
nativeLineEnding = "\r\n";
|
|
}
|
|
return s2.replace(/\r?\n/g, nativeLineEnding);
|
|
}
|
|
function isFileLike(object) {
|
|
return NativeFile && object instanceof NativeFile || object instanceof File3 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
|
|
}
|
|
module2.exports = { File: File3, FileLike, isFileLike };
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/formdata.js
|
|
var require_formdata = __commonJS({
|
|
"node_modules/undici/lib/fetch/formdata.js"(exports2, module2) {
|
|
"use strict";
|
|
var { isBlobLike, toUSVString, makeIterator } = require_util2();
|
|
var { kState } = require_symbols2();
|
|
var { File: UndiciFile, FileLike, isFileLike } = require_file();
|
|
var { webidl } = require_webidl();
|
|
var { Blob: Blob4, File: NativeFile } = require("buffer");
|
|
var File3 = NativeFile ?? UndiciFile;
|
|
var FormData3 = class _FormData {
|
|
constructor(form) {
|
|
if (form !== void 0) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: "FormData constructor",
|
|
argument: "Argument 1",
|
|
types: ["undefined"]
|
|
});
|
|
}
|
|
this[kState] = [];
|
|
}
|
|
append(name, value, filename = void 0) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
|
|
if (arguments.length === 3 && !isBlobLike(value)) {
|
|
throw new TypeError(
|
|
"Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
|
|
);
|
|
}
|
|
name = webidl.converters.USVString(name);
|
|
value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
|
|
filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
|
|
const entry = makeEntry(name, value, filename);
|
|
this[kState].push(entry);
|
|
}
|
|
delete(name) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
|
|
name = webidl.converters.USVString(name);
|
|
this[kState] = this[kState].filter((entry) => entry.name !== name);
|
|
}
|
|
get(name) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
|
|
name = webidl.converters.USVString(name);
|
|
const idx = this[kState].findIndex((entry) => entry.name === name);
|
|
if (idx === -1) {
|
|
return null;
|
|
}
|
|
return this[kState][idx].value;
|
|
}
|
|
getAll(name) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
|
|
name = webidl.converters.USVString(name);
|
|
return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
|
|
}
|
|
has(name) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
|
|
name = webidl.converters.USVString(name);
|
|
return this[kState].findIndex((entry) => entry.name === name) !== -1;
|
|
}
|
|
set(name, value, filename = void 0) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
|
|
if (arguments.length === 3 && !isBlobLike(value)) {
|
|
throw new TypeError(
|
|
"Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
|
|
);
|
|
}
|
|
name = webidl.converters.USVString(name);
|
|
value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
|
|
filename = arguments.length === 3 ? toUSVString(filename) : void 0;
|
|
const entry = makeEntry(name, value, filename);
|
|
const idx = this[kState].findIndex((entry2) => entry2.name === name);
|
|
if (idx !== -1) {
|
|
this[kState] = [
|
|
...this[kState].slice(0, idx),
|
|
entry,
|
|
...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
|
|
];
|
|
} else {
|
|
this[kState].push(entry);
|
|
}
|
|
}
|
|
entries() {
|
|
webidl.brandCheck(this, _FormData);
|
|
return makeIterator(
|
|
() => this[kState].map((pair) => [pair.name, pair.value]),
|
|
"FormData",
|
|
"key+value"
|
|
);
|
|
}
|
|
keys() {
|
|
webidl.brandCheck(this, _FormData);
|
|
return makeIterator(
|
|
() => this[kState].map((pair) => [pair.name, pair.value]),
|
|
"FormData",
|
|
"key"
|
|
);
|
|
}
|
|
values() {
|
|
webidl.brandCheck(this, _FormData);
|
|
return makeIterator(
|
|
() => this[kState].map((pair) => [pair.name, pair.value]),
|
|
"FormData",
|
|
"value"
|
|
);
|
|
}
|
|
/**
|
|
* @param {(value: string, key: string, self: FormData) => void} callbackFn
|
|
* @param {unknown} thisArg
|
|
*/
|
|
forEach(callbackFn, thisArg = globalThis) {
|
|
webidl.brandCheck(this, _FormData);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
|
|
if (typeof callbackFn !== "function") {
|
|
throw new TypeError(
|
|
"Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
|
|
);
|
|
}
|
|
for (const [key, value] of this) {
|
|
callbackFn.apply(thisArg, [value, key, this]);
|
|
}
|
|
}
|
|
};
|
|
FormData3.prototype[Symbol.iterator] = FormData3.prototype.entries;
|
|
Object.defineProperties(FormData3.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "FormData",
|
|
configurable: true
|
|
}
|
|
});
|
|
function makeEntry(name, value, filename) {
|
|
name = Buffer.from(name).toString("utf8");
|
|
if (typeof value === "string") {
|
|
value = Buffer.from(value).toString("utf8");
|
|
} else {
|
|
if (!isFileLike(value)) {
|
|
value = value instanceof Blob4 ? new File3([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
|
|
}
|
|
if (filename !== void 0) {
|
|
const options = {
|
|
type: value.type,
|
|
lastModified: value.lastModified
|
|
};
|
|
value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File3([value], filename, options) : new FileLike(value, filename, options);
|
|
}
|
|
}
|
|
return { name, value };
|
|
}
|
|
module2.exports = { FormData: FormData3 };
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/body.js
|
|
var require_body = __commonJS({
|
|
"node_modules/undici/lib/fetch/body.js"(exports2, module2) {
|
|
"use strict";
|
|
var Busboy = require_main();
|
|
var util = require_util();
|
|
var {
|
|
ReadableStreamFrom,
|
|
isBlobLike,
|
|
isReadableStreamLike,
|
|
readableStreamClose,
|
|
createDeferredPromise,
|
|
fullyReadBody
|
|
} = require_util2();
|
|
var { FormData: FormData3 } = require_formdata();
|
|
var { kState } = require_symbols2();
|
|
var { webidl } = require_webidl();
|
|
var { DOMException: DOMException3, structuredClone: structuredClone2 } = require_constants2();
|
|
var { Blob: Blob4, File: NativeFile } = require("buffer");
|
|
var { kBodyUsed } = require_symbols();
|
|
var assert = require("assert");
|
|
var { isErrored } = require_util();
|
|
var { isUint8Array, isArrayBuffer } = require("util/types");
|
|
var { File: UndiciFile } = require_file();
|
|
var { parseMIMEType, serializeAMimeType } = require_dataURL();
|
|
var random;
|
|
try {
|
|
const crypto = require("node:crypto");
|
|
random = (max) => crypto.randomInt(0, max);
|
|
} catch {
|
|
random = (max) => Math.floor(Math.random(max));
|
|
}
|
|
var ReadableStream2 = globalThis.ReadableStream;
|
|
var File3 = NativeFile ?? UndiciFile;
|
|
var textEncoder = new TextEncoder();
|
|
var textDecoder = new TextDecoder();
|
|
function extractBody(object, keepalive = false) {
|
|
if (!ReadableStream2) {
|
|
ReadableStream2 = require("stream/web").ReadableStream;
|
|
}
|
|
let stream = null;
|
|
if (object instanceof ReadableStream2) {
|
|
stream = object;
|
|
} else if (isBlobLike(object)) {
|
|
stream = object.stream();
|
|
} else {
|
|
stream = new ReadableStream2({
|
|
async pull(controller) {
|
|
controller.enqueue(
|
|
typeof source === "string" ? textEncoder.encode(source) : source
|
|
);
|
|
queueMicrotask(() => readableStreamClose(controller));
|
|
},
|
|
start() {
|
|
},
|
|
type: void 0
|
|
});
|
|
}
|
|
assert(isReadableStreamLike(stream));
|
|
let action = null;
|
|
let source = null;
|
|
let length = null;
|
|
let type = null;
|
|
if (typeof object === "string") {
|
|
source = object;
|
|
type = "text/plain;charset=UTF-8";
|
|
} else if (object instanceof URLSearchParams) {
|
|
source = object.toString();
|
|
type = "application/x-www-form-urlencoded;charset=UTF-8";
|
|
} else if (isArrayBuffer(object)) {
|
|
source = new Uint8Array(object.slice());
|
|
} else if (ArrayBuffer.isView(object)) {
|
|
source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
|
|
} else if (util.isFormDataLike(object)) {
|
|
const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
|
|
const prefix = `--${boundary}\r
|
|
Content-Disposition: form-data`;
|
|
const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
|
|
const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
|
|
const blobParts = [];
|
|
const rn = new Uint8Array([13, 10]);
|
|
length = 0;
|
|
let hasUnknownSizeValue = false;
|
|
for (const [name, value] of object) {
|
|
if (typeof value === "string") {
|
|
const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
|
|
\r
|
|
${normalizeLinefeeds(value)}\r
|
|
`);
|
|
blobParts.push(chunk2);
|
|
length += chunk2.byteLength;
|
|
} else {
|
|
const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
|
|
Content-Type: ${value.type || "application/octet-stream"}\r
|
|
\r
|
|
`);
|
|
blobParts.push(chunk2, value, rn);
|
|
if (typeof value.size === "number") {
|
|
length += chunk2.byteLength + value.size + rn.byteLength;
|
|
} else {
|
|
hasUnknownSizeValue = true;
|
|
}
|
|
}
|
|
}
|
|
const chunk = textEncoder.encode(`--${boundary}--`);
|
|
blobParts.push(chunk);
|
|
length += chunk.byteLength;
|
|
if (hasUnknownSizeValue) {
|
|
length = null;
|
|
}
|
|
source = object;
|
|
action = async function* () {
|
|
for (const part of blobParts) {
|
|
if (part.stream) {
|
|
yield* part.stream();
|
|
} else {
|
|
yield part;
|
|
}
|
|
}
|
|
};
|
|
type = "multipart/form-data; boundary=" + boundary;
|
|
} else if (isBlobLike(object)) {
|
|
source = object;
|
|
length = object.size;
|
|
if (object.type) {
|
|
type = object.type;
|
|
}
|
|
} else if (typeof object[Symbol.asyncIterator] === "function") {
|
|
if (keepalive) {
|
|
throw new TypeError("keepalive");
|
|
}
|
|
if (util.isDisturbed(object) || object.locked) {
|
|
throw new TypeError(
|
|
"Response body object should not be disturbed or locked"
|
|
);
|
|
}
|
|
stream = object instanceof ReadableStream2 ? object : ReadableStreamFrom(object);
|
|
}
|
|
if (typeof source === "string" || util.isBuffer(source)) {
|
|
length = Buffer.byteLength(source);
|
|
}
|
|
if (action != null) {
|
|
let iterator;
|
|
stream = new ReadableStream2({
|
|
async start() {
|
|
iterator = action(object)[Symbol.asyncIterator]();
|
|
},
|
|
async pull(controller) {
|
|
const { value, done } = await iterator.next();
|
|
if (done) {
|
|
queueMicrotask(() => {
|
|
controller.close();
|
|
});
|
|
} else {
|
|
if (!isErrored(stream)) {
|
|
controller.enqueue(new Uint8Array(value));
|
|
}
|
|
}
|
|
return controller.desiredSize > 0;
|
|
},
|
|
async cancel(reason) {
|
|
await iterator.return();
|
|
},
|
|
type: void 0
|
|
});
|
|
}
|
|
const body = { stream, source, length };
|
|
return [body, type];
|
|
}
|
|
function safelyExtractBody(object, keepalive = false) {
|
|
if (!ReadableStream2) {
|
|
ReadableStream2 = require("stream/web").ReadableStream;
|
|
}
|
|
if (object instanceof ReadableStream2) {
|
|
assert(!util.isDisturbed(object), "The body has already been consumed.");
|
|
assert(!object.locked, "The stream is locked.");
|
|
}
|
|
return extractBody(object, keepalive);
|
|
}
|
|
function cloneBody(body) {
|
|
const [out1, out2] = body.stream.tee();
|
|
const out2Clone = structuredClone2(out2, { transfer: [out2] });
|
|
const [, finalClone] = out2Clone.tee();
|
|
body.stream = out1;
|
|
return {
|
|
stream: finalClone,
|
|
length: body.length,
|
|
source: body.source
|
|
};
|
|
}
|
|
async function* consumeBody2(body) {
|
|
if (body) {
|
|
if (isUint8Array(body)) {
|
|
yield body;
|
|
} else {
|
|
const stream = body.stream;
|
|
if (util.isDisturbed(stream)) {
|
|
throw new TypeError("The body has already been consumed.");
|
|
}
|
|
if (stream.locked) {
|
|
throw new TypeError("The stream is locked.");
|
|
}
|
|
stream[kBodyUsed] = true;
|
|
yield* stream;
|
|
}
|
|
}
|
|
}
|
|
function throwIfAborted(state) {
|
|
if (state.aborted) {
|
|
throw new DOMException3("The operation was aborted.", "AbortError");
|
|
}
|
|
}
|
|
function bodyMixinMethods(instance) {
|
|
const methods = {
|
|
blob() {
|
|
return specConsumeBody(this, (bytes) => {
|
|
let mimeType = bodyMimeType(this);
|
|
if (mimeType === "failure") {
|
|
mimeType = "";
|
|
} else if (mimeType) {
|
|
mimeType = serializeAMimeType(mimeType);
|
|
}
|
|
return new Blob4([bytes], { type: mimeType });
|
|
}, instance);
|
|
},
|
|
arrayBuffer() {
|
|
return specConsumeBody(this, (bytes) => {
|
|
return new Uint8Array(bytes).buffer;
|
|
}, instance);
|
|
},
|
|
text() {
|
|
return specConsumeBody(this, utf8DecodeBytes, instance);
|
|
},
|
|
json() {
|
|
return specConsumeBody(this, parseJSONFromBytes, instance);
|
|
},
|
|
async formData() {
|
|
webidl.brandCheck(this, instance);
|
|
throwIfAborted(this[kState]);
|
|
const contentType = this.headers.get("Content-Type");
|
|
if (/multipart\/form-data/.test(contentType)) {
|
|
const headers = {};
|
|
for (const [key, value] of this.headers) headers[key.toLowerCase()] = value;
|
|
const responseFormData = new FormData3();
|
|
let busboy;
|
|
try {
|
|
busboy = new Busboy({
|
|
headers,
|
|
preservePath: true
|
|
});
|
|
} catch (err) {
|
|
throw new DOMException3(`${err}`, "AbortError");
|
|
}
|
|
busboy.on("field", (name, value) => {
|
|
responseFormData.append(name, value);
|
|
});
|
|
busboy.on("file", (name, value, filename, encoding, mimeType) => {
|
|
const chunks = [];
|
|
if (encoding === "base64" || encoding.toLowerCase() === "base64") {
|
|
let base64chunk = "";
|
|
value.on("data", (chunk) => {
|
|
base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
|
|
const end = base64chunk.length - base64chunk.length % 4;
|
|
chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
|
|
base64chunk = base64chunk.slice(end);
|
|
});
|
|
value.on("end", () => {
|
|
chunks.push(Buffer.from(base64chunk, "base64"));
|
|
responseFormData.append(name, new File3(chunks, filename, { type: mimeType }));
|
|
});
|
|
} else {
|
|
value.on("data", (chunk) => {
|
|
chunks.push(chunk);
|
|
});
|
|
value.on("end", () => {
|
|
responseFormData.append(name, new File3(chunks, filename, { type: mimeType }));
|
|
});
|
|
}
|
|
});
|
|
const busboyResolve = new Promise((resolve, reject) => {
|
|
busboy.on("finish", resolve);
|
|
busboy.on("error", (err) => reject(new TypeError(err)));
|
|
});
|
|
if (this.body !== null) for await (const chunk of consumeBody2(this[kState].body)) busboy.write(chunk);
|
|
busboy.end();
|
|
await busboyResolve;
|
|
return responseFormData;
|
|
} else if (/application\/x-www-form-urlencoded/.test(contentType)) {
|
|
let entries;
|
|
try {
|
|
let text = "";
|
|
const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
|
|
for await (const chunk of consumeBody2(this[kState].body)) {
|
|
if (!isUint8Array(chunk)) {
|
|
throw new TypeError("Expected Uint8Array chunk");
|
|
}
|
|
text += streamingDecoder.decode(chunk, { stream: true });
|
|
}
|
|
text += streamingDecoder.decode();
|
|
entries = new URLSearchParams(text);
|
|
} catch (err) {
|
|
throw Object.assign(new TypeError(), { cause: err });
|
|
}
|
|
const formData = new FormData3();
|
|
for (const [name, value] of entries) {
|
|
formData.append(name, value);
|
|
}
|
|
return formData;
|
|
} else {
|
|
await Promise.resolve();
|
|
throwIfAborted(this[kState]);
|
|
throw webidl.errors.exception({
|
|
header: `${instance.name}.formData`,
|
|
message: "Could not parse content as FormData."
|
|
});
|
|
}
|
|
}
|
|
};
|
|
return methods;
|
|
}
|
|
function mixinBody(prototype) {
|
|
Object.assign(prototype.prototype, bodyMixinMethods(prototype));
|
|
}
|
|
async function specConsumeBody(object, convertBytesToJSValue, instance) {
|
|
webidl.brandCheck(object, instance);
|
|
throwIfAborted(object[kState]);
|
|
if (bodyUnusable(object[kState].body)) {
|
|
throw new TypeError("Body is unusable");
|
|
}
|
|
const promise = createDeferredPromise();
|
|
const errorSteps = (error) => promise.reject(error);
|
|
const successSteps = (data) => {
|
|
try {
|
|
promise.resolve(convertBytesToJSValue(data));
|
|
} catch (e2) {
|
|
errorSteps(e2);
|
|
}
|
|
};
|
|
if (object[kState].body == null) {
|
|
successSteps(new Uint8Array());
|
|
return promise.promise;
|
|
}
|
|
await fullyReadBody(object[kState].body, successSteps, errorSteps);
|
|
return promise.promise;
|
|
}
|
|
function bodyUnusable(body) {
|
|
return body != null && (body.stream.locked || util.isDisturbed(body.stream));
|
|
}
|
|
function utf8DecodeBytes(buffer) {
|
|
if (buffer.length === 0) {
|
|
return "";
|
|
}
|
|
if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
|
|
buffer = buffer.subarray(3);
|
|
}
|
|
const output = textDecoder.decode(buffer);
|
|
return output;
|
|
}
|
|
function parseJSONFromBytes(bytes) {
|
|
return JSON.parse(utf8DecodeBytes(bytes));
|
|
}
|
|
function bodyMimeType(object) {
|
|
const { headersList } = object[kState];
|
|
const contentType = headersList.get("content-type");
|
|
if (contentType === null) {
|
|
return "failure";
|
|
}
|
|
return parseMIMEType(contentType);
|
|
}
|
|
module2.exports = {
|
|
extractBody,
|
|
safelyExtractBody,
|
|
cloneBody,
|
|
mixinBody
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/request.js
|
|
var require_request = __commonJS({
|
|
"node_modules/undici/lib/core/request.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
InvalidArgumentError,
|
|
NotSupportedError
|
|
} = require_errors();
|
|
var assert = require("assert");
|
|
var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols();
|
|
var util = require_util();
|
|
var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
|
|
var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
|
|
var invalidPathRegex = /[^\u0021-\u00ff]/;
|
|
var kHandler = Symbol("handler");
|
|
var channels = {};
|
|
var extractBody;
|
|
try {
|
|
const diagnosticsChannel = require("diagnostics_channel");
|
|
channels.create = diagnosticsChannel.channel("undici:request:create");
|
|
channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
|
|
channels.headers = diagnosticsChannel.channel("undici:request:headers");
|
|
channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
|
|
channels.error = diagnosticsChannel.channel("undici:request:error");
|
|
} catch {
|
|
channels.create = { hasSubscribers: false };
|
|
channels.bodySent = { hasSubscribers: false };
|
|
channels.headers = { hasSubscribers: false };
|
|
channels.trailers = { hasSubscribers: false };
|
|
channels.error = { hasSubscribers: false };
|
|
}
|
|
var Request2 = class _Request {
|
|
constructor(origin, {
|
|
path: path3,
|
|
method,
|
|
body,
|
|
headers,
|
|
query,
|
|
idempotent,
|
|
blocking,
|
|
upgrade,
|
|
headersTimeout,
|
|
bodyTimeout,
|
|
reset,
|
|
throwOnError,
|
|
expectContinue
|
|
}, handler) {
|
|
if (typeof path3 !== "string") {
|
|
throw new InvalidArgumentError("path must be a string");
|
|
} else if (path3[0] !== "/" && !(path3.startsWith("http://") || path3.startsWith("https://")) && method !== "CONNECT") {
|
|
throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
|
|
} else if (invalidPathRegex.exec(path3) !== null) {
|
|
throw new InvalidArgumentError("invalid request path");
|
|
}
|
|
if (typeof method !== "string") {
|
|
throw new InvalidArgumentError("method must be a string");
|
|
} else if (tokenRegExp.exec(method) === null) {
|
|
throw new InvalidArgumentError("invalid request method");
|
|
}
|
|
if (upgrade && typeof upgrade !== "string") {
|
|
throw new InvalidArgumentError("upgrade must be a string");
|
|
}
|
|
if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
|
|
throw new InvalidArgumentError("invalid headersTimeout");
|
|
}
|
|
if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
|
|
throw new InvalidArgumentError("invalid bodyTimeout");
|
|
}
|
|
if (reset != null && typeof reset !== "boolean") {
|
|
throw new InvalidArgumentError("invalid reset");
|
|
}
|
|
if (expectContinue != null && typeof expectContinue !== "boolean") {
|
|
throw new InvalidArgumentError("invalid expectContinue");
|
|
}
|
|
this.headersTimeout = headersTimeout;
|
|
this.bodyTimeout = bodyTimeout;
|
|
this.throwOnError = throwOnError === true;
|
|
this.method = method;
|
|
this.abort = null;
|
|
if (body == null) {
|
|
this.body = null;
|
|
} else if (util.isStream(body)) {
|
|
this.body = body;
|
|
const rState = this.body._readableState;
|
|
if (!rState || !rState.autoDestroy) {
|
|
this.endHandler = function autoDestroy() {
|
|
util.destroy(this);
|
|
};
|
|
this.body.on("end", this.endHandler);
|
|
}
|
|
this.errorHandler = (err) => {
|
|
if (this.abort) {
|
|
this.abort(err);
|
|
} else {
|
|
this.error = err;
|
|
}
|
|
};
|
|
this.body.on("error", this.errorHandler);
|
|
} else if (util.isBuffer(body)) {
|
|
this.body = body.byteLength ? body : null;
|
|
} else if (ArrayBuffer.isView(body)) {
|
|
this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
|
|
} else if (body instanceof ArrayBuffer) {
|
|
this.body = body.byteLength ? Buffer.from(body) : null;
|
|
} else if (typeof body === "string") {
|
|
this.body = body.length ? Buffer.from(body) : null;
|
|
} else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) {
|
|
this.body = body;
|
|
} else {
|
|
throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
|
|
}
|
|
this.completed = false;
|
|
this.aborted = false;
|
|
this.upgrade = upgrade || null;
|
|
this.path = query ? util.buildURL(path3, query) : path3;
|
|
this.origin = origin;
|
|
this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
|
|
this.blocking = blocking == null ? false : blocking;
|
|
this.reset = reset == null ? null : reset;
|
|
this.host = null;
|
|
this.contentLength = null;
|
|
this.contentType = null;
|
|
this.headers = "";
|
|
this.expectContinue = expectContinue != null ? expectContinue : false;
|
|
if (Array.isArray(headers)) {
|
|
if (headers.length % 2 !== 0) {
|
|
throw new InvalidArgumentError("headers array must be even");
|
|
}
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
processHeader(this, headers[i2], headers[i2 + 1]);
|
|
}
|
|
} else if (headers && typeof headers === "object") {
|
|
const keys = Object.keys(headers);
|
|
for (let i2 = 0; i2 < keys.length; i2++) {
|
|
const key = keys[i2];
|
|
processHeader(this, key, headers[key]);
|
|
}
|
|
} else if (headers != null) {
|
|
throw new InvalidArgumentError("headers must be an object or an array");
|
|
}
|
|
if (util.isFormDataLike(this.body)) {
|
|
if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) {
|
|
throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
|
|
}
|
|
if (!extractBody) {
|
|
extractBody = require_body().extractBody;
|
|
}
|
|
const [bodyStream, contentType] = extractBody(body);
|
|
if (this.contentType == null) {
|
|
this.contentType = contentType;
|
|
this.headers += `content-type: ${contentType}\r
|
|
`;
|
|
}
|
|
this.body = bodyStream.stream;
|
|
this.contentLength = bodyStream.length;
|
|
} else if (util.isBlobLike(body) && this.contentType == null && body.type) {
|
|
this.contentType = body.type;
|
|
this.headers += `content-type: ${body.type}\r
|
|
`;
|
|
}
|
|
util.validateHandler(handler, method, upgrade);
|
|
this.servername = util.getServerName(this.host);
|
|
this[kHandler] = handler;
|
|
if (channels.create.hasSubscribers) {
|
|
channels.create.publish({ request: this });
|
|
}
|
|
}
|
|
onBodySent(chunk) {
|
|
if (this[kHandler].onBodySent) {
|
|
try {
|
|
return this[kHandler].onBodySent(chunk);
|
|
} catch (err) {
|
|
this.abort(err);
|
|
}
|
|
}
|
|
}
|
|
onRequestSent() {
|
|
if (channels.bodySent.hasSubscribers) {
|
|
channels.bodySent.publish({ request: this });
|
|
}
|
|
if (this[kHandler].onRequestSent) {
|
|
try {
|
|
return this[kHandler].onRequestSent();
|
|
} catch (err) {
|
|
this.abort(err);
|
|
}
|
|
}
|
|
}
|
|
onConnect(abort) {
|
|
assert(!this.aborted);
|
|
assert(!this.completed);
|
|
if (this.error) {
|
|
abort(this.error);
|
|
} else {
|
|
this.abort = abort;
|
|
return this[kHandler].onConnect(abort);
|
|
}
|
|
}
|
|
onHeaders(statusCode, headers, resume, statusText) {
|
|
assert(!this.aborted);
|
|
assert(!this.completed);
|
|
if (channels.headers.hasSubscribers) {
|
|
channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
|
|
}
|
|
try {
|
|
return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
|
|
} catch (err) {
|
|
this.abort(err);
|
|
}
|
|
}
|
|
onData(chunk) {
|
|
assert(!this.aborted);
|
|
assert(!this.completed);
|
|
try {
|
|
return this[kHandler].onData(chunk);
|
|
} catch (err) {
|
|
this.abort(err);
|
|
return false;
|
|
}
|
|
}
|
|
onUpgrade(statusCode, headers, socket) {
|
|
assert(!this.aborted);
|
|
assert(!this.completed);
|
|
return this[kHandler].onUpgrade(statusCode, headers, socket);
|
|
}
|
|
onComplete(trailers) {
|
|
this.onFinally();
|
|
assert(!this.aborted);
|
|
this.completed = true;
|
|
if (channels.trailers.hasSubscribers) {
|
|
channels.trailers.publish({ request: this, trailers });
|
|
}
|
|
try {
|
|
return this[kHandler].onComplete(trailers);
|
|
} catch (err) {
|
|
this.onError(err);
|
|
}
|
|
}
|
|
onError(error) {
|
|
this.onFinally();
|
|
if (channels.error.hasSubscribers) {
|
|
channels.error.publish({ request: this, error });
|
|
}
|
|
if (this.aborted) {
|
|
return;
|
|
}
|
|
this.aborted = true;
|
|
return this[kHandler].onError(error);
|
|
}
|
|
onFinally() {
|
|
if (this.errorHandler) {
|
|
this.body.off("error", this.errorHandler);
|
|
this.errorHandler = null;
|
|
}
|
|
if (this.endHandler) {
|
|
this.body.off("end", this.endHandler);
|
|
this.endHandler = null;
|
|
}
|
|
}
|
|
// TODO: adjust to support H2
|
|
addHeader(key, value) {
|
|
processHeader(this, key, value);
|
|
return this;
|
|
}
|
|
static [kHTTP1BuildRequest](origin, opts, handler) {
|
|
return new _Request(origin, opts, handler);
|
|
}
|
|
static [kHTTP2BuildRequest](origin, opts, handler) {
|
|
const headers = opts.headers;
|
|
opts = { ...opts, headers: null };
|
|
const request = new _Request(origin, opts, handler);
|
|
request.headers = {};
|
|
if (Array.isArray(headers)) {
|
|
if (headers.length % 2 !== 0) {
|
|
throw new InvalidArgumentError("headers array must be even");
|
|
}
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
processHeader(request, headers[i2], headers[i2 + 1], true);
|
|
}
|
|
} else if (headers && typeof headers === "object") {
|
|
const keys = Object.keys(headers);
|
|
for (let i2 = 0; i2 < keys.length; i2++) {
|
|
const key = keys[i2];
|
|
processHeader(request, key, headers[key], true);
|
|
}
|
|
} else if (headers != null) {
|
|
throw new InvalidArgumentError("headers must be an object or an array");
|
|
}
|
|
return request;
|
|
}
|
|
static [kHTTP2CopyHeaders](raw) {
|
|
const rawHeaders = raw.split("\r\n");
|
|
const headers = {};
|
|
for (const header of rawHeaders) {
|
|
const [key, value] = header.split(": ");
|
|
if (value == null || value.length === 0) continue;
|
|
if (headers[key]) headers[key] += `,${value}`;
|
|
else headers[key] = value;
|
|
}
|
|
return headers;
|
|
}
|
|
};
|
|
function processHeaderValue(key, val, skipAppend) {
|
|
if (val && typeof val === "object") {
|
|
throw new InvalidArgumentError(`invalid ${key} header`);
|
|
}
|
|
val = val != null ? `${val}` : "";
|
|
if (headerCharRegex.exec(val) !== null) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`);
|
|
}
|
|
return skipAppend ? val : `${key}: ${val}\r
|
|
`;
|
|
}
|
|
function processHeader(request, key, val, skipAppend = false) {
|
|
if (val && (typeof val === "object" && !Array.isArray(val))) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`);
|
|
} else if (val === void 0) {
|
|
return;
|
|
}
|
|
if (request.host === null && key.length === 4 && key.toLowerCase() === "host") {
|
|
if (headerCharRegex.exec(val) !== null) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`);
|
|
}
|
|
request.host = val;
|
|
} else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
|
|
request.contentLength = parseInt(val, 10);
|
|
if (!Number.isFinite(request.contentLength)) {
|
|
throw new InvalidArgumentError("invalid content-length header");
|
|
}
|
|
} else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") {
|
|
request.contentType = val;
|
|
if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend);
|
|
else request.headers += processHeaderValue(key, val);
|
|
} else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
|
|
throw new InvalidArgumentError("invalid transfer-encoding header");
|
|
} else if (key.length === 10 && key.toLowerCase() === "connection") {
|
|
const value = typeof val === "string" ? val.toLowerCase() : null;
|
|
if (value !== "close" && value !== "keep-alive") {
|
|
throw new InvalidArgumentError("invalid connection header");
|
|
} else if (value === "close") {
|
|
request.reset = true;
|
|
}
|
|
} else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
|
|
throw new InvalidArgumentError("invalid keep-alive header");
|
|
} else if (key.length === 7 && key.toLowerCase() === "upgrade") {
|
|
throw new InvalidArgumentError("invalid upgrade header");
|
|
} else if (key.length === 6 && key.toLowerCase() === "expect") {
|
|
throw new NotSupportedError("expect header not supported");
|
|
} else if (tokenRegExp.exec(key) === null) {
|
|
throw new InvalidArgumentError("invalid header key");
|
|
} else {
|
|
if (Array.isArray(val)) {
|
|
for (let i2 = 0; i2 < val.length; i2++) {
|
|
if (skipAppend) {
|
|
if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i2], skipAppend)}`;
|
|
else request.headers[key] = processHeaderValue(key, val[i2], skipAppend);
|
|
} else {
|
|
request.headers += processHeaderValue(key, val[i2]);
|
|
}
|
|
}
|
|
} else {
|
|
if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend);
|
|
else request.headers += processHeaderValue(key, val);
|
|
}
|
|
}
|
|
}
|
|
module2.exports = Request2;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/dispatcher.js
|
|
var require_dispatcher = __commonJS({
|
|
"node_modules/undici/lib/dispatcher.js"(exports2, module2) {
|
|
"use strict";
|
|
var EventEmitter = require("events");
|
|
var Dispatcher = class extends EventEmitter {
|
|
dispatch() {
|
|
throw new Error("not implemented");
|
|
}
|
|
close() {
|
|
throw new Error("not implemented");
|
|
}
|
|
destroy() {
|
|
throw new Error("not implemented");
|
|
}
|
|
};
|
|
module2.exports = Dispatcher;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/dispatcher-base.js
|
|
var require_dispatcher_base = __commonJS({
|
|
"node_modules/undici/lib/dispatcher-base.js"(exports2, module2) {
|
|
"use strict";
|
|
var Dispatcher = require_dispatcher();
|
|
var {
|
|
ClientDestroyedError,
|
|
ClientClosedError,
|
|
InvalidArgumentError
|
|
} = require_errors();
|
|
var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
|
|
var kDestroyed = Symbol("destroyed");
|
|
var kClosed = Symbol("closed");
|
|
var kOnDestroyed = Symbol("onDestroyed");
|
|
var kOnClosed = Symbol("onClosed");
|
|
var kInterceptedDispatch = Symbol("Intercepted Dispatch");
|
|
var DispatcherBase = class extends Dispatcher {
|
|
constructor() {
|
|
super();
|
|
this[kDestroyed] = false;
|
|
this[kOnDestroyed] = null;
|
|
this[kClosed] = false;
|
|
this[kOnClosed] = [];
|
|
}
|
|
get destroyed() {
|
|
return this[kDestroyed];
|
|
}
|
|
get closed() {
|
|
return this[kClosed];
|
|
}
|
|
get interceptors() {
|
|
return this[kInterceptors];
|
|
}
|
|
set interceptors(newInterceptors) {
|
|
if (newInterceptors) {
|
|
for (let i2 = newInterceptors.length - 1; i2 >= 0; i2--) {
|
|
const interceptor = this[kInterceptors][i2];
|
|
if (typeof interceptor !== "function") {
|
|
throw new InvalidArgumentError("interceptor must be an function");
|
|
}
|
|
}
|
|
}
|
|
this[kInterceptors] = newInterceptors;
|
|
}
|
|
close(callback) {
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
this.close((err, data) => {
|
|
return err ? reject(err) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
if (this[kDestroyed]) {
|
|
queueMicrotask(() => callback(new ClientDestroyedError(), null));
|
|
return;
|
|
}
|
|
if (this[kClosed]) {
|
|
if (this[kOnClosed]) {
|
|
this[kOnClosed].push(callback);
|
|
} else {
|
|
queueMicrotask(() => callback(null, null));
|
|
}
|
|
return;
|
|
}
|
|
this[kClosed] = true;
|
|
this[kOnClosed].push(callback);
|
|
const onClosed = () => {
|
|
const callbacks = this[kOnClosed];
|
|
this[kOnClosed] = null;
|
|
for (let i2 = 0; i2 < callbacks.length; i2++) {
|
|
callbacks[i2](null, null);
|
|
}
|
|
};
|
|
this[kClose]().then(() => this.destroy()).then(() => {
|
|
queueMicrotask(onClosed);
|
|
});
|
|
}
|
|
destroy(err, callback) {
|
|
if (typeof err === "function") {
|
|
callback = err;
|
|
err = null;
|
|
}
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
this.destroy(err, (err2, data) => {
|
|
return err2 ? (
|
|
/* istanbul ignore next: should never error */
|
|
reject(err2)
|
|
) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
if (this[kDestroyed]) {
|
|
if (this[kOnDestroyed]) {
|
|
this[kOnDestroyed].push(callback);
|
|
} else {
|
|
queueMicrotask(() => callback(null, null));
|
|
}
|
|
return;
|
|
}
|
|
if (!err) {
|
|
err = new ClientDestroyedError();
|
|
}
|
|
this[kDestroyed] = true;
|
|
this[kOnDestroyed] = this[kOnDestroyed] || [];
|
|
this[kOnDestroyed].push(callback);
|
|
const onDestroyed = () => {
|
|
const callbacks = this[kOnDestroyed];
|
|
this[kOnDestroyed] = null;
|
|
for (let i2 = 0; i2 < callbacks.length; i2++) {
|
|
callbacks[i2](null, null);
|
|
}
|
|
};
|
|
this[kDestroy](err).then(() => {
|
|
queueMicrotask(onDestroyed);
|
|
});
|
|
}
|
|
[kInterceptedDispatch](opts, handler) {
|
|
if (!this[kInterceptors] || this[kInterceptors].length === 0) {
|
|
this[kInterceptedDispatch] = this[kDispatch];
|
|
return this[kDispatch](opts, handler);
|
|
}
|
|
let dispatch = this[kDispatch].bind(this);
|
|
for (let i2 = this[kInterceptors].length - 1; i2 >= 0; i2--) {
|
|
dispatch = this[kInterceptors][i2](dispatch);
|
|
}
|
|
this[kInterceptedDispatch] = dispatch;
|
|
return dispatch(opts, handler);
|
|
}
|
|
dispatch(opts, handler) {
|
|
if (!handler || typeof handler !== "object") {
|
|
throw new InvalidArgumentError("handler must be an object");
|
|
}
|
|
try {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("opts must be an object.");
|
|
}
|
|
if (this[kDestroyed] || this[kOnDestroyed]) {
|
|
throw new ClientDestroyedError();
|
|
}
|
|
if (this[kClosed]) {
|
|
throw new ClientClosedError();
|
|
}
|
|
return this[kInterceptedDispatch](opts, handler);
|
|
} catch (err) {
|
|
if (typeof handler.onError !== "function") {
|
|
throw new InvalidArgumentError("invalid onError method");
|
|
}
|
|
handler.onError(err);
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
module2.exports = DispatcherBase;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/core/connect.js
|
|
var require_connect = __commonJS({
|
|
"node_modules/undici/lib/core/connect.js"(exports2, module2) {
|
|
"use strict";
|
|
var net = require("net");
|
|
var assert = require("assert");
|
|
var util = require_util();
|
|
var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
|
|
var tls;
|
|
var SessionCache;
|
|
if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) {
|
|
SessionCache = class WeakSessionCache {
|
|
constructor(maxCachedSessions) {
|
|
this._maxCachedSessions = maxCachedSessions;
|
|
this._sessionCache = /* @__PURE__ */ new Map();
|
|
this._sessionRegistry = new global.FinalizationRegistry((key) => {
|
|
if (this._sessionCache.size < this._maxCachedSessions) {
|
|
return;
|
|
}
|
|
const ref = this._sessionCache.get(key);
|
|
if (ref !== void 0 && ref.deref() === void 0) {
|
|
this._sessionCache.delete(key);
|
|
}
|
|
});
|
|
}
|
|
get(sessionKey) {
|
|
const ref = this._sessionCache.get(sessionKey);
|
|
return ref ? ref.deref() : null;
|
|
}
|
|
set(sessionKey, session) {
|
|
if (this._maxCachedSessions === 0) {
|
|
return;
|
|
}
|
|
this._sessionCache.set(sessionKey, new WeakRef(session));
|
|
this._sessionRegistry.register(session, sessionKey);
|
|
}
|
|
};
|
|
} else {
|
|
SessionCache = class SimpleSessionCache {
|
|
constructor(maxCachedSessions) {
|
|
this._maxCachedSessions = maxCachedSessions;
|
|
this._sessionCache = /* @__PURE__ */ new Map();
|
|
}
|
|
get(sessionKey) {
|
|
return this._sessionCache.get(sessionKey);
|
|
}
|
|
set(sessionKey, session) {
|
|
if (this._maxCachedSessions === 0) {
|
|
return;
|
|
}
|
|
if (this._sessionCache.size >= this._maxCachedSessions) {
|
|
const { value: oldestKey } = this._sessionCache.keys().next();
|
|
this._sessionCache.delete(oldestKey);
|
|
}
|
|
this._sessionCache.set(sessionKey, session);
|
|
}
|
|
};
|
|
}
|
|
function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) {
|
|
if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
|
|
throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
|
|
}
|
|
const options = { path: socketPath, ...opts };
|
|
const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
|
|
timeout = timeout == null ? 1e4 : timeout;
|
|
allowH2 = allowH2 != null ? allowH2 : false;
|
|
return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
|
|
let socket;
|
|
if (protocol === "https:") {
|
|
if (!tls) {
|
|
tls = require("tls");
|
|
}
|
|
servername = servername || options.servername || util.getServerName(host) || null;
|
|
const sessionKey = servername || hostname;
|
|
const session = sessionCache.get(sessionKey) || null;
|
|
assert(sessionKey);
|
|
socket = tls.connect({
|
|
highWaterMark: 16384,
|
|
// TLS in node can't have bigger HWM anyway...
|
|
...options,
|
|
servername,
|
|
session,
|
|
localAddress,
|
|
// TODO(HTTP/2): Add support for h2c
|
|
ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
|
|
socket: httpSocket,
|
|
// upgrade socket connection
|
|
port: port || 443,
|
|
host: hostname
|
|
});
|
|
socket.on("session", function(session2) {
|
|
sessionCache.set(sessionKey, session2);
|
|
});
|
|
} else {
|
|
assert(!httpSocket, "httpSocket can only be sent on TLS update");
|
|
socket = net.connect({
|
|
highWaterMark: 64 * 1024,
|
|
// Same as nodejs fs streams.
|
|
...options,
|
|
localAddress,
|
|
port: port || 80,
|
|
host: hostname
|
|
});
|
|
}
|
|
if (options.keepAlive == null || options.keepAlive) {
|
|
const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
|
|
socket.setKeepAlive(true, keepAliveInitialDelay);
|
|
}
|
|
const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout);
|
|
socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
|
|
cancelTimeout();
|
|
if (callback) {
|
|
const cb = callback;
|
|
callback = null;
|
|
cb(null, this);
|
|
}
|
|
}).on("error", function(err) {
|
|
cancelTimeout();
|
|
if (callback) {
|
|
const cb = callback;
|
|
callback = null;
|
|
cb(err);
|
|
}
|
|
});
|
|
return socket;
|
|
};
|
|
}
|
|
function setupTimeout(onConnectTimeout2, timeout) {
|
|
if (!timeout) {
|
|
return () => {
|
|
};
|
|
}
|
|
let s1 = null;
|
|
let s2 = null;
|
|
const timeoutId = setTimeout(() => {
|
|
s1 = setImmediate(() => {
|
|
if (process.platform === "win32") {
|
|
s2 = setImmediate(() => onConnectTimeout2());
|
|
} else {
|
|
onConnectTimeout2();
|
|
}
|
|
});
|
|
}, timeout);
|
|
return () => {
|
|
clearTimeout(timeoutId);
|
|
clearImmediate(s1);
|
|
clearImmediate(s2);
|
|
};
|
|
}
|
|
function onConnectTimeout(socket) {
|
|
util.destroy(socket, new ConnectTimeoutError());
|
|
}
|
|
module2.exports = buildConnector;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/llhttp/utils.js
|
|
var require_utils2 = __commonJS({
|
|
"node_modules/undici/lib/llhttp/utils.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.enumToMap = void 0;
|
|
function enumToMap(obj) {
|
|
const res = {};
|
|
Object.keys(obj).forEach((key) => {
|
|
const value = obj[key];
|
|
if (typeof value === "number") {
|
|
res[key] = value;
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
exports2.enumToMap = enumToMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/llhttp/constants.js
|
|
var require_constants3 = __commonJS({
|
|
"node_modules/undici/lib/llhttp/constants.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
|
|
var utils_1 = require_utils2();
|
|
var ERROR;
|
|
(function(ERROR2) {
|
|
ERROR2[ERROR2["OK"] = 0] = "OK";
|
|
ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
|
|
ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
|
|
ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
|
|
ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
|
|
ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
|
|
ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
|
|
ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
|
|
ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
|
|
ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
|
|
ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
|
|
ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
|
|
ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
|
|
ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
|
|
ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
|
|
ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
|
|
ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
|
|
ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
|
|
ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
|
|
ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
|
|
ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
|
|
ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
|
|
ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
|
|
ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
|
|
ERROR2[ERROR2["USER"] = 24] = "USER";
|
|
})(ERROR = exports2.ERROR || (exports2.ERROR = {}));
|
|
var TYPE;
|
|
(function(TYPE2) {
|
|
TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
|
|
TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
|
|
TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
|
|
})(TYPE = exports2.TYPE || (exports2.TYPE = {}));
|
|
var FLAGS;
|
|
(function(FLAGS2) {
|
|
FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
|
|
FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
|
|
FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
|
|
FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
|
|
FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
|
|
FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
|
|
FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
|
|
FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
|
|
FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
|
|
})(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
|
|
var LENIENT_FLAGS;
|
|
(function(LENIENT_FLAGS2) {
|
|
LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
|
|
LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
|
|
LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
|
|
})(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
|
|
var METHODS;
|
|
(function(METHODS2) {
|
|
METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
|
|
METHODS2[METHODS2["GET"] = 1] = "GET";
|
|
METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
|
|
METHODS2[METHODS2["POST"] = 3] = "POST";
|
|
METHODS2[METHODS2["PUT"] = 4] = "PUT";
|
|
METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
|
|
METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
|
|
METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
|
|
METHODS2[METHODS2["COPY"] = 8] = "COPY";
|
|
METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
|
|
METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
|
|
METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
|
|
METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
|
|
METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
|
|
METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
|
|
METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
|
|
METHODS2[METHODS2["BIND"] = 16] = "BIND";
|
|
METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
|
|
METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
|
|
METHODS2[METHODS2["ACL"] = 19] = "ACL";
|
|
METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
|
|
METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
|
|
METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
|
|
METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
|
|
METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
|
|
METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
|
|
METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
|
|
METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
|
|
METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
|
|
METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
|
|
METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
|
|
METHODS2[METHODS2["LINK"] = 31] = "LINK";
|
|
METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
|
|
METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
|
|
METHODS2[METHODS2["PRI"] = 34] = "PRI";
|
|
METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
|
|
METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
|
|
METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
|
|
METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
|
|
METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
|
|
METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
|
|
METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
|
|
METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
|
|
METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
|
|
METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
|
|
METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
|
|
})(METHODS = exports2.METHODS || (exports2.METHODS = {}));
|
|
exports2.METHODS_HTTP = [
|
|
METHODS.DELETE,
|
|
METHODS.GET,
|
|
METHODS.HEAD,
|
|
METHODS.POST,
|
|
METHODS.PUT,
|
|
METHODS.CONNECT,
|
|
METHODS.OPTIONS,
|
|
METHODS.TRACE,
|
|
METHODS.COPY,
|
|
METHODS.LOCK,
|
|
METHODS.MKCOL,
|
|
METHODS.MOVE,
|
|
METHODS.PROPFIND,
|
|
METHODS.PROPPATCH,
|
|
METHODS.SEARCH,
|
|
METHODS.UNLOCK,
|
|
METHODS.BIND,
|
|
METHODS.REBIND,
|
|
METHODS.UNBIND,
|
|
METHODS.ACL,
|
|
METHODS.REPORT,
|
|
METHODS.MKACTIVITY,
|
|
METHODS.CHECKOUT,
|
|
METHODS.MERGE,
|
|
METHODS["M-SEARCH"],
|
|
METHODS.NOTIFY,
|
|
METHODS.SUBSCRIBE,
|
|
METHODS.UNSUBSCRIBE,
|
|
METHODS.PATCH,
|
|
METHODS.PURGE,
|
|
METHODS.MKCALENDAR,
|
|
METHODS.LINK,
|
|
METHODS.UNLINK,
|
|
METHODS.PRI,
|
|
// TODO(indutny): should we allow it with HTTP?
|
|
METHODS.SOURCE
|
|
];
|
|
exports2.METHODS_ICE = [
|
|
METHODS.SOURCE
|
|
];
|
|
exports2.METHODS_RTSP = [
|
|
METHODS.OPTIONS,
|
|
METHODS.DESCRIBE,
|
|
METHODS.ANNOUNCE,
|
|
METHODS.SETUP,
|
|
METHODS.PLAY,
|
|
METHODS.PAUSE,
|
|
METHODS.TEARDOWN,
|
|
METHODS.GET_PARAMETER,
|
|
METHODS.SET_PARAMETER,
|
|
METHODS.REDIRECT,
|
|
METHODS.RECORD,
|
|
METHODS.FLUSH,
|
|
// For AirPlay
|
|
METHODS.GET,
|
|
METHODS.POST
|
|
];
|
|
exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
|
|
exports2.H_METHOD_MAP = {};
|
|
Object.keys(exports2.METHOD_MAP).forEach((key) => {
|
|
if (/^H/.test(key)) {
|
|
exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
|
|
}
|
|
});
|
|
var FINISH;
|
|
(function(FINISH2) {
|
|
FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
|
|
FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
|
|
FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
|
|
})(FINISH = exports2.FINISH || (exports2.FINISH = {}));
|
|
exports2.ALPHA = [];
|
|
for (let i2 = "A".charCodeAt(0); i2 <= "Z".charCodeAt(0); i2++) {
|
|
exports2.ALPHA.push(String.fromCharCode(i2));
|
|
exports2.ALPHA.push(String.fromCharCode(i2 + 32));
|
|
}
|
|
exports2.NUM_MAP = {
|
|
0: 0,
|
|
1: 1,
|
|
2: 2,
|
|
3: 3,
|
|
4: 4,
|
|
5: 5,
|
|
6: 6,
|
|
7: 7,
|
|
8: 8,
|
|
9: 9
|
|
};
|
|
exports2.HEX_MAP = {
|
|
0: 0,
|
|
1: 1,
|
|
2: 2,
|
|
3: 3,
|
|
4: 4,
|
|
5: 5,
|
|
6: 6,
|
|
7: 7,
|
|
8: 8,
|
|
9: 9,
|
|
A: 10,
|
|
B: 11,
|
|
C: 12,
|
|
D: 13,
|
|
E: 14,
|
|
F: 15,
|
|
a: 10,
|
|
b: 11,
|
|
c: 12,
|
|
d: 13,
|
|
e: 14,
|
|
f: 15
|
|
};
|
|
exports2.NUM = [
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9"
|
|
];
|
|
exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
|
|
exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
|
|
exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
|
|
exports2.STRICT_URL_CHAR = [
|
|
"!",
|
|
'"',
|
|
"$",
|
|
"%",
|
|
"&",
|
|
"'",
|
|
"(",
|
|
")",
|
|
"*",
|
|
"+",
|
|
",",
|
|
"-",
|
|
".",
|
|
"/",
|
|
":",
|
|
";",
|
|
"<",
|
|
"=",
|
|
">",
|
|
"@",
|
|
"[",
|
|
"\\",
|
|
"]",
|
|
"^",
|
|
"_",
|
|
"`",
|
|
"{",
|
|
"|",
|
|
"}",
|
|
"~"
|
|
].concat(exports2.ALPHANUM);
|
|
exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]);
|
|
for (let i2 = 128; i2 <= 255; i2++) {
|
|
exports2.URL_CHAR.push(i2);
|
|
}
|
|
exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
|
|
exports2.STRICT_TOKEN = [
|
|
"!",
|
|
"#",
|
|
"$",
|
|
"%",
|
|
"&",
|
|
"'",
|
|
"*",
|
|
"+",
|
|
"-",
|
|
".",
|
|
"^",
|
|
"_",
|
|
"`",
|
|
"|",
|
|
"~"
|
|
].concat(exports2.ALPHANUM);
|
|
exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
|
|
exports2.HEADER_CHARS = [" "];
|
|
for (let i2 = 32; i2 <= 255; i2++) {
|
|
if (i2 !== 127) {
|
|
exports2.HEADER_CHARS.push(i2);
|
|
}
|
|
}
|
|
exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
|
|
exports2.MAJOR = exports2.NUM_MAP;
|
|
exports2.MINOR = exports2.MAJOR;
|
|
var HEADER_STATE;
|
|
(function(HEADER_STATE2) {
|
|
HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
|
|
HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
|
|
HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
|
|
HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
|
|
HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
|
|
HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
|
|
HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
|
|
HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
|
|
HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
|
|
})(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
|
|
exports2.SPECIAL_HEADERS = {
|
|
"connection": HEADER_STATE.CONNECTION,
|
|
"content-length": HEADER_STATE.CONTENT_LENGTH,
|
|
"proxy-connection": HEADER_STATE.CONNECTION,
|
|
"transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
|
|
"upgrade": HEADER_STATE.UPGRADE
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/handler/RedirectHandler.js
|
|
var require_RedirectHandler = __commonJS({
|
|
"node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) {
|
|
"use strict";
|
|
var util = require_util();
|
|
var { kBodyUsed } = require_symbols();
|
|
var assert = require("assert");
|
|
var { InvalidArgumentError } = require_errors();
|
|
var EE = require("events");
|
|
var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
|
|
var kBody = Symbol("body");
|
|
var BodyAsyncIterable = class {
|
|
constructor(body) {
|
|
this[kBody] = body;
|
|
this[kBodyUsed] = false;
|
|
}
|
|
async *[Symbol.asyncIterator]() {
|
|
assert(!this[kBodyUsed], "disturbed");
|
|
this[kBodyUsed] = true;
|
|
yield* this[kBody];
|
|
}
|
|
};
|
|
var RedirectHandler = class {
|
|
constructor(dispatch, maxRedirections, opts, handler) {
|
|
if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
|
|
throw new InvalidArgumentError("maxRedirections must be a positive number");
|
|
}
|
|
util.validateHandler(handler, opts.method, opts.upgrade);
|
|
this.dispatch = dispatch;
|
|
this.location = null;
|
|
this.abort = null;
|
|
this.opts = { ...opts, maxRedirections: 0 };
|
|
this.maxRedirections = maxRedirections;
|
|
this.handler = handler;
|
|
this.history = [];
|
|
if (util.isStream(this.opts.body)) {
|
|
if (util.bodyLength(this.opts.body) === 0) {
|
|
this.opts.body.on("data", function() {
|
|
assert(false);
|
|
});
|
|
}
|
|
if (typeof this.opts.body.readableDidRead !== "boolean") {
|
|
this.opts.body[kBodyUsed] = false;
|
|
EE.prototype.on.call(this.opts.body, "data", function() {
|
|
this[kBodyUsed] = true;
|
|
});
|
|
}
|
|
} else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
|
|
this.opts.body = new BodyAsyncIterable(this.opts.body);
|
|
} else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) {
|
|
this.opts.body = new BodyAsyncIterable(this.opts.body);
|
|
}
|
|
}
|
|
onConnect(abort) {
|
|
this.abort = abort;
|
|
this.handler.onConnect(abort, { history: this.history });
|
|
}
|
|
onUpgrade(statusCode, headers, socket) {
|
|
this.handler.onUpgrade(statusCode, headers, socket);
|
|
}
|
|
onError(error) {
|
|
this.handler.onError(error);
|
|
}
|
|
onHeaders(statusCode, headers, resume, statusText) {
|
|
this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
|
|
if (this.opts.origin) {
|
|
this.history.push(new URL(this.opts.path, this.opts.origin));
|
|
}
|
|
if (!this.location) {
|
|
return this.handler.onHeaders(statusCode, headers, resume, statusText);
|
|
}
|
|
const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
|
|
const path3 = search ? `${pathname}${search}` : pathname;
|
|
this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
|
|
this.opts.path = path3;
|
|
this.opts.origin = origin;
|
|
this.opts.maxRedirections = 0;
|
|
this.opts.query = null;
|
|
if (statusCode === 303 && this.opts.method !== "HEAD") {
|
|
this.opts.method = "GET";
|
|
this.opts.body = null;
|
|
}
|
|
}
|
|
onData(chunk) {
|
|
if (this.location) {
|
|
} else {
|
|
return this.handler.onData(chunk);
|
|
}
|
|
}
|
|
onComplete(trailers) {
|
|
if (this.location) {
|
|
this.location = null;
|
|
this.abort = null;
|
|
this.dispatch(this.opts, this);
|
|
} else {
|
|
this.handler.onComplete(trailers);
|
|
}
|
|
}
|
|
onBodySent(chunk) {
|
|
if (this.handler.onBodySent) {
|
|
this.handler.onBodySent(chunk);
|
|
}
|
|
}
|
|
};
|
|
function parseLocation(statusCode, headers) {
|
|
if (redirectableStatusCodes.indexOf(statusCode) === -1) {
|
|
return null;
|
|
}
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
if (headers[i2].toString().toLowerCase() === "location") {
|
|
return headers[i2 + 1];
|
|
}
|
|
}
|
|
}
|
|
function shouldRemoveHeader(header, removeContent, unknownOrigin) {
|
|
if (header.length === 4) {
|
|
return util.headerNameToString(header) === "host";
|
|
}
|
|
if (removeContent && util.headerNameToString(header).startsWith("content-")) {
|
|
return true;
|
|
}
|
|
if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
|
|
const name = util.headerNameToString(header);
|
|
return name === "authorization" || name === "cookie" || name === "proxy-authorization";
|
|
}
|
|
return false;
|
|
}
|
|
function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
|
|
const ret = [];
|
|
if (Array.isArray(headers)) {
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
if (!shouldRemoveHeader(headers[i2], removeContent, unknownOrigin)) {
|
|
ret.push(headers[i2], headers[i2 + 1]);
|
|
}
|
|
}
|
|
} else if (headers && typeof headers === "object") {
|
|
for (const key of Object.keys(headers)) {
|
|
if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
|
|
ret.push(key, headers[key]);
|
|
}
|
|
}
|
|
} else {
|
|
assert(headers == null, "headers must be an object or an array");
|
|
}
|
|
return ret;
|
|
}
|
|
module2.exports = RedirectHandler;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/interceptor/redirectInterceptor.js
|
|
var require_redirectInterceptor = __commonJS({
|
|
"node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) {
|
|
"use strict";
|
|
var RedirectHandler = require_RedirectHandler();
|
|
function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
|
|
return (dispatch) => {
|
|
return function Intercept(opts, handler) {
|
|
const { maxRedirections = defaultMaxRedirections } = opts;
|
|
if (!maxRedirections) {
|
|
return dispatch(opts, handler);
|
|
}
|
|
const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
|
|
opts = { ...opts, maxRedirections: 0 };
|
|
return dispatch(opts, redirectHandler);
|
|
};
|
|
};
|
|
}
|
|
module2.exports = createRedirectInterceptor;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/llhttp/llhttp-wasm.js
|
|
var require_llhttp_wasm = __commonJS({
|
|
"node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) {
|
|
module2.exports = "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";
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
|
|
var require_llhttp_simd_wasm = __commonJS({
|
|
"node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
|
|
module2.exports = "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";
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/client.js
|
|
var require_client = __commonJS({
|
|
"node_modules/undici/lib/client.js"(exports2, module2) {
|
|
"use strict";
|
|
var assert = require("assert");
|
|
var net = require("net");
|
|
var http3 = require("http");
|
|
var { pipeline: pipeline3 } = require("stream");
|
|
var util = require_util();
|
|
var timers = require_timers();
|
|
var Request2 = require_request();
|
|
var DispatcherBase = require_dispatcher_base();
|
|
var {
|
|
RequestContentLengthMismatchError,
|
|
ResponseContentLengthMismatchError,
|
|
InvalidArgumentError,
|
|
RequestAbortedError,
|
|
HeadersTimeoutError,
|
|
HeadersOverflowError,
|
|
SocketError,
|
|
InformationalError,
|
|
BodyTimeoutError,
|
|
HTTPParserError,
|
|
ResponseExceededMaxSizeError,
|
|
ClientDestroyedError
|
|
} = require_errors();
|
|
var buildConnector = require_connect();
|
|
var {
|
|
kUrl,
|
|
kReset,
|
|
kServerName,
|
|
kClient,
|
|
kBusy,
|
|
kParser,
|
|
kConnect,
|
|
kBlocking,
|
|
kResuming,
|
|
kRunning,
|
|
kPending,
|
|
kSize,
|
|
kWriting,
|
|
kQueue,
|
|
kConnected,
|
|
kConnecting,
|
|
kNeedDrain,
|
|
kNoRef,
|
|
kKeepAliveDefaultTimeout,
|
|
kHostHeader,
|
|
kPendingIdx,
|
|
kRunningIdx,
|
|
kError,
|
|
kPipelining,
|
|
kSocket,
|
|
kKeepAliveTimeoutValue,
|
|
kMaxHeadersSize,
|
|
kKeepAliveMaxTimeout,
|
|
kKeepAliveTimeoutThreshold,
|
|
kHeadersTimeout,
|
|
kBodyTimeout,
|
|
kStrictContentLength,
|
|
kConnector,
|
|
kMaxRedirections,
|
|
kMaxRequests,
|
|
kCounter,
|
|
kClose,
|
|
kDestroy,
|
|
kDispatch,
|
|
kInterceptors,
|
|
kLocalAddress,
|
|
kMaxResponseSize,
|
|
kHTTPConnVersion,
|
|
// HTTP2
|
|
kHost,
|
|
kHTTP2Session,
|
|
kHTTP2SessionState,
|
|
kHTTP2BuildRequest,
|
|
kHTTP2CopyHeaders,
|
|
kHTTP1BuildRequest
|
|
} = require_symbols();
|
|
var http22;
|
|
try {
|
|
http22 = require("http2");
|
|
} catch {
|
|
http22 = { constants: {} };
|
|
}
|
|
var {
|
|
constants: {
|
|
HTTP2_HEADER_AUTHORITY,
|
|
HTTP2_HEADER_METHOD,
|
|
HTTP2_HEADER_PATH,
|
|
HTTP2_HEADER_SCHEME,
|
|
HTTP2_HEADER_CONTENT_LENGTH,
|
|
HTTP2_HEADER_EXPECT,
|
|
HTTP2_HEADER_STATUS
|
|
}
|
|
} = http22;
|
|
var h2ExperimentalWarned = false;
|
|
var FastBuffer = Buffer[Symbol.species];
|
|
var kClosedResolve = Symbol("kClosedResolve");
|
|
var channels = {};
|
|
try {
|
|
const diagnosticsChannel = require("diagnostics_channel");
|
|
channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
|
|
channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
|
|
channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
|
|
channels.connected = diagnosticsChannel.channel("undici:client:connected");
|
|
} catch {
|
|
channels.sendHeaders = { hasSubscribers: false };
|
|
channels.beforeConnect = { hasSubscribers: false };
|
|
channels.connectError = { hasSubscribers: false };
|
|
channels.connected = { hasSubscribers: false };
|
|
}
|
|
var Client = class extends DispatcherBase {
|
|
/**
|
|
*
|
|
* @param {string|URL} url
|
|
* @param {import('../types/client').Client.Options} options
|
|
*/
|
|
constructor(url, {
|
|
interceptors,
|
|
maxHeaderSize,
|
|
headersTimeout,
|
|
socketTimeout,
|
|
requestTimeout,
|
|
connectTimeout,
|
|
bodyTimeout,
|
|
idleTimeout,
|
|
keepAlive,
|
|
keepAliveTimeout,
|
|
maxKeepAliveTimeout,
|
|
keepAliveMaxTimeout,
|
|
keepAliveTimeoutThreshold,
|
|
socketPath,
|
|
pipelining,
|
|
tls,
|
|
strictContentLength,
|
|
maxCachedSessions,
|
|
maxRedirections,
|
|
connect: connect2,
|
|
maxRequestsPerClient,
|
|
localAddress,
|
|
maxResponseSize,
|
|
autoSelectFamily,
|
|
autoSelectFamilyAttemptTimeout,
|
|
// h2
|
|
allowH2,
|
|
maxConcurrentStreams
|
|
} = {}) {
|
|
super();
|
|
if (keepAlive !== void 0) {
|
|
throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
|
|
}
|
|
if (socketTimeout !== void 0) {
|
|
throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
|
|
}
|
|
if (requestTimeout !== void 0) {
|
|
throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
|
|
}
|
|
if (idleTimeout !== void 0) {
|
|
throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
|
|
}
|
|
if (maxKeepAliveTimeout !== void 0) {
|
|
throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
|
|
}
|
|
if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
|
|
throw new InvalidArgumentError("invalid maxHeaderSize");
|
|
}
|
|
if (socketPath != null && typeof socketPath !== "string") {
|
|
throw new InvalidArgumentError("invalid socketPath");
|
|
}
|
|
if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
|
|
throw new InvalidArgumentError("invalid connectTimeout");
|
|
}
|
|
if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
|
|
throw new InvalidArgumentError("invalid keepAliveTimeout");
|
|
}
|
|
if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
|
|
throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
|
|
}
|
|
if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
|
|
throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
|
|
}
|
|
if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
|
|
throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
|
|
}
|
|
if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
|
|
throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
|
|
}
|
|
if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
|
|
throw new InvalidArgumentError("connect must be a function or an object");
|
|
}
|
|
if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
|
|
throw new InvalidArgumentError("maxRedirections must be a positive number");
|
|
}
|
|
if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
|
|
throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
|
|
}
|
|
if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) {
|
|
throw new InvalidArgumentError("localAddress must be valid string IP address");
|
|
}
|
|
if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
|
|
throw new InvalidArgumentError("maxResponseSize must be a positive number");
|
|
}
|
|
if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
|
|
throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
|
|
}
|
|
if (allowH2 != null && typeof allowH2 !== "boolean") {
|
|
throw new InvalidArgumentError("allowH2 must be a valid boolean value");
|
|
}
|
|
if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
|
|
throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0");
|
|
}
|
|
if (typeof connect2 !== "function") {
|
|
connect2 = buildConnector({
|
|
...tls,
|
|
maxCachedSessions,
|
|
allowH2,
|
|
socketPath,
|
|
timeout: connectTimeout,
|
|
...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
|
|
...connect2
|
|
});
|
|
}
|
|
this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
|
|
this[kUrl] = util.parseOrigin(url);
|
|
this[kConnector] = connect2;
|
|
this[kSocket] = null;
|
|
this[kPipelining] = pipelining != null ? pipelining : 1;
|
|
this[kMaxHeadersSize] = maxHeaderSize || http3.maxHeaderSize;
|
|
this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
|
|
this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
|
|
this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold;
|
|
this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
|
|
this[kServerName] = null;
|
|
this[kLocalAddress] = localAddress != null ? localAddress : null;
|
|
this[kResuming] = 0;
|
|
this[kNeedDrain] = 0;
|
|
this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
|
|
`;
|
|
this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
|
|
this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
|
|
this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
|
|
this[kMaxRedirections] = maxRedirections;
|
|
this[kMaxRequests] = maxRequestsPerClient;
|
|
this[kClosedResolve] = null;
|
|
this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
|
|
this[kHTTPConnVersion] = "h1";
|
|
this[kHTTP2Session] = null;
|
|
this[kHTTP2SessionState] = !allowH2 ? null : {
|
|
// streams: null, // Fixed queue of streams - For future support of `push`
|
|
openStreams: 0,
|
|
// Keep track of them to decide wether or not unref the session
|
|
maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100
|
|
// Max peerConcurrentStreams for a Node h2 server
|
|
};
|
|
this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
|
|
this[kQueue] = [];
|
|
this[kRunningIdx] = 0;
|
|
this[kPendingIdx] = 0;
|
|
}
|
|
get pipelining() {
|
|
return this[kPipelining];
|
|
}
|
|
set pipelining(value) {
|
|
this[kPipelining] = value;
|
|
resume(this, true);
|
|
}
|
|
get [kPending]() {
|
|
return this[kQueue].length - this[kPendingIdx];
|
|
}
|
|
get [kRunning]() {
|
|
return this[kPendingIdx] - this[kRunningIdx];
|
|
}
|
|
get [kSize]() {
|
|
return this[kQueue].length - this[kRunningIdx];
|
|
}
|
|
get [kConnected]() {
|
|
return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
|
|
}
|
|
get [kBusy]() {
|
|
const socket = this[kSocket];
|
|
return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
|
|
}
|
|
/* istanbul ignore: only used for test */
|
|
[kConnect](cb) {
|
|
connect(this);
|
|
this.once("connect", cb);
|
|
}
|
|
[kDispatch](opts, handler) {
|
|
const origin = opts.origin || this[kUrl].origin;
|
|
const request = this[kHTTPConnVersion] === "h2" ? Request2[kHTTP2BuildRequest](origin, opts, handler) : Request2[kHTTP1BuildRequest](origin, opts, handler);
|
|
this[kQueue].push(request);
|
|
if (this[kResuming]) {
|
|
} else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
|
|
this[kResuming] = 1;
|
|
process.nextTick(resume, this);
|
|
} else {
|
|
resume(this, true);
|
|
}
|
|
if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
|
|
this[kNeedDrain] = 2;
|
|
}
|
|
return this[kNeedDrain] < 2;
|
|
}
|
|
async [kClose]() {
|
|
return new Promise((resolve) => {
|
|
if (!this[kSize]) {
|
|
resolve(null);
|
|
} else {
|
|
this[kClosedResolve] = resolve;
|
|
}
|
|
});
|
|
}
|
|
async [kDestroy](err) {
|
|
return new Promise((resolve) => {
|
|
const requests = this[kQueue].splice(this[kPendingIdx]);
|
|
for (let i2 = 0; i2 < requests.length; i2++) {
|
|
const request = requests[i2];
|
|
errorRequest(this, request, err);
|
|
}
|
|
const callback = () => {
|
|
if (this[kClosedResolve]) {
|
|
this[kClosedResolve]();
|
|
this[kClosedResolve] = null;
|
|
}
|
|
resolve();
|
|
};
|
|
if (this[kHTTP2Session] != null) {
|
|
util.destroy(this[kHTTP2Session], err);
|
|
this[kHTTP2Session] = null;
|
|
this[kHTTP2SessionState] = null;
|
|
}
|
|
if (!this[kSocket]) {
|
|
queueMicrotask(callback);
|
|
} else {
|
|
util.destroy(this[kSocket].on("close", callback), err);
|
|
}
|
|
resume(this);
|
|
});
|
|
}
|
|
};
|
|
function onHttp2SessionError(err) {
|
|
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
|
|
this[kSocket][kError] = err;
|
|
onError(this[kClient], err);
|
|
}
|
|
function onHttp2FrameError(type, code, id) {
|
|
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
|
|
if (id === 0) {
|
|
this[kSocket][kError] = err;
|
|
onError(this[kClient], err);
|
|
}
|
|
}
|
|
function onHttp2SessionEnd() {
|
|
util.destroy(this, new SocketError("other side closed"));
|
|
util.destroy(this[kSocket], new SocketError("other side closed"));
|
|
}
|
|
function onHTTP2GoAway(code) {
|
|
const client = this[kClient];
|
|
const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`);
|
|
client[kSocket] = null;
|
|
client[kHTTP2Session] = null;
|
|
if (client.destroyed) {
|
|
assert(this[kPending] === 0);
|
|
const requests = client[kQueue].splice(client[kRunningIdx]);
|
|
for (let i2 = 0; i2 < requests.length; i2++) {
|
|
const request = requests[i2];
|
|
errorRequest(this, request, err);
|
|
}
|
|
} else if (client[kRunning] > 0) {
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
client[kQueue][client[kRunningIdx]++] = null;
|
|
errorRequest(client, request, err);
|
|
}
|
|
client[kPendingIdx] = client[kRunningIdx];
|
|
assert(client[kRunning] === 0);
|
|
client.emit(
|
|
"disconnect",
|
|
client[kUrl],
|
|
[client],
|
|
err
|
|
);
|
|
resume(client);
|
|
}
|
|
var constants = require_constants3();
|
|
var createRedirectInterceptor = require_redirectInterceptor();
|
|
var EMPTY_BUF = Buffer.alloc(0);
|
|
async function lazyllhttp() {
|
|
const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
|
|
let mod;
|
|
try {
|
|
mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64"));
|
|
} catch (e2) {
|
|
mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64"));
|
|
}
|
|
return await WebAssembly.instantiate(mod, {
|
|
env: {
|
|
/* eslint-disable camelcase */
|
|
wasm_on_url: (p, at, len) => {
|
|
return 0;
|
|
},
|
|
wasm_on_status: (p, at, len) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
|
|
return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
|
|
},
|
|
wasm_on_message_begin: (p) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
return currentParser.onMessageBegin() || 0;
|
|
},
|
|
wasm_on_header_field: (p, at, len) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
|
|
return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
|
|
},
|
|
wasm_on_header_value: (p, at, len) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
|
|
return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
|
|
},
|
|
wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
|
|
},
|
|
wasm_on_body: (p, at, len) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
|
|
return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
|
|
},
|
|
wasm_on_message_complete: (p) => {
|
|
assert.strictEqual(currentParser.ptr, p);
|
|
return currentParser.onMessageComplete() || 0;
|
|
}
|
|
/* eslint-enable camelcase */
|
|
}
|
|
});
|
|
}
|
|
var llhttpInstance = null;
|
|
var llhttpPromise = lazyllhttp();
|
|
llhttpPromise.catch();
|
|
var currentParser = null;
|
|
var currentBufferRef = null;
|
|
var currentBufferSize = 0;
|
|
var currentBufferPtr = null;
|
|
var TIMEOUT_HEADERS = 1;
|
|
var TIMEOUT_BODY = 2;
|
|
var TIMEOUT_IDLE = 3;
|
|
var Parser = class {
|
|
constructor(client, socket, { exports: exports3 }) {
|
|
assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
|
|
this.llhttp = exports3;
|
|
this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE);
|
|
this.client = client;
|
|
this.socket = socket;
|
|
this.timeout = null;
|
|
this.timeoutValue = null;
|
|
this.timeoutType = null;
|
|
this.statusCode = null;
|
|
this.statusText = "";
|
|
this.upgrade = false;
|
|
this.headers = [];
|
|
this.headersSize = 0;
|
|
this.headersMaxSize = client[kMaxHeadersSize];
|
|
this.shouldKeepAlive = false;
|
|
this.paused = false;
|
|
this.resume = this.resume.bind(this);
|
|
this.bytesRead = 0;
|
|
this.keepAlive = "";
|
|
this.contentLength = "";
|
|
this.connection = "";
|
|
this.maxResponseSize = client[kMaxResponseSize];
|
|
}
|
|
setTimeout(value, type) {
|
|
this.timeoutType = type;
|
|
if (value !== this.timeoutValue) {
|
|
timers.clearTimeout(this.timeout);
|
|
if (value) {
|
|
this.timeout = timers.setTimeout(onParserTimeout, value, this);
|
|
if (this.timeout.unref) {
|
|
this.timeout.unref();
|
|
}
|
|
} else {
|
|
this.timeout = null;
|
|
}
|
|
this.timeoutValue = value;
|
|
} else if (this.timeout) {
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh();
|
|
}
|
|
}
|
|
}
|
|
resume() {
|
|
if (this.socket.destroyed || !this.paused) {
|
|
return;
|
|
}
|
|
assert(this.ptr != null);
|
|
assert(currentParser == null);
|
|
this.llhttp.llhttp_resume(this.ptr);
|
|
assert(this.timeoutType === TIMEOUT_BODY);
|
|
if (this.timeout) {
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh();
|
|
}
|
|
}
|
|
this.paused = false;
|
|
this.execute(this.socket.read() || EMPTY_BUF);
|
|
this.readMore();
|
|
}
|
|
readMore() {
|
|
while (!this.paused && this.ptr) {
|
|
const chunk = this.socket.read();
|
|
if (chunk === null) {
|
|
break;
|
|
}
|
|
this.execute(chunk);
|
|
}
|
|
}
|
|
execute(data) {
|
|
assert(this.ptr != null);
|
|
assert(currentParser == null);
|
|
assert(!this.paused);
|
|
const { socket, llhttp } = this;
|
|
if (data.length > currentBufferSize) {
|
|
if (currentBufferPtr) {
|
|
llhttp.free(currentBufferPtr);
|
|
}
|
|
currentBufferSize = Math.ceil(data.length / 4096) * 4096;
|
|
currentBufferPtr = llhttp.malloc(currentBufferSize);
|
|
}
|
|
new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
|
|
try {
|
|
let ret;
|
|
try {
|
|
currentBufferRef = data;
|
|
currentParser = this;
|
|
ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
|
|
} catch (err) {
|
|
throw err;
|
|
} finally {
|
|
currentParser = null;
|
|
currentBufferRef = null;
|
|
}
|
|
const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
|
|
if (ret === constants.ERROR.PAUSED_UPGRADE) {
|
|
this.onUpgrade(data.slice(offset));
|
|
} else if (ret === constants.ERROR.PAUSED) {
|
|
this.paused = true;
|
|
socket.unshift(data.slice(offset));
|
|
} else if (ret !== constants.ERROR.OK) {
|
|
const ptr = llhttp.llhttp_get_error_reason(this.ptr);
|
|
let message = "";
|
|
if (ptr) {
|
|
const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
|
|
message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
|
|
}
|
|
throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset));
|
|
}
|
|
} catch (err) {
|
|
util.destroy(socket, err);
|
|
}
|
|
}
|
|
destroy() {
|
|
assert(this.ptr != null);
|
|
assert(currentParser == null);
|
|
this.llhttp.llhttp_free(this.ptr);
|
|
this.ptr = null;
|
|
timers.clearTimeout(this.timeout);
|
|
this.timeout = null;
|
|
this.timeoutValue = null;
|
|
this.timeoutType = null;
|
|
this.paused = false;
|
|
}
|
|
onStatus(buf) {
|
|
this.statusText = buf.toString();
|
|
}
|
|
onMessageBegin() {
|
|
const { socket, client } = this;
|
|
if (socket.destroyed) {
|
|
return -1;
|
|
}
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
if (!request) {
|
|
return -1;
|
|
}
|
|
}
|
|
onHeaderField(buf) {
|
|
const len = this.headers.length;
|
|
if ((len & 1) === 0) {
|
|
this.headers.push(buf);
|
|
} else {
|
|
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
|
|
}
|
|
this.trackHeader(buf.length);
|
|
}
|
|
onHeaderValue(buf) {
|
|
let len = this.headers.length;
|
|
if ((len & 1) === 1) {
|
|
this.headers.push(buf);
|
|
len += 1;
|
|
} else {
|
|
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
|
|
}
|
|
const key = this.headers[len - 2];
|
|
if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") {
|
|
this.keepAlive += buf.toString();
|
|
} else if (key.length === 10 && key.toString().toLowerCase() === "connection") {
|
|
this.connection += buf.toString();
|
|
} else if (key.length === 14 && key.toString().toLowerCase() === "content-length") {
|
|
this.contentLength += buf.toString();
|
|
}
|
|
this.trackHeader(buf.length);
|
|
}
|
|
trackHeader(len) {
|
|
this.headersSize += len;
|
|
if (this.headersSize >= this.headersMaxSize) {
|
|
util.destroy(this.socket, new HeadersOverflowError());
|
|
}
|
|
}
|
|
onUpgrade(head) {
|
|
const { upgrade, client, socket, headers, statusCode } = this;
|
|
assert(upgrade);
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
assert(request);
|
|
assert(!socket.destroyed);
|
|
assert(socket === client[kSocket]);
|
|
assert(!this.paused);
|
|
assert(request.upgrade || request.method === "CONNECT");
|
|
this.statusCode = null;
|
|
this.statusText = "";
|
|
this.shouldKeepAlive = null;
|
|
assert(this.headers.length % 2 === 0);
|
|
this.headers = [];
|
|
this.headersSize = 0;
|
|
socket.unshift(head);
|
|
socket[kParser].destroy();
|
|
socket[kParser] = null;
|
|
socket[kClient] = null;
|
|
socket[kError] = null;
|
|
socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
|
|
client[kSocket] = null;
|
|
client[kQueue][client[kRunningIdx]++] = null;
|
|
client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
|
|
try {
|
|
request.onUpgrade(statusCode, headers, socket);
|
|
} catch (err) {
|
|
util.destroy(socket, err);
|
|
}
|
|
resume(client);
|
|
}
|
|
onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
|
|
const { client, socket, headers, statusText } = this;
|
|
if (socket.destroyed) {
|
|
return -1;
|
|
}
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
if (!request) {
|
|
return -1;
|
|
}
|
|
assert(!this.upgrade);
|
|
assert(this.statusCode < 200);
|
|
if (statusCode === 100) {
|
|
util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
|
|
return -1;
|
|
}
|
|
if (upgrade && !request.upgrade) {
|
|
util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
|
|
return -1;
|
|
}
|
|
assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
|
|
this.statusCode = statusCode;
|
|
this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
|
|
request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
|
|
if (this.statusCode >= 200) {
|
|
const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
|
|
this.setTimeout(bodyTimeout, TIMEOUT_BODY);
|
|
} else if (this.timeout) {
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh();
|
|
}
|
|
}
|
|
if (request.method === "CONNECT") {
|
|
assert(client[kRunning] === 1);
|
|
this.upgrade = true;
|
|
return 2;
|
|
}
|
|
if (upgrade) {
|
|
assert(client[kRunning] === 1);
|
|
this.upgrade = true;
|
|
return 2;
|
|
}
|
|
assert(this.headers.length % 2 === 0);
|
|
this.headers = [];
|
|
this.headersSize = 0;
|
|
if (this.shouldKeepAlive && client[kPipelining]) {
|
|
const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
|
|
if (keepAliveTimeout != null) {
|
|
const timeout = Math.min(
|
|
keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
|
|
client[kKeepAliveMaxTimeout]
|
|
);
|
|
if (timeout <= 0) {
|
|
socket[kReset] = true;
|
|
} else {
|
|
client[kKeepAliveTimeoutValue] = timeout;
|
|
}
|
|
} else {
|
|
client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
|
|
}
|
|
} else {
|
|
socket[kReset] = true;
|
|
}
|
|
const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
|
|
if (request.aborted) {
|
|
return -1;
|
|
}
|
|
if (request.method === "HEAD") {
|
|
return 1;
|
|
}
|
|
if (statusCode < 200) {
|
|
return 1;
|
|
}
|
|
if (socket[kBlocking]) {
|
|
socket[kBlocking] = false;
|
|
resume(client);
|
|
}
|
|
return pause ? constants.ERROR.PAUSED : 0;
|
|
}
|
|
onBody(buf) {
|
|
const { client, socket, statusCode, maxResponseSize } = this;
|
|
if (socket.destroyed) {
|
|
return -1;
|
|
}
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
assert(request);
|
|
assert.strictEqual(this.timeoutType, TIMEOUT_BODY);
|
|
if (this.timeout) {
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh();
|
|
}
|
|
}
|
|
assert(statusCode >= 200);
|
|
if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
|
|
util.destroy(socket, new ResponseExceededMaxSizeError());
|
|
return -1;
|
|
}
|
|
this.bytesRead += buf.length;
|
|
if (request.onData(buf) === false) {
|
|
return constants.ERROR.PAUSED;
|
|
}
|
|
}
|
|
onMessageComplete() {
|
|
const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
|
|
if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
|
|
return -1;
|
|
}
|
|
if (upgrade) {
|
|
return;
|
|
}
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
assert(request);
|
|
assert(statusCode >= 100);
|
|
this.statusCode = null;
|
|
this.statusText = "";
|
|
this.bytesRead = 0;
|
|
this.contentLength = "";
|
|
this.keepAlive = "";
|
|
this.connection = "";
|
|
assert(this.headers.length % 2 === 0);
|
|
this.headers = [];
|
|
this.headersSize = 0;
|
|
if (statusCode < 200) {
|
|
return;
|
|
}
|
|
if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
|
|
util.destroy(socket, new ResponseContentLengthMismatchError());
|
|
return -1;
|
|
}
|
|
request.onComplete(headers);
|
|
client[kQueue][client[kRunningIdx]++] = null;
|
|
if (socket[kWriting]) {
|
|
assert.strictEqual(client[kRunning], 0);
|
|
util.destroy(socket, new InformationalError("reset"));
|
|
return constants.ERROR.PAUSED;
|
|
} else if (!shouldKeepAlive) {
|
|
util.destroy(socket, new InformationalError("reset"));
|
|
return constants.ERROR.PAUSED;
|
|
} else if (socket[kReset] && client[kRunning] === 0) {
|
|
util.destroy(socket, new InformationalError("reset"));
|
|
return constants.ERROR.PAUSED;
|
|
} else if (client[kPipelining] === 1) {
|
|
setImmediate(resume, client);
|
|
} else {
|
|
resume(client);
|
|
}
|
|
}
|
|
};
|
|
function onParserTimeout(parser) {
|
|
const { socket, timeoutType, client } = parser;
|
|
if (timeoutType === TIMEOUT_HEADERS) {
|
|
if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
|
|
assert(!parser.paused, "cannot be paused while waiting for headers");
|
|
util.destroy(socket, new HeadersTimeoutError());
|
|
}
|
|
} else if (timeoutType === TIMEOUT_BODY) {
|
|
if (!parser.paused) {
|
|
util.destroy(socket, new BodyTimeoutError());
|
|
}
|
|
} else if (timeoutType === TIMEOUT_IDLE) {
|
|
assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
|
|
util.destroy(socket, new InformationalError("socket idle timeout"));
|
|
}
|
|
}
|
|
function onSocketReadable() {
|
|
const { [kParser]: parser } = this;
|
|
if (parser) {
|
|
parser.readMore();
|
|
}
|
|
}
|
|
function onSocketError(err) {
|
|
const { [kClient]: client, [kParser]: parser } = this;
|
|
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
|
|
if (client[kHTTPConnVersion] !== "h2") {
|
|
if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
|
|
parser.onMessageComplete();
|
|
return;
|
|
}
|
|
}
|
|
this[kError] = err;
|
|
onError(this[kClient], err);
|
|
}
|
|
function onError(client, err) {
|
|
if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
|
|
assert(client[kPendingIdx] === client[kRunningIdx]);
|
|
const requests = client[kQueue].splice(client[kRunningIdx]);
|
|
for (let i2 = 0; i2 < requests.length; i2++) {
|
|
const request = requests[i2];
|
|
errorRequest(client, request, err);
|
|
}
|
|
assert(client[kSize] === 0);
|
|
}
|
|
}
|
|
function onSocketEnd() {
|
|
const { [kParser]: parser, [kClient]: client } = this;
|
|
if (client[kHTTPConnVersion] !== "h2") {
|
|
if (parser.statusCode && !parser.shouldKeepAlive) {
|
|
parser.onMessageComplete();
|
|
return;
|
|
}
|
|
}
|
|
util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
|
|
}
|
|
function onSocketClose() {
|
|
const { [kClient]: client, [kParser]: parser } = this;
|
|
if (client[kHTTPConnVersion] === "h1" && parser) {
|
|
if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
|
|
parser.onMessageComplete();
|
|
}
|
|
this[kParser].destroy();
|
|
this[kParser] = null;
|
|
}
|
|
const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
|
|
client[kSocket] = null;
|
|
if (client.destroyed) {
|
|
assert(client[kPending] === 0);
|
|
const requests = client[kQueue].splice(client[kRunningIdx]);
|
|
for (let i2 = 0; i2 < requests.length; i2++) {
|
|
const request = requests[i2];
|
|
errorRequest(client, request, err);
|
|
}
|
|
} else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
|
|
const request = client[kQueue][client[kRunningIdx]];
|
|
client[kQueue][client[kRunningIdx]++] = null;
|
|
errorRequest(client, request, err);
|
|
}
|
|
client[kPendingIdx] = client[kRunningIdx];
|
|
assert(client[kRunning] === 0);
|
|
client.emit("disconnect", client[kUrl], [client], err);
|
|
resume(client);
|
|
}
|
|
async function connect(client) {
|
|
assert(!client[kConnecting]);
|
|
assert(!client[kSocket]);
|
|
let { host, hostname, protocol, port } = client[kUrl];
|
|
if (hostname[0] === "[") {
|
|
const idx = hostname.indexOf("]");
|
|
assert(idx !== -1);
|
|
const ip = hostname.substring(1, idx);
|
|
assert(net.isIP(ip));
|
|
hostname = ip;
|
|
}
|
|
client[kConnecting] = true;
|
|
if (channels.beforeConnect.hasSubscribers) {
|
|
channels.beforeConnect.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
},
|
|
connector: client[kConnector]
|
|
});
|
|
}
|
|
try {
|
|
const socket = await new Promise((resolve, reject) => {
|
|
client[kConnector]({
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
}, (err, socket2) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(socket2);
|
|
}
|
|
});
|
|
});
|
|
if (client.destroyed) {
|
|
util.destroy(socket.on("error", () => {
|
|
}), new ClientDestroyedError());
|
|
return;
|
|
}
|
|
client[kConnecting] = false;
|
|
assert(socket);
|
|
const isH2 = socket.alpnProtocol === "h2";
|
|
if (isH2) {
|
|
if (!h2ExperimentalWarned) {
|
|
h2ExperimentalWarned = true;
|
|
process.emitWarning("H2 support is experimental, expect them to change at any time.", {
|
|
code: "UNDICI-H2"
|
|
});
|
|
}
|
|
const session = http22.connect(client[kUrl], {
|
|
createConnection: () => socket,
|
|
peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
|
|
});
|
|
client[kHTTPConnVersion] = "h2";
|
|
session[kClient] = client;
|
|
session[kSocket] = socket;
|
|
session.on("error", onHttp2SessionError);
|
|
session.on("frameError", onHttp2FrameError);
|
|
session.on("end", onHttp2SessionEnd);
|
|
session.on("goaway", onHTTP2GoAway);
|
|
session.on("close", onSocketClose);
|
|
session.unref();
|
|
client[kHTTP2Session] = session;
|
|
socket[kHTTP2Session] = session;
|
|
} else {
|
|
if (!llhttpInstance) {
|
|
llhttpInstance = await llhttpPromise;
|
|
llhttpPromise = null;
|
|
}
|
|
socket[kNoRef] = false;
|
|
socket[kWriting] = false;
|
|
socket[kReset] = false;
|
|
socket[kBlocking] = false;
|
|
socket[kParser] = new Parser(client, socket, llhttpInstance);
|
|
}
|
|
socket[kCounter] = 0;
|
|
socket[kMaxRequests] = client[kMaxRequests];
|
|
socket[kClient] = client;
|
|
socket[kError] = null;
|
|
socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
|
|
client[kSocket] = socket;
|
|
if (channels.connected.hasSubscribers) {
|
|
channels.connected.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
},
|
|
connector: client[kConnector],
|
|
socket
|
|
});
|
|
}
|
|
client.emit("connect", client[kUrl], [client]);
|
|
} catch (err) {
|
|
if (client.destroyed) {
|
|
return;
|
|
}
|
|
client[kConnecting] = false;
|
|
if (channels.connectError.hasSubscribers) {
|
|
channels.connectError.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
},
|
|
connector: client[kConnector],
|
|
error: err
|
|
});
|
|
}
|
|
if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
|
|
assert(client[kRunning] === 0);
|
|
while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
|
|
const request = client[kQueue][client[kPendingIdx]++];
|
|
errorRequest(client, request, err);
|
|
}
|
|
} else {
|
|
onError(client, err);
|
|
}
|
|
client.emit("connectionError", client[kUrl], [client], err);
|
|
}
|
|
resume(client);
|
|
}
|
|
function emitDrain(client) {
|
|
client[kNeedDrain] = 0;
|
|
client.emit("drain", client[kUrl], [client]);
|
|
}
|
|
function resume(client, sync) {
|
|
if (client[kResuming] === 2) {
|
|
return;
|
|
}
|
|
client[kResuming] = 2;
|
|
_resume(client, sync);
|
|
client[kResuming] = 0;
|
|
if (client[kRunningIdx] > 256) {
|
|
client[kQueue].splice(0, client[kRunningIdx]);
|
|
client[kPendingIdx] -= client[kRunningIdx];
|
|
client[kRunningIdx] = 0;
|
|
}
|
|
}
|
|
function _resume(client, sync) {
|
|
while (true) {
|
|
if (client.destroyed) {
|
|
assert(client[kPending] === 0);
|
|
return;
|
|
}
|
|
if (client[kClosedResolve] && !client[kSize]) {
|
|
client[kClosedResolve]();
|
|
client[kClosedResolve] = null;
|
|
return;
|
|
}
|
|
const socket = client[kSocket];
|
|
if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") {
|
|
if (client[kSize] === 0) {
|
|
if (!socket[kNoRef] && socket.unref) {
|
|
socket.unref();
|
|
socket[kNoRef] = true;
|
|
}
|
|
} else if (socket[kNoRef] && socket.ref) {
|
|
socket.ref();
|
|
socket[kNoRef] = false;
|
|
}
|
|
if (client[kSize] === 0) {
|
|
if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
|
|
socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
|
|
}
|
|
} else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
|
|
if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
|
|
const request2 = client[kQueue][client[kRunningIdx]];
|
|
const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout];
|
|
socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
|
|
}
|
|
}
|
|
}
|
|
if (client[kBusy]) {
|
|
client[kNeedDrain] = 2;
|
|
} else if (client[kNeedDrain] === 2) {
|
|
if (sync) {
|
|
client[kNeedDrain] = 1;
|
|
process.nextTick(emitDrain, client);
|
|
} else {
|
|
emitDrain(client);
|
|
}
|
|
continue;
|
|
}
|
|
if (client[kPending] === 0) {
|
|
return;
|
|
}
|
|
if (client[kRunning] >= (client[kPipelining] || 1)) {
|
|
return;
|
|
}
|
|
const request = client[kQueue][client[kPendingIdx]];
|
|
if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
|
|
if (client[kRunning] > 0) {
|
|
return;
|
|
}
|
|
client[kServerName] = request.servername;
|
|
if (socket && socket.servername !== request.servername) {
|
|
util.destroy(socket, new InformationalError("servername changed"));
|
|
return;
|
|
}
|
|
}
|
|
if (client[kConnecting]) {
|
|
return;
|
|
}
|
|
if (!socket && !client[kHTTP2Session]) {
|
|
connect(client);
|
|
return;
|
|
}
|
|
if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) {
|
|
return;
|
|
}
|
|
if (client[kRunning] > 0 && !request.idempotent) {
|
|
return;
|
|
}
|
|
if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) {
|
|
return;
|
|
}
|
|
if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) {
|
|
return;
|
|
}
|
|
if (!request.aborted && write(client, request)) {
|
|
client[kPendingIdx]++;
|
|
} else {
|
|
client[kQueue].splice(client[kPendingIdx], 1);
|
|
}
|
|
}
|
|
}
|
|
function shouldSendContentLength(method) {
|
|
return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
|
|
}
|
|
function write(client, request) {
|
|
if (client[kHTTPConnVersion] === "h2") {
|
|
writeH2(client, client[kHTTP2Session], request);
|
|
return;
|
|
}
|
|
const { body, method, path: path3, host, upgrade, headers, blocking, reset } = request;
|
|
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
|
|
if (body && typeof body.read === "function") {
|
|
body.read(0);
|
|
}
|
|
const bodyLength = util.bodyLength(body);
|
|
let contentLength = bodyLength;
|
|
if (contentLength === null) {
|
|
contentLength = request.contentLength;
|
|
}
|
|
if (contentLength === 0 && !expectsPayload) {
|
|
contentLength = null;
|
|
}
|
|
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
errorRequest(client, request, new RequestContentLengthMismatchError());
|
|
return false;
|
|
}
|
|
process.emitWarning(new RequestContentLengthMismatchError());
|
|
}
|
|
const socket = client[kSocket];
|
|
try {
|
|
request.onConnect((err) => {
|
|
if (request.aborted || request.completed) {
|
|
return;
|
|
}
|
|
errorRequest(client, request, err || new RequestAbortedError());
|
|
util.destroy(socket, new InformationalError("aborted"));
|
|
});
|
|
} catch (err) {
|
|
errorRequest(client, request, err);
|
|
}
|
|
if (request.aborted) {
|
|
return false;
|
|
}
|
|
if (method === "HEAD") {
|
|
socket[kReset] = true;
|
|
}
|
|
if (upgrade || method === "CONNECT") {
|
|
socket[kReset] = true;
|
|
}
|
|
if (reset != null) {
|
|
socket[kReset] = reset;
|
|
}
|
|
if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
|
|
socket[kReset] = true;
|
|
}
|
|
if (blocking) {
|
|
socket[kBlocking] = true;
|
|
}
|
|
let header = `${method} ${path3} HTTP/1.1\r
|
|
`;
|
|
if (typeof host === "string") {
|
|
header += `host: ${host}\r
|
|
`;
|
|
} else {
|
|
header += client[kHostHeader];
|
|
}
|
|
if (upgrade) {
|
|
header += `connection: upgrade\r
|
|
upgrade: ${upgrade}\r
|
|
`;
|
|
} else if (client[kPipelining] && !socket[kReset]) {
|
|
header += "connection: keep-alive\r\n";
|
|
} else {
|
|
header += "connection: close\r\n";
|
|
}
|
|
if (headers) {
|
|
header += headers;
|
|
}
|
|
if (channels.sendHeaders.hasSubscribers) {
|
|
channels.sendHeaders.publish({ request, headers: header, socket });
|
|
}
|
|
if (!body || bodyLength === 0) {
|
|
if (contentLength === 0) {
|
|
socket.write(`${header}content-length: 0\r
|
|
\r
|
|
`, "latin1");
|
|
} else {
|
|
assert(contentLength === null, "no body must not have content length");
|
|
socket.write(`${header}\r
|
|
`, "latin1");
|
|
}
|
|
request.onRequestSent();
|
|
} else if (util.isBuffer(body)) {
|
|
assert(contentLength === body.byteLength, "buffer body must have content length");
|
|
socket.cork();
|
|
socket.write(`${header}content-length: ${contentLength}\r
|
|
\r
|
|
`, "latin1");
|
|
socket.write(body);
|
|
socket.uncork();
|
|
request.onBodySent(body);
|
|
request.onRequestSent();
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true;
|
|
}
|
|
} else if (util.isBlobLike(body)) {
|
|
if (typeof body.stream === "function") {
|
|
writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload });
|
|
} else {
|
|
writeBlob({ body, client, request, socket, contentLength, header, expectsPayload });
|
|
}
|
|
} else if (util.isStream(body)) {
|
|
writeStream({ body, client, request, socket, contentLength, header, expectsPayload });
|
|
} else if (util.isIterable(body)) {
|
|
writeIterable({ body, client, request, socket, contentLength, header, expectsPayload });
|
|
} else {
|
|
assert(false);
|
|
}
|
|
return true;
|
|
}
|
|
function writeH2(client, session, request) {
|
|
const { body, method, path: path3, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
|
|
let headers;
|
|
if (typeof reqHeaders === "string") headers = Request2[kHTTP2CopyHeaders](reqHeaders.trim());
|
|
else headers = reqHeaders;
|
|
if (upgrade) {
|
|
errorRequest(client, request, new Error("Upgrade not supported for H2"));
|
|
return false;
|
|
}
|
|
try {
|
|
request.onConnect((err) => {
|
|
if (request.aborted || request.completed) {
|
|
return;
|
|
}
|
|
errorRequest(client, request, err || new RequestAbortedError());
|
|
});
|
|
} catch (err) {
|
|
errorRequest(client, request, err);
|
|
}
|
|
if (request.aborted) {
|
|
return false;
|
|
}
|
|
let stream;
|
|
const h2State = client[kHTTP2SessionState];
|
|
headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost];
|
|
headers[HTTP2_HEADER_METHOD] = method;
|
|
if (method === "CONNECT") {
|
|
session.ref();
|
|
stream = session.request(headers, { endStream: false, signal });
|
|
if (stream.id && !stream.pending) {
|
|
request.onUpgrade(null, null, stream);
|
|
++h2State.openStreams;
|
|
} else {
|
|
stream.once("ready", () => {
|
|
request.onUpgrade(null, null, stream);
|
|
++h2State.openStreams;
|
|
});
|
|
}
|
|
stream.once("close", () => {
|
|
h2State.openStreams -= 1;
|
|
if (h2State.openStreams === 0) session.unref();
|
|
});
|
|
return true;
|
|
}
|
|
headers[HTTP2_HEADER_PATH] = path3;
|
|
headers[HTTP2_HEADER_SCHEME] = "https";
|
|
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
|
|
if (body && typeof body.read === "function") {
|
|
body.read(0);
|
|
}
|
|
let contentLength = util.bodyLength(body);
|
|
if (contentLength == null) {
|
|
contentLength = request.contentLength;
|
|
}
|
|
if (contentLength === 0 || !expectsPayload) {
|
|
contentLength = null;
|
|
}
|
|
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
errorRequest(client, request, new RequestContentLengthMismatchError());
|
|
return false;
|
|
}
|
|
process.emitWarning(new RequestContentLengthMismatchError());
|
|
}
|
|
if (contentLength != null) {
|
|
assert(body, "no body must not have content length");
|
|
headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
|
|
}
|
|
session.ref();
|
|
const shouldEndStream = method === "GET" || method === "HEAD";
|
|
if (expectContinue) {
|
|
headers[HTTP2_HEADER_EXPECT] = "100-continue";
|
|
stream = session.request(headers, { endStream: shouldEndStream, signal });
|
|
stream.once("continue", writeBodyH2);
|
|
} else {
|
|
stream = session.request(headers, {
|
|
endStream: shouldEndStream,
|
|
signal
|
|
});
|
|
writeBodyH2();
|
|
}
|
|
++h2State.openStreams;
|
|
stream.once("response", (headers2) => {
|
|
const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
|
|
if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) {
|
|
stream.pause();
|
|
}
|
|
});
|
|
stream.once("end", () => {
|
|
request.onComplete([]);
|
|
});
|
|
stream.on("data", (chunk) => {
|
|
if (request.onData(chunk) === false) {
|
|
stream.pause();
|
|
}
|
|
});
|
|
stream.once("close", () => {
|
|
h2State.openStreams -= 1;
|
|
if (h2State.openStreams === 0) {
|
|
session.unref();
|
|
}
|
|
});
|
|
stream.once("error", function(err) {
|
|
if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
|
|
h2State.streams -= 1;
|
|
util.destroy(stream, err);
|
|
}
|
|
});
|
|
stream.once("frameError", (type, code) => {
|
|
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
|
|
errorRequest(client, request, err);
|
|
if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
|
|
h2State.streams -= 1;
|
|
util.destroy(stream, err);
|
|
}
|
|
});
|
|
return true;
|
|
function writeBodyH2() {
|
|
if (!body) {
|
|
request.onRequestSent();
|
|
} else if (util.isBuffer(body)) {
|
|
assert(contentLength === body.byteLength, "buffer body must have content length");
|
|
stream.cork();
|
|
stream.write(body);
|
|
stream.uncork();
|
|
stream.end();
|
|
request.onBodySent(body);
|
|
request.onRequestSent();
|
|
} else if (util.isBlobLike(body)) {
|
|
if (typeof body.stream === "function") {
|
|
writeIterable({
|
|
client,
|
|
request,
|
|
contentLength,
|
|
h2stream: stream,
|
|
expectsPayload,
|
|
body: body.stream(),
|
|
socket: client[kSocket],
|
|
header: ""
|
|
});
|
|
} else {
|
|
writeBlob({
|
|
body,
|
|
client,
|
|
request,
|
|
contentLength,
|
|
expectsPayload,
|
|
h2stream: stream,
|
|
header: "",
|
|
socket: client[kSocket]
|
|
});
|
|
}
|
|
} else if (util.isStream(body)) {
|
|
writeStream({
|
|
body,
|
|
client,
|
|
request,
|
|
contentLength,
|
|
expectsPayload,
|
|
socket: client[kSocket],
|
|
h2stream: stream,
|
|
header: ""
|
|
});
|
|
} else if (util.isIterable(body)) {
|
|
writeIterable({
|
|
body,
|
|
client,
|
|
request,
|
|
contentLength,
|
|
expectsPayload,
|
|
header: "",
|
|
h2stream: stream,
|
|
socket: client[kSocket]
|
|
});
|
|
} else {
|
|
assert(false);
|
|
}
|
|
}
|
|
}
|
|
function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
|
|
assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
|
|
if (client[kHTTPConnVersion] === "h2") {
|
|
let onPipeData = function(chunk) {
|
|
request.onBodySent(chunk);
|
|
};
|
|
const pipe = pipeline3(
|
|
body,
|
|
h2stream,
|
|
(err) => {
|
|
if (err) {
|
|
util.destroy(body, err);
|
|
util.destroy(h2stream, err);
|
|
} else {
|
|
request.onRequestSent();
|
|
}
|
|
}
|
|
);
|
|
pipe.on("data", onPipeData);
|
|
pipe.once("end", () => {
|
|
pipe.removeListener("data", onPipeData);
|
|
util.destroy(pipe);
|
|
});
|
|
return;
|
|
}
|
|
let finished = false;
|
|
const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
|
|
const onData = function(chunk) {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
try {
|
|
if (!writer.write(chunk) && this.pause) {
|
|
this.pause();
|
|
}
|
|
} catch (err) {
|
|
util.destroy(this, err);
|
|
}
|
|
};
|
|
const onDrain = function() {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
if (body.resume) {
|
|
body.resume();
|
|
}
|
|
};
|
|
const onAbort = function() {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
const err = new RequestAbortedError();
|
|
queueMicrotask(() => onFinished(err));
|
|
};
|
|
const onFinished = function(err) {
|
|
if (finished) {
|
|
return;
|
|
}
|
|
finished = true;
|
|
assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
|
|
socket.off("drain", onDrain).off("error", onFinished);
|
|
body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
|
|
if (!err) {
|
|
try {
|
|
writer.end();
|
|
} catch (er) {
|
|
err = er;
|
|
}
|
|
}
|
|
writer.destroy(err);
|
|
if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
|
|
util.destroy(body, err);
|
|
} else {
|
|
util.destroy(body);
|
|
}
|
|
};
|
|
body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
|
|
if (body.resume) {
|
|
body.resume();
|
|
}
|
|
socket.on("drain", onDrain).on("error", onFinished);
|
|
}
|
|
async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
|
|
assert(contentLength === body.size, "blob body must have content length");
|
|
const isH2 = client[kHTTPConnVersion] === "h2";
|
|
try {
|
|
if (contentLength != null && contentLength !== body.size) {
|
|
throw new RequestContentLengthMismatchError();
|
|
}
|
|
const buffer = Buffer.from(await body.arrayBuffer());
|
|
if (isH2) {
|
|
h2stream.cork();
|
|
h2stream.write(buffer);
|
|
h2stream.uncork();
|
|
} else {
|
|
socket.cork();
|
|
socket.write(`${header}content-length: ${contentLength}\r
|
|
\r
|
|
`, "latin1");
|
|
socket.write(buffer);
|
|
socket.uncork();
|
|
}
|
|
request.onBodySent(buffer);
|
|
request.onRequestSent();
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true;
|
|
}
|
|
resume(client);
|
|
} catch (err) {
|
|
util.destroy(isH2 ? h2stream : socket, err);
|
|
}
|
|
}
|
|
async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
|
|
assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
|
|
let callback = null;
|
|
function onDrain() {
|
|
if (callback) {
|
|
const cb = callback;
|
|
callback = null;
|
|
cb();
|
|
}
|
|
}
|
|
const waitForDrain = () => new Promise((resolve, reject) => {
|
|
assert(callback === null);
|
|
if (socket[kError]) {
|
|
reject(socket[kError]);
|
|
} else {
|
|
callback = resolve;
|
|
}
|
|
});
|
|
if (client[kHTTPConnVersion] === "h2") {
|
|
h2stream.on("close", onDrain).on("drain", onDrain);
|
|
try {
|
|
for await (const chunk of body) {
|
|
if (socket[kError]) {
|
|
throw socket[kError];
|
|
}
|
|
const res = h2stream.write(chunk);
|
|
request.onBodySent(chunk);
|
|
if (!res) {
|
|
await waitForDrain();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
h2stream.destroy(err);
|
|
} finally {
|
|
request.onRequestSent();
|
|
h2stream.end();
|
|
h2stream.off("close", onDrain).off("drain", onDrain);
|
|
}
|
|
return;
|
|
}
|
|
socket.on("close", onDrain).on("drain", onDrain);
|
|
const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
|
|
try {
|
|
for await (const chunk of body) {
|
|
if (socket[kError]) {
|
|
throw socket[kError];
|
|
}
|
|
if (!writer.write(chunk)) {
|
|
await waitForDrain();
|
|
}
|
|
}
|
|
writer.end();
|
|
} catch (err) {
|
|
writer.destroy(err);
|
|
} finally {
|
|
socket.off("close", onDrain).off("drain", onDrain);
|
|
}
|
|
}
|
|
var AsyncWriter = class {
|
|
constructor({ socket, request, contentLength, client, expectsPayload, header }) {
|
|
this.socket = socket;
|
|
this.request = request;
|
|
this.contentLength = contentLength;
|
|
this.client = client;
|
|
this.bytesWritten = 0;
|
|
this.expectsPayload = expectsPayload;
|
|
this.header = header;
|
|
socket[kWriting] = true;
|
|
}
|
|
write(chunk) {
|
|
const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
|
|
if (socket[kError]) {
|
|
throw socket[kError];
|
|
}
|
|
if (socket.destroyed) {
|
|
return false;
|
|
}
|
|
const len = Buffer.byteLength(chunk);
|
|
if (!len) {
|
|
return true;
|
|
}
|
|
if (contentLength !== null && bytesWritten + len > contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
throw new RequestContentLengthMismatchError();
|
|
}
|
|
process.emitWarning(new RequestContentLengthMismatchError());
|
|
}
|
|
socket.cork();
|
|
if (bytesWritten === 0) {
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true;
|
|
}
|
|
if (contentLength === null) {
|
|
socket.write(`${header}transfer-encoding: chunked\r
|
|
`, "latin1");
|
|
} else {
|
|
socket.write(`${header}content-length: ${contentLength}\r
|
|
\r
|
|
`, "latin1");
|
|
}
|
|
}
|
|
if (contentLength === null) {
|
|
socket.write(`\r
|
|
${len.toString(16)}\r
|
|
`, "latin1");
|
|
}
|
|
this.bytesWritten += len;
|
|
const ret = socket.write(chunk);
|
|
socket.uncork();
|
|
request.onBodySent(chunk);
|
|
if (!ret) {
|
|
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
|
|
if (socket[kParser].timeout.refresh) {
|
|
socket[kParser].timeout.refresh();
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
end() {
|
|
const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
|
|
request.onRequestSent();
|
|
socket[kWriting] = false;
|
|
if (socket[kError]) {
|
|
throw socket[kError];
|
|
}
|
|
if (socket.destroyed) {
|
|
return;
|
|
}
|
|
if (bytesWritten === 0) {
|
|
if (expectsPayload) {
|
|
socket.write(`${header}content-length: 0\r
|
|
\r
|
|
`, "latin1");
|
|
} else {
|
|
socket.write(`${header}\r
|
|
`, "latin1");
|
|
}
|
|
} else if (contentLength === null) {
|
|
socket.write("\r\n0\r\n\r\n", "latin1");
|
|
}
|
|
if (contentLength !== null && bytesWritten !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
throw new RequestContentLengthMismatchError();
|
|
} else {
|
|
process.emitWarning(new RequestContentLengthMismatchError());
|
|
}
|
|
}
|
|
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
|
|
if (socket[kParser].timeout.refresh) {
|
|
socket[kParser].timeout.refresh();
|
|
}
|
|
}
|
|
resume(client);
|
|
}
|
|
destroy(err) {
|
|
const { socket, client } = this;
|
|
socket[kWriting] = false;
|
|
if (err) {
|
|
assert(client[kRunning] <= 1, "pipeline should only contain this request");
|
|
util.destroy(socket, err);
|
|
}
|
|
}
|
|
};
|
|
function errorRequest(client, request, err) {
|
|
try {
|
|
request.onError(err);
|
|
assert(request.aborted);
|
|
} catch (err2) {
|
|
client.emit("error", err2);
|
|
}
|
|
}
|
|
module2.exports = Client;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/node/fixed-queue.js
|
|
var require_fixed_queue = __commonJS({
|
|
"node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) {
|
|
"use strict";
|
|
var kSize = 2048;
|
|
var kMask = kSize - 1;
|
|
var FixedCircularBuffer = class {
|
|
constructor() {
|
|
this.bottom = 0;
|
|
this.top = 0;
|
|
this.list = new Array(kSize);
|
|
this.next = null;
|
|
}
|
|
isEmpty() {
|
|
return this.top === this.bottom;
|
|
}
|
|
isFull() {
|
|
return (this.top + 1 & kMask) === this.bottom;
|
|
}
|
|
push(data) {
|
|
this.list[this.top] = data;
|
|
this.top = this.top + 1 & kMask;
|
|
}
|
|
shift() {
|
|
const nextItem = this.list[this.bottom];
|
|
if (nextItem === void 0)
|
|
return null;
|
|
this.list[this.bottom] = void 0;
|
|
this.bottom = this.bottom + 1 & kMask;
|
|
return nextItem;
|
|
}
|
|
};
|
|
module2.exports = class FixedQueue {
|
|
constructor() {
|
|
this.head = this.tail = new FixedCircularBuffer();
|
|
}
|
|
isEmpty() {
|
|
return this.head.isEmpty();
|
|
}
|
|
push(data) {
|
|
if (this.head.isFull()) {
|
|
this.head = this.head.next = new FixedCircularBuffer();
|
|
}
|
|
this.head.push(data);
|
|
}
|
|
shift() {
|
|
const tail = this.tail;
|
|
const next = tail.shift();
|
|
if (tail.isEmpty() && tail.next !== null) {
|
|
this.tail = tail.next;
|
|
}
|
|
return next;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/pool-stats.js
|
|
var require_pool_stats = __commonJS({
|
|
"node_modules/undici/lib/pool-stats.js"(exports2, module2) {
|
|
var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
|
|
var kPool = Symbol("pool");
|
|
var PoolStats = class {
|
|
constructor(pool) {
|
|
this[kPool] = pool;
|
|
}
|
|
get connected() {
|
|
return this[kPool][kConnected];
|
|
}
|
|
get free() {
|
|
return this[kPool][kFree];
|
|
}
|
|
get pending() {
|
|
return this[kPool][kPending];
|
|
}
|
|
get queued() {
|
|
return this[kPool][kQueued];
|
|
}
|
|
get running() {
|
|
return this[kPool][kRunning];
|
|
}
|
|
get size() {
|
|
return this[kPool][kSize];
|
|
}
|
|
};
|
|
module2.exports = PoolStats;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/pool-base.js
|
|
var require_pool_base = __commonJS({
|
|
"node_modules/undici/lib/pool-base.js"(exports2, module2) {
|
|
"use strict";
|
|
var DispatcherBase = require_dispatcher_base();
|
|
var FixedQueue = require_fixed_queue();
|
|
var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
|
|
var PoolStats = require_pool_stats();
|
|
var kClients = Symbol("clients");
|
|
var kNeedDrain = Symbol("needDrain");
|
|
var kQueue = Symbol("queue");
|
|
var kClosedResolve = Symbol("closed resolve");
|
|
var kOnDrain = Symbol("onDrain");
|
|
var kOnConnect = Symbol("onConnect");
|
|
var kOnDisconnect = Symbol("onDisconnect");
|
|
var kOnConnectionError = Symbol("onConnectionError");
|
|
var kGetDispatcher = Symbol("get dispatcher");
|
|
var kAddClient = Symbol("add client");
|
|
var kRemoveClient = Symbol("remove client");
|
|
var kStats = Symbol("stats");
|
|
var PoolBase = class extends DispatcherBase {
|
|
constructor() {
|
|
super();
|
|
this[kQueue] = new FixedQueue();
|
|
this[kClients] = [];
|
|
this[kQueued] = 0;
|
|
const pool = this;
|
|
this[kOnDrain] = function onDrain(origin, targets) {
|
|
const queue = pool[kQueue];
|
|
let needDrain = false;
|
|
while (!needDrain) {
|
|
const item = queue.shift();
|
|
if (!item) {
|
|
break;
|
|
}
|
|
pool[kQueued]--;
|
|
needDrain = !this.dispatch(item.opts, item.handler);
|
|
}
|
|
this[kNeedDrain] = needDrain;
|
|
if (!this[kNeedDrain] && pool[kNeedDrain]) {
|
|
pool[kNeedDrain] = false;
|
|
pool.emit("drain", origin, [pool, ...targets]);
|
|
}
|
|
if (pool[kClosedResolve] && queue.isEmpty()) {
|
|
Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
|
|
}
|
|
};
|
|
this[kOnConnect] = (origin, targets) => {
|
|
pool.emit("connect", origin, [pool, ...targets]);
|
|
};
|
|
this[kOnDisconnect] = (origin, targets, err) => {
|
|
pool.emit("disconnect", origin, [pool, ...targets], err);
|
|
};
|
|
this[kOnConnectionError] = (origin, targets, err) => {
|
|
pool.emit("connectionError", origin, [pool, ...targets], err);
|
|
};
|
|
this[kStats] = new PoolStats(this);
|
|
}
|
|
get [kBusy]() {
|
|
return this[kNeedDrain];
|
|
}
|
|
get [kConnected]() {
|
|
return this[kClients].filter((client) => client[kConnected]).length;
|
|
}
|
|
get [kFree]() {
|
|
return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
|
|
}
|
|
get [kPending]() {
|
|
let ret = this[kQueued];
|
|
for (const { [kPending]: pending } of this[kClients]) {
|
|
ret += pending;
|
|
}
|
|
return ret;
|
|
}
|
|
get [kRunning]() {
|
|
let ret = 0;
|
|
for (const { [kRunning]: running } of this[kClients]) {
|
|
ret += running;
|
|
}
|
|
return ret;
|
|
}
|
|
get [kSize]() {
|
|
let ret = this[kQueued];
|
|
for (const { [kSize]: size } of this[kClients]) {
|
|
ret += size;
|
|
}
|
|
return ret;
|
|
}
|
|
get stats() {
|
|
return this[kStats];
|
|
}
|
|
async [kClose]() {
|
|
if (this[kQueue].isEmpty()) {
|
|
return Promise.all(this[kClients].map((c) => c.close()));
|
|
} else {
|
|
return new Promise((resolve) => {
|
|
this[kClosedResolve] = resolve;
|
|
});
|
|
}
|
|
}
|
|
async [kDestroy](err) {
|
|
while (true) {
|
|
const item = this[kQueue].shift();
|
|
if (!item) {
|
|
break;
|
|
}
|
|
item.handler.onError(err);
|
|
}
|
|
return Promise.all(this[kClients].map((c) => c.destroy(err)));
|
|
}
|
|
[kDispatch](opts, handler) {
|
|
const dispatcher = this[kGetDispatcher]();
|
|
if (!dispatcher) {
|
|
this[kNeedDrain] = true;
|
|
this[kQueue].push({ opts, handler });
|
|
this[kQueued]++;
|
|
} else if (!dispatcher.dispatch(opts, handler)) {
|
|
dispatcher[kNeedDrain] = true;
|
|
this[kNeedDrain] = !this[kGetDispatcher]();
|
|
}
|
|
return !this[kNeedDrain];
|
|
}
|
|
[kAddClient](client) {
|
|
client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
|
|
this[kClients].push(client);
|
|
if (this[kNeedDrain]) {
|
|
process.nextTick(() => {
|
|
if (this[kNeedDrain]) {
|
|
this[kOnDrain](client[kUrl], [this, client]);
|
|
}
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
[kRemoveClient](client) {
|
|
client.close(() => {
|
|
const idx = this[kClients].indexOf(client);
|
|
if (idx !== -1) {
|
|
this[kClients].splice(idx, 1);
|
|
}
|
|
});
|
|
this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
|
|
}
|
|
};
|
|
module2.exports = {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kRemoveClient,
|
|
kGetDispatcher
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/pool.js
|
|
var require_pool = __commonJS({
|
|
"node_modules/undici/lib/pool.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kGetDispatcher
|
|
} = require_pool_base();
|
|
var Client = require_client();
|
|
var {
|
|
InvalidArgumentError
|
|
} = require_errors();
|
|
var util = require_util();
|
|
var { kUrl, kInterceptors } = require_symbols();
|
|
var buildConnector = require_connect();
|
|
var kOptions = Symbol("options");
|
|
var kConnections = Symbol("connections");
|
|
var kFactory = Symbol("factory");
|
|
function defaultFactory(origin, opts) {
|
|
return new Client(origin, opts);
|
|
}
|
|
var Pool = class extends PoolBase {
|
|
constructor(origin, {
|
|
connections,
|
|
factory = defaultFactory,
|
|
connect,
|
|
connectTimeout,
|
|
tls,
|
|
maxCachedSessions,
|
|
socketPath,
|
|
autoSelectFamily,
|
|
autoSelectFamilyAttemptTimeout,
|
|
allowH2,
|
|
...options
|
|
} = {}) {
|
|
super();
|
|
if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
|
|
throw new InvalidArgumentError("invalid connections");
|
|
}
|
|
if (typeof factory !== "function") {
|
|
throw new InvalidArgumentError("factory must be a function.");
|
|
}
|
|
if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
|
|
throw new InvalidArgumentError("connect must be a function or an object");
|
|
}
|
|
if (typeof connect !== "function") {
|
|
connect = buildConnector({
|
|
...tls,
|
|
maxCachedSessions,
|
|
allowH2,
|
|
socketPath,
|
|
timeout: connectTimeout,
|
|
...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
|
|
...connect
|
|
});
|
|
}
|
|
this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : [];
|
|
this[kConnections] = connections || null;
|
|
this[kUrl] = util.parseOrigin(origin);
|
|
this[kOptions] = { ...util.deepClone(options), connect, allowH2 };
|
|
this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
|
|
this[kFactory] = factory;
|
|
this.on("connectionError", (origin2, targets, error) => {
|
|
for (const target of targets) {
|
|
const idx = this[kClients].indexOf(target);
|
|
if (idx !== -1) {
|
|
this[kClients].splice(idx, 1);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
[kGetDispatcher]() {
|
|
let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
|
|
if (dispatcher) {
|
|
return dispatcher;
|
|
}
|
|
if (!this[kConnections] || this[kClients].length < this[kConnections]) {
|
|
dispatcher = this[kFactory](this[kUrl], this[kOptions]);
|
|
this[kAddClient](dispatcher);
|
|
}
|
|
return dispatcher;
|
|
}
|
|
};
|
|
module2.exports = Pool;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/balanced-pool.js
|
|
var require_balanced_pool = __commonJS({
|
|
"node_modules/undici/lib/balanced-pool.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
BalancedPoolMissingUpstreamError,
|
|
InvalidArgumentError
|
|
} = require_errors();
|
|
var {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kRemoveClient,
|
|
kGetDispatcher
|
|
} = require_pool_base();
|
|
var Pool = require_pool();
|
|
var { kUrl, kInterceptors } = require_symbols();
|
|
var { parseOrigin } = require_util();
|
|
var kFactory = Symbol("factory");
|
|
var kOptions = Symbol("options");
|
|
var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
|
|
var kCurrentWeight = Symbol("kCurrentWeight");
|
|
var kIndex = Symbol("kIndex");
|
|
var kWeight = Symbol("kWeight");
|
|
var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
|
|
var kErrorPenalty = Symbol("kErrorPenalty");
|
|
function getGreatestCommonDivisor(a, b) {
|
|
if (b === 0) return a;
|
|
return getGreatestCommonDivisor(b, a % b);
|
|
}
|
|
function defaultFactory(origin, opts) {
|
|
return new Pool(origin, opts);
|
|
}
|
|
var BalancedPool = class extends PoolBase {
|
|
constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
|
|
super();
|
|
this[kOptions] = opts;
|
|
this[kIndex] = -1;
|
|
this[kCurrentWeight] = 0;
|
|
this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
|
|
this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
|
|
if (!Array.isArray(upstreams)) {
|
|
upstreams = [upstreams];
|
|
}
|
|
if (typeof factory !== "function") {
|
|
throw new InvalidArgumentError("factory must be a function.");
|
|
}
|
|
this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
|
|
this[kFactory] = factory;
|
|
for (const upstream of upstreams) {
|
|
this.addUpstream(upstream);
|
|
}
|
|
this._updateBalancedPoolStats();
|
|
}
|
|
addUpstream(upstream) {
|
|
const upstreamOrigin = parseOrigin(upstream).origin;
|
|
if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) {
|
|
return this;
|
|
}
|
|
const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
|
|
this[kAddClient](pool);
|
|
pool.on("connect", () => {
|
|
pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]);
|
|
});
|
|
pool.on("connectionError", () => {
|
|
pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
|
|
this._updateBalancedPoolStats();
|
|
});
|
|
pool.on("disconnect", (...args) => {
|
|
const err = args[2];
|
|
if (err && err.code === "UND_ERR_SOCKET") {
|
|
pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
|
|
this._updateBalancedPoolStats();
|
|
}
|
|
});
|
|
for (const client of this[kClients]) {
|
|
client[kWeight] = this[kMaxWeightPerServer];
|
|
}
|
|
this._updateBalancedPoolStats();
|
|
return this;
|
|
}
|
|
_updateBalancedPoolStats() {
|
|
this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0);
|
|
}
|
|
removeUpstream(upstream) {
|
|
const upstreamOrigin = parseOrigin(upstream).origin;
|
|
const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true);
|
|
if (pool) {
|
|
this[kRemoveClient](pool);
|
|
}
|
|
return this;
|
|
}
|
|
get upstreams() {
|
|
return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin);
|
|
}
|
|
[kGetDispatcher]() {
|
|
if (this[kClients].length === 0) {
|
|
throw new BalancedPoolMissingUpstreamError();
|
|
}
|
|
const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true);
|
|
if (!dispatcher) {
|
|
return;
|
|
}
|
|
const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true);
|
|
if (allClientsBusy) {
|
|
return;
|
|
}
|
|
let counter = 0;
|
|
let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]);
|
|
while (counter++ < this[kClients].length) {
|
|
this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
|
|
const pool = this[kClients][this[kIndex]];
|
|
if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
|
|
maxWeightIndex = this[kIndex];
|
|
}
|
|
if (this[kIndex] === 0) {
|
|
this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
|
|
if (this[kCurrentWeight] <= 0) {
|
|
this[kCurrentWeight] = this[kMaxWeightPerServer];
|
|
}
|
|
}
|
|
if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) {
|
|
return pool;
|
|
}
|
|
}
|
|
this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
|
|
this[kIndex] = maxWeightIndex;
|
|
return this[kClients][maxWeightIndex];
|
|
}
|
|
};
|
|
module2.exports = BalancedPool;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/compat/dispatcher-weakref.js
|
|
var require_dispatcher_weakref = __commonJS({
|
|
"node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kConnected, kSize } = require_symbols();
|
|
var CompatWeakRef = class {
|
|
constructor(value) {
|
|
this.value = value;
|
|
}
|
|
deref() {
|
|
return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
|
|
}
|
|
};
|
|
var CompatFinalizer = class {
|
|
constructor(finalizer) {
|
|
this.finalizer = finalizer;
|
|
}
|
|
register(dispatcher, key) {
|
|
if (dispatcher.on) {
|
|
dispatcher.on("disconnect", () => {
|
|
if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
|
|
this.finalizer(key);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
};
|
|
module2.exports = function() {
|
|
if (process.env.NODE_V8_COVERAGE) {
|
|
return {
|
|
WeakRef: CompatWeakRef,
|
|
FinalizationRegistry: CompatFinalizer
|
|
};
|
|
}
|
|
return {
|
|
WeakRef: global.WeakRef || CompatWeakRef,
|
|
FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/agent.js
|
|
var require_agent = __commonJS({
|
|
"node_modules/undici/lib/agent.js"(exports2, module2) {
|
|
"use strict";
|
|
var { InvalidArgumentError } = require_errors();
|
|
var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
|
|
var DispatcherBase = require_dispatcher_base();
|
|
var Pool = require_pool();
|
|
var Client = require_client();
|
|
var util = require_util();
|
|
var createRedirectInterceptor = require_redirectInterceptor();
|
|
var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()();
|
|
var kOnConnect = Symbol("onConnect");
|
|
var kOnDisconnect = Symbol("onDisconnect");
|
|
var kOnConnectionError = Symbol("onConnectionError");
|
|
var kMaxRedirections = Symbol("maxRedirections");
|
|
var kOnDrain = Symbol("onDrain");
|
|
var kFactory = Symbol("factory");
|
|
var kFinalizer = Symbol("finalizer");
|
|
var kOptions = Symbol("options");
|
|
function defaultFactory(origin, opts) {
|
|
return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
|
|
}
|
|
var Agent = class extends DispatcherBase {
|
|
constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
|
|
super();
|
|
if (typeof factory !== "function") {
|
|
throw new InvalidArgumentError("factory must be a function.");
|
|
}
|
|
if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
|
|
throw new InvalidArgumentError("connect must be a function or an object");
|
|
}
|
|
if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
|
|
throw new InvalidArgumentError("maxRedirections must be a positive number");
|
|
}
|
|
if (connect && typeof connect !== "function") {
|
|
connect = { ...connect };
|
|
}
|
|
this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
|
|
this[kOptions] = { ...util.deepClone(options), connect };
|
|
this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
|
|
this[kMaxRedirections] = maxRedirections;
|
|
this[kFactory] = factory;
|
|
this[kClients] = /* @__PURE__ */ new Map();
|
|
this[kFinalizer] = new FinalizationRegistry(
|
|
/* istanbul ignore next: gc is undeterministic */
|
|
(key) => {
|
|
const ref = this[kClients].get(key);
|
|
if (ref !== void 0 && ref.deref() === void 0) {
|
|
this[kClients].delete(key);
|
|
}
|
|
}
|
|
);
|
|
const agent = this;
|
|
this[kOnDrain] = (origin, targets) => {
|
|
agent.emit("drain", origin, [agent, ...targets]);
|
|
};
|
|
this[kOnConnect] = (origin, targets) => {
|
|
agent.emit("connect", origin, [agent, ...targets]);
|
|
};
|
|
this[kOnDisconnect] = (origin, targets, err) => {
|
|
agent.emit("disconnect", origin, [agent, ...targets], err);
|
|
};
|
|
this[kOnConnectionError] = (origin, targets, err) => {
|
|
agent.emit("connectionError", origin, [agent, ...targets], err);
|
|
};
|
|
}
|
|
get [kRunning]() {
|
|
let ret = 0;
|
|
for (const ref of this[kClients].values()) {
|
|
const client = ref.deref();
|
|
if (client) {
|
|
ret += client[kRunning];
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
[kDispatch](opts, handler) {
|
|
let key;
|
|
if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
|
|
key = String(opts.origin);
|
|
} else {
|
|
throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
|
|
}
|
|
const ref = this[kClients].get(key);
|
|
let dispatcher = ref ? ref.deref() : null;
|
|
if (!dispatcher) {
|
|
dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
|
|
this[kClients].set(key, new WeakRef2(dispatcher));
|
|
this[kFinalizer].register(dispatcher, key);
|
|
}
|
|
return dispatcher.dispatch(opts, handler);
|
|
}
|
|
async [kClose]() {
|
|
const closePromises = [];
|
|
for (const ref of this[kClients].values()) {
|
|
const client = ref.deref();
|
|
if (client) {
|
|
closePromises.push(client.close());
|
|
}
|
|
}
|
|
await Promise.all(closePromises);
|
|
}
|
|
async [kDestroy](err) {
|
|
const destroyPromises = [];
|
|
for (const ref of this[kClients].values()) {
|
|
const client = ref.deref();
|
|
if (client) {
|
|
destroyPromises.push(client.destroy(err));
|
|
}
|
|
}
|
|
await Promise.all(destroyPromises);
|
|
}
|
|
};
|
|
module2.exports = Agent;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/readable.js
|
|
var require_readable = __commonJS({
|
|
"node_modules/undici/lib/api/readable.js"(exports2, module2) {
|
|
"use strict";
|
|
var assert = require("assert");
|
|
var { Readable } = require("stream");
|
|
var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors();
|
|
var util = require_util();
|
|
var { ReadableStreamFrom, toUSVString } = require_util();
|
|
var Blob4;
|
|
var kConsume = Symbol("kConsume");
|
|
var kReading = Symbol("kReading");
|
|
var kBody = Symbol("kBody");
|
|
var kAbort = Symbol("abort");
|
|
var kContentType = Symbol("kContentType");
|
|
var noop2 = () => {
|
|
};
|
|
module2.exports = class BodyReadable extends Readable {
|
|
constructor({
|
|
resume,
|
|
abort,
|
|
contentType = "",
|
|
highWaterMark = 64 * 1024
|
|
// Same as nodejs fs streams.
|
|
}) {
|
|
super({
|
|
autoDestroy: true,
|
|
read: resume,
|
|
highWaterMark
|
|
});
|
|
this._readableState.dataEmitted = false;
|
|
this[kAbort] = abort;
|
|
this[kConsume] = null;
|
|
this[kBody] = null;
|
|
this[kContentType] = contentType;
|
|
this[kReading] = false;
|
|
}
|
|
destroy(err) {
|
|
if (this.destroyed) {
|
|
return this;
|
|
}
|
|
if (!err && !this._readableState.endEmitted) {
|
|
err = new RequestAbortedError();
|
|
}
|
|
if (err) {
|
|
this[kAbort]();
|
|
}
|
|
return super.destroy(err);
|
|
}
|
|
emit(ev, ...args) {
|
|
if (ev === "data") {
|
|
this._readableState.dataEmitted = true;
|
|
} else if (ev === "error") {
|
|
this._readableState.errorEmitted = true;
|
|
}
|
|
return super.emit(ev, ...args);
|
|
}
|
|
on(ev, ...args) {
|
|
if (ev === "data" || ev === "readable") {
|
|
this[kReading] = true;
|
|
}
|
|
return super.on(ev, ...args);
|
|
}
|
|
addListener(ev, ...args) {
|
|
return this.on(ev, ...args);
|
|
}
|
|
off(ev, ...args) {
|
|
const ret = super.off(ev, ...args);
|
|
if (ev === "data" || ev === "readable") {
|
|
this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
|
|
}
|
|
return ret;
|
|
}
|
|
removeListener(ev, ...args) {
|
|
return this.off(ev, ...args);
|
|
}
|
|
push(chunk) {
|
|
if (this[kConsume] && chunk !== null && this.readableLength === 0) {
|
|
consumePush(this[kConsume], chunk);
|
|
return this[kReading] ? super.push(chunk) : true;
|
|
}
|
|
return super.push(chunk);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-text
|
|
async text() {
|
|
return consume(this, "text");
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-json
|
|
async json() {
|
|
return consume(this, "json");
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-blob
|
|
async blob() {
|
|
return consume(this, "blob");
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-arraybuffer
|
|
async arrayBuffer() {
|
|
return consume(this, "arrayBuffer");
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-formdata
|
|
async formData() {
|
|
throw new NotSupportedError();
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-bodyused
|
|
get bodyUsed() {
|
|
return util.isDisturbed(this);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-body-body
|
|
get body() {
|
|
if (!this[kBody]) {
|
|
this[kBody] = ReadableStreamFrom(this);
|
|
if (this[kConsume]) {
|
|
this[kBody].getReader();
|
|
assert(this[kBody].locked);
|
|
}
|
|
}
|
|
return this[kBody];
|
|
}
|
|
dump(opts) {
|
|
let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144;
|
|
const signal = opts && opts.signal;
|
|
if (signal) {
|
|
try {
|
|
if (typeof signal !== "object" || !("aborted" in signal)) {
|
|
throw new InvalidArgumentError("signal must be an AbortSignal");
|
|
}
|
|
util.throwIfAborted(signal);
|
|
} catch (err) {
|
|
return Promise.reject(err);
|
|
}
|
|
}
|
|
if (this.closed) {
|
|
return Promise.resolve(null);
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const signalListenerCleanup = signal ? util.addAbortListener(signal, () => {
|
|
this.destroy();
|
|
}) : noop2;
|
|
this.on("close", function() {
|
|
signalListenerCleanup();
|
|
if (signal && signal.aborted) {
|
|
reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
|
|
} else {
|
|
resolve(null);
|
|
}
|
|
}).on("error", noop2).on("data", function(chunk) {
|
|
limit -= chunk.length;
|
|
if (limit <= 0) {
|
|
this.destroy();
|
|
}
|
|
}).resume();
|
|
});
|
|
}
|
|
};
|
|
function isLocked(self2) {
|
|
return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
|
|
}
|
|
function isUnusable(self2) {
|
|
return util.isDisturbed(self2) || isLocked(self2);
|
|
}
|
|
async function consume(stream, type) {
|
|
if (isUnusable(stream)) {
|
|
throw new TypeError("unusable");
|
|
}
|
|
assert(!stream[kConsume]);
|
|
return new Promise((resolve, reject) => {
|
|
stream[kConsume] = {
|
|
type,
|
|
stream,
|
|
resolve,
|
|
reject,
|
|
length: 0,
|
|
body: []
|
|
};
|
|
stream.on("error", function(err) {
|
|
consumeFinish(this[kConsume], err);
|
|
}).on("close", function() {
|
|
if (this[kConsume].body !== null) {
|
|
consumeFinish(this[kConsume], new RequestAbortedError());
|
|
}
|
|
});
|
|
process.nextTick(consumeStart, stream[kConsume]);
|
|
});
|
|
}
|
|
function consumeStart(consume2) {
|
|
if (consume2.body === null) {
|
|
return;
|
|
}
|
|
const { _readableState: state } = consume2.stream;
|
|
for (const chunk of state.buffer) {
|
|
consumePush(consume2, chunk);
|
|
}
|
|
if (state.endEmitted) {
|
|
consumeEnd(this[kConsume]);
|
|
} else {
|
|
consume2.stream.on("end", function() {
|
|
consumeEnd(this[kConsume]);
|
|
});
|
|
}
|
|
consume2.stream.resume();
|
|
while (consume2.stream.read() != null) {
|
|
}
|
|
}
|
|
function consumeEnd(consume2) {
|
|
const { type, body, resolve, stream, length } = consume2;
|
|
try {
|
|
if (type === "text") {
|
|
resolve(toUSVString(Buffer.concat(body)));
|
|
} else if (type === "json") {
|
|
resolve(JSON.parse(Buffer.concat(body)));
|
|
} else if (type === "arrayBuffer") {
|
|
const dst = new Uint8Array(length);
|
|
let pos = 0;
|
|
for (const buf of body) {
|
|
dst.set(buf, pos);
|
|
pos += buf.byteLength;
|
|
}
|
|
resolve(dst.buffer);
|
|
} else if (type === "blob") {
|
|
if (!Blob4) {
|
|
Blob4 = require("buffer").Blob;
|
|
}
|
|
resolve(new Blob4(body, { type: stream[kContentType] }));
|
|
}
|
|
consumeFinish(consume2);
|
|
} catch (err) {
|
|
stream.destroy(err);
|
|
}
|
|
}
|
|
function consumePush(consume2, chunk) {
|
|
consume2.length += chunk.length;
|
|
consume2.body.push(chunk);
|
|
}
|
|
function consumeFinish(consume2, err) {
|
|
if (consume2.body === null) {
|
|
return;
|
|
}
|
|
if (err) {
|
|
consume2.reject(err);
|
|
} else {
|
|
consume2.resolve();
|
|
}
|
|
consume2.type = null;
|
|
consume2.stream = null;
|
|
consume2.resolve = null;
|
|
consume2.reject = null;
|
|
consume2.length = 0;
|
|
consume2.body = null;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/util.js
|
|
var require_util3 = __commonJS({
|
|
"node_modules/undici/lib/api/util.js"(exports2, module2) {
|
|
var assert = require("assert");
|
|
var {
|
|
ResponseStatusCodeError
|
|
} = require_errors();
|
|
var { toUSVString } = require_util();
|
|
async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
|
|
assert(body);
|
|
let chunks = [];
|
|
let limit = 0;
|
|
for await (const chunk of body) {
|
|
chunks.push(chunk);
|
|
limit += chunk.length;
|
|
if (limit > 128 * 1024) {
|
|
chunks = null;
|
|
break;
|
|
}
|
|
}
|
|
if (statusCode === 204 || !contentType || !chunks) {
|
|
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
|
|
return;
|
|
}
|
|
try {
|
|
if (contentType.startsWith("application/json")) {
|
|
const payload = JSON.parse(toUSVString(Buffer.concat(chunks)));
|
|
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
|
|
return;
|
|
}
|
|
if (contentType.startsWith("text/")) {
|
|
const payload = toUSVString(Buffer.concat(chunks));
|
|
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
|
|
return;
|
|
}
|
|
} catch (err) {
|
|
}
|
|
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
|
|
}
|
|
module2.exports = { getResolveErrorBodyCallback };
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/abort-signal.js
|
|
var require_abort_signal = __commonJS({
|
|
"node_modules/undici/lib/api/abort-signal.js"(exports2, module2) {
|
|
var { addAbortListener } = require_util();
|
|
var { RequestAbortedError } = require_errors();
|
|
var kListener = Symbol("kListener");
|
|
var kSignal = Symbol("kSignal");
|
|
function abort(self2) {
|
|
if (self2.abort) {
|
|
self2.abort();
|
|
} else {
|
|
self2.onError(new RequestAbortedError());
|
|
}
|
|
}
|
|
function addSignal(self2, signal) {
|
|
self2[kSignal] = null;
|
|
self2[kListener] = null;
|
|
if (!signal) {
|
|
return;
|
|
}
|
|
if (signal.aborted) {
|
|
abort(self2);
|
|
return;
|
|
}
|
|
self2[kSignal] = signal;
|
|
self2[kListener] = () => {
|
|
abort(self2);
|
|
};
|
|
addAbortListener(self2[kSignal], self2[kListener]);
|
|
}
|
|
function removeSignal(self2) {
|
|
if (!self2[kSignal]) {
|
|
return;
|
|
}
|
|
if ("removeEventListener" in self2[kSignal]) {
|
|
self2[kSignal].removeEventListener("abort", self2[kListener]);
|
|
} else {
|
|
self2[kSignal].removeListener("abort", self2[kListener]);
|
|
}
|
|
self2[kSignal] = null;
|
|
self2[kListener] = null;
|
|
}
|
|
module2.exports = {
|
|
addSignal,
|
|
removeSignal
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/api-request.js
|
|
var require_api_request = __commonJS({
|
|
"node_modules/undici/lib/api/api-request.js"(exports2, module2) {
|
|
"use strict";
|
|
var Readable = require_readable();
|
|
var {
|
|
InvalidArgumentError,
|
|
RequestAbortedError
|
|
} = require_errors();
|
|
var util = require_util();
|
|
var { getResolveErrorBodyCallback } = require_util3();
|
|
var { AsyncResource } = require("async_hooks");
|
|
var { addSignal, removeSignal } = require_abort_signal();
|
|
var RequestHandler = class extends AsyncResource {
|
|
constructor(opts, callback) {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts;
|
|
try {
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) {
|
|
throw new InvalidArgumentError("invalid highWaterMark");
|
|
}
|
|
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
|
|
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
|
|
}
|
|
if (method === "CONNECT") {
|
|
throw new InvalidArgumentError("invalid method");
|
|
}
|
|
if (onInfo && typeof onInfo !== "function") {
|
|
throw new InvalidArgumentError("invalid onInfo callback");
|
|
}
|
|
super("UNDICI_REQUEST");
|
|
} catch (err) {
|
|
if (util.isStream(body)) {
|
|
util.destroy(body.on("error", util.nop), err);
|
|
}
|
|
throw err;
|
|
}
|
|
this.responseHeaders = responseHeaders || null;
|
|
this.opaque = opaque || null;
|
|
this.callback = callback;
|
|
this.res = null;
|
|
this.abort = null;
|
|
this.body = body;
|
|
this.trailers = {};
|
|
this.context = null;
|
|
this.onInfo = onInfo || null;
|
|
this.throwOnError = throwOnError;
|
|
this.highWaterMark = highWaterMark;
|
|
if (util.isStream(body)) {
|
|
body.on("error", (err) => {
|
|
this.onError(err);
|
|
});
|
|
}
|
|
addSignal(this, signal);
|
|
}
|
|
onConnect(abort, context) {
|
|
if (!this.callback) {
|
|
throw new RequestAbortedError();
|
|
}
|
|
this.abort = abort;
|
|
this.context = context;
|
|
}
|
|
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
|
|
const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this;
|
|
const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
if (statusCode < 200) {
|
|
if (this.onInfo) {
|
|
this.onInfo({ statusCode, headers });
|
|
}
|
|
return;
|
|
}
|
|
const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
|
|
const contentType = parsedHeaders["content-type"];
|
|
const body = new Readable({ resume, abort, contentType, highWaterMark });
|
|
this.callback = null;
|
|
this.res = body;
|
|
if (callback !== null) {
|
|
if (this.throwOnError && statusCode >= 400) {
|
|
this.runInAsyncScope(
|
|
getResolveErrorBodyCallback,
|
|
null,
|
|
{ callback, body, contentType, statusCode, statusMessage, headers }
|
|
);
|
|
} else {
|
|
this.runInAsyncScope(callback, null, null, {
|
|
statusCode,
|
|
headers,
|
|
trailers: this.trailers,
|
|
opaque,
|
|
body,
|
|
context
|
|
});
|
|
}
|
|
}
|
|
}
|
|
onData(chunk) {
|
|
const { res } = this;
|
|
return res.push(chunk);
|
|
}
|
|
onComplete(trailers) {
|
|
const { res } = this;
|
|
removeSignal(this);
|
|
util.parseHeaders(trailers, this.trailers);
|
|
res.push(null);
|
|
}
|
|
onError(err) {
|
|
const { res, callback, body, opaque } = this;
|
|
removeSignal(this);
|
|
if (callback) {
|
|
this.callback = null;
|
|
queueMicrotask(() => {
|
|
this.runInAsyncScope(callback, null, err, { opaque });
|
|
});
|
|
}
|
|
if (res) {
|
|
this.res = null;
|
|
queueMicrotask(() => {
|
|
util.destroy(res, err);
|
|
});
|
|
}
|
|
if (body) {
|
|
this.body = null;
|
|
util.destroy(body, err);
|
|
}
|
|
}
|
|
};
|
|
function request(opts, callback) {
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
request.call(this, opts, (err, data) => {
|
|
return err ? reject(err) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
try {
|
|
this.dispatch(opts, new RequestHandler(opts, callback));
|
|
} catch (err) {
|
|
if (typeof callback !== "function") {
|
|
throw err;
|
|
}
|
|
const opaque = opts && opts.opaque;
|
|
queueMicrotask(() => callback(err, { opaque }));
|
|
}
|
|
}
|
|
module2.exports = request;
|
|
module2.exports.RequestHandler = RequestHandler;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/api-stream.js
|
|
var require_api_stream = __commonJS({
|
|
"node_modules/undici/lib/api/api-stream.js"(exports2, module2) {
|
|
"use strict";
|
|
var { finished, PassThrough: PassThrough3 } = require("stream");
|
|
var {
|
|
InvalidArgumentError,
|
|
InvalidReturnValueError,
|
|
RequestAbortedError
|
|
} = require_errors();
|
|
var util = require_util();
|
|
var { getResolveErrorBodyCallback } = require_util3();
|
|
var { AsyncResource } = require("async_hooks");
|
|
var { addSignal, removeSignal } = require_abort_signal();
|
|
var StreamHandler = class extends AsyncResource {
|
|
constructor(opts, factory, callback) {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
|
|
try {
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
if (typeof factory !== "function") {
|
|
throw new InvalidArgumentError("invalid factory");
|
|
}
|
|
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
|
|
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
|
|
}
|
|
if (method === "CONNECT") {
|
|
throw new InvalidArgumentError("invalid method");
|
|
}
|
|
if (onInfo && typeof onInfo !== "function") {
|
|
throw new InvalidArgumentError("invalid onInfo callback");
|
|
}
|
|
super("UNDICI_STREAM");
|
|
} catch (err) {
|
|
if (util.isStream(body)) {
|
|
util.destroy(body.on("error", util.nop), err);
|
|
}
|
|
throw err;
|
|
}
|
|
this.responseHeaders = responseHeaders || null;
|
|
this.opaque = opaque || null;
|
|
this.factory = factory;
|
|
this.callback = callback;
|
|
this.res = null;
|
|
this.abort = null;
|
|
this.context = null;
|
|
this.trailers = null;
|
|
this.body = body;
|
|
this.onInfo = onInfo || null;
|
|
this.throwOnError = throwOnError || false;
|
|
if (util.isStream(body)) {
|
|
body.on("error", (err) => {
|
|
this.onError(err);
|
|
});
|
|
}
|
|
addSignal(this, signal);
|
|
}
|
|
onConnect(abort, context) {
|
|
if (!this.callback) {
|
|
throw new RequestAbortedError();
|
|
}
|
|
this.abort = abort;
|
|
this.context = context;
|
|
}
|
|
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
|
|
const { factory, opaque, context, callback, responseHeaders } = this;
|
|
const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
if (statusCode < 200) {
|
|
if (this.onInfo) {
|
|
this.onInfo({ statusCode, headers });
|
|
}
|
|
return;
|
|
}
|
|
this.factory = null;
|
|
let res;
|
|
if (this.throwOnError && statusCode >= 400) {
|
|
const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
|
|
const contentType = parsedHeaders["content-type"];
|
|
res = new PassThrough3();
|
|
this.callback = null;
|
|
this.runInAsyncScope(
|
|
getResolveErrorBodyCallback,
|
|
null,
|
|
{ callback, body: res, contentType, statusCode, statusMessage, headers }
|
|
);
|
|
} else {
|
|
if (factory === null) {
|
|
return;
|
|
}
|
|
res = this.runInAsyncScope(factory, null, {
|
|
statusCode,
|
|
headers,
|
|
opaque,
|
|
context
|
|
});
|
|
if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
|
|
throw new InvalidReturnValueError("expected Writable");
|
|
}
|
|
finished(res, { readable: false }, (err) => {
|
|
const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this;
|
|
this.res = null;
|
|
if (err || !res2.readable) {
|
|
util.destroy(res2, err);
|
|
}
|
|
this.callback = null;
|
|
this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers });
|
|
if (err) {
|
|
abort();
|
|
}
|
|
});
|
|
}
|
|
res.on("drain", resume);
|
|
this.res = res;
|
|
const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain;
|
|
return needDrain !== true;
|
|
}
|
|
onData(chunk) {
|
|
const { res } = this;
|
|
return res ? res.write(chunk) : true;
|
|
}
|
|
onComplete(trailers) {
|
|
const { res } = this;
|
|
removeSignal(this);
|
|
if (!res) {
|
|
return;
|
|
}
|
|
this.trailers = util.parseHeaders(trailers);
|
|
res.end();
|
|
}
|
|
onError(err) {
|
|
const { res, callback, opaque, body } = this;
|
|
removeSignal(this);
|
|
this.factory = null;
|
|
if (res) {
|
|
this.res = null;
|
|
util.destroy(res, err);
|
|
} else if (callback) {
|
|
this.callback = null;
|
|
queueMicrotask(() => {
|
|
this.runInAsyncScope(callback, null, err, { opaque });
|
|
});
|
|
}
|
|
if (body) {
|
|
this.body = null;
|
|
util.destroy(body, err);
|
|
}
|
|
}
|
|
};
|
|
function stream(opts, factory, callback) {
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
stream.call(this, opts, factory, (err, data) => {
|
|
return err ? reject(err) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
try {
|
|
this.dispatch(opts, new StreamHandler(opts, factory, callback));
|
|
} catch (err) {
|
|
if (typeof callback !== "function") {
|
|
throw err;
|
|
}
|
|
const opaque = opts && opts.opaque;
|
|
queueMicrotask(() => callback(err, { opaque }));
|
|
}
|
|
}
|
|
module2.exports = stream;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/api-pipeline.js
|
|
var require_api_pipeline = __commonJS({
|
|
"node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
Readable,
|
|
Duplex,
|
|
PassThrough: PassThrough3
|
|
} = require("stream");
|
|
var {
|
|
InvalidArgumentError,
|
|
InvalidReturnValueError,
|
|
RequestAbortedError
|
|
} = require_errors();
|
|
var util = require_util();
|
|
var { AsyncResource } = require("async_hooks");
|
|
var { addSignal, removeSignal } = require_abort_signal();
|
|
var assert = require("assert");
|
|
var kResume = Symbol("resume");
|
|
var PipelineRequest = class extends Readable {
|
|
constructor() {
|
|
super({ autoDestroy: true });
|
|
this[kResume] = null;
|
|
}
|
|
_read() {
|
|
const { [kResume]: resume } = this;
|
|
if (resume) {
|
|
this[kResume] = null;
|
|
resume();
|
|
}
|
|
}
|
|
_destroy(err, callback) {
|
|
this._read();
|
|
callback(err);
|
|
}
|
|
};
|
|
var PipelineResponse = class extends Readable {
|
|
constructor(resume) {
|
|
super({ autoDestroy: true });
|
|
this[kResume] = resume;
|
|
}
|
|
_read() {
|
|
this[kResume]();
|
|
}
|
|
_destroy(err, callback) {
|
|
if (!err && !this._readableState.endEmitted) {
|
|
err = new RequestAbortedError();
|
|
}
|
|
callback(err);
|
|
}
|
|
};
|
|
var PipelineHandler = class extends AsyncResource {
|
|
constructor(opts, handler) {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
if (typeof handler !== "function") {
|
|
throw new InvalidArgumentError("invalid handler");
|
|
}
|
|
const { signal, method, opaque, onInfo, responseHeaders } = opts;
|
|
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
|
|
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
|
|
}
|
|
if (method === "CONNECT") {
|
|
throw new InvalidArgumentError("invalid method");
|
|
}
|
|
if (onInfo && typeof onInfo !== "function") {
|
|
throw new InvalidArgumentError("invalid onInfo callback");
|
|
}
|
|
super("UNDICI_PIPELINE");
|
|
this.opaque = opaque || null;
|
|
this.responseHeaders = responseHeaders || null;
|
|
this.handler = handler;
|
|
this.abort = null;
|
|
this.context = null;
|
|
this.onInfo = onInfo || null;
|
|
this.req = new PipelineRequest().on("error", util.nop);
|
|
this.ret = new Duplex({
|
|
readableObjectMode: opts.objectMode,
|
|
autoDestroy: true,
|
|
read: () => {
|
|
const { body } = this;
|
|
if (body && body.resume) {
|
|
body.resume();
|
|
}
|
|
},
|
|
write: (chunk, encoding, callback) => {
|
|
const { req } = this;
|
|
if (req.push(chunk, encoding) || req._readableState.destroyed) {
|
|
callback();
|
|
} else {
|
|
req[kResume] = callback;
|
|
}
|
|
},
|
|
destroy: (err, callback) => {
|
|
const { body, req, res, ret, abort } = this;
|
|
if (!err && !ret._readableState.endEmitted) {
|
|
err = new RequestAbortedError();
|
|
}
|
|
if (abort && err) {
|
|
abort();
|
|
}
|
|
util.destroy(body, err);
|
|
util.destroy(req, err);
|
|
util.destroy(res, err);
|
|
removeSignal(this);
|
|
callback(err);
|
|
}
|
|
}).on("prefinish", () => {
|
|
const { req } = this;
|
|
req.push(null);
|
|
});
|
|
this.res = null;
|
|
addSignal(this, signal);
|
|
}
|
|
onConnect(abort, context) {
|
|
const { ret, res } = this;
|
|
assert(!res, "pipeline cannot be retried");
|
|
if (ret.destroyed) {
|
|
throw new RequestAbortedError();
|
|
}
|
|
this.abort = abort;
|
|
this.context = context;
|
|
}
|
|
onHeaders(statusCode, rawHeaders, resume) {
|
|
const { opaque, handler, context } = this;
|
|
if (statusCode < 200) {
|
|
if (this.onInfo) {
|
|
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
this.onInfo({ statusCode, headers });
|
|
}
|
|
return;
|
|
}
|
|
this.res = new PipelineResponse(resume);
|
|
let body;
|
|
try {
|
|
this.handler = null;
|
|
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
body = this.runInAsyncScope(handler, null, {
|
|
statusCode,
|
|
headers,
|
|
opaque,
|
|
body: this.res,
|
|
context
|
|
});
|
|
} catch (err) {
|
|
this.res.on("error", util.nop);
|
|
throw err;
|
|
}
|
|
if (!body || typeof body.on !== "function") {
|
|
throw new InvalidReturnValueError("expected Readable");
|
|
}
|
|
body.on("data", (chunk) => {
|
|
const { ret, body: body2 } = this;
|
|
if (!ret.push(chunk) && body2.pause) {
|
|
body2.pause();
|
|
}
|
|
}).on("error", (err) => {
|
|
const { ret } = this;
|
|
util.destroy(ret, err);
|
|
}).on("end", () => {
|
|
const { ret } = this;
|
|
ret.push(null);
|
|
}).on("close", () => {
|
|
const { ret } = this;
|
|
if (!ret._readableState.ended) {
|
|
util.destroy(ret, new RequestAbortedError());
|
|
}
|
|
});
|
|
this.body = body;
|
|
}
|
|
onData(chunk) {
|
|
const { res } = this;
|
|
return res.push(chunk);
|
|
}
|
|
onComplete(trailers) {
|
|
const { res } = this;
|
|
res.push(null);
|
|
}
|
|
onError(err) {
|
|
const { ret } = this;
|
|
this.handler = null;
|
|
util.destroy(ret, err);
|
|
}
|
|
};
|
|
function pipeline3(opts, handler) {
|
|
try {
|
|
const pipelineHandler = new PipelineHandler(opts, handler);
|
|
this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
|
|
return pipelineHandler.ret;
|
|
} catch (err) {
|
|
return new PassThrough3().destroy(err);
|
|
}
|
|
}
|
|
module2.exports = pipeline3;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/api-upgrade.js
|
|
var require_api_upgrade = __commonJS({
|
|
"node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) {
|
|
"use strict";
|
|
var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
|
|
var { AsyncResource } = require("async_hooks");
|
|
var util = require_util();
|
|
var { addSignal, removeSignal } = require_abort_signal();
|
|
var assert = require("assert");
|
|
var UpgradeHandler = class extends AsyncResource {
|
|
constructor(opts, callback) {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
const { signal, opaque, responseHeaders } = opts;
|
|
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
|
|
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
|
|
}
|
|
super("UNDICI_UPGRADE");
|
|
this.responseHeaders = responseHeaders || null;
|
|
this.opaque = opaque || null;
|
|
this.callback = callback;
|
|
this.abort = null;
|
|
this.context = null;
|
|
addSignal(this, signal);
|
|
}
|
|
onConnect(abort, context) {
|
|
if (!this.callback) {
|
|
throw new RequestAbortedError();
|
|
}
|
|
this.abort = abort;
|
|
this.context = null;
|
|
}
|
|
onHeaders() {
|
|
throw new SocketError("bad upgrade", null);
|
|
}
|
|
onUpgrade(statusCode, rawHeaders, socket) {
|
|
const { callback, opaque, context } = this;
|
|
assert.strictEqual(statusCode, 101);
|
|
removeSignal(this);
|
|
this.callback = null;
|
|
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
this.runInAsyncScope(callback, null, null, {
|
|
headers,
|
|
socket,
|
|
opaque,
|
|
context
|
|
});
|
|
}
|
|
onError(err) {
|
|
const { callback, opaque } = this;
|
|
removeSignal(this);
|
|
if (callback) {
|
|
this.callback = null;
|
|
queueMicrotask(() => {
|
|
this.runInAsyncScope(callback, null, err, { opaque });
|
|
});
|
|
}
|
|
}
|
|
};
|
|
function upgrade(opts, callback) {
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
upgrade.call(this, opts, (err, data) => {
|
|
return err ? reject(err) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
try {
|
|
const upgradeHandler = new UpgradeHandler(opts, callback);
|
|
this.dispatch({
|
|
...opts,
|
|
method: opts.method || "GET",
|
|
upgrade: opts.protocol || "Websocket"
|
|
}, upgradeHandler);
|
|
} catch (err) {
|
|
if (typeof callback !== "function") {
|
|
throw err;
|
|
}
|
|
const opaque = opts && opts.opaque;
|
|
queueMicrotask(() => callback(err, { opaque }));
|
|
}
|
|
}
|
|
module2.exports = upgrade;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/api-connect.js
|
|
var require_api_connect = __commonJS({
|
|
"node_modules/undici/lib/api/api-connect.js"(exports2, module2) {
|
|
"use strict";
|
|
var { AsyncResource } = require("async_hooks");
|
|
var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
|
|
var util = require_util();
|
|
var { addSignal, removeSignal } = require_abort_signal();
|
|
var ConnectHandler = class extends AsyncResource {
|
|
constructor(opts, callback) {
|
|
if (!opts || typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
if (typeof callback !== "function") {
|
|
throw new InvalidArgumentError("invalid callback");
|
|
}
|
|
const { signal, opaque, responseHeaders } = opts;
|
|
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
|
|
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
|
|
}
|
|
super("UNDICI_CONNECT");
|
|
this.opaque = opaque || null;
|
|
this.responseHeaders = responseHeaders || null;
|
|
this.callback = callback;
|
|
this.abort = null;
|
|
addSignal(this, signal);
|
|
}
|
|
onConnect(abort, context) {
|
|
if (!this.callback) {
|
|
throw new RequestAbortedError();
|
|
}
|
|
this.abort = abort;
|
|
this.context = context;
|
|
}
|
|
onHeaders() {
|
|
throw new SocketError("bad connect", null);
|
|
}
|
|
onUpgrade(statusCode, rawHeaders, socket) {
|
|
const { callback, opaque, context } = this;
|
|
removeSignal(this);
|
|
this.callback = null;
|
|
let headers = rawHeaders;
|
|
if (headers != null) {
|
|
headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
|
|
}
|
|
this.runInAsyncScope(callback, null, null, {
|
|
statusCode,
|
|
headers,
|
|
socket,
|
|
opaque,
|
|
context
|
|
});
|
|
}
|
|
onError(err) {
|
|
const { callback, opaque } = this;
|
|
removeSignal(this);
|
|
if (callback) {
|
|
this.callback = null;
|
|
queueMicrotask(() => {
|
|
this.runInAsyncScope(callback, null, err, { opaque });
|
|
});
|
|
}
|
|
}
|
|
};
|
|
function connect(opts, callback) {
|
|
if (callback === void 0) {
|
|
return new Promise((resolve, reject) => {
|
|
connect.call(this, opts, (err, data) => {
|
|
return err ? reject(err) : resolve(data);
|
|
});
|
|
});
|
|
}
|
|
try {
|
|
const connectHandler = new ConnectHandler(opts, callback);
|
|
this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
|
|
} catch (err) {
|
|
if (typeof callback !== "function") {
|
|
throw err;
|
|
}
|
|
const opaque = opts && opts.opaque;
|
|
queueMicrotask(() => callback(err, { opaque }));
|
|
}
|
|
}
|
|
module2.exports = connect;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/api/index.js
|
|
var require_api = __commonJS({
|
|
"node_modules/undici/lib/api/index.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports.request = require_api_request();
|
|
module2.exports.stream = require_api_stream();
|
|
module2.exports.pipeline = require_api_pipeline();
|
|
module2.exports.upgrade = require_api_upgrade();
|
|
module2.exports.connect = require_api_connect();
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-errors.js
|
|
var require_mock_errors = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) {
|
|
"use strict";
|
|
var { UndiciError } = require_errors();
|
|
var MockNotMatchedError = class _MockNotMatchedError extends UndiciError {
|
|
constructor(message) {
|
|
super(message);
|
|
Error.captureStackTrace(this, _MockNotMatchedError);
|
|
this.name = "MockNotMatchedError";
|
|
this.message = message || "The request does not match any registered mock dispatches";
|
|
this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
|
|
}
|
|
};
|
|
module2.exports = {
|
|
MockNotMatchedError
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-symbols.js
|
|
var require_mock_symbols = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = {
|
|
kAgent: Symbol("agent"),
|
|
kOptions: Symbol("options"),
|
|
kFactory: Symbol("factory"),
|
|
kDispatches: Symbol("dispatches"),
|
|
kDispatchKey: Symbol("dispatch key"),
|
|
kDefaultHeaders: Symbol("default headers"),
|
|
kDefaultTrailers: Symbol("default trailers"),
|
|
kContentLength: Symbol("content length"),
|
|
kMockAgent: Symbol("mock agent"),
|
|
kMockAgentSet: Symbol("mock agent set"),
|
|
kMockAgentGet: Symbol("mock agent get"),
|
|
kMockDispatch: Symbol("mock dispatch"),
|
|
kClose: Symbol("close"),
|
|
kOriginalClose: Symbol("original agent close"),
|
|
kOrigin: Symbol("origin"),
|
|
kIsMockActive: Symbol("is mock active"),
|
|
kNetConnect: Symbol("net connect"),
|
|
kGetNetConnect: Symbol("get net connect"),
|
|
kConnected: Symbol("connected")
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-utils.js
|
|
var require_mock_utils = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) {
|
|
"use strict";
|
|
var { MockNotMatchedError } = require_mock_errors();
|
|
var {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kOriginalDispatch,
|
|
kOrigin,
|
|
kGetNetConnect
|
|
} = require_mock_symbols();
|
|
var { buildURL, nop } = require_util();
|
|
var { STATUS_CODES } = require("http");
|
|
var {
|
|
types: {
|
|
isPromise
|
|
}
|
|
} = require("util");
|
|
function matchValue(match, value) {
|
|
if (typeof match === "string") {
|
|
return match === value;
|
|
}
|
|
if (match instanceof RegExp) {
|
|
return match.test(value);
|
|
}
|
|
if (typeof match === "function") {
|
|
return match(value) === true;
|
|
}
|
|
return false;
|
|
}
|
|
function lowerCaseEntries(headers) {
|
|
return Object.fromEntries(
|
|
Object.entries(headers).map(([headerName, headerValue]) => {
|
|
return [headerName.toLocaleLowerCase(), headerValue];
|
|
})
|
|
);
|
|
}
|
|
function getHeaderByName(headers, key) {
|
|
if (Array.isArray(headers)) {
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
if (headers[i2].toLocaleLowerCase() === key.toLocaleLowerCase()) {
|
|
return headers[i2 + 1];
|
|
}
|
|
}
|
|
return void 0;
|
|
} else if (typeof headers.get === "function") {
|
|
return headers.get(key);
|
|
} else {
|
|
return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
|
|
}
|
|
}
|
|
function buildHeadersFromArray(headers) {
|
|
const clone2 = headers.slice();
|
|
const entries = [];
|
|
for (let index = 0; index < clone2.length; index += 2) {
|
|
entries.push([clone2[index], clone2[index + 1]]);
|
|
}
|
|
return Object.fromEntries(entries);
|
|
}
|
|
function matchHeaders(mockDispatch2, headers) {
|
|
if (typeof mockDispatch2.headers === "function") {
|
|
if (Array.isArray(headers)) {
|
|
headers = buildHeadersFromArray(headers);
|
|
}
|
|
return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
|
|
}
|
|
if (typeof mockDispatch2.headers === "undefined") {
|
|
return true;
|
|
}
|
|
if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
|
|
return false;
|
|
}
|
|
for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
|
|
const headerValue = getHeaderByName(headers, matchHeaderName);
|
|
if (!matchValue(matchHeaderValue, headerValue)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function safeUrl(path3) {
|
|
if (typeof path3 !== "string") {
|
|
return path3;
|
|
}
|
|
const pathSegments = path3.split("?");
|
|
if (pathSegments.length !== 2) {
|
|
return path3;
|
|
}
|
|
const qp = new URLSearchParams(pathSegments.pop());
|
|
qp.sort();
|
|
return [...pathSegments, qp.toString()].join("?");
|
|
}
|
|
function matchKey(mockDispatch2, { path: path3, method, body, headers }) {
|
|
const pathMatch = matchValue(mockDispatch2.path, path3);
|
|
const methodMatch = matchValue(mockDispatch2.method, method);
|
|
const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
|
|
const headersMatch = matchHeaders(mockDispatch2, headers);
|
|
return pathMatch && methodMatch && bodyMatch && headersMatch;
|
|
}
|
|
function getResponseData(data) {
|
|
if (Buffer.isBuffer(data)) {
|
|
return data;
|
|
} else if (typeof data === "object") {
|
|
return JSON.stringify(data);
|
|
} else {
|
|
return data.toString();
|
|
}
|
|
}
|
|
function getMockDispatch(mockDispatches, key) {
|
|
const basePath = key.query ? buildURL(key.path, key.query) : key.path;
|
|
const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
|
|
let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path3 }) => matchValue(safeUrl(path3), resolvedPath));
|
|
if (matchedMockDispatches.length === 0) {
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
|
|
}
|
|
matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
|
|
if (matchedMockDispatches.length === 0) {
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
|
|
}
|
|
matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
|
|
if (matchedMockDispatches.length === 0) {
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
|
|
}
|
|
matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
|
|
if (matchedMockDispatches.length === 0) {
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
|
|
}
|
|
return matchedMockDispatches[0];
|
|
}
|
|
function addMockDispatch(mockDispatches, key, data) {
|
|
const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
|
|
const replyData = typeof data === "function" ? { callback: data } : { ...data };
|
|
const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
|
|
mockDispatches.push(newMockDispatch);
|
|
return newMockDispatch;
|
|
}
|
|
function deleteMockDispatch(mockDispatches, key) {
|
|
const index = mockDispatches.findIndex((dispatch) => {
|
|
if (!dispatch.consumed) {
|
|
return false;
|
|
}
|
|
return matchKey(dispatch, key);
|
|
});
|
|
if (index !== -1) {
|
|
mockDispatches.splice(index, 1);
|
|
}
|
|
}
|
|
function buildKey(opts) {
|
|
const { path: path3, method, body, headers, query } = opts;
|
|
return {
|
|
path: path3,
|
|
method,
|
|
body,
|
|
headers,
|
|
query
|
|
};
|
|
}
|
|
function generateKeyValues(data) {
|
|
return Object.entries(data).reduce((keyValuePairs, [key, value]) => [
|
|
...keyValuePairs,
|
|
Buffer.from(`${key}`),
|
|
Array.isArray(value) ? value.map((x2) => Buffer.from(`${x2}`)) : Buffer.from(`${value}`)
|
|
], []);
|
|
}
|
|
function getStatusText(statusCode) {
|
|
return STATUS_CODES[statusCode] || "unknown";
|
|
}
|
|
async function getResponse(body) {
|
|
const buffers = [];
|
|
for await (const data of body) {
|
|
buffers.push(data);
|
|
}
|
|
return Buffer.concat(buffers).toString("utf8");
|
|
}
|
|
function mockDispatch(opts, handler) {
|
|
const key = buildKey(opts);
|
|
const mockDispatch2 = getMockDispatch(this[kDispatches], key);
|
|
mockDispatch2.timesInvoked++;
|
|
if (mockDispatch2.data.callback) {
|
|
mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
|
|
}
|
|
const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2;
|
|
const { timesInvoked, times } = mockDispatch2;
|
|
mockDispatch2.consumed = !persist && timesInvoked >= times;
|
|
mockDispatch2.pending = timesInvoked < times;
|
|
if (error !== null) {
|
|
deleteMockDispatch(this[kDispatches], key);
|
|
handler.onError(error);
|
|
return true;
|
|
}
|
|
if (typeof delay === "number" && delay > 0) {
|
|
setTimeout(() => {
|
|
handleReply(this[kDispatches]);
|
|
}, delay);
|
|
} else {
|
|
handleReply(this[kDispatches]);
|
|
}
|
|
function handleReply(mockDispatches, _data = data) {
|
|
const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
|
|
const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
|
|
if (isPromise(body)) {
|
|
body.then((newData) => handleReply(mockDispatches, newData));
|
|
return;
|
|
}
|
|
const responseData = getResponseData(body);
|
|
const responseHeaders = generateKeyValues(headers);
|
|
const responseTrailers = generateKeyValues(trailers);
|
|
handler.abort = nop;
|
|
handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
|
|
handler.onData(Buffer.from(responseData));
|
|
handler.onComplete(responseTrailers);
|
|
deleteMockDispatch(mockDispatches, key);
|
|
}
|
|
function resume() {
|
|
}
|
|
return true;
|
|
}
|
|
function buildMockDispatch() {
|
|
const agent = this[kMockAgent];
|
|
const origin = this[kOrigin];
|
|
const originalDispatch = this[kOriginalDispatch];
|
|
return function dispatch(opts, handler) {
|
|
if (agent.isMockActive) {
|
|
try {
|
|
mockDispatch.call(this, opts, handler);
|
|
} catch (error) {
|
|
if (error instanceof MockNotMatchedError) {
|
|
const netConnect = agent[kGetNetConnect]();
|
|
if (netConnect === false) {
|
|
throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
|
|
}
|
|
if (checkNetConnect(netConnect, origin)) {
|
|
originalDispatch.call(this, opts, handler);
|
|
} else {
|
|
throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
|
|
}
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
} else {
|
|
originalDispatch.call(this, opts, handler);
|
|
}
|
|
};
|
|
}
|
|
function checkNetConnect(netConnect, origin) {
|
|
const url = new URL(origin);
|
|
if (netConnect === true) {
|
|
return true;
|
|
} else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function buildMockOptions(opts) {
|
|
if (opts) {
|
|
const { agent, ...mockOptions } = opts;
|
|
return mockOptions;
|
|
}
|
|
}
|
|
module2.exports = {
|
|
getResponseData,
|
|
getMockDispatch,
|
|
addMockDispatch,
|
|
deleteMockDispatch,
|
|
buildKey,
|
|
generateKeyValues,
|
|
matchValue,
|
|
getResponse,
|
|
getStatusText,
|
|
mockDispatch,
|
|
buildMockDispatch,
|
|
checkNetConnect,
|
|
buildMockOptions,
|
|
getHeaderByName
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-interceptor.js
|
|
var require_mock_interceptor = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) {
|
|
"use strict";
|
|
var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
|
|
var {
|
|
kDispatches,
|
|
kDispatchKey,
|
|
kDefaultHeaders,
|
|
kDefaultTrailers,
|
|
kContentLength,
|
|
kMockDispatch
|
|
} = require_mock_symbols();
|
|
var { InvalidArgumentError } = require_errors();
|
|
var { buildURL } = require_util();
|
|
var MockScope = class {
|
|
constructor(mockDispatch) {
|
|
this[kMockDispatch] = mockDispatch;
|
|
}
|
|
/**
|
|
* Delay a reply by a set amount in ms.
|
|
*/
|
|
delay(waitInMs) {
|
|
if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
|
|
throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
|
|
}
|
|
this[kMockDispatch].delay = waitInMs;
|
|
return this;
|
|
}
|
|
/**
|
|
* For a defined reply, never mark as consumed.
|
|
*/
|
|
persist() {
|
|
this[kMockDispatch].persist = true;
|
|
return this;
|
|
}
|
|
/**
|
|
* Allow one to define a reply for a set amount of matching requests.
|
|
*/
|
|
times(repeatTimes) {
|
|
if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
|
|
throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
|
|
}
|
|
this[kMockDispatch].times = repeatTimes;
|
|
return this;
|
|
}
|
|
};
|
|
var MockInterceptor = class {
|
|
constructor(opts, mockDispatches) {
|
|
if (typeof opts !== "object") {
|
|
throw new InvalidArgumentError("opts must be an object");
|
|
}
|
|
if (typeof opts.path === "undefined") {
|
|
throw new InvalidArgumentError("opts.path must be defined");
|
|
}
|
|
if (typeof opts.method === "undefined") {
|
|
opts.method = "GET";
|
|
}
|
|
if (typeof opts.path === "string") {
|
|
if (opts.query) {
|
|
opts.path = buildURL(opts.path, opts.query);
|
|
} else {
|
|
const parsedURL = new URL(opts.path, "data://");
|
|
opts.path = parsedURL.pathname + parsedURL.search;
|
|
}
|
|
}
|
|
if (typeof opts.method === "string") {
|
|
opts.method = opts.method.toUpperCase();
|
|
}
|
|
this[kDispatchKey] = buildKey(opts);
|
|
this[kDispatches] = mockDispatches;
|
|
this[kDefaultHeaders] = {};
|
|
this[kDefaultTrailers] = {};
|
|
this[kContentLength] = false;
|
|
}
|
|
createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
|
|
const responseData = getResponseData(data);
|
|
const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
|
|
const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
|
|
const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
|
|
return { statusCode, data, headers, trailers };
|
|
}
|
|
validateReplyParameters(statusCode, data, responseOptions) {
|
|
if (typeof statusCode === "undefined") {
|
|
throw new InvalidArgumentError("statusCode must be defined");
|
|
}
|
|
if (typeof data === "undefined") {
|
|
throw new InvalidArgumentError("data must be defined");
|
|
}
|
|
if (typeof responseOptions !== "object") {
|
|
throw new InvalidArgumentError("responseOptions must be an object");
|
|
}
|
|
}
|
|
/**
|
|
* Mock an undici request with a defined reply.
|
|
*/
|
|
reply(replyData) {
|
|
if (typeof replyData === "function") {
|
|
const wrappedDefaultsCallback = (opts) => {
|
|
const resolvedData = replyData(opts);
|
|
if (typeof resolvedData !== "object") {
|
|
throw new InvalidArgumentError("reply options callback must return an object");
|
|
}
|
|
const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
|
|
this.validateReplyParameters(statusCode2, data2, responseOptions2);
|
|
return {
|
|
...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
|
|
};
|
|
};
|
|
const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback);
|
|
return new MockScope(newMockDispatch2);
|
|
}
|
|
const [statusCode, data = "", responseOptions = {}] = [...arguments];
|
|
this.validateReplyParameters(statusCode, data, responseOptions);
|
|
const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
|
|
const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData);
|
|
return new MockScope(newMockDispatch);
|
|
}
|
|
/**
|
|
* Mock an undici request with a defined error.
|
|
*/
|
|
replyWithError(error) {
|
|
if (typeof error === "undefined") {
|
|
throw new InvalidArgumentError("error must be defined");
|
|
}
|
|
const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error });
|
|
return new MockScope(newMockDispatch);
|
|
}
|
|
/**
|
|
* Set default reply headers on the interceptor for subsequent replies
|
|
*/
|
|
defaultReplyHeaders(headers) {
|
|
if (typeof headers === "undefined") {
|
|
throw new InvalidArgumentError("headers must be defined");
|
|
}
|
|
this[kDefaultHeaders] = headers;
|
|
return this;
|
|
}
|
|
/**
|
|
* Set default reply trailers on the interceptor for subsequent replies
|
|
*/
|
|
defaultReplyTrailers(trailers) {
|
|
if (typeof trailers === "undefined") {
|
|
throw new InvalidArgumentError("trailers must be defined");
|
|
}
|
|
this[kDefaultTrailers] = trailers;
|
|
return this;
|
|
}
|
|
/**
|
|
* Set reply content length header for replies on the interceptor
|
|
*/
|
|
replyContentLength() {
|
|
this[kContentLength] = true;
|
|
return this;
|
|
}
|
|
};
|
|
module2.exports.MockInterceptor = MockInterceptor;
|
|
module2.exports.MockScope = MockScope;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-client.js
|
|
var require_mock_client = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
|
|
"use strict";
|
|
var { promisify: promisify3 } = require("util");
|
|
var Client = require_client();
|
|
var { buildMockDispatch } = require_mock_utils();
|
|
var {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kClose,
|
|
kOriginalClose,
|
|
kOrigin,
|
|
kOriginalDispatch,
|
|
kConnected
|
|
} = require_mock_symbols();
|
|
var { MockInterceptor } = require_mock_interceptor();
|
|
var Symbols = require_symbols();
|
|
var { InvalidArgumentError } = require_errors();
|
|
var MockClient = class extends Client {
|
|
constructor(origin, opts) {
|
|
super(origin, opts);
|
|
if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
|
|
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
|
|
}
|
|
this[kMockAgent] = opts.agent;
|
|
this[kOrigin] = origin;
|
|
this[kDispatches] = [];
|
|
this[kConnected] = 1;
|
|
this[kOriginalDispatch] = this.dispatch;
|
|
this[kOriginalClose] = this.close.bind(this);
|
|
this.dispatch = buildMockDispatch.call(this);
|
|
this.close = this[kClose];
|
|
}
|
|
get [Symbols.kConnected]() {
|
|
return this[kConnected];
|
|
}
|
|
/**
|
|
* Sets up the base interceptor for mocking replies from undici.
|
|
*/
|
|
intercept(opts) {
|
|
return new MockInterceptor(opts, this[kDispatches]);
|
|
}
|
|
async [kClose]() {
|
|
await promisify3(this[kOriginalClose])();
|
|
this[kConnected] = 0;
|
|
this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
|
|
}
|
|
};
|
|
module2.exports = MockClient;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-pool.js
|
|
var require_mock_pool = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
|
|
"use strict";
|
|
var { promisify: promisify3 } = require("util");
|
|
var Pool = require_pool();
|
|
var { buildMockDispatch } = require_mock_utils();
|
|
var {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kClose,
|
|
kOriginalClose,
|
|
kOrigin,
|
|
kOriginalDispatch,
|
|
kConnected
|
|
} = require_mock_symbols();
|
|
var { MockInterceptor } = require_mock_interceptor();
|
|
var Symbols = require_symbols();
|
|
var { InvalidArgumentError } = require_errors();
|
|
var MockPool = class extends Pool {
|
|
constructor(origin, opts) {
|
|
super(origin, opts);
|
|
if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
|
|
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
|
|
}
|
|
this[kMockAgent] = opts.agent;
|
|
this[kOrigin] = origin;
|
|
this[kDispatches] = [];
|
|
this[kConnected] = 1;
|
|
this[kOriginalDispatch] = this.dispatch;
|
|
this[kOriginalClose] = this.close.bind(this);
|
|
this.dispatch = buildMockDispatch.call(this);
|
|
this.close = this[kClose];
|
|
}
|
|
get [Symbols.kConnected]() {
|
|
return this[kConnected];
|
|
}
|
|
/**
|
|
* Sets up the base interceptor for mocking replies from undici.
|
|
*/
|
|
intercept(opts) {
|
|
return new MockInterceptor(opts, this[kDispatches]);
|
|
}
|
|
async [kClose]() {
|
|
await promisify3(this[kOriginalClose])();
|
|
this[kConnected] = 0;
|
|
this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
|
|
}
|
|
};
|
|
module2.exports = MockPool;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/pluralizer.js
|
|
var require_pluralizer = __commonJS({
|
|
"node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) {
|
|
"use strict";
|
|
var singulars = {
|
|
pronoun: "it",
|
|
is: "is",
|
|
was: "was",
|
|
this: "this"
|
|
};
|
|
var plurals = {
|
|
pronoun: "they",
|
|
is: "are",
|
|
was: "were",
|
|
this: "these"
|
|
};
|
|
module2.exports = class Pluralizer {
|
|
constructor(singular, plural) {
|
|
this.singular = singular;
|
|
this.plural = plural;
|
|
}
|
|
pluralize(count) {
|
|
const one = count === 1;
|
|
const keys = one ? singulars : plurals;
|
|
const noun = one ? this.singular : this.plural;
|
|
return { ...keys, count, noun };
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/pending-interceptors-formatter.js
|
|
var require_pending_interceptors_formatter = __commonJS({
|
|
"node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Transform } = require("stream");
|
|
var { Console } = require("console");
|
|
module2.exports = class PendingInterceptorsFormatter {
|
|
constructor({ disableColors } = {}) {
|
|
this.transform = new Transform({
|
|
transform(chunk, _enc, cb) {
|
|
cb(null, chunk);
|
|
}
|
|
});
|
|
this.logger = new Console({
|
|
stdout: this.transform,
|
|
inspectOptions: {
|
|
colors: !disableColors && !process.env.CI
|
|
}
|
|
});
|
|
}
|
|
format(pendingInterceptors) {
|
|
const withPrettyHeaders = pendingInterceptors.map(
|
|
({ method, path: path3, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
|
|
Method: method,
|
|
Origin: origin,
|
|
Path: path3,
|
|
"Status code": statusCode,
|
|
Persistent: persist ? "\u2705" : "\u274C",
|
|
Invocations: timesInvoked,
|
|
Remaining: persist ? Infinity : times - timesInvoked
|
|
})
|
|
);
|
|
this.logger.table(withPrettyHeaders);
|
|
return this.transform.read().toString();
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/mock/mock-agent.js
|
|
var require_mock_agent = __commonJS({
|
|
"node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kClients } = require_symbols();
|
|
var Agent = require_agent();
|
|
var {
|
|
kAgent,
|
|
kMockAgentSet,
|
|
kMockAgentGet,
|
|
kDispatches,
|
|
kIsMockActive,
|
|
kNetConnect,
|
|
kGetNetConnect,
|
|
kOptions,
|
|
kFactory
|
|
} = require_mock_symbols();
|
|
var MockClient = require_mock_client();
|
|
var MockPool = require_mock_pool();
|
|
var { matchValue, buildMockOptions } = require_mock_utils();
|
|
var { InvalidArgumentError, UndiciError } = require_errors();
|
|
var Dispatcher = require_dispatcher();
|
|
var Pluralizer = require_pluralizer();
|
|
var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
|
|
var FakeWeakRef = class {
|
|
constructor(value) {
|
|
this.value = value;
|
|
}
|
|
deref() {
|
|
return this.value;
|
|
}
|
|
};
|
|
var MockAgent = class extends Dispatcher {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this[kNetConnect] = true;
|
|
this[kIsMockActive] = true;
|
|
if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
|
|
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
|
|
}
|
|
const agent = opts && opts.agent ? opts.agent : new Agent(opts);
|
|
this[kAgent] = agent;
|
|
this[kClients] = agent[kClients];
|
|
this[kOptions] = buildMockOptions(opts);
|
|
}
|
|
get(origin) {
|
|
let dispatcher = this[kMockAgentGet](origin);
|
|
if (!dispatcher) {
|
|
dispatcher = this[kFactory](origin);
|
|
this[kMockAgentSet](origin, dispatcher);
|
|
}
|
|
return dispatcher;
|
|
}
|
|
dispatch(opts, handler) {
|
|
this.get(opts.origin);
|
|
return this[kAgent].dispatch(opts, handler);
|
|
}
|
|
async close() {
|
|
await this[kAgent].close();
|
|
this[kClients].clear();
|
|
}
|
|
deactivate() {
|
|
this[kIsMockActive] = false;
|
|
}
|
|
activate() {
|
|
this[kIsMockActive] = true;
|
|
}
|
|
enableNetConnect(matcher) {
|
|
if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
|
|
if (Array.isArray(this[kNetConnect])) {
|
|
this[kNetConnect].push(matcher);
|
|
} else {
|
|
this[kNetConnect] = [matcher];
|
|
}
|
|
} else if (typeof matcher === "undefined") {
|
|
this[kNetConnect] = true;
|
|
} else {
|
|
throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
|
|
}
|
|
}
|
|
disableNetConnect() {
|
|
this[kNetConnect] = false;
|
|
}
|
|
// This is required to bypass issues caused by using global symbols - see:
|
|
// https://github.com/nodejs/undici/issues/1447
|
|
get isMockActive() {
|
|
return this[kIsMockActive];
|
|
}
|
|
[kMockAgentSet](origin, dispatcher) {
|
|
this[kClients].set(origin, new FakeWeakRef(dispatcher));
|
|
}
|
|
[kFactory](origin) {
|
|
const mockOptions = Object.assign({ agent: this }, this[kOptions]);
|
|
return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
|
|
}
|
|
[kMockAgentGet](origin) {
|
|
const ref = this[kClients].get(origin);
|
|
if (ref) {
|
|
return ref.deref();
|
|
}
|
|
if (typeof origin !== "string") {
|
|
const dispatcher = this[kFactory]("http://localhost:9999");
|
|
this[kMockAgentSet](origin, dispatcher);
|
|
return dispatcher;
|
|
}
|
|
for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) {
|
|
const nonExplicitDispatcher = nonExplicitRef.deref();
|
|
if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
|
|
const dispatcher = this[kFactory](origin);
|
|
this[kMockAgentSet](origin, dispatcher);
|
|
dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
|
|
return dispatcher;
|
|
}
|
|
}
|
|
}
|
|
[kGetNetConnect]() {
|
|
return this[kNetConnect];
|
|
}
|
|
pendingInterceptors() {
|
|
const mockAgentClients = this[kClients];
|
|
return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
|
|
}
|
|
assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
|
|
const pending = this.pendingInterceptors();
|
|
if (pending.length === 0) {
|
|
return;
|
|
}
|
|
const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
|
|
throw new UndiciError(`
|
|
${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
|
|
|
|
${pendingInterceptorsFormatter.format(pending)}
|
|
`.trim());
|
|
}
|
|
};
|
|
module2.exports = MockAgent;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/proxy-agent.js
|
|
var require_proxy_agent = __commonJS({
|
|
"node_modules/undici/lib/proxy-agent.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols();
|
|
var { URL: URL2 } = require("url");
|
|
var Agent = require_agent();
|
|
var Pool = require_pool();
|
|
var DispatcherBase = require_dispatcher_base();
|
|
var { InvalidArgumentError, RequestAbortedError } = require_errors();
|
|
var buildConnector = require_connect();
|
|
var kAgent = Symbol("proxy agent");
|
|
var kClient = Symbol("proxy client");
|
|
var kProxyHeaders = Symbol("proxy headers");
|
|
var kRequestTls = Symbol("request tls settings");
|
|
var kProxyTls = Symbol("proxy tls settings");
|
|
var kConnectEndpoint = Symbol("connect endpoint function");
|
|
function defaultProtocolPort(protocol) {
|
|
return protocol === "https:" ? 443 : 80;
|
|
}
|
|
function buildProxyOptions(opts) {
|
|
if (typeof opts === "string") {
|
|
opts = { uri: opts };
|
|
}
|
|
if (!opts || !opts.uri) {
|
|
throw new InvalidArgumentError("Proxy opts.uri is mandatory");
|
|
}
|
|
return {
|
|
uri: opts.uri,
|
|
protocol: opts.protocol || "https"
|
|
};
|
|
}
|
|
function defaultFactory(origin, opts) {
|
|
return new Pool(origin, opts);
|
|
}
|
|
var ProxyAgent = class extends DispatcherBase {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this[kProxy] = buildProxyOptions(opts);
|
|
this[kAgent] = new Agent(opts);
|
|
this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
|
|
if (typeof opts === "string") {
|
|
opts = { uri: opts };
|
|
}
|
|
if (!opts || !opts.uri) {
|
|
throw new InvalidArgumentError("Proxy opts.uri is mandatory");
|
|
}
|
|
const { clientFactory = defaultFactory } = opts;
|
|
if (typeof clientFactory !== "function") {
|
|
throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
|
|
}
|
|
this[kRequestTls] = opts.requestTls;
|
|
this[kProxyTls] = opts.proxyTls;
|
|
this[kProxyHeaders] = opts.headers || {};
|
|
const resolvedUrl = new URL2(opts.uri);
|
|
const { origin, port, host, username, password } = resolvedUrl;
|
|
if (opts.auth && opts.token) {
|
|
throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
|
|
} else if (opts.auth) {
|
|
this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
|
|
} else if (opts.token) {
|
|
this[kProxyHeaders]["proxy-authorization"] = opts.token;
|
|
} else if (username && password) {
|
|
this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
|
|
}
|
|
const connect = buildConnector({ ...opts.proxyTls });
|
|
this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
|
|
this[kClient] = clientFactory(resolvedUrl, { connect });
|
|
this[kAgent] = new Agent({
|
|
...opts,
|
|
connect: async (opts2, callback) => {
|
|
let requestedHost = opts2.host;
|
|
if (!opts2.port) {
|
|
requestedHost += `:${defaultProtocolPort(opts2.protocol)}`;
|
|
}
|
|
try {
|
|
const { socket, statusCode } = await this[kClient].connect({
|
|
origin,
|
|
port,
|
|
path: requestedHost,
|
|
signal: opts2.signal,
|
|
headers: {
|
|
...this[kProxyHeaders],
|
|
host
|
|
}
|
|
});
|
|
if (statusCode !== 200) {
|
|
socket.on("error", () => {
|
|
}).destroy();
|
|
callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
|
|
}
|
|
if (opts2.protocol !== "https:") {
|
|
callback(null, socket);
|
|
return;
|
|
}
|
|
let servername;
|
|
if (this[kRequestTls]) {
|
|
servername = this[kRequestTls].servername;
|
|
} else {
|
|
servername = opts2.servername;
|
|
}
|
|
this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
|
|
} catch (err) {
|
|
callback(err);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
dispatch(opts, handler) {
|
|
const { host } = new URL2(opts.origin);
|
|
const headers = buildHeaders(opts.headers);
|
|
throwIfProxyAuthIsSent(headers);
|
|
return this[kAgent].dispatch(
|
|
{
|
|
...opts,
|
|
headers: {
|
|
...headers,
|
|
host
|
|
}
|
|
},
|
|
handler
|
|
);
|
|
}
|
|
async [kClose]() {
|
|
await this[kAgent].close();
|
|
await this[kClient].close();
|
|
}
|
|
async [kDestroy]() {
|
|
await this[kAgent].destroy();
|
|
await this[kClient].destroy();
|
|
}
|
|
};
|
|
function buildHeaders(headers) {
|
|
if (Array.isArray(headers)) {
|
|
const headersPair = {};
|
|
for (let i2 = 0; i2 < headers.length; i2 += 2) {
|
|
headersPair[headers[i2]] = headers[i2 + 1];
|
|
}
|
|
return headersPair;
|
|
}
|
|
return headers;
|
|
}
|
|
function throwIfProxyAuthIsSent(headers) {
|
|
const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
|
|
if (existProxyAuth) {
|
|
throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
|
|
}
|
|
}
|
|
module2.exports = ProxyAgent;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/handler/RetryHandler.js
|
|
var require_RetryHandler = __commonJS({
|
|
"node_modules/undici/lib/handler/RetryHandler.js"(exports2, module2) {
|
|
var assert = require("assert");
|
|
var { kRetryHandlerDefaultRetry } = require_symbols();
|
|
var { RequestRetryError } = require_errors();
|
|
var { isDisturbed, parseHeaders, parseRangeHeader } = require_util();
|
|
function calculateRetryAfterHeader(retryAfter) {
|
|
const current = Date.now();
|
|
const diff = new Date(retryAfter).getTime() - current;
|
|
return diff;
|
|
}
|
|
var RetryHandler = class _RetryHandler {
|
|
constructor(opts, handlers) {
|
|
const { retryOptions, ...dispatchOpts } = opts;
|
|
const {
|
|
// Retry scoped
|
|
retry: retryFn,
|
|
maxRetries,
|
|
maxTimeout,
|
|
minTimeout,
|
|
timeoutFactor,
|
|
// Response scoped
|
|
methods,
|
|
errorCodes,
|
|
retryAfter,
|
|
statusCodes
|
|
} = retryOptions ?? {};
|
|
this.dispatch = handlers.dispatch;
|
|
this.handler = handlers.handler;
|
|
this.opts = dispatchOpts;
|
|
this.abort = null;
|
|
this.aborted = false;
|
|
this.retryOpts = {
|
|
retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry],
|
|
retryAfter: retryAfter ?? true,
|
|
maxTimeout: maxTimeout ?? 30 * 1e3,
|
|
// 30s,
|
|
timeout: minTimeout ?? 500,
|
|
// .5s
|
|
timeoutFactor: timeoutFactor ?? 2,
|
|
maxRetries: maxRetries ?? 5,
|
|
// What errors we should retry
|
|
methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"],
|
|
// Indicates which errors to retry
|
|
statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
|
|
// List of errors to retry
|
|
errorCodes: errorCodes ?? [
|
|
"ECONNRESET",
|
|
"ECONNREFUSED",
|
|
"ENOTFOUND",
|
|
"ENETDOWN",
|
|
"ENETUNREACH",
|
|
"EHOSTDOWN",
|
|
"EHOSTUNREACH",
|
|
"EPIPE"
|
|
]
|
|
};
|
|
this.retryCount = 0;
|
|
this.start = 0;
|
|
this.end = null;
|
|
this.etag = null;
|
|
this.resume = null;
|
|
this.handler.onConnect((reason) => {
|
|
this.aborted = true;
|
|
if (this.abort) {
|
|
this.abort(reason);
|
|
} else {
|
|
this.reason = reason;
|
|
}
|
|
});
|
|
}
|
|
onRequestSent() {
|
|
if (this.handler.onRequestSent) {
|
|
this.handler.onRequestSent();
|
|
}
|
|
}
|
|
onUpgrade(statusCode, headers, socket) {
|
|
if (this.handler.onUpgrade) {
|
|
this.handler.onUpgrade(statusCode, headers, socket);
|
|
}
|
|
}
|
|
onConnect(abort) {
|
|
if (this.aborted) {
|
|
abort(this.reason);
|
|
} else {
|
|
this.abort = abort;
|
|
}
|
|
}
|
|
onBodySent(chunk) {
|
|
if (this.handler.onBodySent) return this.handler.onBodySent(chunk);
|
|
}
|
|
static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
|
|
const { statusCode, code, headers } = err;
|
|
const { method, retryOptions } = opts;
|
|
const {
|
|
maxRetries,
|
|
timeout,
|
|
maxTimeout,
|
|
timeoutFactor,
|
|
statusCodes,
|
|
errorCodes,
|
|
methods
|
|
} = retryOptions;
|
|
let { counter, currentTimeout } = state;
|
|
currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout;
|
|
if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) {
|
|
cb(err);
|
|
return;
|
|
}
|
|
if (Array.isArray(methods) && !methods.includes(method)) {
|
|
cb(err);
|
|
return;
|
|
}
|
|
if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) {
|
|
cb(err);
|
|
return;
|
|
}
|
|
if (counter > maxRetries) {
|
|
cb(err);
|
|
return;
|
|
}
|
|
let retryAfterHeader = headers != null && headers["retry-after"];
|
|
if (retryAfterHeader) {
|
|
retryAfterHeader = Number(retryAfterHeader);
|
|
retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3;
|
|
}
|
|
const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout);
|
|
state.currentTimeout = retryTimeout;
|
|
setTimeout(() => cb(null), retryTimeout);
|
|
}
|
|
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
|
|
const headers = parseHeaders(rawHeaders);
|
|
this.retryCount += 1;
|
|
if (statusCode >= 300) {
|
|
this.abort(
|
|
new RequestRetryError("Request failed", statusCode, {
|
|
headers,
|
|
count: this.retryCount
|
|
})
|
|
);
|
|
return false;
|
|
}
|
|
if (this.resume != null) {
|
|
this.resume = null;
|
|
if (statusCode !== 206) {
|
|
return true;
|
|
}
|
|
const contentRange = parseRangeHeader(headers["content-range"]);
|
|
if (!contentRange) {
|
|
this.abort(
|
|
new RequestRetryError("Content-Range mismatch", statusCode, {
|
|
headers,
|
|
count: this.retryCount
|
|
})
|
|
);
|
|
return false;
|
|
}
|
|
if (this.etag != null && this.etag !== headers.etag) {
|
|
this.abort(
|
|
new RequestRetryError("ETag mismatch", statusCode, {
|
|
headers,
|
|
count: this.retryCount
|
|
})
|
|
);
|
|
return false;
|
|
}
|
|
const { start, size, end = size } = contentRange;
|
|
assert(this.start === start, "content-range mismatch");
|
|
assert(this.end == null || this.end === end, "content-range mismatch");
|
|
this.resume = resume;
|
|
return true;
|
|
}
|
|
if (this.end == null) {
|
|
if (statusCode === 206) {
|
|
const range = parseRangeHeader(headers["content-range"]);
|
|
if (range == null) {
|
|
return this.handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
);
|
|
}
|
|
const { start, size, end = size } = range;
|
|
assert(
|
|
start != null && Number.isFinite(start) && this.start !== start,
|
|
"content-range mismatch"
|
|
);
|
|
assert(Number.isFinite(start));
|
|
assert(
|
|
end != null && Number.isFinite(end) && this.end !== end,
|
|
"invalid content-length"
|
|
);
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
if (this.end == null) {
|
|
const contentLength = headers["content-length"];
|
|
this.end = contentLength != null ? Number(contentLength) : null;
|
|
}
|
|
assert(Number.isFinite(this.start));
|
|
assert(
|
|
this.end == null || Number.isFinite(this.end),
|
|
"invalid content-length"
|
|
);
|
|
this.resume = resume;
|
|
this.etag = headers.etag != null ? headers.etag : null;
|
|
return this.handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
);
|
|
}
|
|
const err = new RequestRetryError("Request failed", statusCode, {
|
|
headers,
|
|
count: this.retryCount
|
|
});
|
|
this.abort(err);
|
|
return false;
|
|
}
|
|
onData(chunk) {
|
|
this.start += chunk.length;
|
|
return this.handler.onData(chunk);
|
|
}
|
|
onComplete(rawTrailers) {
|
|
this.retryCount = 0;
|
|
return this.handler.onComplete(rawTrailers);
|
|
}
|
|
onError(err) {
|
|
if (this.aborted || isDisturbed(this.opts.body)) {
|
|
return this.handler.onError(err);
|
|
}
|
|
this.retryOpts.retry(
|
|
err,
|
|
{
|
|
state: { counter: this.retryCount++, currentTimeout: this.retryAfter },
|
|
opts: { retryOptions: this.retryOpts, ...this.opts }
|
|
},
|
|
onRetry.bind(this)
|
|
);
|
|
function onRetry(err2) {
|
|
if (err2 != null || this.aborted || isDisturbed(this.opts.body)) {
|
|
return this.handler.onError(err2);
|
|
}
|
|
if (this.start !== 0) {
|
|
this.opts = {
|
|
...this.opts,
|
|
headers: {
|
|
...this.opts.headers,
|
|
range: `bytes=${this.start}-${this.end ?? ""}`
|
|
}
|
|
};
|
|
}
|
|
try {
|
|
this.dispatch(this.opts, this);
|
|
} catch (err3) {
|
|
this.handler.onError(err3);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
module2.exports = RetryHandler;
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/global.js
|
|
var require_global2 = __commonJS({
|
|
"node_modules/undici/lib/global.js"(exports2, module2) {
|
|
"use strict";
|
|
var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
|
|
var { InvalidArgumentError } = require_errors();
|
|
var Agent = require_agent();
|
|
if (getGlobalDispatcher() === void 0) {
|
|
setGlobalDispatcher(new Agent());
|
|
}
|
|
function setGlobalDispatcher(agent) {
|
|
if (!agent || typeof agent.dispatch !== "function") {
|
|
throw new InvalidArgumentError("Argument agent must implement Agent");
|
|
}
|
|
Object.defineProperty(globalThis, globalDispatcher, {
|
|
value: agent,
|
|
writable: true,
|
|
enumerable: false,
|
|
configurable: false
|
|
});
|
|
}
|
|
function getGlobalDispatcher() {
|
|
return globalThis[globalDispatcher];
|
|
}
|
|
module2.exports = {
|
|
setGlobalDispatcher,
|
|
getGlobalDispatcher
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/handler/DecoratorHandler.js
|
|
var require_DecoratorHandler = __commonJS({
|
|
"node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = class DecoratorHandler {
|
|
constructor(handler) {
|
|
this.handler = handler;
|
|
}
|
|
onConnect(...args) {
|
|
return this.handler.onConnect(...args);
|
|
}
|
|
onError(...args) {
|
|
return this.handler.onError(...args);
|
|
}
|
|
onUpgrade(...args) {
|
|
return this.handler.onUpgrade(...args);
|
|
}
|
|
onHeaders(...args) {
|
|
return this.handler.onHeaders(...args);
|
|
}
|
|
onData(...args) {
|
|
return this.handler.onData(...args);
|
|
}
|
|
onComplete(...args) {
|
|
return this.handler.onComplete(...args);
|
|
}
|
|
onBodySent(...args) {
|
|
return this.handler.onBodySent(...args);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/headers.js
|
|
var require_headers = __commonJS({
|
|
"node_modules/undici/lib/fetch/headers.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kHeadersList, kConstruct } = require_symbols();
|
|
var { kGuard } = require_symbols2();
|
|
var { kEnumerableProperty } = require_util();
|
|
var {
|
|
makeIterator,
|
|
isValidHeaderName,
|
|
isValidHeaderValue
|
|
} = require_util2();
|
|
var util = require("util");
|
|
var { webidl } = require_webidl();
|
|
var assert = require("assert");
|
|
var kHeadersMap = Symbol("headers map");
|
|
var kHeadersSortedMap = Symbol("headers map sorted");
|
|
function isHTTPWhiteSpaceCharCode(code) {
|
|
return code === 10 || code === 13 || code === 9 || code === 32;
|
|
}
|
|
function headerValueNormalize(potentialValue) {
|
|
let i2 = 0;
|
|
let j = potentialValue.length;
|
|
while (j > i2 && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j;
|
|
while (j > i2 && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i2))) ++i2;
|
|
return i2 === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i2, j);
|
|
}
|
|
function fill(headers, object) {
|
|
if (Array.isArray(object)) {
|
|
for (let i2 = 0; i2 < object.length; ++i2) {
|
|
const header = object[i2];
|
|
if (header.length !== 2) {
|
|
throw webidl.errors.exception({
|
|
header: "Headers constructor",
|
|
message: `expected name/value pair to be length 2, found ${header.length}.`
|
|
});
|
|
}
|
|
appendHeader(headers, header[0], header[1]);
|
|
}
|
|
} else if (typeof object === "object" && object !== null) {
|
|
const keys = Object.keys(object);
|
|
for (let i2 = 0; i2 < keys.length; ++i2) {
|
|
appendHeader(headers, keys[i2], object[keys[i2]]);
|
|
}
|
|
} else {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: "Headers constructor",
|
|
argument: "Argument 1",
|
|
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
|
|
});
|
|
}
|
|
}
|
|
function appendHeader(headers, name, value) {
|
|
value = headerValueNormalize(value);
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.append",
|
|
value: name,
|
|
type: "header name"
|
|
});
|
|
} else if (!isValidHeaderValue(value)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.append",
|
|
value,
|
|
type: "header value"
|
|
});
|
|
}
|
|
if (headers[kGuard] === "immutable") {
|
|
throw new TypeError("immutable");
|
|
} else if (headers[kGuard] === "request-no-cors") {
|
|
}
|
|
return headers[kHeadersList].append(name, value);
|
|
}
|
|
var HeadersList = class _HeadersList {
|
|
/** @type {[string, string][]|null} */
|
|
cookies = null;
|
|
constructor(init) {
|
|
if (init instanceof _HeadersList) {
|
|
this[kHeadersMap] = new Map(init[kHeadersMap]);
|
|
this[kHeadersSortedMap] = init[kHeadersSortedMap];
|
|
this.cookies = init.cookies === null ? null : [...init.cookies];
|
|
} else {
|
|
this[kHeadersMap] = new Map(init);
|
|
this[kHeadersSortedMap] = null;
|
|
}
|
|
}
|
|
// https://fetch.spec.whatwg.org/#header-list-contains
|
|
contains(name) {
|
|
name = name.toLowerCase();
|
|
return this[kHeadersMap].has(name);
|
|
}
|
|
clear() {
|
|
this[kHeadersMap].clear();
|
|
this[kHeadersSortedMap] = null;
|
|
this.cookies = null;
|
|
}
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-append
|
|
append(name, value) {
|
|
this[kHeadersSortedMap] = null;
|
|
const lowercaseName = name.toLowerCase();
|
|
const exists = this[kHeadersMap].get(lowercaseName);
|
|
if (exists) {
|
|
const delimiter = lowercaseName === "cookie" ? "; " : ", ";
|
|
this[kHeadersMap].set(lowercaseName, {
|
|
name: exists.name,
|
|
value: `${exists.value}${delimiter}${value}`
|
|
});
|
|
} else {
|
|
this[kHeadersMap].set(lowercaseName, { name, value });
|
|
}
|
|
if (lowercaseName === "set-cookie") {
|
|
this.cookies ??= [];
|
|
this.cookies.push(value);
|
|
}
|
|
}
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-set
|
|
set(name, value) {
|
|
this[kHeadersSortedMap] = null;
|
|
const lowercaseName = name.toLowerCase();
|
|
if (lowercaseName === "set-cookie") {
|
|
this.cookies = [value];
|
|
}
|
|
this[kHeadersMap].set(lowercaseName, { name, value });
|
|
}
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-delete
|
|
delete(name) {
|
|
this[kHeadersSortedMap] = null;
|
|
name = name.toLowerCase();
|
|
if (name === "set-cookie") {
|
|
this.cookies = null;
|
|
}
|
|
this[kHeadersMap].delete(name);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-get
|
|
get(name) {
|
|
const value = this[kHeadersMap].get(name.toLowerCase());
|
|
return value === void 0 ? null : value.value;
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (const [name, { value }] of this[kHeadersMap]) {
|
|
yield [name, value];
|
|
}
|
|
}
|
|
get entries() {
|
|
const headers = {};
|
|
if (this[kHeadersMap].size) {
|
|
for (const { name, value } of this[kHeadersMap].values()) {
|
|
headers[name] = value;
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
};
|
|
var Headers2 = class _Headers {
|
|
constructor(init = void 0) {
|
|
if (init === kConstruct) {
|
|
return;
|
|
}
|
|
this[kHeadersList] = new HeadersList();
|
|
this[kGuard] = "none";
|
|
if (init !== void 0) {
|
|
init = webidl.converters.HeadersInit(init);
|
|
fill(this, init);
|
|
}
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-append
|
|
append(name, value) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
|
|
name = webidl.converters.ByteString(name);
|
|
value = webidl.converters.ByteString(value);
|
|
return appendHeader(this, name, value);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-delete
|
|
delete(name) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
|
|
name = webidl.converters.ByteString(name);
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.delete",
|
|
value: name,
|
|
type: "header name"
|
|
});
|
|
}
|
|
if (this[kGuard] === "immutable") {
|
|
throw new TypeError("immutable");
|
|
} else if (this[kGuard] === "request-no-cors") {
|
|
}
|
|
if (!this[kHeadersList].contains(name)) {
|
|
return;
|
|
}
|
|
this[kHeadersList].delete(name);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-get
|
|
get(name) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
|
|
name = webidl.converters.ByteString(name);
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.get",
|
|
value: name,
|
|
type: "header name"
|
|
});
|
|
}
|
|
return this[kHeadersList].get(name);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-has
|
|
has(name) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
|
|
name = webidl.converters.ByteString(name);
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.has",
|
|
value: name,
|
|
type: "header name"
|
|
});
|
|
}
|
|
return this[kHeadersList].contains(name);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-set
|
|
set(name, value) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
|
|
name = webidl.converters.ByteString(name);
|
|
value = webidl.converters.ByteString(value);
|
|
value = headerValueNormalize(value);
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.set",
|
|
value: name,
|
|
type: "header name"
|
|
});
|
|
} else if (!isValidHeaderValue(value)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: "Headers.set",
|
|
value,
|
|
type: "header value"
|
|
});
|
|
}
|
|
if (this[kGuard] === "immutable") {
|
|
throw new TypeError("immutable");
|
|
} else if (this[kGuard] === "request-no-cors") {
|
|
}
|
|
this[kHeadersList].set(name, value);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
|
|
getSetCookie() {
|
|
webidl.brandCheck(this, _Headers);
|
|
const list = this[kHeadersList].cookies;
|
|
if (list) {
|
|
return [...list];
|
|
}
|
|
return [];
|
|
}
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
|
|
get [kHeadersSortedMap]() {
|
|
if (this[kHeadersList][kHeadersSortedMap]) {
|
|
return this[kHeadersList][kHeadersSortedMap];
|
|
}
|
|
const headers = [];
|
|
const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1);
|
|
const cookies = this[kHeadersList].cookies;
|
|
for (let i2 = 0; i2 < names.length; ++i2) {
|
|
const [name, value] = names[i2];
|
|
if (name === "set-cookie") {
|
|
for (let j = 0; j < cookies.length; ++j) {
|
|
headers.push([name, cookies[j]]);
|
|
}
|
|
} else {
|
|
assert(value !== null);
|
|
headers.push([name, value]);
|
|
}
|
|
}
|
|
this[kHeadersList][kHeadersSortedMap] = headers;
|
|
return headers;
|
|
}
|
|
keys() {
|
|
webidl.brandCheck(this, _Headers);
|
|
if (this[kGuard] === "immutable") {
|
|
const value = this[kHeadersSortedMap];
|
|
return makeIterator(
|
|
() => value,
|
|
"Headers",
|
|
"key"
|
|
);
|
|
}
|
|
return makeIterator(
|
|
() => [...this[kHeadersSortedMap].values()],
|
|
"Headers",
|
|
"key"
|
|
);
|
|
}
|
|
values() {
|
|
webidl.brandCheck(this, _Headers);
|
|
if (this[kGuard] === "immutable") {
|
|
const value = this[kHeadersSortedMap];
|
|
return makeIterator(
|
|
() => value,
|
|
"Headers",
|
|
"value"
|
|
);
|
|
}
|
|
return makeIterator(
|
|
() => [...this[kHeadersSortedMap].values()],
|
|
"Headers",
|
|
"value"
|
|
);
|
|
}
|
|
entries() {
|
|
webidl.brandCheck(this, _Headers);
|
|
if (this[kGuard] === "immutable") {
|
|
const value = this[kHeadersSortedMap];
|
|
return makeIterator(
|
|
() => value,
|
|
"Headers",
|
|
"key+value"
|
|
);
|
|
}
|
|
return makeIterator(
|
|
() => [...this[kHeadersSortedMap].values()],
|
|
"Headers",
|
|
"key+value"
|
|
);
|
|
}
|
|
/**
|
|
* @param {(value: string, key: string, self: Headers) => void} callbackFn
|
|
* @param {unknown} thisArg
|
|
*/
|
|
forEach(callbackFn, thisArg = globalThis) {
|
|
webidl.brandCheck(this, _Headers);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
|
|
if (typeof callbackFn !== "function") {
|
|
throw new TypeError(
|
|
"Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
|
|
);
|
|
}
|
|
for (const [key, value] of this) {
|
|
callbackFn.apply(thisArg, [value, key, this]);
|
|
}
|
|
}
|
|
[Symbol.for("nodejs.util.inspect.custom")]() {
|
|
webidl.brandCheck(this, _Headers);
|
|
return this[kHeadersList];
|
|
}
|
|
};
|
|
Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries;
|
|
Object.defineProperties(Headers2.prototype, {
|
|
append: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
get: kEnumerableProperty,
|
|
has: kEnumerableProperty,
|
|
set: kEnumerableProperty,
|
|
getSetCookie: kEnumerableProperty,
|
|
keys: kEnumerableProperty,
|
|
values: kEnumerableProperty,
|
|
entries: kEnumerableProperty,
|
|
forEach: kEnumerableProperty,
|
|
[Symbol.iterator]: { enumerable: false },
|
|
[Symbol.toStringTag]: {
|
|
value: "Headers",
|
|
configurable: true
|
|
},
|
|
[util.inspect.custom]: {
|
|
enumerable: false
|
|
}
|
|
});
|
|
webidl.converters.HeadersInit = function(V) {
|
|
if (webidl.util.Type(V) === "Object") {
|
|
if (V[Symbol.iterator]) {
|
|
return webidl.converters["sequence<sequence<ByteString>>"](V);
|
|
}
|
|
return webidl.converters["record<ByteString, ByteString>"](V);
|
|
}
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: "Headers constructor",
|
|
argument: "Argument 1",
|
|
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
|
|
});
|
|
};
|
|
module2.exports = {
|
|
fill,
|
|
Headers: Headers2,
|
|
HeadersList
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/response.js
|
|
var require_response = __commonJS({
|
|
"node_modules/undici/lib/fetch/response.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Headers: Headers2, HeadersList, fill } = require_headers();
|
|
var { extractBody, cloneBody, mixinBody } = require_body();
|
|
var util = require_util();
|
|
var { kEnumerableProperty } = util;
|
|
var {
|
|
isValidReasonPhrase,
|
|
isCancelled,
|
|
isAborted,
|
|
isBlobLike,
|
|
serializeJavascriptValueToJSONString,
|
|
isErrorLike,
|
|
isomorphicEncode
|
|
} = require_util2();
|
|
var {
|
|
redirectStatusSet,
|
|
nullBodyStatus,
|
|
DOMException: DOMException3
|
|
} = require_constants2();
|
|
var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
|
|
var { webidl } = require_webidl();
|
|
var { FormData: FormData3 } = require_formdata();
|
|
var { getGlobalOrigin } = require_global();
|
|
var { URLSerializer } = require_dataURL();
|
|
var { kHeadersList, kConstruct } = require_symbols();
|
|
var assert = require("assert");
|
|
var { types: types3 } = require("util");
|
|
var ReadableStream2 = globalThis.ReadableStream || require("stream/web").ReadableStream;
|
|
var textEncoder = new TextEncoder("utf-8");
|
|
var Response2 = class _Response {
|
|
// Creates network error Response.
|
|
static error() {
|
|
const relevantRealm = { settingsObject: {} };
|
|
const responseObject = new _Response();
|
|
responseObject[kState] = makeNetworkError();
|
|
responseObject[kRealm] = relevantRealm;
|
|
responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
|
|
responseObject[kHeaders][kGuard] = "immutable";
|
|
responseObject[kHeaders][kRealm] = relevantRealm;
|
|
return responseObject;
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-response-json
|
|
static json(data, init = {}) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
|
|
if (init !== null) {
|
|
init = webidl.converters.ResponseInit(init);
|
|
}
|
|
const bytes = textEncoder.encode(
|
|
serializeJavascriptValueToJSONString(data)
|
|
);
|
|
const body = extractBody(bytes);
|
|
const relevantRealm = { settingsObject: {} };
|
|
const responseObject = new _Response();
|
|
responseObject[kRealm] = relevantRealm;
|
|
responseObject[kHeaders][kGuard] = "response";
|
|
responseObject[kHeaders][kRealm] = relevantRealm;
|
|
initializeResponse(responseObject, init, { body: body[0], type: "application/json" });
|
|
return responseObject;
|
|
}
|
|
// Creates a redirect Response that redirects to url with status status.
|
|
static redirect(url, status = 302) {
|
|
const relevantRealm = { settingsObject: {} };
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
|
|
url = webidl.converters.USVString(url);
|
|
status = webidl.converters["unsigned short"](status);
|
|
let parsedURL;
|
|
try {
|
|
parsedURL = new URL(url, getGlobalOrigin());
|
|
} catch (err) {
|
|
throw Object.assign(new TypeError("Failed to parse URL from " + url), {
|
|
cause: err
|
|
});
|
|
}
|
|
if (!redirectStatusSet.has(status)) {
|
|
throw new RangeError("Invalid status code " + status);
|
|
}
|
|
const responseObject = new _Response();
|
|
responseObject[kRealm] = relevantRealm;
|
|
responseObject[kHeaders][kGuard] = "immutable";
|
|
responseObject[kHeaders][kRealm] = relevantRealm;
|
|
responseObject[kState].status = status;
|
|
const value = isomorphicEncode(URLSerializer(parsedURL));
|
|
responseObject[kState].headersList.append("location", value);
|
|
return responseObject;
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-response
|
|
constructor(body = null, init = {}) {
|
|
if (body !== null) {
|
|
body = webidl.converters.BodyInit(body);
|
|
}
|
|
init = webidl.converters.ResponseInit(init);
|
|
this[kRealm] = { settingsObject: {} };
|
|
this[kState] = makeResponse({});
|
|
this[kHeaders] = new Headers2(kConstruct);
|
|
this[kHeaders][kGuard] = "response";
|
|
this[kHeaders][kHeadersList] = this[kState].headersList;
|
|
this[kHeaders][kRealm] = this[kRealm];
|
|
let bodyWithType = null;
|
|
if (body != null) {
|
|
const [extractedBody, type] = extractBody(body);
|
|
bodyWithType = { body: extractedBody, type };
|
|
}
|
|
initializeResponse(this, init, bodyWithType);
|
|
}
|
|
// Returns response’s type, e.g., "cors".
|
|
get type() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].type;
|
|
}
|
|
// Returns response’s URL, if it has one; otherwise the empty string.
|
|
get url() {
|
|
webidl.brandCheck(this, _Response);
|
|
const urlList = this[kState].urlList;
|
|
const url = urlList[urlList.length - 1] ?? null;
|
|
if (url === null) {
|
|
return "";
|
|
}
|
|
return URLSerializer(url, true);
|
|
}
|
|
// Returns whether response was obtained through a redirect.
|
|
get redirected() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].urlList.length > 1;
|
|
}
|
|
// Returns response’s status.
|
|
get status() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].status;
|
|
}
|
|
// Returns whether response’s status is an ok status.
|
|
get ok() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].status >= 200 && this[kState].status <= 299;
|
|
}
|
|
// Returns response’s status message.
|
|
get statusText() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].statusText;
|
|
}
|
|
// Returns response’s headers as Headers.
|
|
get headers() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kHeaders];
|
|
}
|
|
get body() {
|
|
webidl.brandCheck(this, _Response);
|
|
return this[kState].body ? this[kState].body.stream : null;
|
|
}
|
|
get bodyUsed() {
|
|
webidl.brandCheck(this, _Response);
|
|
return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
|
|
}
|
|
// Returns a clone of response.
|
|
clone() {
|
|
webidl.brandCheck(this, _Response);
|
|
if (this.bodyUsed || this.body && this.body.locked) {
|
|
throw webidl.errors.exception({
|
|
header: "Response.clone",
|
|
message: "Body has already been consumed."
|
|
});
|
|
}
|
|
const clonedResponse = cloneResponse(this[kState]);
|
|
const clonedResponseObject = new _Response();
|
|
clonedResponseObject[kState] = clonedResponse;
|
|
clonedResponseObject[kRealm] = this[kRealm];
|
|
clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
|
|
clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
|
|
clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
|
|
return clonedResponseObject;
|
|
}
|
|
};
|
|
mixinBody(Response2);
|
|
Object.defineProperties(Response2.prototype, {
|
|
type: kEnumerableProperty,
|
|
url: kEnumerableProperty,
|
|
status: kEnumerableProperty,
|
|
ok: kEnumerableProperty,
|
|
redirected: kEnumerableProperty,
|
|
statusText: kEnumerableProperty,
|
|
headers: kEnumerableProperty,
|
|
clone: kEnumerableProperty,
|
|
body: kEnumerableProperty,
|
|
bodyUsed: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: "Response",
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperties(Response2, {
|
|
json: kEnumerableProperty,
|
|
redirect: kEnumerableProperty,
|
|
error: kEnumerableProperty
|
|
});
|
|
function cloneResponse(response) {
|
|
if (response.internalResponse) {
|
|
return filterResponse(
|
|
cloneResponse(response.internalResponse),
|
|
response.type
|
|
);
|
|
}
|
|
const newResponse = makeResponse({ ...response, body: null });
|
|
if (response.body != null) {
|
|
newResponse.body = cloneBody(response.body);
|
|
}
|
|
return newResponse;
|
|
}
|
|
function makeResponse(init) {
|
|
return {
|
|
aborted: false,
|
|
rangeRequested: false,
|
|
timingAllowPassed: false,
|
|
requestIncludesCredentials: false,
|
|
type: "default",
|
|
status: 200,
|
|
timingInfo: null,
|
|
cacheState: "",
|
|
statusText: "",
|
|
...init,
|
|
headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(),
|
|
urlList: init.urlList ? [...init.urlList] : []
|
|
};
|
|
}
|
|
function makeNetworkError(reason) {
|
|
const isError = isErrorLike(reason);
|
|
return makeResponse({
|
|
type: "error",
|
|
status: 0,
|
|
error: isError ? reason : new Error(reason ? String(reason) : reason),
|
|
aborted: reason && reason.name === "AbortError"
|
|
});
|
|
}
|
|
function makeFilteredResponse(response, state) {
|
|
state = {
|
|
internalResponse: response,
|
|
...state
|
|
};
|
|
return new Proxy(response, {
|
|
get(target, p) {
|
|
return p in state ? state[p] : target[p];
|
|
},
|
|
set(target, p, value) {
|
|
assert(!(p in state));
|
|
target[p] = value;
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
function filterResponse(response, type) {
|
|
if (type === "basic") {
|
|
return makeFilteredResponse(response, {
|
|
type: "basic",
|
|
headersList: response.headersList
|
|
});
|
|
} else if (type === "cors") {
|
|
return makeFilteredResponse(response, {
|
|
type: "cors",
|
|
headersList: response.headersList
|
|
});
|
|
} else if (type === "opaque") {
|
|
return makeFilteredResponse(response, {
|
|
type: "opaque",
|
|
urlList: Object.freeze([]),
|
|
status: 0,
|
|
statusText: "",
|
|
body: null
|
|
});
|
|
} else if (type === "opaqueredirect") {
|
|
return makeFilteredResponse(response, {
|
|
type: "opaqueredirect",
|
|
status: 0,
|
|
statusText: "",
|
|
headersList: [],
|
|
body: null
|
|
});
|
|
} else {
|
|
assert(false);
|
|
}
|
|
}
|
|
function makeAppropriateNetworkError(fetchParams, err = null) {
|
|
assert(isCancelled(fetchParams));
|
|
return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException3("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException3("Request was cancelled."), { cause: err }));
|
|
}
|
|
function initializeResponse(response, init, body) {
|
|
if (init.status !== null && (init.status < 200 || init.status > 599)) {
|
|
throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
|
|
}
|
|
if ("statusText" in init && init.statusText != null) {
|
|
if (!isValidReasonPhrase(String(init.statusText))) {
|
|
throw new TypeError("Invalid statusText");
|
|
}
|
|
}
|
|
if ("status" in init && init.status != null) {
|
|
response[kState].status = init.status;
|
|
}
|
|
if ("statusText" in init && init.statusText != null) {
|
|
response[kState].statusText = init.statusText;
|
|
}
|
|
if ("headers" in init && init.headers != null) {
|
|
fill(response[kHeaders], init.headers);
|
|
}
|
|
if (body) {
|
|
if (nullBodyStatus.includes(response.status)) {
|
|
throw webidl.errors.exception({
|
|
header: "Response constructor",
|
|
message: "Invalid response status code " + response.status
|
|
});
|
|
}
|
|
response[kState].body = body.body;
|
|
if (body.type != null && !response[kState].headersList.contains("Content-Type")) {
|
|
response[kState].headersList.append("content-type", body.type);
|
|
}
|
|
}
|
|
}
|
|
webidl.converters.ReadableStream = webidl.interfaceConverter(
|
|
ReadableStream2
|
|
);
|
|
webidl.converters.FormData = webidl.interfaceConverter(
|
|
FormData3
|
|
);
|
|
webidl.converters.URLSearchParams = webidl.interfaceConverter(
|
|
URLSearchParams
|
|
);
|
|
webidl.converters.XMLHttpRequestBodyInit = function(V) {
|
|
if (typeof V === "string") {
|
|
return webidl.converters.USVString(V);
|
|
}
|
|
if (isBlobLike(V)) {
|
|
return webidl.converters.Blob(V, { strict: false });
|
|
}
|
|
if (types3.isArrayBuffer(V) || types3.isTypedArray(V) || types3.isDataView(V)) {
|
|
return webidl.converters.BufferSource(V);
|
|
}
|
|
if (util.isFormDataLike(V)) {
|
|
return webidl.converters.FormData(V, { strict: false });
|
|
}
|
|
if (V instanceof URLSearchParams) {
|
|
return webidl.converters.URLSearchParams(V);
|
|
}
|
|
return webidl.converters.DOMString(V);
|
|
};
|
|
webidl.converters.BodyInit = function(V) {
|
|
if (V instanceof ReadableStream2) {
|
|
return webidl.converters.ReadableStream(V);
|
|
}
|
|
if (V?.[Symbol.asyncIterator]) {
|
|
return V;
|
|
}
|
|
return webidl.converters.XMLHttpRequestBodyInit(V);
|
|
};
|
|
webidl.converters.ResponseInit = webidl.dictionaryConverter([
|
|
{
|
|
key: "status",
|
|
converter: webidl.converters["unsigned short"],
|
|
defaultValue: 200
|
|
},
|
|
{
|
|
key: "statusText",
|
|
converter: webidl.converters.ByteString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "headers",
|
|
converter: webidl.converters.HeadersInit
|
|
}
|
|
]);
|
|
module2.exports = {
|
|
makeNetworkError,
|
|
makeResponse,
|
|
makeAppropriateNetworkError,
|
|
filterResponse,
|
|
Response: Response2,
|
|
cloneResponse
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/request.js
|
|
var require_request2 = __commonJS({
|
|
"node_modules/undici/lib/fetch/request.js"(exports2, module2) {
|
|
"use strict";
|
|
var { extractBody, mixinBody, cloneBody } = require_body();
|
|
var { Headers: Headers2, fill: fillHeaders, HeadersList } = require_headers();
|
|
var { FinalizationRegistry } = require_dispatcher_weakref()();
|
|
var util = require_util();
|
|
var {
|
|
isValidHTTPToken,
|
|
sameOrigin,
|
|
normalizeMethod,
|
|
makePolicyContainer,
|
|
normalizeMethodRecord
|
|
} = require_util2();
|
|
var {
|
|
forbiddenMethodsSet,
|
|
corsSafeListedMethodsSet,
|
|
referrerPolicy,
|
|
requestRedirect,
|
|
requestMode,
|
|
requestCredentials,
|
|
requestCache,
|
|
requestDuplex
|
|
} = require_constants2();
|
|
var { kEnumerableProperty } = util;
|
|
var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2();
|
|
var { webidl } = require_webidl();
|
|
var { getGlobalOrigin } = require_global();
|
|
var { URLSerializer } = require_dataURL();
|
|
var { kHeadersList, kConstruct } = require_symbols();
|
|
var assert = require("assert");
|
|
var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events");
|
|
var TransformStream = globalThis.TransformStream;
|
|
var kAbortController = Symbol("abortController");
|
|
var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
|
|
signal.removeEventListener("abort", abort);
|
|
});
|
|
var Request2 = class _Request {
|
|
// https://fetch.spec.whatwg.org/#dom-request
|
|
constructor(input, init = {}) {
|
|
if (input === kConstruct) {
|
|
return;
|
|
}
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
|
|
input = webidl.converters.RequestInfo(input);
|
|
init = webidl.converters.RequestInit(init);
|
|
this[kRealm] = {
|
|
settingsObject: {
|
|
baseUrl: getGlobalOrigin(),
|
|
get origin() {
|
|
return this.baseUrl?.origin;
|
|
},
|
|
policyContainer: makePolicyContainer()
|
|
}
|
|
};
|
|
let request = null;
|
|
let fallbackMode = null;
|
|
const baseUrl = this[kRealm].settingsObject.baseUrl;
|
|
let signal = null;
|
|
if (typeof input === "string") {
|
|
let parsedURL;
|
|
try {
|
|
parsedURL = new URL(input, baseUrl);
|
|
} catch (err) {
|
|
throw new TypeError("Failed to parse URL from " + input, { cause: err });
|
|
}
|
|
if (parsedURL.username || parsedURL.password) {
|
|
throw new TypeError(
|
|
"Request cannot be constructed from a URL that includes credentials: " + input
|
|
);
|
|
}
|
|
request = makeRequest({ urlList: [parsedURL] });
|
|
fallbackMode = "cors";
|
|
} else {
|
|
assert(input instanceof _Request);
|
|
request = input[kState];
|
|
signal = input[kSignal];
|
|
}
|
|
const origin = this[kRealm].settingsObject.origin;
|
|
let window = "client";
|
|
if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) {
|
|
window = request.window;
|
|
}
|
|
if (init.window != null) {
|
|
throw new TypeError(`'window' option '${window}' must be null`);
|
|
}
|
|
if ("window" in init) {
|
|
window = "no-window";
|
|
}
|
|
request = makeRequest({
|
|
// URL request’s URL.
|
|
// undici implementation note: this is set as the first item in request's urlList in makeRequest
|
|
// method request’s method.
|
|
method: request.method,
|
|
// header list A copy of request’s header list.
|
|
// undici implementation note: headersList is cloned in makeRequest
|
|
headersList: request.headersList,
|
|
// unsafe-request flag Set.
|
|
unsafeRequest: request.unsafeRequest,
|
|
// client This’s relevant settings object.
|
|
client: this[kRealm].settingsObject,
|
|
// window window.
|
|
window,
|
|
// priority request’s priority.
|
|
priority: request.priority,
|
|
// origin request’s origin. The propagation of the origin is only significant for navigation requests
|
|
// being handled by a service worker. In this scenario a request can have an origin that is different
|
|
// from the current client.
|
|
origin: request.origin,
|
|
// referrer request’s referrer.
|
|
referrer: request.referrer,
|
|
// referrer policy request’s referrer policy.
|
|
referrerPolicy: request.referrerPolicy,
|
|
// mode request’s mode.
|
|
mode: request.mode,
|
|
// credentials mode request’s credentials mode.
|
|
credentials: request.credentials,
|
|
// cache mode request’s cache mode.
|
|
cache: request.cache,
|
|
// redirect mode request’s redirect mode.
|
|
redirect: request.redirect,
|
|
// integrity metadata request’s integrity metadata.
|
|
integrity: request.integrity,
|
|
// keepalive request’s keepalive.
|
|
keepalive: request.keepalive,
|
|
// reload-navigation flag request’s reload-navigation flag.
|
|
reloadNavigation: request.reloadNavigation,
|
|
// history-navigation flag request’s history-navigation flag.
|
|
historyNavigation: request.historyNavigation,
|
|
// URL list A clone of request’s URL list.
|
|
urlList: [...request.urlList]
|
|
});
|
|
const initHasKey = Object.keys(init).length !== 0;
|
|
if (initHasKey) {
|
|
if (request.mode === "navigate") {
|
|
request.mode = "same-origin";
|
|
}
|
|
request.reloadNavigation = false;
|
|
request.historyNavigation = false;
|
|
request.origin = "client";
|
|
request.referrer = "client";
|
|
request.referrerPolicy = "";
|
|
request.url = request.urlList[request.urlList.length - 1];
|
|
request.urlList = [request.url];
|
|
}
|
|
if (init.referrer !== void 0) {
|
|
const referrer = init.referrer;
|
|
if (referrer === "") {
|
|
request.referrer = "no-referrer";
|
|
} else {
|
|
let parsedReferrer;
|
|
try {
|
|
parsedReferrer = new URL(referrer, baseUrl);
|
|
} catch (err) {
|
|
throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
|
|
}
|
|
if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) {
|
|
request.referrer = "client";
|
|
} else {
|
|
request.referrer = parsedReferrer;
|
|
}
|
|
}
|
|
}
|
|
if (init.referrerPolicy !== void 0) {
|
|
request.referrerPolicy = init.referrerPolicy;
|
|
}
|
|
let mode;
|
|
if (init.mode !== void 0) {
|
|
mode = init.mode;
|
|
} else {
|
|
mode = fallbackMode;
|
|
}
|
|
if (mode === "navigate") {
|
|
throw webidl.errors.exception({
|
|
header: "Request constructor",
|
|
message: "invalid request mode navigate."
|
|
});
|
|
}
|
|
if (mode != null) {
|
|
request.mode = mode;
|
|
}
|
|
if (init.credentials !== void 0) {
|
|
request.credentials = init.credentials;
|
|
}
|
|
if (init.cache !== void 0) {
|
|
request.cache = init.cache;
|
|
}
|
|
if (request.cache === "only-if-cached" && request.mode !== "same-origin") {
|
|
throw new TypeError(
|
|
"'only-if-cached' can be set only with 'same-origin' mode"
|
|
);
|
|
}
|
|
if (init.redirect !== void 0) {
|
|
request.redirect = init.redirect;
|
|
}
|
|
if (init.integrity != null) {
|
|
request.integrity = String(init.integrity);
|
|
}
|
|
if (init.keepalive !== void 0) {
|
|
request.keepalive = Boolean(init.keepalive);
|
|
}
|
|
if (init.method !== void 0) {
|
|
let method = init.method;
|
|
if (!isValidHTTPToken(method)) {
|
|
throw new TypeError(`'${method}' is not a valid HTTP method.`);
|
|
}
|
|
if (forbiddenMethodsSet.has(method.toUpperCase())) {
|
|
throw new TypeError(`'${method}' HTTP method is unsupported.`);
|
|
}
|
|
method = normalizeMethodRecord[method] ?? normalizeMethod(method);
|
|
request.method = method;
|
|
}
|
|
if (init.signal !== void 0) {
|
|
signal = init.signal;
|
|
}
|
|
this[kState] = request;
|
|
const ac = new AbortController();
|
|
this[kSignal] = ac.signal;
|
|
this[kSignal][kRealm] = this[kRealm];
|
|
if (signal != null) {
|
|
if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
|
|
throw new TypeError(
|
|
"Failed to construct 'Request': member signal is not of type AbortSignal."
|
|
);
|
|
}
|
|
if (signal.aborted) {
|
|
ac.abort(signal.reason);
|
|
} else {
|
|
this[kAbortController] = ac;
|
|
const acRef = new WeakRef(ac);
|
|
const abort = function() {
|
|
const ac2 = acRef.deref();
|
|
if (ac2 !== void 0) {
|
|
ac2.abort(this.reason);
|
|
}
|
|
};
|
|
try {
|
|
if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) {
|
|
setMaxListeners(100, signal);
|
|
} else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
|
|
setMaxListeners(100, signal);
|
|
}
|
|
} catch {
|
|
}
|
|
util.addAbortListener(signal, abort);
|
|
requestFinalizer.register(ac, { signal, abort });
|
|
}
|
|
}
|
|
this[kHeaders] = new Headers2(kConstruct);
|
|
this[kHeaders][kHeadersList] = request.headersList;
|
|
this[kHeaders][kGuard] = "request";
|
|
this[kHeaders][kRealm] = this[kRealm];
|
|
if (mode === "no-cors") {
|
|
if (!corsSafeListedMethodsSet.has(request.method)) {
|
|
throw new TypeError(
|
|
`'${request.method} is unsupported in no-cors mode.`
|
|
);
|
|
}
|
|
this[kHeaders][kGuard] = "request-no-cors";
|
|
}
|
|
if (initHasKey) {
|
|
const headersList = this[kHeaders][kHeadersList];
|
|
const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList);
|
|
headersList.clear();
|
|
if (headers instanceof HeadersList) {
|
|
for (const [key, val] of headers) {
|
|
headersList.append(key, val);
|
|
}
|
|
headersList.cookies = headers.cookies;
|
|
} else {
|
|
fillHeaders(this[kHeaders], headers);
|
|
}
|
|
}
|
|
const inputBody = input instanceof _Request ? input[kState].body : null;
|
|
if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) {
|
|
throw new TypeError("Request with GET/HEAD method cannot have body.");
|
|
}
|
|
let initBody = null;
|
|
if (init.body != null) {
|
|
const [extractedBody, contentType] = extractBody(
|
|
init.body,
|
|
request.keepalive
|
|
);
|
|
initBody = extractedBody;
|
|
if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
|
|
this[kHeaders].append("content-type", contentType);
|
|
}
|
|
}
|
|
const inputOrInitBody = initBody ?? inputBody;
|
|
if (inputOrInitBody != null && inputOrInitBody.source == null) {
|
|
if (initBody != null && init.duplex == null) {
|
|
throw new TypeError("RequestInit: duplex option is required when sending a body.");
|
|
}
|
|
if (request.mode !== "same-origin" && request.mode !== "cors") {
|
|
throw new TypeError(
|
|
'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
|
|
);
|
|
}
|
|
request.useCORSPreflightFlag = true;
|
|
}
|
|
let finalBody = inputOrInitBody;
|
|
if (initBody == null && inputBody != null) {
|
|
if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
|
|
throw new TypeError(
|
|
"Cannot construct a Request with a Request object that has already been used."
|
|
);
|
|
}
|
|
if (!TransformStream) {
|
|
TransformStream = require("stream/web").TransformStream;
|
|
}
|
|
const identityTransform = new TransformStream();
|
|
inputBody.stream.pipeThrough(identityTransform);
|
|
finalBody = {
|
|
source: inputBody.source,
|
|
length: inputBody.length,
|
|
stream: identityTransform.readable
|
|
};
|
|
}
|
|
this[kState].body = finalBody;
|
|
}
|
|
// Returns request’s HTTP method, which is "GET" by default.
|
|
get method() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].method;
|
|
}
|
|
// Returns the URL of request as a string.
|
|
get url() {
|
|
webidl.brandCheck(this, _Request);
|
|
return URLSerializer(this[kState].url);
|
|
}
|
|
// Returns a Headers object consisting of the headers associated with request.
|
|
// Note that headers added in the network layer by the user agent will not
|
|
// be accounted for in this object, e.g., the "Host" header.
|
|
get headers() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kHeaders];
|
|
}
|
|
// Returns the kind of resource requested by request, e.g., "document"
|
|
// or "script".
|
|
get destination() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].destination;
|
|
}
|
|
// Returns the referrer of request. Its value can be a same-origin URL if
|
|
// explicitly set in init, the empty string to indicate no referrer, and
|
|
// "about:client" when defaulting to the global’s default. This is used
|
|
// during fetching to determine the value of the `Referer` header of the
|
|
// request being made.
|
|
get referrer() {
|
|
webidl.brandCheck(this, _Request);
|
|
if (this[kState].referrer === "no-referrer") {
|
|
return "";
|
|
}
|
|
if (this[kState].referrer === "client") {
|
|
return "about:client";
|
|
}
|
|
return this[kState].referrer.toString();
|
|
}
|
|
// Returns the referrer policy associated with request.
|
|
// This is used during fetching to compute the value of the request’s
|
|
// referrer.
|
|
get referrerPolicy() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].referrerPolicy;
|
|
}
|
|
// Returns the mode associated with request, which is a string indicating
|
|
// whether the request will use CORS, or will be restricted to same-origin
|
|
// URLs.
|
|
get mode() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].mode;
|
|
}
|
|
// Returns the credentials mode associated with request,
|
|
// which is a string indicating whether credentials will be sent with the
|
|
// request always, never, or only when sent to a same-origin URL.
|
|
get credentials() {
|
|
return this[kState].credentials;
|
|
}
|
|
// Returns the cache mode associated with request,
|
|
// which is a string indicating how the request will
|
|
// interact with the browser’s cache when fetching.
|
|
get cache() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].cache;
|
|
}
|
|
// Returns the redirect mode associated with request,
|
|
// which is a string indicating how redirects for the
|
|
// request will be handled during fetching. A request
|
|
// will follow redirects by default.
|
|
get redirect() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].redirect;
|
|
}
|
|
// Returns request’s subresource integrity metadata, which is a
|
|
// cryptographic hash of the resource being fetched. Its value
|
|
// consists of multiple hashes separated by whitespace. [SRI]
|
|
get integrity() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].integrity;
|
|
}
|
|
// Returns a boolean indicating whether or not request can outlive the
|
|
// global in which it was created.
|
|
get keepalive() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].keepalive;
|
|
}
|
|
// Returns a boolean indicating whether or not request is for a reload
|
|
// navigation.
|
|
get isReloadNavigation() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].reloadNavigation;
|
|
}
|
|
// Returns a boolean indicating whether or not request is for a history
|
|
// navigation (a.k.a. back-foward navigation).
|
|
get isHistoryNavigation() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].historyNavigation;
|
|
}
|
|
// Returns the signal associated with request, which is an AbortSignal
|
|
// object indicating whether or not request has been aborted, and its
|
|
// abort event handler.
|
|
get signal() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kSignal];
|
|
}
|
|
get body() {
|
|
webidl.brandCheck(this, _Request);
|
|
return this[kState].body ? this[kState].body.stream : null;
|
|
}
|
|
get bodyUsed() {
|
|
webidl.brandCheck(this, _Request);
|
|
return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
|
|
}
|
|
get duplex() {
|
|
webidl.brandCheck(this, _Request);
|
|
return "half";
|
|
}
|
|
// Returns a clone of request.
|
|
clone() {
|
|
webidl.brandCheck(this, _Request);
|
|
if (this.bodyUsed || this.body?.locked) {
|
|
throw new TypeError("unusable");
|
|
}
|
|
const clonedRequest = cloneRequest(this[kState]);
|
|
const clonedRequestObject = new _Request(kConstruct);
|
|
clonedRequestObject[kState] = clonedRequest;
|
|
clonedRequestObject[kRealm] = this[kRealm];
|
|
clonedRequestObject[kHeaders] = new Headers2(kConstruct);
|
|
clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
|
|
clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
|
|
clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
|
|
const ac = new AbortController();
|
|
if (this.signal.aborted) {
|
|
ac.abort(this.signal.reason);
|
|
} else {
|
|
util.addAbortListener(
|
|
this.signal,
|
|
() => {
|
|
ac.abort(this.signal.reason);
|
|
}
|
|
);
|
|
}
|
|
clonedRequestObject[kSignal] = ac.signal;
|
|
return clonedRequestObject;
|
|
}
|
|
};
|
|
mixinBody(Request2);
|
|
function makeRequest(init) {
|
|
const request = {
|
|
method: "GET",
|
|
localURLsOnly: false,
|
|
unsafeRequest: false,
|
|
body: null,
|
|
client: null,
|
|
reservedClient: null,
|
|
replacesClientId: "",
|
|
window: "client",
|
|
keepalive: false,
|
|
serviceWorkers: "all",
|
|
initiator: "",
|
|
destination: "",
|
|
priority: null,
|
|
origin: "client",
|
|
policyContainer: "client",
|
|
referrer: "client",
|
|
referrerPolicy: "",
|
|
mode: "no-cors",
|
|
useCORSPreflightFlag: false,
|
|
credentials: "same-origin",
|
|
useCredentials: false,
|
|
cache: "default",
|
|
redirect: "follow",
|
|
integrity: "",
|
|
cryptoGraphicsNonceMetadata: "",
|
|
parserMetadata: "",
|
|
reloadNavigation: false,
|
|
historyNavigation: false,
|
|
userActivation: false,
|
|
taintedOrigin: false,
|
|
redirectCount: 0,
|
|
responseTainting: "basic",
|
|
preventNoCacheCacheControlHeaderModification: false,
|
|
done: false,
|
|
timingAllowFailed: false,
|
|
...init,
|
|
headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
|
|
};
|
|
request.url = request.urlList[0];
|
|
return request;
|
|
}
|
|
function cloneRequest(request) {
|
|
const newRequest = makeRequest({ ...request, body: null });
|
|
if (request.body != null) {
|
|
newRequest.body = cloneBody(request.body);
|
|
}
|
|
return newRequest;
|
|
}
|
|
Object.defineProperties(Request2.prototype, {
|
|
method: kEnumerableProperty,
|
|
url: kEnumerableProperty,
|
|
headers: kEnumerableProperty,
|
|
redirect: kEnumerableProperty,
|
|
clone: kEnumerableProperty,
|
|
signal: kEnumerableProperty,
|
|
duplex: kEnumerableProperty,
|
|
destination: kEnumerableProperty,
|
|
body: kEnumerableProperty,
|
|
bodyUsed: kEnumerableProperty,
|
|
isHistoryNavigation: kEnumerableProperty,
|
|
isReloadNavigation: kEnumerableProperty,
|
|
keepalive: kEnumerableProperty,
|
|
integrity: kEnumerableProperty,
|
|
cache: kEnumerableProperty,
|
|
credentials: kEnumerableProperty,
|
|
attribute: kEnumerableProperty,
|
|
referrerPolicy: kEnumerableProperty,
|
|
referrer: kEnumerableProperty,
|
|
mode: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: "Request",
|
|
configurable: true
|
|
}
|
|
});
|
|
webidl.converters.Request = webidl.interfaceConverter(
|
|
Request2
|
|
);
|
|
webidl.converters.RequestInfo = function(V) {
|
|
if (typeof V === "string") {
|
|
return webidl.converters.USVString(V);
|
|
}
|
|
if (V instanceof Request2) {
|
|
return webidl.converters.Request(V);
|
|
}
|
|
return webidl.converters.USVString(V);
|
|
};
|
|
webidl.converters.AbortSignal = webidl.interfaceConverter(
|
|
AbortSignal
|
|
);
|
|
webidl.converters.RequestInit = webidl.dictionaryConverter([
|
|
{
|
|
key: "method",
|
|
converter: webidl.converters.ByteString
|
|
},
|
|
{
|
|
key: "headers",
|
|
converter: webidl.converters.HeadersInit
|
|
},
|
|
{
|
|
key: "body",
|
|
converter: webidl.nullableConverter(
|
|
webidl.converters.BodyInit
|
|
)
|
|
},
|
|
{
|
|
key: "referrer",
|
|
converter: webidl.converters.USVString
|
|
},
|
|
{
|
|
key: "referrerPolicy",
|
|
converter: webidl.converters.DOMString,
|
|
// https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
|
|
allowedValues: referrerPolicy
|
|
},
|
|
{
|
|
key: "mode",
|
|
converter: webidl.converters.DOMString,
|
|
// https://fetch.spec.whatwg.org/#concept-request-mode
|
|
allowedValues: requestMode
|
|
},
|
|
{
|
|
key: "credentials",
|
|
converter: webidl.converters.DOMString,
|
|
// https://fetch.spec.whatwg.org/#requestcredentials
|
|
allowedValues: requestCredentials
|
|
},
|
|
{
|
|
key: "cache",
|
|
converter: webidl.converters.DOMString,
|
|
// https://fetch.spec.whatwg.org/#requestcache
|
|
allowedValues: requestCache
|
|
},
|
|
{
|
|
key: "redirect",
|
|
converter: webidl.converters.DOMString,
|
|
// https://fetch.spec.whatwg.org/#requestredirect
|
|
allowedValues: requestRedirect
|
|
},
|
|
{
|
|
key: "integrity",
|
|
converter: webidl.converters.DOMString
|
|
},
|
|
{
|
|
key: "keepalive",
|
|
converter: webidl.converters.boolean
|
|
},
|
|
{
|
|
key: "signal",
|
|
converter: webidl.nullableConverter(
|
|
(signal) => webidl.converters.AbortSignal(
|
|
signal,
|
|
{ strict: false }
|
|
)
|
|
)
|
|
},
|
|
{
|
|
key: "window",
|
|
converter: webidl.converters.any
|
|
},
|
|
{
|
|
key: "duplex",
|
|
converter: webidl.converters.DOMString,
|
|
allowedValues: requestDuplex
|
|
}
|
|
]);
|
|
module2.exports = { Request: Request2, makeRequest };
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fetch/index.js
|
|
var require_fetch = __commonJS({
|
|
"node_modules/undici/lib/fetch/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
Response: Response2,
|
|
makeNetworkError,
|
|
makeAppropriateNetworkError,
|
|
filterResponse,
|
|
makeResponse
|
|
} = require_response();
|
|
var { Headers: Headers2 } = require_headers();
|
|
var { Request: Request2, makeRequest } = require_request2();
|
|
var zlib2 = require("zlib");
|
|
var {
|
|
bytesMatch,
|
|
makePolicyContainer,
|
|
clonePolicyContainer,
|
|
requestBadPort,
|
|
TAOCheck,
|
|
appendRequestOriginHeader,
|
|
responseLocationURL,
|
|
requestCurrentURL,
|
|
setRequestReferrerPolicyOnRedirect,
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL,
|
|
createOpaqueTimingInfo,
|
|
appendFetchMetadata,
|
|
corsCheck,
|
|
crossOriginResourcePolicyCheck,
|
|
determineRequestsReferrer: determineRequestsReferrer2,
|
|
coarsenedSharedCurrentTime,
|
|
createDeferredPromise,
|
|
isBlobLike,
|
|
sameOrigin,
|
|
isCancelled,
|
|
isAborted,
|
|
isErrorLike,
|
|
fullyReadBody,
|
|
readableStreamClose,
|
|
isomorphicEncode,
|
|
urlIsLocal,
|
|
urlIsHttpHttpsScheme,
|
|
urlHasHttpsScheme
|
|
} = require_util2();
|
|
var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
|
|
var assert = require("assert");
|
|
var { safelyExtractBody } = require_body();
|
|
var {
|
|
redirectStatusSet,
|
|
nullBodyStatus,
|
|
safeMethodsSet,
|
|
requestBodyHeader,
|
|
subresourceSet,
|
|
DOMException: DOMException3
|
|
} = require_constants2();
|
|
var { kHeadersList } = require_symbols();
|
|
var EE = require("events");
|
|
var { Readable, pipeline: pipeline3 } = require("stream");
|
|
var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util();
|
|
var { dataURLProcessor, serializeAMimeType } = require_dataURL();
|
|
var { TransformStream } = require("stream/web");
|
|
var { getGlobalDispatcher } = require_global2();
|
|
var { webidl } = require_webidl();
|
|
var { STATUS_CODES } = require("http");
|
|
var GET_OR_HEAD = ["GET", "HEAD"];
|
|
var resolveObjectURL;
|
|
var ReadableStream2 = globalThis.ReadableStream;
|
|
var Fetch = class extends EE {
|
|
constructor(dispatcher) {
|
|
super();
|
|
this.dispatcher = dispatcher;
|
|
this.connection = null;
|
|
this.dump = false;
|
|
this.state = "ongoing";
|
|
this.setMaxListeners(21);
|
|
}
|
|
terminate(reason) {
|
|
if (this.state !== "ongoing") {
|
|
return;
|
|
}
|
|
this.state = "terminated";
|
|
this.connection?.destroy(reason);
|
|
this.emit("terminated", reason);
|
|
}
|
|
// https://fetch.spec.whatwg.org/#fetch-controller-abort
|
|
abort(error) {
|
|
if (this.state !== "ongoing") {
|
|
return;
|
|
}
|
|
this.state = "aborted";
|
|
if (!error) {
|
|
error = new DOMException3("The operation was aborted.", "AbortError");
|
|
}
|
|
this.serializedAbortReason = error;
|
|
this.connection?.destroy(error);
|
|
this.emit("terminated", error);
|
|
}
|
|
};
|
|
function fetch2(input, init = {}) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
|
|
const p = createDeferredPromise();
|
|
let requestObject;
|
|
try {
|
|
requestObject = new Request2(input, init);
|
|
} catch (e2) {
|
|
p.reject(e2);
|
|
return p.promise;
|
|
}
|
|
const request = requestObject[kState];
|
|
if (requestObject.signal.aborted) {
|
|
abortFetch(p, request, null, requestObject.signal.reason);
|
|
return p.promise;
|
|
}
|
|
const globalObject = request.client.globalObject;
|
|
if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
|
|
request.serviceWorkers = "none";
|
|
}
|
|
let responseObject = null;
|
|
const relevantRealm = null;
|
|
let locallyAborted = false;
|
|
let controller = null;
|
|
addAbortListener(
|
|
requestObject.signal,
|
|
() => {
|
|
locallyAborted = true;
|
|
assert(controller != null);
|
|
controller.abort(requestObject.signal.reason);
|
|
abortFetch(p, request, responseObject, requestObject.signal.reason);
|
|
}
|
|
);
|
|
const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch");
|
|
const processResponse = (response) => {
|
|
if (locallyAborted) {
|
|
return Promise.resolve();
|
|
}
|
|
if (response.aborted) {
|
|
abortFetch(p, request, responseObject, controller.serializedAbortReason);
|
|
return Promise.resolve();
|
|
}
|
|
if (response.type === "error") {
|
|
p.reject(
|
|
Object.assign(new TypeError("fetch failed"), { cause: response.error })
|
|
);
|
|
return Promise.resolve();
|
|
}
|
|
responseObject = new Response2();
|
|
responseObject[kState] = response;
|
|
responseObject[kRealm] = relevantRealm;
|
|
responseObject[kHeaders][kHeadersList] = response.headersList;
|
|
responseObject[kHeaders][kGuard] = "immutable";
|
|
responseObject[kHeaders][kRealm] = relevantRealm;
|
|
p.resolve(responseObject);
|
|
};
|
|
controller = fetching({
|
|
request,
|
|
processResponseEndOfBody: handleFetchDone,
|
|
processResponse,
|
|
dispatcher: init.dispatcher ?? getGlobalDispatcher()
|
|
// undici
|
|
});
|
|
return p.promise;
|
|
}
|
|
function finalizeAndReportTiming(response, initiatorType = "other") {
|
|
if (response.type === "error" && response.aborted) {
|
|
return;
|
|
}
|
|
if (!response.urlList?.length) {
|
|
return;
|
|
}
|
|
const originalURL = response.urlList[0];
|
|
let timingInfo = response.timingInfo;
|
|
let cacheState = response.cacheState;
|
|
if (!urlIsHttpHttpsScheme(originalURL)) {
|
|
return;
|
|
}
|
|
if (timingInfo === null) {
|
|
return;
|
|
}
|
|
if (!response.timingAllowPassed) {
|
|
timingInfo = createOpaqueTimingInfo({
|
|
startTime: timingInfo.startTime
|
|
});
|
|
cacheState = "";
|
|
}
|
|
timingInfo.endTime = coarsenedSharedCurrentTime();
|
|
response.timingInfo = timingInfo;
|
|
markResourceTiming(
|
|
timingInfo,
|
|
originalURL,
|
|
initiatorType,
|
|
globalThis,
|
|
cacheState
|
|
);
|
|
}
|
|
function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
|
|
if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) {
|
|
performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState);
|
|
}
|
|
}
|
|
function abortFetch(p, request, responseObject, error) {
|
|
if (!error) {
|
|
error = new DOMException3("The operation was aborted.", "AbortError");
|
|
}
|
|
p.reject(error);
|
|
if (request.body != null && isReadable(request.body?.stream)) {
|
|
request.body.stream.cancel(error).catch((err) => {
|
|
if (err.code === "ERR_INVALID_STATE") {
|
|
return;
|
|
}
|
|
throw err;
|
|
});
|
|
}
|
|
if (responseObject == null) {
|
|
return;
|
|
}
|
|
const response = responseObject[kState];
|
|
if (response.body != null && isReadable(response.body?.stream)) {
|
|
response.body.stream.cancel(error).catch((err) => {
|
|
if (err.code === "ERR_INVALID_STATE") {
|
|
return;
|
|
}
|
|
throw err;
|
|
});
|
|
}
|
|
}
|
|
function fetching({
|
|
request,
|
|
processRequestBodyChunkLength,
|
|
processRequestEndOfBody,
|
|
processResponse,
|
|
processResponseEndOfBody,
|
|
processResponseConsumeBody,
|
|
useParallelQueue = false,
|
|
dispatcher
|
|
// undici
|
|
}) {
|
|
let taskDestination = null;
|
|
let crossOriginIsolatedCapability = false;
|
|
if (request.client != null) {
|
|
taskDestination = request.client.globalObject;
|
|
crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
|
|
}
|
|
const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
|
|
const timingInfo = createOpaqueTimingInfo({
|
|
startTime: currenTime
|
|
});
|
|
const fetchParams = {
|
|
controller: new Fetch(dispatcher),
|
|
request,
|
|
timingInfo,
|
|
processRequestBodyChunkLength,
|
|
processRequestEndOfBody,
|
|
processResponse,
|
|
processResponseConsumeBody,
|
|
processResponseEndOfBody,
|
|
taskDestination,
|
|
crossOriginIsolatedCapability
|
|
};
|
|
assert(!request.body || request.body.stream);
|
|
if (request.window === "client") {
|
|
request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
|
|
}
|
|
if (request.origin === "client") {
|
|
request.origin = request.client?.origin;
|
|
}
|
|
if (request.policyContainer === "client") {
|
|
if (request.client != null) {
|
|
request.policyContainer = clonePolicyContainer(
|
|
request.client.policyContainer
|
|
);
|
|
} else {
|
|
request.policyContainer = makePolicyContainer();
|
|
}
|
|
}
|
|
if (!request.headersList.contains("accept")) {
|
|
const value = "*/*";
|
|
request.headersList.append("accept", value);
|
|
}
|
|
if (!request.headersList.contains("accept-language")) {
|
|
request.headersList.append("accept-language", "*");
|
|
}
|
|
if (request.priority === null) {
|
|
}
|
|
if (subresourceSet.has(request.destination)) {
|
|
}
|
|
mainFetch(fetchParams).catch((err) => {
|
|
fetchParams.controller.terminate(err);
|
|
});
|
|
return fetchParams.controller;
|
|
}
|
|
async function mainFetch(fetchParams, recursive = false) {
|
|
const request = fetchParams.request;
|
|
let response = null;
|
|
if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
|
|
response = makeNetworkError("local URLs only");
|
|
}
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL(request);
|
|
if (requestBadPort(request) === "blocked") {
|
|
response = makeNetworkError("bad port");
|
|
}
|
|
if (request.referrerPolicy === "") {
|
|
request.referrerPolicy = request.policyContainer.referrerPolicy;
|
|
}
|
|
if (request.referrer !== "no-referrer") {
|
|
request.referrer = determineRequestsReferrer2(request);
|
|
}
|
|
if (response === null) {
|
|
response = await (async () => {
|
|
const currentURL = requestCurrentURL(request);
|
|
if (
|
|
// - request’s current URL’s origin is same origin with request’s origin,
|
|
// and request’s response tainting is "basic"
|
|
sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data"
|
|
currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
|
|
(request.mode === "navigate" || request.mode === "websocket")
|
|
) {
|
|
request.responseTainting = "basic";
|
|
return await schemeFetch(fetchParams);
|
|
}
|
|
if (request.mode === "same-origin") {
|
|
return makeNetworkError('request mode cannot be "same-origin"');
|
|
}
|
|
if (request.mode === "no-cors") {
|
|
if (request.redirect !== "follow") {
|
|
return makeNetworkError(
|
|
'redirect mode cannot be "follow" for "no-cors" request'
|
|
);
|
|
}
|
|
request.responseTainting = "opaque";
|
|
return await schemeFetch(fetchParams);
|
|
}
|
|
if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
|
|
return makeNetworkError("URL scheme must be a HTTP(S) scheme");
|
|
}
|
|
request.responseTainting = "cors";
|
|
return await httpFetch(fetchParams);
|
|
})();
|
|
}
|
|
if (recursive) {
|
|
return response;
|
|
}
|
|
if (response.status !== 0 && !response.internalResponse) {
|
|
if (request.responseTainting === "cors") {
|
|
}
|
|
if (request.responseTainting === "basic") {
|
|
response = filterResponse(response, "basic");
|
|
} else if (request.responseTainting === "cors") {
|
|
response = filterResponse(response, "cors");
|
|
} else if (request.responseTainting === "opaque") {
|
|
response = filterResponse(response, "opaque");
|
|
} else {
|
|
assert(false);
|
|
}
|
|
}
|
|
let internalResponse = response.status === 0 ? response : response.internalResponse;
|
|
if (internalResponse.urlList.length === 0) {
|
|
internalResponse.urlList.push(...request.urlList);
|
|
}
|
|
if (!request.timingAllowFailed) {
|
|
response.timingAllowPassed = true;
|
|
}
|
|
if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) {
|
|
response = internalResponse = makeNetworkError();
|
|
}
|
|
if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
|
|
internalResponse.body = null;
|
|
fetchParams.controller.dump = true;
|
|
}
|
|
if (request.integrity) {
|
|
const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
|
|
if (request.responseTainting === "opaque" || response.body == null) {
|
|
processBodyError(response.error);
|
|
return;
|
|
}
|
|
const processBody = (bytes) => {
|
|
if (!bytesMatch(bytes, request.integrity)) {
|
|
processBodyError("integrity mismatch");
|
|
return;
|
|
}
|
|
response.body = safelyExtractBody(bytes)[0];
|
|
fetchFinale(fetchParams, response);
|
|
};
|
|
await fullyReadBody(response.body, processBody, processBodyError);
|
|
} else {
|
|
fetchFinale(fetchParams, response);
|
|
}
|
|
}
|
|
function schemeFetch(fetchParams) {
|
|
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
|
|
return Promise.resolve(makeAppropriateNetworkError(fetchParams));
|
|
}
|
|
const { request } = fetchParams;
|
|
const { protocol: scheme } = requestCurrentURL(request);
|
|
switch (scheme) {
|
|
case "about:": {
|
|
return Promise.resolve(makeNetworkError("about scheme is not supported"));
|
|
}
|
|
case "blob:": {
|
|
if (!resolveObjectURL) {
|
|
resolveObjectURL = require("buffer").resolveObjectURL;
|
|
}
|
|
const blobURLEntry = requestCurrentURL(request);
|
|
if (blobURLEntry.search.length !== 0) {
|
|
return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
|
|
}
|
|
const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
|
|
if (request.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
|
|
return Promise.resolve(makeNetworkError("invalid method"));
|
|
}
|
|
const bodyWithType = safelyExtractBody(blobURLEntryObject);
|
|
const body = bodyWithType[0];
|
|
const length = isomorphicEncode(`${body.length}`);
|
|
const type = bodyWithType[1] ?? "";
|
|
const response = makeResponse({
|
|
statusText: "OK",
|
|
headersList: [
|
|
["content-length", { name: "Content-Length", value: length }],
|
|
["content-type", { name: "Content-Type", value: type }]
|
|
]
|
|
});
|
|
response.body = body;
|
|
return Promise.resolve(response);
|
|
}
|
|
case "data:": {
|
|
const currentURL = requestCurrentURL(request);
|
|
const dataURLStruct = dataURLProcessor(currentURL);
|
|
if (dataURLStruct === "failure") {
|
|
return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
|
|
}
|
|
const mimeType = serializeAMimeType(dataURLStruct.mimeType);
|
|
return Promise.resolve(makeResponse({
|
|
statusText: "OK",
|
|
headersList: [
|
|
["content-type", { name: "Content-Type", value: mimeType }]
|
|
],
|
|
body: safelyExtractBody(dataURLStruct.body)[0]
|
|
}));
|
|
}
|
|
case "file:": {
|
|
return Promise.resolve(makeNetworkError("not implemented... yet..."));
|
|
}
|
|
case "http:":
|
|
case "https:": {
|
|
return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
|
|
}
|
|
default: {
|
|
return Promise.resolve(makeNetworkError("unknown scheme"));
|
|
}
|
|
}
|
|
}
|
|
function finalizeResponse(fetchParams, response) {
|
|
fetchParams.request.done = true;
|
|
if (fetchParams.processResponseDone != null) {
|
|
queueMicrotask(() => fetchParams.processResponseDone(response));
|
|
}
|
|
}
|
|
function fetchFinale(fetchParams, response) {
|
|
if (response.type === "error") {
|
|
response.urlList = [fetchParams.request.urlList[0]];
|
|
response.timingInfo = createOpaqueTimingInfo({
|
|
startTime: fetchParams.timingInfo.startTime
|
|
});
|
|
}
|
|
const processResponseEndOfBody = () => {
|
|
fetchParams.request.done = true;
|
|
if (fetchParams.processResponseEndOfBody != null) {
|
|
queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
|
|
}
|
|
};
|
|
if (fetchParams.processResponse != null) {
|
|
queueMicrotask(() => fetchParams.processResponse(response));
|
|
}
|
|
if (response.body == null) {
|
|
processResponseEndOfBody();
|
|
} else {
|
|
const identityTransformAlgorithm = (chunk, controller) => {
|
|
controller.enqueue(chunk);
|
|
};
|
|
const transformStream = new TransformStream({
|
|
start() {
|
|
},
|
|
transform: identityTransformAlgorithm,
|
|
flush: processResponseEndOfBody
|
|
}, {
|
|
size() {
|
|
return 1;
|
|
}
|
|
}, {
|
|
size() {
|
|
return 1;
|
|
}
|
|
});
|
|
response.body = { stream: response.body.stream.pipeThrough(transformStream) };
|
|
}
|
|
if (fetchParams.processResponseConsumeBody != null) {
|
|
const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes);
|
|
const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure);
|
|
if (response.body == null) {
|
|
queueMicrotask(() => processBody(null));
|
|
} else {
|
|
return fullyReadBody(response.body, processBody, processBodyError);
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
async function httpFetch(fetchParams) {
|
|
const request = fetchParams.request;
|
|
let response = null;
|
|
let actualResponse = null;
|
|
const timingInfo = fetchParams.timingInfo;
|
|
if (request.serviceWorkers === "all") {
|
|
}
|
|
if (response === null) {
|
|
if (request.redirect === "follow") {
|
|
request.serviceWorkers = "none";
|
|
}
|
|
actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
|
|
if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") {
|
|
return makeNetworkError("cors failure");
|
|
}
|
|
if (TAOCheck(request, response) === "failure") {
|
|
request.timingAllowFailed = true;
|
|
}
|
|
}
|
|
if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
|
|
request.origin,
|
|
request.client,
|
|
request.destination,
|
|
actualResponse
|
|
) === "blocked") {
|
|
return makeNetworkError("blocked");
|
|
}
|
|
if (redirectStatusSet.has(actualResponse.status)) {
|
|
if (request.redirect !== "manual") {
|
|
fetchParams.controller.connection.destroy();
|
|
}
|
|
if (request.redirect === "error") {
|
|
response = makeNetworkError("unexpected redirect");
|
|
} else if (request.redirect === "manual") {
|
|
response = actualResponse;
|
|
} else if (request.redirect === "follow") {
|
|
response = await httpRedirectFetch(fetchParams, response);
|
|
} else {
|
|
assert(false);
|
|
}
|
|
}
|
|
response.timingInfo = timingInfo;
|
|
return response;
|
|
}
|
|
function httpRedirectFetch(fetchParams, response) {
|
|
const request = fetchParams.request;
|
|
const actualResponse = response.internalResponse ? response.internalResponse : response;
|
|
let locationURL;
|
|
try {
|
|
locationURL = responseLocationURL(
|
|
actualResponse,
|
|
requestCurrentURL(request).hash
|
|
);
|
|
if (locationURL == null) {
|
|
return response;
|
|
}
|
|
} catch (err) {
|
|
return Promise.resolve(makeNetworkError(err));
|
|
}
|
|
if (!urlIsHttpHttpsScheme(locationURL)) {
|
|
return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
|
|
}
|
|
if (request.redirectCount === 20) {
|
|
return Promise.resolve(makeNetworkError("redirect count exceeded"));
|
|
}
|
|
request.redirectCount += 1;
|
|
if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) {
|
|
return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
|
|
}
|
|
if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
|
|
return Promise.resolve(makeNetworkError(
|
|
'URL cannot contain credentials for request mode "cors"'
|
|
));
|
|
}
|
|
if (actualResponse.status !== 303 && request.body != null && request.body.source == null) {
|
|
return Promise.resolve(makeNetworkError());
|
|
}
|
|
if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) {
|
|
request.method = "GET";
|
|
request.body = null;
|
|
for (const headerName of requestBodyHeader) {
|
|
request.headersList.delete(headerName);
|
|
}
|
|
}
|
|
if (!sameOrigin(requestCurrentURL(request), locationURL)) {
|
|
request.headersList.delete("authorization");
|
|
request.headersList.delete("proxy-authorization", true);
|
|
request.headersList.delete("cookie");
|
|
request.headersList.delete("host");
|
|
}
|
|
if (request.body != null) {
|
|
assert(request.body.source != null);
|
|
request.body = safelyExtractBody(request.body.source)[0];
|
|
}
|
|
const timingInfo = fetchParams.timingInfo;
|
|
timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
|
|
if (timingInfo.redirectStartTime === 0) {
|
|
timingInfo.redirectStartTime = timingInfo.startTime;
|
|
}
|
|
request.urlList.push(locationURL);
|
|
setRequestReferrerPolicyOnRedirect(request, actualResponse);
|
|
return mainFetch(fetchParams, true);
|
|
}
|
|
async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
|
|
const request = fetchParams.request;
|
|
let httpFetchParams = null;
|
|
let httpRequest = null;
|
|
let response = null;
|
|
const httpCache = null;
|
|
const revalidatingFlag = false;
|
|
if (request.window === "no-window" && request.redirect === "error") {
|
|
httpFetchParams = fetchParams;
|
|
httpRequest = request;
|
|
} else {
|
|
httpRequest = makeRequest(request);
|
|
httpFetchParams = { ...fetchParams };
|
|
httpFetchParams.request = httpRequest;
|
|
}
|
|
const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic";
|
|
const contentLength = httpRequest.body ? httpRequest.body.length : null;
|
|
let contentLengthHeaderValue = null;
|
|
if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
|
|
contentLengthHeaderValue = "0";
|
|
}
|
|
if (contentLength != null) {
|
|
contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
|
|
}
|
|
if (contentLengthHeaderValue != null) {
|
|
httpRequest.headersList.append("content-length", contentLengthHeaderValue);
|
|
}
|
|
if (contentLength != null && httpRequest.keepalive) {
|
|
}
|
|
if (httpRequest.referrer instanceof URL) {
|
|
httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
|
|
}
|
|
appendRequestOriginHeader(httpRequest);
|
|
appendFetchMetadata(httpRequest);
|
|
if (!httpRequest.headersList.contains("user-agent")) {
|
|
httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node");
|
|
}
|
|
if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
|
|
httpRequest.cache = "no-store";
|
|
}
|
|
if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
|
|
httpRequest.headersList.append("cache-control", "max-age=0");
|
|
}
|
|
if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
|
|
if (!httpRequest.headersList.contains("pragma")) {
|
|
httpRequest.headersList.append("pragma", "no-cache");
|
|
}
|
|
if (!httpRequest.headersList.contains("cache-control")) {
|
|
httpRequest.headersList.append("cache-control", "no-cache");
|
|
}
|
|
}
|
|
if (httpRequest.headersList.contains("range")) {
|
|
httpRequest.headersList.append("accept-encoding", "identity");
|
|
}
|
|
if (!httpRequest.headersList.contains("accept-encoding")) {
|
|
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
|
|
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
|
|
} else {
|
|
httpRequest.headersList.append("accept-encoding", "gzip, deflate");
|
|
}
|
|
}
|
|
httpRequest.headersList.delete("host");
|
|
if (includeCredentials) {
|
|
}
|
|
if (httpCache == null) {
|
|
httpRequest.cache = "no-store";
|
|
}
|
|
if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
|
|
}
|
|
if (response == null) {
|
|
if (httpRequest.mode === "only-if-cached") {
|
|
return makeNetworkError("only if cached");
|
|
}
|
|
const forwardResponse = await httpNetworkFetch(
|
|
httpFetchParams,
|
|
includeCredentials,
|
|
isNewConnectionFetch
|
|
);
|
|
if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {
|
|
}
|
|
if (revalidatingFlag && forwardResponse.status === 304) {
|
|
}
|
|
if (response == null) {
|
|
response = forwardResponse;
|
|
}
|
|
}
|
|
response.urlList = [...httpRequest.urlList];
|
|
if (httpRequest.headersList.contains("range")) {
|
|
response.rangeRequested = true;
|
|
}
|
|
response.requestIncludesCredentials = includeCredentials;
|
|
if (response.status === 407) {
|
|
if (request.window === "no-window") {
|
|
return makeNetworkError();
|
|
}
|
|
if (isCancelled(fetchParams)) {
|
|
return makeAppropriateNetworkError(fetchParams);
|
|
}
|
|
return makeNetworkError("proxy authentication required");
|
|
}
|
|
if (
|
|
// response’s status is 421
|
|
response.status === 421 && // isNewConnectionFetch is false
|
|
!isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
|
|
(request.body == null || request.body.source != null)
|
|
) {
|
|
if (isCancelled(fetchParams)) {
|
|
return makeAppropriateNetworkError(fetchParams);
|
|
}
|
|
fetchParams.controller.connection.destroy();
|
|
response = await httpNetworkOrCacheFetch(
|
|
fetchParams,
|
|
isAuthenticationFetch,
|
|
true
|
|
);
|
|
}
|
|
if (isAuthenticationFetch) {
|
|
}
|
|
return response;
|
|
}
|
|
async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
|
|
assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
|
|
fetchParams.controller.connection = {
|
|
abort: null,
|
|
destroyed: false,
|
|
destroy(err) {
|
|
if (!this.destroyed) {
|
|
this.destroyed = true;
|
|
this.abort?.(err ?? new DOMException3("The operation was aborted.", "AbortError"));
|
|
}
|
|
}
|
|
};
|
|
const request = fetchParams.request;
|
|
let response = null;
|
|
const timingInfo = fetchParams.timingInfo;
|
|
const httpCache = null;
|
|
if (httpCache == null) {
|
|
request.cache = "no-store";
|
|
}
|
|
const newConnection = forceNewConnection ? "yes" : "no";
|
|
if (request.mode === "websocket") {
|
|
} else {
|
|
}
|
|
let requestBody = null;
|
|
if (request.body == null && fetchParams.processRequestEndOfBody) {
|
|
queueMicrotask(() => fetchParams.processRequestEndOfBody());
|
|
} else if (request.body != null) {
|
|
const processBodyChunk = async function* (bytes) {
|
|
if (isCancelled(fetchParams)) {
|
|
return;
|
|
}
|
|
yield bytes;
|
|
fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
|
|
};
|
|
const processEndOfBody = () => {
|
|
if (isCancelled(fetchParams)) {
|
|
return;
|
|
}
|
|
if (fetchParams.processRequestEndOfBody) {
|
|
fetchParams.processRequestEndOfBody();
|
|
}
|
|
};
|
|
const processBodyError = (e2) => {
|
|
if (isCancelled(fetchParams)) {
|
|
return;
|
|
}
|
|
if (e2.name === "AbortError") {
|
|
fetchParams.controller.abort();
|
|
} else {
|
|
fetchParams.controller.terminate(e2);
|
|
}
|
|
};
|
|
requestBody = async function* () {
|
|
try {
|
|
for await (const bytes of request.body.stream) {
|
|
yield* processBodyChunk(bytes);
|
|
}
|
|
processEndOfBody();
|
|
} catch (err) {
|
|
processBodyError(err);
|
|
}
|
|
}();
|
|
}
|
|
try {
|
|
const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
|
|
if (socket) {
|
|
response = makeResponse({ status, statusText, headersList, socket });
|
|
} else {
|
|
const iterator = body[Symbol.asyncIterator]();
|
|
fetchParams.controller.next = () => iterator.next();
|
|
response = makeResponse({ status, statusText, headersList });
|
|
}
|
|
} catch (err) {
|
|
if (err.name === "AbortError") {
|
|
fetchParams.controller.connection.destroy();
|
|
return makeAppropriateNetworkError(fetchParams, err);
|
|
}
|
|
return makeNetworkError(err);
|
|
}
|
|
const pullAlgorithm = () => {
|
|
fetchParams.controller.resume();
|
|
};
|
|
const cancelAlgorithm = (reason) => {
|
|
fetchParams.controller.abort(reason);
|
|
};
|
|
if (!ReadableStream2) {
|
|
ReadableStream2 = require("stream/web").ReadableStream;
|
|
}
|
|
const stream = new ReadableStream2(
|
|
{
|
|
async start(controller) {
|
|
fetchParams.controller.controller = controller;
|
|
},
|
|
async pull(controller) {
|
|
await pullAlgorithm(controller);
|
|
},
|
|
async cancel(reason) {
|
|
await cancelAlgorithm(reason);
|
|
}
|
|
},
|
|
{
|
|
highWaterMark: 0,
|
|
size() {
|
|
return 1;
|
|
}
|
|
}
|
|
);
|
|
response.body = { stream };
|
|
fetchParams.controller.on("terminated", onAborted);
|
|
fetchParams.controller.resume = async () => {
|
|
while (true) {
|
|
let bytes;
|
|
let isFailure;
|
|
try {
|
|
const { done, value } = await fetchParams.controller.next();
|
|
if (isAborted(fetchParams)) {
|
|
break;
|
|
}
|
|
bytes = done ? void 0 : value;
|
|
} catch (err) {
|
|
if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
|
|
bytes = void 0;
|
|
} else {
|
|
bytes = err;
|
|
isFailure = true;
|
|
}
|
|
}
|
|
if (bytes === void 0) {
|
|
readableStreamClose(fetchParams.controller.controller);
|
|
finalizeResponse(fetchParams, response);
|
|
return;
|
|
}
|
|
timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
|
|
if (isFailure) {
|
|
fetchParams.controller.terminate(bytes);
|
|
return;
|
|
}
|
|
fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
|
|
if (isErrored(stream)) {
|
|
fetchParams.controller.terminate();
|
|
return;
|
|
}
|
|
if (!fetchParams.controller.controller.desiredSize) {
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
function onAborted(reason) {
|
|
if (isAborted(fetchParams)) {
|
|
response.aborted = true;
|
|
if (isReadable(stream)) {
|
|
fetchParams.controller.controller.error(
|
|
fetchParams.controller.serializedAbortReason
|
|
);
|
|
}
|
|
} else {
|
|
if (isReadable(stream)) {
|
|
fetchParams.controller.controller.error(new TypeError("terminated", {
|
|
cause: isErrorLike(reason) ? reason : void 0
|
|
}));
|
|
}
|
|
}
|
|
fetchParams.controller.connection.destroy();
|
|
}
|
|
return response;
|
|
async function dispatch({ body }) {
|
|
const url = requestCurrentURL(request);
|
|
const agent = fetchParams.controller.dispatcher;
|
|
return new Promise((resolve, reject) => agent.dispatch(
|
|
{
|
|
path: url.pathname + url.search,
|
|
origin: url.origin,
|
|
method: request.method,
|
|
body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
|
|
headers: request.headersList.entries,
|
|
maxRedirections: 0,
|
|
upgrade: request.mode === "websocket" ? "websocket" : void 0
|
|
},
|
|
{
|
|
body: null,
|
|
abort: null,
|
|
onConnect(abort) {
|
|
const { connection } = fetchParams.controller;
|
|
if (connection.destroyed) {
|
|
abort(new DOMException3("The operation was aborted.", "AbortError"));
|
|
} else {
|
|
fetchParams.controller.on("terminated", abort);
|
|
this.abort = connection.abort = abort;
|
|
}
|
|
},
|
|
onHeaders(status, headersList, resume, statusText) {
|
|
if (status < 200) {
|
|
return;
|
|
}
|
|
let codings = [];
|
|
let location = "";
|
|
const headers = new Headers2();
|
|
if (Array.isArray(headersList)) {
|
|
for (let n = 0; n < headersList.length; n += 2) {
|
|
const key = headersList[n + 0].toString("latin1");
|
|
const val = headersList[n + 1].toString("latin1");
|
|
if (key.toLowerCase() === "content-encoding") {
|
|
codings = val.toLowerCase().split(",").map((x2) => x2.trim());
|
|
} else if (key.toLowerCase() === "location") {
|
|
location = val;
|
|
}
|
|
headers[kHeadersList].append(key, val);
|
|
}
|
|
} else {
|
|
const keys = Object.keys(headersList);
|
|
for (const key of keys) {
|
|
const val = headersList[key];
|
|
if (key.toLowerCase() === "content-encoding") {
|
|
codings = val.toLowerCase().split(",").map((x2) => x2.trim()).reverse();
|
|
} else if (key.toLowerCase() === "location") {
|
|
location = val;
|
|
}
|
|
headers[kHeadersList].append(key, val);
|
|
}
|
|
}
|
|
this.body = new Readable({ read: resume });
|
|
const decoders = [];
|
|
const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status);
|
|
if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
|
|
for (const coding of codings) {
|
|
if (coding === "x-gzip" || coding === "gzip") {
|
|
decoders.push(zlib2.createGunzip({
|
|
// Be less strict when decoding compressed responses, since sometimes
|
|
// servers send slightly invalid responses that are still accepted
|
|
// by common browsers.
|
|
// Always using Z_SYNC_FLUSH is what cURL does.
|
|
flush: zlib2.constants.Z_SYNC_FLUSH,
|
|
finishFlush: zlib2.constants.Z_SYNC_FLUSH
|
|
}));
|
|
} else if (coding === "deflate") {
|
|
decoders.push(zlib2.createInflate());
|
|
} else if (coding === "br") {
|
|
decoders.push(zlib2.createBrotliDecompress());
|
|
} else {
|
|
decoders.length = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
resolve({
|
|
status,
|
|
statusText,
|
|
headersList: headers[kHeadersList],
|
|
body: decoders.length ? pipeline3(this.body, ...decoders, () => {
|
|
}) : this.body.on("error", () => {
|
|
})
|
|
});
|
|
return true;
|
|
},
|
|
onData(chunk) {
|
|
if (fetchParams.controller.dump) {
|
|
return;
|
|
}
|
|
const bytes = chunk;
|
|
timingInfo.encodedBodySize += bytes.byteLength;
|
|
return this.body.push(bytes);
|
|
},
|
|
onComplete() {
|
|
if (this.abort) {
|
|
fetchParams.controller.off("terminated", this.abort);
|
|
}
|
|
fetchParams.controller.ended = true;
|
|
this.body.push(null);
|
|
},
|
|
onError(error) {
|
|
if (this.abort) {
|
|
fetchParams.controller.off("terminated", this.abort);
|
|
}
|
|
this.body?.destroy(error);
|
|
fetchParams.controller.terminate(error);
|
|
reject(error);
|
|
},
|
|
onUpgrade(status, headersList, socket) {
|
|
if (status !== 101) {
|
|
return;
|
|
}
|
|
const headers = new Headers2();
|
|
for (let n = 0; n < headersList.length; n += 2) {
|
|
const key = headersList[n + 0].toString("latin1");
|
|
const val = headersList[n + 1].toString("latin1");
|
|
headers[kHeadersList].append(key, val);
|
|
}
|
|
resolve({
|
|
status,
|
|
statusText: STATUS_CODES[status],
|
|
headersList: headers[kHeadersList],
|
|
socket
|
|
});
|
|
return true;
|
|
}
|
|
}
|
|
));
|
|
}
|
|
}
|
|
module2.exports = {
|
|
fetch: fetch2,
|
|
Fetch,
|
|
fetching,
|
|
finalizeAndReportTiming
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fileapi/symbols.js
|
|
var require_symbols3 = __commonJS({
|
|
"node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = {
|
|
kState: Symbol("FileReader state"),
|
|
kResult: Symbol("FileReader result"),
|
|
kError: Symbol("FileReader error"),
|
|
kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
|
|
kEvents: Symbol("FileReader events"),
|
|
kAborted: Symbol("FileReader aborted")
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fileapi/progressevent.js
|
|
var require_progressevent = __commonJS({
|
|
"node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) {
|
|
"use strict";
|
|
var { webidl } = require_webidl();
|
|
var kState = Symbol("ProgressEvent state");
|
|
var ProgressEvent = class _ProgressEvent extends Event {
|
|
constructor(type, eventInitDict = {}) {
|
|
type = webidl.converters.DOMString(type);
|
|
eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
|
|
super(type, eventInitDict);
|
|
this[kState] = {
|
|
lengthComputable: eventInitDict.lengthComputable,
|
|
loaded: eventInitDict.loaded,
|
|
total: eventInitDict.total
|
|
};
|
|
}
|
|
get lengthComputable() {
|
|
webidl.brandCheck(this, _ProgressEvent);
|
|
return this[kState].lengthComputable;
|
|
}
|
|
get loaded() {
|
|
webidl.brandCheck(this, _ProgressEvent);
|
|
return this[kState].loaded;
|
|
}
|
|
get total() {
|
|
webidl.brandCheck(this, _ProgressEvent);
|
|
return this[kState].total;
|
|
}
|
|
};
|
|
webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
|
|
{
|
|
key: "lengthComputable",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "loaded",
|
|
converter: webidl.converters["unsigned long long"],
|
|
defaultValue: 0
|
|
},
|
|
{
|
|
key: "total",
|
|
converter: webidl.converters["unsigned long long"],
|
|
defaultValue: 0
|
|
},
|
|
{
|
|
key: "bubbles",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "cancelable",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "composed",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
}
|
|
]);
|
|
module2.exports = {
|
|
ProgressEvent
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fileapi/encoding.js
|
|
var require_encoding = __commonJS({
|
|
"node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) {
|
|
"use strict";
|
|
function getEncoding(label) {
|
|
if (!label) {
|
|
return "failure";
|
|
}
|
|
switch (label.trim().toLowerCase()) {
|
|
case "unicode-1-1-utf-8":
|
|
case "unicode11utf8":
|
|
case "unicode20utf8":
|
|
case "utf-8":
|
|
case "utf8":
|
|
case "x-unicode20utf8":
|
|
return "UTF-8";
|
|
case "866":
|
|
case "cp866":
|
|
case "csibm866":
|
|
case "ibm866":
|
|
return "IBM866";
|
|
case "csisolatin2":
|
|
case "iso-8859-2":
|
|
case "iso-ir-101":
|
|
case "iso8859-2":
|
|
case "iso88592":
|
|
case "iso_8859-2":
|
|
case "iso_8859-2:1987":
|
|
case "l2":
|
|
case "latin2":
|
|
return "ISO-8859-2";
|
|
case "csisolatin3":
|
|
case "iso-8859-3":
|
|
case "iso-ir-109":
|
|
case "iso8859-3":
|
|
case "iso88593":
|
|
case "iso_8859-3":
|
|
case "iso_8859-3:1988":
|
|
case "l3":
|
|
case "latin3":
|
|
return "ISO-8859-3";
|
|
case "csisolatin4":
|
|
case "iso-8859-4":
|
|
case "iso-ir-110":
|
|
case "iso8859-4":
|
|
case "iso88594":
|
|
case "iso_8859-4":
|
|
case "iso_8859-4:1988":
|
|
case "l4":
|
|
case "latin4":
|
|
return "ISO-8859-4";
|
|
case "csisolatincyrillic":
|
|
case "cyrillic":
|
|
case "iso-8859-5":
|
|
case "iso-ir-144":
|
|
case "iso8859-5":
|
|
case "iso88595":
|
|
case "iso_8859-5":
|
|
case "iso_8859-5:1988":
|
|
return "ISO-8859-5";
|
|
case "arabic":
|
|
case "asmo-708":
|
|
case "csiso88596e":
|
|
case "csiso88596i":
|
|
case "csisolatinarabic":
|
|
case "ecma-114":
|
|
case "iso-8859-6":
|
|
case "iso-8859-6-e":
|
|
case "iso-8859-6-i":
|
|
case "iso-ir-127":
|
|
case "iso8859-6":
|
|
case "iso88596":
|
|
case "iso_8859-6":
|
|
case "iso_8859-6:1987":
|
|
return "ISO-8859-6";
|
|
case "csisolatingreek":
|
|
case "ecma-118":
|
|
case "elot_928":
|
|
case "greek":
|
|
case "greek8":
|
|
case "iso-8859-7":
|
|
case "iso-ir-126":
|
|
case "iso8859-7":
|
|
case "iso88597":
|
|
case "iso_8859-7":
|
|
case "iso_8859-7:1987":
|
|
case "sun_eu_greek":
|
|
return "ISO-8859-7";
|
|
case "csiso88598e":
|
|
case "csisolatinhebrew":
|
|
case "hebrew":
|
|
case "iso-8859-8":
|
|
case "iso-8859-8-e":
|
|
case "iso-ir-138":
|
|
case "iso8859-8":
|
|
case "iso88598":
|
|
case "iso_8859-8":
|
|
case "iso_8859-8:1988":
|
|
case "visual":
|
|
return "ISO-8859-8";
|
|
case "csiso88598i":
|
|
case "iso-8859-8-i":
|
|
case "logical":
|
|
return "ISO-8859-8-I";
|
|
case "csisolatin6":
|
|
case "iso-8859-10":
|
|
case "iso-ir-157":
|
|
case "iso8859-10":
|
|
case "iso885910":
|
|
case "l6":
|
|
case "latin6":
|
|
return "ISO-8859-10";
|
|
case "iso-8859-13":
|
|
case "iso8859-13":
|
|
case "iso885913":
|
|
return "ISO-8859-13";
|
|
case "iso-8859-14":
|
|
case "iso8859-14":
|
|
case "iso885914":
|
|
return "ISO-8859-14";
|
|
case "csisolatin9":
|
|
case "iso-8859-15":
|
|
case "iso8859-15":
|
|
case "iso885915":
|
|
case "iso_8859-15":
|
|
case "l9":
|
|
return "ISO-8859-15";
|
|
case "iso-8859-16":
|
|
return "ISO-8859-16";
|
|
case "cskoi8r":
|
|
case "koi":
|
|
case "koi8":
|
|
case "koi8-r":
|
|
case "koi8_r":
|
|
return "KOI8-R";
|
|
case "koi8-ru":
|
|
case "koi8-u":
|
|
return "KOI8-U";
|
|
case "csmacintosh":
|
|
case "mac":
|
|
case "macintosh":
|
|
case "x-mac-roman":
|
|
return "macintosh";
|
|
case "iso-8859-11":
|
|
case "iso8859-11":
|
|
case "iso885911":
|
|
case "tis-620":
|
|
case "windows-874":
|
|
return "windows-874";
|
|
case "cp1250":
|
|
case "windows-1250":
|
|
case "x-cp1250":
|
|
return "windows-1250";
|
|
case "cp1251":
|
|
case "windows-1251":
|
|
case "x-cp1251":
|
|
return "windows-1251";
|
|
case "ansi_x3.4-1968":
|
|
case "ascii":
|
|
case "cp1252":
|
|
case "cp819":
|
|
case "csisolatin1":
|
|
case "ibm819":
|
|
case "iso-8859-1":
|
|
case "iso-ir-100":
|
|
case "iso8859-1":
|
|
case "iso88591":
|
|
case "iso_8859-1":
|
|
case "iso_8859-1:1987":
|
|
case "l1":
|
|
case "latin1":
|
|
case "us-ascii":
|
|
case "windows-1252":
|
|
case "x-cp1252":
|
|
return "windows-1252";
|
|
case "cp1253":
|
|
case "windows-1253":
|
|
case "x-cp1253":
|
|
return "windows-1253";
|
|
case "cp1254":
|
|
case "csisolatin5":
|
|
case "iso-8859-9":
|
|
case "iso-ir-148":
|
|
case "iso8859-9":
|
|
case "iso88599":
|
|
case "iso_8859-9":
|
|
case "iso_8859-9:1989":
|
|
case "l5":
|
|
case "latin5":
|
|
case "windows-1254":
|
|
case "x-cp1254":
|
|
return "windows-1254";
|
|
case "cp1255":
|
|
case "windows-1255":
|
|
case "x-cp1255":
|
|
return "windows-1255";
|
|
case "cp1256":
|
|
case "windows-1256":
|
|
case "x-cp1256":
|
|
return "windows-1256";
|
|
case "cp1257":
|
|
case "windows-1257":
|
|
case "x-cp1257":
|
|
return "windows-1257";
|
|
case "cp1258":
|
|
case "windows-1258":
|
|
case "x-cp1258":
|
|
return "windows-1258";
|
|
case "x-mac-cyrillic":
|
|
case "x-mac-ukrainian":
|
|
return "x-mac-cyrillic";
|
|
case "chinese":
|
|
case "csgb2312":
|
|
case "csiso58gb231280":
|
|
case "gb2312":
|
|
case "gb_2312":
|
|
case "gb_2312-80":
|
|
case "gbk":
|
|
case "iso-ir-58":
|
|
case "x-gbk":
|
|
return "GBK";
|
|
case "gb18030":
|
|
return "gb18030";
|
|
case "big5":
|
|
case "big5-hkscs":
|
|
case "cn-big5":
|
|
case "csbig5":
|
|
case "x-x-big5":
|
|
return "Big5";
|
|
case "cseucpkdfmtjapanese":
|
|
case "euc-jp":
|
|
case "x-euc-jp":
|
|
return "EUC-JP";
|
|
case "csiso2022jp":
|
|
case "iso-2022-jp":
|
|
return "ISO-2022-JP";
|
|
case "csshiftjis":
|
|
case "ms932":
|
|
case "ms_kanji":
|
|
case "shift-jis":
|
|
case "shift_jis":
|
|
case "sjis":
|
|
case "windows-31j":
|
|
case "x-sjis":
|
|
return "Shift_JIS";
|
|
case "cseuckr":
|
|
case "csksc56011987":
|
|
case "euc-kr":
|
|
case "iso-ir-149":
|
|
case "korean":
|
|
case "ks_c_5601-1987":
|
|
case "ks_c_5601-1989":
|
|
case "ksc5601":
|
|
case "ksc_5601":
|
|
case "windows-949":
|
|
return "EUC-KR";
|
|
case "csiso2022kr":
|
|
case "hz-gb-2312":
|
|
case "iso-2022-cn":
|
|
case "iso-2022-cn-ext":
|
|
case "iso-2022-kr":
|
|
case "replacement":
|
|
return "replacement";
|
|
case "unicodefffe":
|
|
case "utf-16be":
|
|
return "UTF-16BE";
|
|
case "csunicode":
|
|
case "iso-10646-ucs-2":
|
|
case "ucs-2":
|
|
case "unicode":
|
|
case "unicodefeff":
|
|
case "utf-16":
|
|
case "utf-16le":
|
|
return "UTF-16LE";
|
|
case "x-user-defined":
|
|
return "x-user-defined";
|
|
default:
|
|
return "failure";
|
|
}
|
|
}
|
|
module2.exports = {
|
|
getEncoding
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fileapi/util.js
|
|
var require_util4 = __commonJS({
|
|
"node_modules/undici/lib/fileapi/util.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
kState,
|
|
kError,
|
|
kResult,
|
|
kAborted,
|
|
kLastProgressEventFired
|
|
} = require_symbols3();
|
|
var { ProgressEvent } = require_progressevent();
|
|
var { getEncoding } = require_encoding();
|
|
var { DOMException: DOMException3 } = require_constants2();
|
|
var { serializeAMimeType, parseMIMEType } = require_dataURL();
|
|
var { types: types3 } = require("util");
|
|
var { StringDecoder } = require("string_decoder");
|
|
var { btoa } = require("buffer");
|
|
var staticPropertyDescriptors = {
|
|
enumerable: true,
|
|
writable: false,
|
|
configurable: false
|
|
};
|
|
function readOperation(fr, blob, type, encodingName) {
|
|
if (fr[kState] === "loading") {
|
|
throw new DOMException3("Invalid state", "InvalidStateError");
|
|
}
|
|
fr[kState] = "loading";
|
|
fr[kResult] = null;
|
|
fr[kError] = null;
|
|
const stream = blob.stream();
|
|
const reader = stream.getReader();
|
|
const bytes = [];
|
|
let chunkPromise = reader.read();
|
|
let isFirstChunk = true;
|
|
(async () => {
|
|
while (!fr[kAborted]) {
|
|
try {
|
|
const { done, value } = await chunkPromise;
|
|
if (isFirstChunk && !fr[kAborted]) {
|
|
queueMicrotask(() => {
|
|
fireAProgressEvent("loadstart", fr);
|
|
});
|
|
}
|
|
isFirstChunk = false;
|
|
if (!done && types3.isUint8Array(value)) {
|
|
bytes.push(value);
|
|
if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
|
|
fr[kLastProgressEventFired] = Date.now();
|
|
queueMicrotask(() => {
|
|
fireAProgressEvent("progress", fr);
|
|
});
|
|
}
|
|
chunkPromise = reader.read();
|
|
} else if (done) {
|
|
queueMicrotask(() => {
|
|
fr[kState] = "done";
|
|
try {
|
|
const result = packageData(bytes, type, blob.type, encodingName);
|
|
if (fr[kAborted]) {
|
|
return;
|
|
}
|
|
fr[kResult] = result;
|
|
fireAProgressEvent("load", fr);
|
|
} catch (error) {
|
|
fr[kError] = error;
|
|
fireAProgressEvent("error", fr);
|
|
}
|
|
if (fr[kState] !== "loading") {
|
|
fireAProgressEvent("loadend", fr);
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
} catch (error) {
|
|
if (fr[kAborted]) {
|
|
return;
|
|
}
|
|
queueMicrotask(() => {
|
|
fr[kState] = "done";
|
|
fr[kError] = error;
|
|
fireAProgressEvent("error", fr);
|
|
if (fr[kState] !== "loading") {
|
|
fireAProgressEvent("loadend", fr);
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
})();
|
|
}
|
|
function fireAProgressEvent(e2, reader) {
|
|
const event = new ProgressEvent(e2, {
|
|
bubbles: false,
|
|
cancelable: false
|
|
});
|
|
reader.dispatchEvent(event);
|
|
}
|
|
function packageData(bytes, type, mimeType, encodingName) {
|
|
switch (type) {
|
|
case "DataURL": {
|
|
let dataURL = "data:";
|
|
const parsed = parseMIMEType(mimeType || "application/octet-stream");
|
|
if (parsed !== "failure") {
|
|
dataURL += serializeAMimeType(parsed);
|
|
}
|
|
dataURL += ";base64,";
|
|
const decoder = new StringDecoder("latin1");
|
|
for (const chunk of bytes) {
|
|
dataURL += btoa(decoder.write(chunk));
|
|
}
|
|
dataURL += btoa(decoder.end());
|
|
return dataURL;
|
|
}
|
|
case "Text": {
|
|
let encoding = "failure";
|
|
if (encodingName) {
|
|
encoding = getEncoding(encodingName);
|
|
}
|
|
if (encoding === "failure" && mimeType) {
|
|
const type2 = parseMIMEType(mimeType);
|
|
if (type2 !== "failure") {
|
|
encoding = getEncoding(type2.parameters.get("charset"));
|
|
}
|
|
}
|
|
if (encoding === "failure") {
|
|
encoding = "UTF-8";
|
|
}
|
|
return decode(bytes, encoding);
|
|
}
|
|
case "ArrayBuffer": {
|
|
const sequence = combineByteSequences(bytes);
|
|
return sequence.buffer;
|
|
}
|
|
case "BinaryString": {
|
|
let binaryString = "";
|
|
const decoder = new StringDecoder("latin1");
|
|
for (const chunk of bytes) {
|
|
binaryString += decoder.write(chunk);
|
|
}
|
|
binaryString += decoder.end();
|
|
return binaryString;
|
|
}
|
|
}
|
|
}
|
|
function decode(ioQueue, encoding) {
|
|
const bytes = combineByteSequences(ioQueue);
|
|
const BOMEncoding = BOMSniffing(bytes);
|
|
let slice = 0;
|
|
if (BOMEncoding !== null) {
|
|
encoding = BOMEncoding;
|
|
slice = BOMEncoding === "UTF-8" ? 3 : 2;
|
|
}
|
|
const sliced = bytes.slice(slice);
|
|
return new TextDecoder(encoding).decode(sliced);
|
|
}
|
|
function BOMSniffing(ioQueue) {
|
|
const [a, b, c] = ioQueue;
|
|
if (a === 239 && b === 187 && c === 191) {
|
|
return "UTF-8";
|
|
} else if (a === 254 && b === 255) {
|
|
return "UTF-16BE";
|
|
} else if (a === 255 && b === 254) {
|
|
return "UTF-16LE";
|
|
}
|
|
return null;
|
|
}
|
|
function combineByteSequences(sequences) {
|
|
const size = sequences.reduce((a, b) => {
|
|
return a + b.byteLength;
|
|
}, 0);
|
|
let offset = 0;
|
|
return sequences.reduce((a, b) => {
|
|
a.set(b, offset);
|
|
offset += b.byteLength;
|
|
return a;
|
|
}, new Uint8Array(size));
|
|
}
|
|
module2.exports = {
|
|
staticPropertyDescriptors,
|
|
readOperation,
|
|
fireAProgressEvent
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/fileapi/filereader.js
|
|
var require_filereader = __commonJS({
|
|
"node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) {
|
|
"use strict";
|
|
var {
|
|
staticPropertyDescriptors,
|
|
readOperation,
|
|
fireAProgressEvent
|
|
} = require_util4();
|
|
var {
|
|
kState,
|
|
kError,
|
|
kResult,
|
|
kEvents,
|
|
kAborted
|
|
} = require_symbols3();
|
|
var { webidl } = require_webidl();
|
|
var { kEnumerableProperty } = require_util();
|
|
var FileReader = class _FileReader extends EventTarget {
|
|
constructor() {
|
|
super();
|
|
this[kState] = "empty";
|
|
this[kResult] = null;
|
|
this[kError] = null;
|
|
this[kEvents] = {
|
|
loadend: null,
|
|
error: null,
|
|
abort: null,
|
|
load: null,
|
|
progress: null,
|
|
loadstart: null
|
|
};
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
|
|
* @param {import('buffer').Blob} blob
|
|
*/
|
|
readAsArrayBuffer(blob) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" });
|
|
blob = webidl.converters.Blob(blob, { strict: false });
|
|
readOperation(this, blob, "ArrayBuffer");
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#readAsBinaryString
|
|
* @param {import('buffer').Blob} blob
|
|
*/
|
|
readAsBinaryString(blob) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" });
|
|
blob = webidl.converters.Blob(blob, { strict: false });
|
|
readOperation(this, blob, "BinaryString");
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#readAsDataText
|
|
* @param {import('buffer').Blob} blob
|
|
* @param {string?} encoding
|
|
*/
|
|
readAsText(blob, encoding = void 0) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" });
|
|
blob = webidl.converters.Blob(blob, { strict: false });
|
|
if (encoding !== void 0) {
|
|
encoding = webidl.converters.DOMString(encoding);
|
|
}
|
|
readOperation(this, blob, "Text", encoding);
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
|
|
* @param {import('buffer').Blob} blob
|
|
*/
|
|
readAsDataURL(blob) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" });
|
|
blob = webidl.converters.Blob(blob, { strict: false });
|
|
readOperation(this, blob, "DataURL");
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dfn-abort
|
|
*/
|
|
abort() {
|
|
if (this[kState] === "empty" || this[kState] === "done") {
|
|
this[kResult] = null;
|
|
return;
|
|
}
|
|
if (this[kState] === "loading") {
|
|
this[kState] = "done";
|
|
this[kResult] = null;
|
|
}
|
|
this[kAborted] = true;
|
|
fireAProgressEvent("abort", this);
|
|
if (this[kState] !== "loading") {
|
|
fireAProgressEvent("loadend", this);
|
|
}
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
|
|
*/
|
|
get readyState() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
switch (this[kState]) {
|
|
case "empty":
|
|
return this.EMPTY;
|
|
case "loading":
|
|
return this.LOADING;
|
|
case "done":
|
|
return this.DONE;
|
|
}
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dom-filereader-result
|
|
*/
|
|
get result() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kResult];
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dom-filereader-error
|
|
*/
|
|
get error() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kError];
|
|
}
|
|
get onloadend() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].loadend;
|
|
}
|
|
set onloadend(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].loadend) {
|
|
this.removeEventListener("loadend", this[kEvents].loadend);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].loadend = fn;
|
|
this.addEventListener("loadend", fn);
|
|
} else {
|
|
this[kEvents].loadend = null;
|
|
}
|
|
}
|
|
get onerror() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].error;
|
|
}
|
|
set onerror(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].error) {
|
|
this.removeEventListener("error", this[kEvents].error);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].error = fn;
|
|
this.addEventListener("error", fn);
|
|
} else {
|
|
this[kEvents].error = null;
|
|
}
|
|
}
|
|
get onloadstart() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].loadstart;
|
|
}
|
|
set onloadstart(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].loadstart) {
|
|
this.removeEventListener("loadstart", this[kEvents].loadstart);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].loadstart = fn;
|
|
this.addEventListener("loadstart", fn);
|
|
} else {
|
|
this[kEvents].loadstart = null;
|
|
}
|
|
}
|
|
get onprogress() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].progress;
|
|
}
|
|
set onprogress(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].progress) {
|
|
this.removeEventListener("progress", this[kEvents].progress);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].progress = fn;
|
|
this.addEventListener("progress", fn);
|
|
} else {
|
|
this[kEvents].progress = null;
|
|
}
|
|
}
|
|
get onload() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].load;
|
|
}
|
|
set onload(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].load) {
|
|
this.removeEventListener("load", this[kEvents].load);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].load = fn;
|
|
this.addEventListener("load", fn);
|
|
} else {
|
|
this[kEvents].load = null;
|
|
}
|
|
}
|
|
get onabort() {
|
|
webidl.brandCheck(this, _FileReader);
|
|
return this[kEvents].abort;
|
|
}
|
|
set onabort(fn) {
|
|
webidl.brandCheck(this, _FileReader);
|
|
if (this[kEvents].abort) {
|
|
this.removeEventListener("abort", this[kEvents].abort);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this[kEvents].abort = fn;
|
|
this.addEventListener("abort", fn);
|
|
} else {
|
|
this[kEvents].abort = null;
|
|
}
|
|
}
|
|
};
|
|
FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
|
|
FileReader.LOADING = FileReader.prototype.LOADING = 1;
|
|
FileReader.DONE = FileReader.prototype.DONE = 2;
|
|
Object.defineProperties(FileReader.prototype, {
|
|
EMPTY: staticPropertyDescriptors,
|
|
LOADING: staticPropertyDescriptors,
|
|
DONE: staticPropertyDescriptors,
|
|
readAsArrayBuffer: kEnumerableProperty,
|
|
readAsBinaryString: kEnumerableProperty,
|
|
readAsText: kEnumerableProperty,
|
|
readAsDataURL: kEnumerableProperty,
|
|
abort: kEnumerableProperty,
|
|
readyState: kEnumerableProperty,
|
|
result: kEnumerableProperty,
|
|
error: kEnumerableProperty,
|
|
onloadstart: kEnumerableProperty,
|
|
onprogress: kEnumerableProperty,
|
|
onload: kEnumerableProperty,
|
|
onabort: kEnumerableProperty,
|
|
onerror: kEnumerableProperty,
|
|
onloadend: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: "FileReader",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperties(FileReader, {
|
|
EMPTY: staticPropertyDescriptors,
|
|
LOADING: staticPropertyDescriptors,
|
|
DONE: staticPropertyDescriptors
|
|
});
|
|
module2.exports = {
|
|
FileReader
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cache/symbols.js
|
|
var require_symbols4 = __commonJS({
|
|
"node_modules/undici/lib/cache/symbols.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = {
|
|
kConstruct: require_symbols().kConstruct
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cache/util.js
|
|
var require_util5 = __commonJS({
|
|
"node_modules/undici/lib/cache/util.js"(exports2, module2) {
|
|
"use strict";
|
|
var assert = require("assert");
|
|
var { URLSerializer } = require_dataURL();
|
|
var { isValidHeaderName } = require_util2();
|
|
function urlEquals(A2, B, excludeFragment = false) {
|
|
const serializedA = URLSerializer(A2, excludeFragment);
|
|
const serializedB = URLSerializer(B, excludeFragment);
|
|
return serializedA === serializedB;
|
|
}
|
|
function fieldValues(header) {
|
|
assert(header !== null);
|
|
const values = [];
|
|
for (let value of header.split(",")) {
|
|
value = value.trim();
|
|
if (!value.length) {
|
|
continue;
|
|
} else if (!isValidHeaderName(value)) {
|
|
continue;
|
|
}
|
|
values.push(value);
|
|
}
|
|
return values;
|
|
}
|
|
module2.exports = {
|
|
urlEquals,
|
|
fieldValues
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cache/cache.js
|
|
var require_cache = __commonJS({
|
|
"node_modules/undici/lib/cache/cache.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kConstruct } = require_symbols4();
|
|
var { urlEquals, fieldValues: getFieldValues } = require_util5();
|
|
var { kEnumerableProperty, isDisturbed } = require_util();
|
|
var { kHeadersList } = require_symbols();
|
|
var { webidl } = require_webidl();
|
|
var { Response: Response2, cloneResponse } = require_response();
|
|
var { Request: Request2 } = require_request2();
|
|
var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
|
|
var { fetching } = require_fetch();
|
|
var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2();
|
|
var assert = require("assert");
|
|
var { getGlobalDispatcher } = require_global2();
|
|
var Cache = class _Cache {
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
|
|
* @type {requestResponseList}
|
|
*/
|
|
#relevantRequestResponseList;
|
|
constructor() {
|
|
if (arguments[0] !== kConstruct) {
|
|
webidl.illegalConstructor();
|
|
}
|
|
this.#relevantRequestResponseList = arguments[1];
|
|
}
|
|
async match(request, options = {}) {
|
|
webidl.brandCheck(this, _Cache);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" });
|
|
request = webidl.converters.RequestInfo(request);
|
|
options = webidl.converters.CacheQueryOptions(options);
|
|
const p = await this.matchAll(request, options);
|
|
if (p.length === 0) {
|
|
return;
|
|
}
|
|
return p[0];
|
|
}
|
|
async matchAll(request = void 0, options = {}) {
|
|
webidl.brandCheck(this, _Cache);
|
|
if (request !== void 0) request = webidl.converters.RequestInfo(request);
|
|
options = webidl.converters.CacheQueryOptions(options);
|
|
let r2 = null;
|
|
if (request !== void 0) {
|
|
if (request instanceof Request2) {
|
|
r2 = request[kState];
|
|
if (r2.method !== "GET" && !options.ignoreMethod) {
|
|
return [];
|
|
}
|
|
} else if (typeof request === "string") {
|
|
r2 = new Request2(request)[kState];
|
|
}
|
|
}
|
|
const responses = [];
|
|
if (request === void 0) {
|
|
for (const requestResponse of this.#relevantRequestResponseList) {
|
|
responses.push(requestResponse[1]);
|
|
}
|
|
} else {
|
|
const requestResponses = this.#queryCache(r2, options);
|
|
for (const requestResponse of requestResponses) {
|
|
responses.push(requestResponse[1]);
|
|
}
|
|
}
|
|
const responseList = [];
|
|
for (const response of responses) {
|
|
const responseObject = new Response2(response.body?.source ?? null);
|
|
const body = responseObject[kState].body;
|
|
responseObject[kState] = response;
|
|
responseObject[kState].body = body;
|
|
responseObject[kHeaders][kHeadersList] = response.headersList;
|
|
responseObject[kHeaders][kGuard] = "immutable";
|
|
responseList.push(responseObject);
|
|
}
|
|
return Object.freeze(responseList);
|
|
}
|
|
async add(request) {
|
|
webidl.brandCheck(this, _Cache);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" });
|
|
request = webidl.converters.RequestInfo(request);
|
|
const requests = [request];
|
|
const responseArrayPromise = this.addAll(requests);
|
|
return await responseArrayPromise;
|
|
}
|
|
async addAll(requests) {
|
|
webidl.brandCheck(this, _Cache);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" });
|
|
requests = webidl.converters["sequence<RequestInfo>"](requests);
|
|
const responsePromises = [];
|
|
const requestList = [];
|
|
for (const request of requests) {
|
|
if (typeof request === "string") {
|
|
continue;
|
|
}
|
|
const r2 = request[kState];
|
|
if (!urlIsHttpHttpsScheme(r2.url) || r2.method !== "GET") {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.addAll",
|
|
message: "Expected http/s scheme when method is not GET."
|
|
});
|
|
}
|
|
}
|
|
const fetchControllers = [];
|
|
for (const request of requests) {
|
|
const r2 = new Request2(request)[kState];
|
|
if (!urlIsHttpHttpsScheme(r2.url)) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.addAll",
|
|
message: "Expected http/s scheme."
|
|
});
|
|
}
|
|
r2.initiator = "fetch";
|
|
r2.destination = "subresource";
|
|
requestList.push(r2);
|
|
const responsePromise = createDeferredPromise();
|
|
fetchControllers.push(fetching({
|
|
request: r2,
|
|
dispatcher: getGlobalDispatcher(),
|
|
processResponse(response) {
|
|
if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) {
|
|
responsePromise.reject(webidl.errors.exception({
|
|
header: "Cache.addAll",
|
|
message: "Received an invalid status code or the request failed."
|
|
}));
|
|
} else if (response.headersList.contains("vary")) {
|
|
const fieldValues = getFieldValues(response.headersList.get("vary"));
|
|
for (const fieldValue of fieldValues) {
|
|
if (fieldValue === "*") {
|
|
responsePromise.reject(webidl.errors.exception({
|
|
header: "Cache.addAll",
|
|
message: "invalid vary field value"
|
|
}));
|
|
for (const controller of fetchControllers) {
|
|
controller.abort();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
processResponseEndOfBody(response) {
|
|
if (response.aborted) {
|
|
responsePromise.reject(new DOMException("aborted", "AbortError"));
|
|
return;
|
|
}
|
|
responsePromise.resolve(response);
|
|
}
|
|
}));
|
|
responsePromises.push(responsePromise.promise);
|
|
}
|
|
const p = Promise.all(responsePromises);
|
|
const responses = await p;
|
|
const operations = [];
|
|
let index = 0;
|
|
for (const response of responses) {
|
|
const operation = {
|
|
type: "put",
|
|
// 7.3.2
|
|
request: requestList[index],
|
|
// 7.3.3
|
|
response
|
|
// 7.3.4
|
|
};
|
|
operations.push(operation);
|
|
index++;
|
|
}
|
|
const cacheJobPromise = createDeferredPromise();
|
|
let errorData = null;
|
|
try {
|
|
this.#batchCacheOperations(operations);
|
|
} catch (e2) {
|
|
errorData = e2;
|
|
}
|
|
queueMicrotask(() => {
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve(void 0);
|
|
} else {
|
|
cacheJobPromise.reject(errorData);
|
|
}
|
|
});
|
|
return cacheJobPromise.promise;
|
|
}
|
|
async put(request, response) {
|
|
webidl.brandCheck(this, _Cache);
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" });
|
|
request = webidl.converters.RequestInfo(request);
|
|
response = webidl.converters.Response(response);
|
|
let innerRequest = null;
|
|
if (request instanceof Request2) {
|
|
innerRequest = request[kState];
|
|
} else {
|
|
innerRequest = new Request2(request)[kState];
|
|
}
|
|
if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.put",
|
|
message: "Expected an http/s scheme when method is not GET"
|
|
});
|
|
}
|
|
const innerResponse = response[kState];
|
|
if (innerResponse.status === 206) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.put",
|
|
message: "Got 206 status"
|
|
});
|
|
}
|
|
if (innerResponse.headersList.contains("vary")) {
|
|
const fieldValues = getFieldValues(innerResponse.headersList.get("vary"));
|
|
for (const fieldValue of fieldValues) {
|
|
if (fieldValue === "*") {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.put",
|
|
message: "Got * vary field value"
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.put",
|
|
message: "Response body is locked or disturbed"
|
|
});
|
|
}
|
|
const clonedResponse = cloneResponse(innerResponse);
|
|
const bodyReadPromise = createDeferredPromise();
|
|
if (innerResponse.body != null) {
|
|
const stream = innerResponse.body.stream;
|
|
const reader = stream.getReader();
|
|
readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject);
|
|
} else {
|
|
bodyReadPromise.resolve(void 0);
|
|
}
|
|
const operations = [];
|
|
const operation = {
|
|
type: "put",
|
|
// 14.
|
|
request: innerRequest,
|
|
// 15.
|
|
response: clonedResponse
|
|
// 16.
|
|
};
|
|
operations.push(operation);
|
|
const bytes = await bodyReadPromise.promise;
|
|
if (clonedResponse.body != null) {
|
|
clonedResponse.body.source = bytes;
|
|
}
|
|
const cacheJobPromise = createDeferredPromise();
|
|
let errorData = null;
|
|
try {
|
|
this.#batchCacheOperations(operations);
|
|
} catch (e2) {
|
|
errorData = e2;
|
|
}
|
|
queueMicrotask(() => {
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve();
|
|
} else {
|
|
cacheJobPromise.reject(errorData);
|
|
}
|
|
});
|
|
return cacheJobPromise.promise;
|
|
}
|
|
async delete(request, options = {}) {
|
|
webidl.brandCheck(this, _Cache);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" });
|
|
request = webidl.converters.RequestInfo(request);
|
|
options = webidl.converters.CacheQueryOptions(options);
|
|
let r2 = null;
|
|
if (request instanceof Request2) {
|
|
r2 = request[kState];
|
|
if (r2.method !== "GET" && !options.ignoreMethod) {
|
|
return false;
|
|
}
|
|
} else {
|
|
assert(typeof request === "string");
|
|
r2 = new Request2(request)[kState];
|
|
}
|
|
const operations = [];
|
|
const operation = {
|
|
type: "delete",
|
|
request: r2,
|
|
options
|
|
};
|
|
operations.push(operation);
|
|
const cacheJobPromise = createDeferredPromise();
|
|
let errorData = null;
|
|
let requestResponses;
|
|
try {
|
|
requestResponses = this.#batchCacheOperations(operations);
|
|
} catch (e2) {
|
|
errorData = e2;
|
|
}
|
|
queueMicrotask(() => {
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve(!!requestResponses?.length);
|
|
} else {
|
|
cacheJobPromise.reject(errorData);
|
|
}
|
|
});
|
|
return cacheJobPromise.promise;
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
|
|
* @param {any} request
|
|
* @param {import('../../types/cache').CacheQueryOptions} options
|
|
* @returns {readonly Request[]}
|
|
*/
|
|
async keys(request = void 0, options = {}) {
|
|
webidl.brandCheck(this, _Cache);
|
|
if (request !== void 0) request = webidl.converters.RequestInfo(request);
|
|
options = webidl.converters.CacheQueryOptions(options);
|
|
let r2 = null;
|
|
if (request !== void 0) {
|
|
if (request instanceof Request2) {
|
|
r2 = request[kState];
|
|
if (r2.method !== "GET" && !options.ignoreMethod) {
|
|
return [];
|
|
}
|
|
} else if (typeof request === "string") {
|
|
r2 = new Request2(request)[kState];
|
|
}
|
|
}
|
|
const promise = createDeferredPromise();
|
|
const requests = [];
|
|
if (request === void 0) {
|
|
for (const requestResponse of this.#relevantRequestResponseList) {
|
|
requests.push(requestResponse[0]);
|
|
}
|
|
} else {
|
|
const requestResponses = this.#queryCache(r2, options);
|
|
for (const requestResponse of requestResponses) {
|
|
requests.push(requestResponse[0]);
|
|
}
|
|
}
|
|
queueMicrotask(() => {
|
|
const requestList = [];
|
|
for (const request2 of requests) {
|
|
const requestObject = new Request2("https://a");
|
|
requestObject[kState] = request2;
|
|
requestObject[kHeaders][kHeadersList] = request2.headersList;
|
|
requestObject[kHeaders][kGuard] = "immutable";
|
|
requestObject[kRealm] = request2.client;
|
|
requestList.push(requestObject);
|
|
}
|
|
promise.resolve(Object.freeze(requestList));
|
|
});
|
|
return promise.promise;
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
|
|
* @param {CacheBatchOperation[]} operations
|
|
* @returns {requestResponseList}
|
|
*/
|
|
#batchCacheOperations(operations) {
|
|
const cache = this.#relevantRequestResponseList;
|
|
const backupCache = [...cache];
|
|
const addedItems = [];
|
|
const resultList = [];
|
|
try {
|
|
for (const operation of operations) {
|
|
if (operation.type !== "delete" && operation.type !== "put") {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: 'operation type does not match "delete" or "put"'
|
|
});
|
|
}
|
|
if (operation.type === "delete" && operation.response != null) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: "delete operation should not have an associated response"
|
|
});
|
|
}
|
|
if (this.#queryCache(operation.request, operation.options, addedItems).length) {
|
|
throw new DOMException("???", "InvalidStateError");
|
|
}
|
|
let requestResponses;
|
|
if (operation.type === "delete") {
|
|
requestResponses = this.#queryCache(operation.request, operation.options);
|
|
if (requestResponses.length === 0) {
|
|
return [];
|
|
}
|
|
for (const requestResponse of requestResponses) {
|
|
const idx = cache.indexOf(requestResponse);
|
|
assert(idx !== -1);
|
|
cache.splice(idx, 1);
|
|
}
|
|
} else if (operation.type === "put") {
|
|
if (operation.response == null) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: "put operation should have an associated response"
|
|
});
|
|
}
|
|
const r2 = operation.request;
|
|
if (!urlIsHttpHttpsScheme(r2.url)) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: "expected http or https scheme"
|
|
});
|
|
}
|
|
if (r2.method !== "GET") {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: "not get method"
|
|
});
|
|
}
|
|
if (operation.options != null) {
|
|
throw webidl.errors.exception({
|
|
header: "Cache.#batchCacheOperations",
|
|
message: "options must not be defined"
|
|
});
|
|
}
|
|
requestResponses = this.#queryCache(operation.request);
|
|
for (const requestResponse of requestResponses) {
|
|
const idx = cache.indexOf(requestResponse);
|
|
assert(idx !== -1);
|
|
cache.splice(idx, 1);
|
|
}
|
|
cache.push([operation.request, operation.response]);
|
|
addedItems.push([operation.request, operation.response]);
|
|
}
|
|
resultList.push([operation.request, operation.response]);
|
|
}
|
|
return resultList;
|
|
} catch (e2) {
|
|
this.#relevantRequestResponseList.length = 0;
|
|
this.#relevantRequestResponseList = backupCache;
|
|
throw e2;
|
|
}
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#query-cache
|
|
* @param {any} requestQuery
|
|
* @param {import('../../types/cache').CacheQueryOptions} options
|
|
* @param {requestResponseList} targetStorage
|
|
* @returns {requestResponseList}
|
|
*/
|
|
#queryCache(requestQuery, options, targetStorage) {
|
|
const resultList = [];
|
|
const storage = targetStorage ?? this.#relevantRequestResponseList;
|
|
for (const requestResponse of storage) {
|
|
const [cachedRequest, cachedResponse] = requestResponse;
|
|
if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) {
|
|
resultList.push(requestResponse);
|
|
}
|
|
}
|
|
return resultList;
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
|
|
* @param {any} requestQuery
|
|
* @param {any} request
|
|
* @param {any | null} response
|
|
* @param {import('../../types/cache').CacheQueryOptions | undefined} options
|
|
* @returns {boolean}
|
|
*/
|
|
#requestMatchesCachedItem(requestQuery, request, response = null, options) {
|
|
const queryURL = new URL(requestQuery.url);
|
|
const cachedURL = new URL(request.url);
|
|
if (options?.ignoreSearch) {
|
|
cachedURL.search = "";
|
|
queryURL.search = "";
|
|
}
|
|
if (!urlEquals(queryURL, cachedURL, true)) {
|
|
return false;
|
|
}
|
|
if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) {
|
|
return true;
|
|
}
|
|
const fieldValues = getFieldValues(response.headersList.get("vary"));
|
|
for (const fieldValue of fieldValues) {
|
|
if (fieldValue === "*") {
|
|
return false;
|
|
}
|
|
const requestValue = request.headersList.get(fieldValue);
|
|
const queryValue = requestQuery.headersList.get(fieldValue);
|
|
if (requestValue !== queryValue) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
Object.defineProperties(Cache.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "Cache",
|
|
configurable: true
|
|
},
|
|
match: kEnumerableProperty,
|
|
matchAll: kEnumerableProperty,
|
|
add: kEnumerableProperty,
|
|
addAll: kEnumerableProperty,
|
|
put: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
keys: kEnumerableProperty
|
|
});
|
|
var cacheQueryOptionConverters = [
|
|
{
|
|
key: "ignoreSearch",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "ignoreMethod",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "ignoreVary",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
}
|
|
];
|
|
webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters);
|
|
webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
|
|
...cacheQueryOptionConverters,
|
|
{
|
|
key: "cacheName",
|
|
converter: webidl.converters.DOMString
|
|
}
|
|
]);
|
|
webidl.converters.Response = webidl.interfaceConverter(Response2);
|
|
webidl.converters["sequence<RequestInfo>"] = webidl.sequenceConverter(
|
|
webidl.converters.RequestInfo
|
|
);
|
|
module2.exports = {
|
|
Cache
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cache/cachestorage.js
|
|
var require_cachestorage = __commonJS({
|
|
"node_modules/undici/lib/cache/cachestorage.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kConstruct } = require_symbols4();
|
|
var { Cache } = require_cache();
|
|
var { webidl } = require_webidl();
|
|
var { kEnumerableProperty } = require_util();
|
|
var CacheStorage = class _CacheStorage {
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
|
|
* @type {Map<string, import('./cache').requestResponseList}
|
|
*/
|
|
#caches = /* @__PURE__ */ new Map();
|
|
constructor() {
|
|
if (arguments[0] !== kConstruct) {
|
|
webidl.illegalConstructor();
|
|
}
|
|
}
|
|
async match(request, options = {}) {
|
|
webidl.brandCheck(this, _CacheStorage);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.match" });
|
|
request = webidl.converters.RequestInfo(request);
|
|
options = webidl.converters.MultiCacheQueryOptions(options);
|
|
if (options.cacheName != null) {
|
|
if (this.#caches.has(options.cacheName)) {
|
|
const cacheList = this.#caches.get(options.cacheName);
|
|
const cache = new Cache(kConstruct, cacheList);
|
|
return await cache.match(request, options);
|
|
}
|
|
} else {
|
|
for (const cacheList of this.#caches.values()) {
|
|
const cache = new Cache(kConstruct, cacheList);
|
|
const response = await cache.match(request, options);
|
|
if (response !== void 0) {
|
|
return response;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-has
|
|
* @param {string} cacheName
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async has(cacheName) {
|
|
webidl.brandCheck(this, _CacheStorage);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" });
|
|
cacheName = webidl.converters.DOMString(cacheName);
|
|
return this.#caches.has(cacheName);
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
|
|
* @param {string} cacheName
|
|
* @returns {Promise<Cache>}
|
|
*/
|
|
async open(cacheName) {
|
|
webidl.brandCheck(this, _CacheStorage);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" });
|
|
cacheName = webidl.converters.DOMString(cacheName);
|
|
if (this.#caches.has(cacheName)) {
|
|
const cache2 = this.#caches.get(cacheName);
|
|
return new Cache(kConstruct, cache2);
|
|
}
|
|
const cache = [];
|
|
this.#caches.set(cacheName, cache);
|
|
return new Cache(kConstruct, cache);
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
|
|
* @param {string} cacheName
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async delete(cacheName) {
|
|
webidl.brandCheck(this, _CacheStorage);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" });
|
|
cacheName = webidl.converters.DOMString(cacheName);
|
|
return this.#caches.delete(cacheName);
|
|
}
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
|
|
* @returns {string[]}
|
|
*/
|
|
async keys() {
|
|
webidl.brandCheck(this, _CacheStorage);
|
|
const keys = this.#caches.keys();
|
|
return [...keys];
|
|
}
|
|
};
|
|
Object.defineProperties(CacheStorage.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "CacheStorage",
|
|
configurable: true
|
|
},
|
|
match: kEnumerableProperty,
|
|
has: kEnumerableProperty,
|
|
open: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
keys: kEnumerableProperty
|
|
});
|
|
module2.exports = {
|
|
CacheStorage
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cookies/constants.js
|
|
var require_constants4 = __commonJS({
|
|
"node_modules/undici/lib/cookies/constants.js"(exports2, module2) {
|
|
"use strict";
|
|
var maxAttributeValueSize = 1024;
|
|
var maxNameValuePairSize = 4096;
|
|
module2.exports = {
|
|
maxAttributeValueSize,
|
|
maxNameValuePairSize
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cookies/util.js
|
|
var require_util6 = __commonJS({
|
|
"node_modules/undici/lib/cookies/util.js"(exports2, module2) {
|
|
"use strict";
|
|
function isCTLExcludingHtab(value) {
|
|
if (value.length === 0) {
|
|
return false;
|
|
}
|
|
for (const char of value) {
|
|
const code = char.charCodeAt(0);
|
|
if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function validateCookieName(name) {
|
|
for (const char of name) {
|
|
const code = char.charCodeAt(0);
|
|
if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") {
|
|
throw new Error("Invalid cookie name");
|
|
}
|
|
}
|
|
}
|
|
function validateCookieValue(value) {
|
|
for (const char of value) {
|
|
const code = char.charCodeAt(0);
|
|
if (code < 33 || // exclude CTLs (0-31)
|
|
code === 34 || code === 44 || code === 59 || code === 92 || code > 126) {
|
|
throw new Error("Invalid header value");
|
|
}
|
|
}
|
|
}
|
|
function validateCookiePath(path3) {
|
|
for (const char of path3) {
|
|
const code = char.charCodeAt(0);
|
|
if (code < 33 || char === ";") {
|
|
throw new Error("Invalid cookie path");
|
|
}
|
|
}
|
|
}
|
|
function validateCookieDomain(domain) {
|
|
if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) {
|
|
throw new Error("Invalid cookie domain");
|
|
}
|
|
}
|
|
function toIMFDate(date) {
|
|
if (typeof date === "number") {
|
|
date = new Date(date);
|
|
}
|
|
const days = [
|
|
"Sun",
|
|
"Mon",
|
|
"Tue",
|
|
"Wed",
|
|
"Thu",
|
|
"Fri",
|
|
"Sat"
|
|
];
|
|
const months = [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec"
|
|
];
|
|
const dayName = days[date.getUTCDay()];
|
|
const day = date.getUTCDate().toString().padStart(2, "0");
|
|
const month = months[date.getUTCMonth()];
|
|
const year = date.getUTCFullYear();
|
|
const hour = date.getUTCHours().toString().padStart(2, "0");
|
|
const minute = date.getUTCMinutes().toString().padStart(2, "0");
|
|
const second = date.getUTCSeconds().toString().padStart(2, "0");
|
|
return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`;
|
|
}
|
|
function validateCookieMaxAge(maxAge) {
|
|
if (maxAge < 0) {
|
|
throw new Error("Invalid cookie max-age");
|
|
}
|
|
}
|
|
function stringify(cookie) {
|
|
if (cookie.name.length === 0) {
|
|
return null;
|
|
}
|
|
validateCookieName(cookie.name);
|
|
validateCookieValue(cookie.value);
|
|
const out = [`${cookie.name}=${cookie.value}`];
|
|
if (cookie.name.startsWith("__Secure-")) {
|
|
cookie.secure = true;
|
|
}
|
|
if (cookie.name.startsWith("__Host-")) {
|
|
cookie.secure = true;
|
|
cookie.domain = null;
|
|
cookie.path = "/";
|
|
}
|
|
if (cookie.secure) {
|
|
out.push("Secure");
|
|
}
|
|
if (cookie.httpOnly) {
|
|
out.push("HttpOnly");
|
|
}
|
|
if (typeof cookie.maxAge === "number") {
|
|
validateCookieMaxAge(cookie.maxAge);
|
|
out.push(`Max-Age=${cookie.maxAge}`);
|
|
}
|
|
if (cookie.domain) {
|
|
validateCookieDomain(cookie.domain);
|
|
out.push(`Domain=${cookie.domain}`);
|
|
}
|
|
if (cookie.path) {
|
|
validateCookiePath(cookie.path);
|
|
out.push(`Path=${cookie.path}`);
|
|
}
|
|
if (cookie.expires && cookie.expires.toString() !== "Invalid Date") {
|
|
out.push(`Expires=${toIMFDate(cookie.expires)}`);
|
|
}
|
|
if (cookie.sameSite) {
|
|
out.push(`SameSite=${cookie.sameSite}`);
|
|
}
|
|
for (const part of cookie.unparsed) {
|
|
if (!part.includes("=")) {
|
|
throw new Error("Invalid unparsed");
|
|
}
|
|
const [key, ...value] = part.split("=");
|
|
out.push(`${key.trim()}=${value.join("=")}`);
|
|
}
|
|
return out.join("; ");
|
|
}
|
|
module2.exports = {
|
|
isCTLExcludingHtab,
|
|
validateCookieName,
|
|
validateCookiePath,
|
|
validateCookieValue,
|
|
toIMFDate,
|
|
stringify
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cookies/parse.js
|
|
var require_parse = __commonJS({
|
|
"node_modules/undici/lib/cookies/parse.js"(exports2, module2) {
|
|
"use strict";
|
|
var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4();
|
|
var { isCTLExcludingHtab } = require_util6();
|
|
var { collectASequenceOfCodePointsFast } = require_dataURL();
|
|
var assert = require("assert");
|
|
function parseSetCookie(header) {
|
|
if (isCTLExcludingHtab(header)) {
|
|
return null;
|
|
}
|
|
let nameValuePair = "";
|
|
let unparsedAttributes = "";
|
|
let name = "";
|
|
let value = "";
|
|
if (header.includes(";")) {
|
|
const position = { position: 0 };
|
|
nameValuePair = collectASequenceOfCodePointsFast(";", header, position);
|
|
unparsedAttributes = header.slice(position.position);
|
|
} else {
|
|
nameValuePair = header;
|
|
}
|
|
if (!nameValuePair.includes("=")) {
|
|
value = nameValuePair;
|
|
} else {
|
|
const position = { position: 0 };
|
|
name = collectASequenceOfCodePointsFast(
|
|
"=",
|
|
nameValuePair,
|
|
position
|
|
);
|
|
value = nameValuePair.slice(position.position + 1);
|
|
}
|
|
name = name.trim();
|
|
value = value.trim();
|
|
if (name.length + value.length > maxNameValuePairSize) {
|
|
return null;
|
|
}
|
|
return {
|
|
name,
|
|
value,
|
|
...parseUnparsedAttributes(unparsedAttributes)
|
|
};
|
|
}
|
|
function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
|
|
if (unparsedAttributes.length === 0) {
|
|
return cookieAttributeList;
|
|
}
|
|
assert(unparsedAttributes[0] === ";");
|
|
unparsedAttributes = unparsedAttributes.slice(1);
|
|
let cookieAv = "";
|
|
if (unparsedAttributes.includes(";")) {
|
|
cookieAv = collectASequenceOfCodePointsFast(
|
|
";",
|
|
unparsedAttributes,
|
|
{ position: 0 }
|
|
);
|
|
unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
|
|
} else {
|
|
cookieAv = unparsedAttributes;
|
|
unparsedAttributes = "";
|
|
}
|
|
let attributeName = "";
|
|
let attributeValue = "";
|
|
if (cookieAv.includes("=")) {
|
|
const position = { position: 0 };
|
|
attributeName = collectASequenceOfCodePointsFast(
|
|
"=",
|
|
cookieAv,
|
|
position
|
|
);
|
|
attributeValue = cookieAv.slice(position.position + 1);
|
|
} else {
|
|
attributeName = cookieAv;
|
|
}
|
|
attributeName = attributeName.trim();
|
|
attributeValue = attributeValue.trim();
|
|
if (attributeValue.length > maxAttributeValueSize) {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
|
|
}
|
|
const attributeNameLowercase = attributeName.toLowerCase();
|
|
if (attributeNameLowercase === "expires") {
|
|
const expiryTime = new Date(attributeValue);
|
|
cookieAttributeList.expires = expiryTime;
|
|
} else if (attributeNameLowercase === "max-age") {
|
|
const charCode = attributeValue.charCodeAt(0);
|
|
if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
|
|
}
|
|
if (!/^\d+$/.test(attributeValue)) {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
|
|
}
|
|
const deltaSeconds = Number(attributeValue);
|
|
cookieAttributeList.maxAge = deltaSeconds;
|
|
} else if (attributeNameLowercase === "domain") {
|
|
let cookieDomain = attributeValue;
|
|
if (cookieDomain[0] === ".") {
|
|
cookieDomain = cookieDomain.slice(1);
|
|
}
|
|
cookieDomain = cookieDomain.toLowerCase();
|
|
cookieAttributeList.domain = cookieDomain;
|
|
} else if (attributeNameLowercase === "path") {
|
|
let cookiePath = "";
|
|
if (attributeValue.length === 0 || attributeValue[0] !== "/") {
|
|
cookiePath = "/";
|
|
} else {
|
|
cookiePath = attributeValue;
|
|
}
|
|
cookieAttributeList.path = cookiePath;
|
|
} else if (attributeNameLowercase === "secure") {
|
|
cookieAttributeList.secure = true;
|
|
} else if (attributeNameLowercase === "httponly") {
|
|
cookieAttributeList.httpOnly = true;
|
|
} else if (attributeNameLowercase === "samesite") {
|
|
let enforcement = "Default";
|
|
const attributeValueLowercase = attributeValue.toLowerCase();
|
|
if (attributeValueLowercase.includes("none")) {
|
|
enforcement = "None";
|
|
}
|
|
if (attributeValueLowercase.includes("strict")) {
|
|
enforcement = "Strict";
|
|
}
|
|
if (attributeValueLowercase.includes("lax")) {
|
|
enforcement = "Lax";
|
|
}
|
|
cookieAttributeList.sameSite = enforcement;
|
|
} else {
|
|
cookieAttributeList.unparsed ??= [];
|
|
cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
|
|
}
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
|
|
}
|
|
module2.exports = {
|
|
parseSetCookie,
|
|
parseUnparsedAttributes
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/cookies/index.js
|
|
var require_cookies = __commonJS({
|
|
"node_modules/undici/lib/cookies/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var { parseSetCookie } = require_parse();
|
|
var { stringify } = require_util6();
|
|
var { webidl } = require_webidl();
|
|
var { Headers: Headers2 } = require_headers();
|
|
function getCookies(headers) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" });
|
|
webidl.brandCheck(headers, Headers2, { strict: false });
|
|
const cookie = headers.get("cookie");
|
|
const out = {};
|
|
if (!cookie) {
|
|
return out;
|
|
}
|
|
for (const piece of cookie.split(";")) {
|
|
const [name, ...value] = piece.split("=");
|
|
out[name.trim()] = value.join("=");
|
|
}
|
|
return out;
|
|
}
|
|
function deleteCookie(headers, name, attributes) {
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" });
|
|
webidl.brandCheck(headers, Headers2, { strict: false });
|
|
name = webidl.converters.DOMString(name);
|
|
attributes = webidl.converters.DeleteCookieAttributes(attributes);
|
|
setCookie(headers, {
|
|
name,
|
|
value: "",
|
|
expires: /* @__PURE__ */ new Date(0),
|
|
...attributes
|
|
});
|
|
}
|
|
function getSetCookies(headers) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" });
|
|
webidl.brandCheck(headers, Headers2, { strict: false });
|
|
const cookies = headers.getSetCookie();
|
|
if (!cookies) {
|
|
return [];
|
|
}
|
|
return cookies.map((pair) => parseSetCookie(pair));
|
|
}
|
|
function setCookie(headers, cookie) {
|
|
webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" });
|
|
webidl.brandCheck(headers, Headers2, { strict: false });
|
|
cookie = webidl.converters.Cookie(cookie);
|
|
const str = stringify(cookie);
|
|
if (str) {
|
|
headers.append("Set-Cookie", stringify(cookie));
|
|
}
|
|
}
|
|
webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.DOMString),
|
|
key: "path",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.DOMString),
|
|
key: "domain",
|
|
defaultValue: null
|
|
}
|
|
]);
|
|
webidl.converters.Cookie = webidl.dictionaryConverter([
|
|
{
|
|
converter: webidl.converters.DOMString,
|
|
key: "name"
|
|
},
|
|
{
|
|
converter: webidl.converters.DOMString,
|
|
key: "value"
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter((value) => {
|
|
if (typeof value === "number") {
|
|
return webidl.converters["unsigned long long"](value);
|
|
}
|
|
return new Date(value);
|
|
}),
|
|
key: "expires",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters["long long"]),
|
|
key: "maxAge",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.DOMString),
|
|
key: "domain",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.DOMString),
|
|
key: "path",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.boolean),
|
|
key: "secure",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.nullableConverter(webidl.converters.boolean),
|
|
key: "httpOnly",
|
|
defaultValue: null
|
|
},
|
|
{
|
|
converter: webidl.converters.USVString,
|
|
key: "sameSite",
|
|
allowedValues: ["Strict", "Lax", "None"]
|
|
},
|
|
{
|
|
converter: webidl.sequenceConverter(webidl.converters.DOMString),
|
|
key: "unparsed",
|
|
defaultValue: []
|
|
}
|
|
]);
|
|
module2.exports = {
|
|
getCookies,
|
|
deleteCookie,
|
|
getSetCookies,
|
|
setCookie
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/constants.js
|
|
var require_constants5 = __commonJS({
|
|
"node_modules/undici/lib/websocket/constants.js"(exports2, module2) {
|
|
"use strict";
|
|
var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
|
var staticPropertyDescriptors = {
|
|
enumerable: true,
|
|
writable: false,
|
|
configurable: false
|
|
};
|
|
var states = {
|
|
CONNECTING: 0,
|
|
OPEN: 1,
|
|
CLOSING: 2,
|
|
CLOSED: 3
|
|
};
|
|
var opcodes = {
|
|
CONTINUATION: 0,
|
|
TEXT: 1,
|
|
BINARY: 2,
|
|
CLOSE: 8,
|
|
PING: 9,
|
|
PONG: 10
|
|
};
|
|
var maxUnsigned16Bit = 2 ** 16 - 1;
|
|
var parserStates = {
|
|
INFO: 0,
|
|
PAYLOADLENGTH_16: 2,
|
|
PAYLOADLENGTH_64: 3,
|
|
READ_DATA: 4
|
|
};
|
|
var emptyBuffer = Buffer.allocUnsafe(0);
|
|
module2.exports = {
|
|
uid,
|
|
staticPropertyDescriptors,
|
|
states,
|
|
opcodes,
|
|
maxUnsigned16Bit,
|
|
parserStates,
|
|
emptyBuffer
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/symbols.js
|
|
var require_symbols5 = __commonJS({
|
|
"node_modules/undici/lib/websocket/symbols.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = {
|
|
kWebSocketURL: Symbol("url"),
|
|
kReadyState: Symbol("ready state"),
|
|
kController: Symbol("controller"),
|
|
kResponse: Symbol("response"),
|
|
kBinaryType: Symbol("binary type"),
|
|
kSentClose: Symbol("sent close"),
|
|
kReceivedClose: Symbol("received close"),
|
|
kByteParser: Symbol("byte parser")
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/events.js
|
|
var require_events = __commonJS({
|
|
"node_modules/undici/lib/websocket/events.js"(exports2, module2) {
|
|
"use strict";
|
|
var { webidl } = require_webidl();
|
|
var { kEnumerableProperty } = require_util();
|
|
var { MessagePort } = require("worker_threads");
|
|
var MessageEvent = class _MessageEvent extends Event {
|
|
#eventInit;
|
|
constructor(type, eventInitDict = {}) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
|
|
type = webidl.converters.DOMString(type);
|
|
eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
|
|
super(type, eventInitDict);
|
|
this.#eventInit = eventInitDict;
|
|
}
|
|
get data() {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
return this.#eventInit.data;
|
|
}
|
|
get origin() {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
return this.#eventInit.origin;
|
|
}
|
|
get lastEventId() {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
return this.#eventInit.lastEventId;
|
|
}
|
|
get source() {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
return this.#eventInit.source;
|
|
}
|
|
get ports() {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
if (!Object.isFrozen(this.#eventInit.ports)) {
|
|
Object.freeze(this.#eventInit.ports);
|
|
}
|
|
return this.#eventInit.ports;
|
|
}
|
|
initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) {
|
|
webidl.brandCheck(this, _MessageEvent);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
|
|
return new _MessageEvent(type, {
|
|
bubbles,
|
|
cancelable,
|
|
data,
|
|
origin,
|
|
lastEventId,
|
|
source,
|
|
ports
|
|
});
|
|
}
|
|
};
|
|
var CloseEvent = class _CloseEvent extends Event {
|
|
#eventInit;
|
|
constructor(type, eventInitDict = {}) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
|
|
type = webidl.converters.DOMString(type);
|
|
eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
|
|
super(type, eventInitDict);
|
|
this.#eventInit = eventInitDict;
|
|
}
|
|
get wasClean() {
|
|
webidl.brandCheck(this, _CloseEvent);
|
|
return this.#eventInit.wasClean;
|
|
}
|
|
get code() {
|
|
webidl.brandCheck(this, _CloseEvent);
|
|
return this.#eventInit.code;
|
|
}
|
|
get reason() {
|
|
webidl.brandCheck(this, _CloseEvent);
|
|
return this.#eventInit.reason;
|
|
}
|
|
};
|
|
var ErrorEvent = class _ErrorEvent extends Event {
|
|
#eventInit;
|
|
constructor(type, eventInitDict) {
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
|
|
super(type, eventInitDict);
|
|
type = webidl.converters.DOMString(type);
|
|
eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
|
|
this.#eventInit = eventInitDict;
|
|
}
|
|
get message() {
|
|
webidl.brandCheck(this, _ErrorEvent);
|
|
return this.#eventInit.message;
|
|
}
|
|
get filename() {
|
|
webidl.brandCheck(this, _ErrorEvent);
|
|
return this.#eventInit.filename;
|
|
}
|
|
get lineno() {
|
|
webidl.brandCheck(this, _ErrorEvent);
|
|
return this.#eventInit.lineno;
|
|
}
|
|
get colno() {
|
|
webidl.brandCheck(this, _ErrorEvent);
|
|
return this.#eventInit.colno;
|
|
}
|
|
get error() {
|
|
webidl.brandCheck(this, _ErrorEvent);
|
|
return this.#eventInit.error;
|
|
}
|
|
};
|
|
Object.defineProperties(MessageEvent.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "MessageEvent",
|
|
configurable: true
|
|
},
|
|
data: kEnumerableProperty,
|
|
origin: kEnumerableProperty,
|
|
lastEventId: kEnumerableProperty,
|
|
source: kEnumerableProperty,
|
|
ports: kEnumerableProperty,
|
|
initMessageEvent: kEnumerableProperty
|
|
});
|
|
Object.defineProperties(CloseEvent.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "CloseEvent",
|
|
configurable: true
|
|
},
|
|
reason: kEnumerableProperty,
|
|
code: kEnumerableProperty,
|
|
wasClean: kEnumerableProperty
|
|
});
|
|
Object.defineProperties(ErrorEvent.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: "ErrorEvent",
|
|
configurable: true
|
|
},
|
|
message: kEnumerableProperty,
|
|
filename: kEnumerableProperty,
|
|
lineno: kEnumerableProperty,
|
|
colno: kEnumerableProperty,
|
|
error: kEnumerableProperty
|
|
});
|
|
webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
|
|
webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(
|
|
webidl.converters.MessagePort
|
|
);
|
|
var eventInit = [
|
|
{
|
|
key: "bubbles",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "cancelable",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "composed",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
}
|
|
];
|
|
webidl.converters.MessageEventInit = webidl.dictionaryConverter([
|
|
...eventInit,
|
|
{
|
|
key: "data",
|
|
converter: webidl.converters.any,
|
|
defaultValue: null
|
|
},
|
|
{
|
|
key: "origin",
|
|
converter: webidl.converters.USVString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "lastEventId",
|
|
converter: webidl.converters.DOMString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "source",
|
|
// Node doesn't implement WindowProxy or ServiceWorker, so the only
|
|
// valid value for source is a MessagePort.
|
|
converter: webidl.nullableConverter(webidl.converters.MessagePort),
|
|
defaultValue: null
|
|
},
|
|
{
|
|
key: "ports",
|
|
converter: webidl.converters["sequence<MessagePort>"],
|
|
get defaultValue() {
|
|
return [];
|
|
}
|
|
}
|
|
]);
|
|
webidl.converters.CloseEventInit = webidl.dictionaryConverter([
|
|
...eventInit,
|
|
{
|
|
key: "wasClean",
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: false
|
|
},
|
|
{
|
|
key: "code",
|
|
converter: webidl.converters["unsigned short"],
|
|
defaultValue: 0
|
|
},
|
|
{
|
|
key: "reason",
|
|
converter: webidl.converters.USVString,
|
|
defaultValue: ""
|
|
}
|
|
]);
|
|
webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
|
|
...eventInit,
|
|
{
|
|
key: "message",
|
|
converter: webidl.converters.DOMString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "filename",
|
|
converter: webidl.converters.USVString,
|
|
defaultValue: ""
|
|
},
|
|
{
|
|
key: "lineno",
|
|
converter: webidl.converters["unsigned long"],
|
|
defaultValue: 0
|
|
},
|
|
{
|
|
key: "colno",
|
|
converter: webidl.converters["unsigned long"],
|
|
defaultValue: 0
|
|
},
|
|
{
|
|
key: "error",
|
|
converter: webidl.converters.any
|
|
}
|
|
]);
|
|
module2.exports = {
|
|
MessageEvent,
|
|
CloseEvent,
|
|
ErrorEvent
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/util.js
|
|
var require_util7 = __commonJS({
|
|
"node_modules/undici/lib/websocket/util.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5();
|
|
var { states, opcodes } = require_constants5();
|
|
var { MessageEvent, ErrorEvent } = require_events();
|
|
function isEstablished(ws) {
|
|
return ws[kReadyState] === states.OPEN;
|
|
}
|
|
function isClosing(ws) {
|
|
return ws[kReadyState] === states.CLOSING;
|
|
}
|
|
function isClosed(ws) {
|
|
return ws[kReadyState] === states.CLOSED;
|
|
}
|
|
function fireEvent(e2, target, eventConstructor = Event, eventInitDict) {
|
|
const event = new eventConstructor(e2, eventInitDict);
|
|
target.dispatchEvent(event);
|
|
}
|
|
function websocketMessageReceived(ws, type, data) {
|
|
if (ws[kReadyState] !== states.OPEN) {
|
|
return;
|
|
}
|
|
let dataForEvent;
|
|
if (type === opcodes.TEXT) {
|
|
try {
|
|
dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
|
|
} catch {
|
|
failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
|
|
return;
|
|
}
|
|
} else if (type === opcodes.BINARY) {
|
|
if (ws[kBinaryType] === "blob") {
|
|
dataForEvent = new Blob([data]);
|
|
} else {
|
|
dataForEvent = new Uint8Array(data).buffer;
|
|
}
|
|
}
|
|
fireEvent("message", ws, MessageEvent, {
|
|
origin: ws[kWebSocketURL].origin,
|
|
data: dataForEvent
|
|
});
|
|
}
|
|
function isValidSubprotocol(protocol) {
|
|
if (protocol.length === 0) {
|
|
return false;
|
|
}
|
|
for (const char of protocol) {
|
|
const code = char.charCodeAt(0);
|
|
if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
|
|
code === 9) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isValidStatusCode(code) {
|
|
if (code >= 1e3 && code < 1015) {
|
|
return code !== 1004 && // reserved
|
|
code !== 1005 && // "MUST NOT be set as a status code"
|
|
code !== 1006;
|
|
}
|
|
return code >= 3e3 && code <= 4999;
|
|
}
|
|
function failWebsocketConnection(ws, reason) {
|
|
const { [kController]: controller, [kResponse]: response } = ws;
|
|
controller.abort();
|
|
if (response?.socket && !response.socket.destroyed) {
|
|
response.socket.destroy();
|
|
}
|
|
if (reason) {
|
|
fireEvent("error", ws, ErrorEvent, {
|
|
error: new Error(reason)
|
|
});
|
|
}
|
|
}
|
|
module2.exports = {
|
|
isEstablished,
|
|
isClosing,
|
|
isClosed,
|
|
fireEvent,
|
|
isValidSubprotocol,
|
|
isValidStatusCode,
|
|
failWebsocketConnection,
|
|
websocketMessageReceived
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/connection.js
|
|
var require_connection = __commonJS({
|
|
"node_modules/undici/lib/websocket/connection.js"(exports2, module2) {
|
|
"use strict";
|
|
var diagnosticsChannel = require("diagnostics_channel");
|
|
var { uid, states } = require_constants5();
|
|
var {
|
|
kReadyState,
|
|
kSentClose,
|
|
kByteParser,
|
|
kReceivedClose
|
|
} = require_symbols5();
|
|
var { fireEvent, failWebsocketConnection } = require_util7();
|
|
var { CloseEvent } = require_events();
|
|
var { makeRequest } = require_request2();
|
|
var { fetching } = require_fetch();
|
|
var { Headers: Headers2 } = require_headers();
|
|
var { getGlobalDispatcher } = require_global2();
|
|
var { kHeadersList } = require_symbols();
|
|
var channels = {};
|
|
channels.open = diagnosticsChannel.channel("undici:websocket:open");
|
|
channels.close = diagnosticsChannel.channel("undici:websocket:close");
|
|
channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
|
|
var crypto;
|
|
try {
|
|
crypto = require("crypto");
|
|
} catch {
|
|
}
|
|
function establishWebSocketConnection(url, protocols, ws, onEstablish, options) {
|
|
const requestURL = url;
|
|
requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
|
|
const request = makeRequest({
|
|
urlList: [requestURL],
|
|
serviceWorkers: "none",
|
|
referrer: "no-referrer",
|
|
mode: "websocket",
|
|
credentials: "include",
|
|
cache: "no-store",
|
|
redirect: "error"
|
|
});
|
|
if (options.headers) {
|
|
const headersList = new Headers2(options.headers)[kHeadersList];
|
|
request.headersList = headersList;
|
|
}
|
|
const keyValue = crypto.randomBytes(16).toString("base64");
|
|
request.headersList.append("sec-websocket-key", keyValue);
|
|
request.headersList.append("sec-websocket-version", "13");
|
|
for (const protocol of protocols) {
|
|
request.headersList.append("sec-websocket-protocol", protocol);
|
|
}
|
|
const permessageDeflate = "";
|
|
const controller = fetching({
|
|
request,
|
|
useParallelQueue: true,
|
|
dispatcher: options.dispatcher ?? getGlobalDispatcher(),
|
|
processResponse(response) {
|
|
if (response.type === "error" || response.status !== 101) {
|
|
failWebsocketConnection(ws, "Received network error or non-101 status code.");
|
|
return;
|
|
}
|
|
if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
|
|
failWebsocketConnection(ws, "Server did not respond with sent protocols.");
|
|
return;
|
|
}
|
|
if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
|
|
failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
|
|
return;
|
|
}
|
|
if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
|
|
failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
|
|
return;
|
|
}
|
|
const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
|
|
const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64");
|
|
if (secWSAccept !== digest) {
|
|
failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
|
|
return;
|
|
}
|
|
const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
|
|
if (secExtension !== null && secExtension !== permessageDeflate) {
|
|
failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
|
|
return;
|
|
}
|
|
const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
|
|
if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) {
|
|
failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
|
|
return;
|
|
}
|
|
response.socket.on("data", onSocketData);
|
|
response.socket.on("close", onSocketClose);
|
|
response.socket.on("error", onSocketError);
|
|
if (channels.open.hasSubscribers) {
|
|
channels.open.publish({
|
|
address: response.socket.address(),
|
|
protocol: secProtocol,
|
|
extensions: secExtension
|
|
});
|
|
}
|
|
onEstablish(response);
|
|
}
|
|
});
|
|
return controller;
|
|
}
|
|
function onSocketData(chunk) {
|
|
if (!this.ws[kByteParser].write(chunk)) {
|
|
this.pause();
|
|
}
|
|
}
|
|
function onSocketClose() {
|
|
const { ws } = this;
|
|
const wasClean = ws[kSentClose] && ws[kReceivedClose];
|
|
let code = 1005;
|
|
let reason = "";
|
|
const result = ws[kByteParser].closingInfo;
|
|
if (result) {
|
|
code = result.code ?? 1005;
|
|
reason = result.reason;
|
|
} else if (!ws[kSentClose]) {
|
|
code = 1006;
|
|
}
|
|
ws[kReadyState] = states.CLOSED;
|
|
fireEvent("close", ws, CloseEvent, {
|
|
wasClean,
|
|
code,
|
|
reason
|
|
});
|
|
if (channels.close.hasSubscribers) {
|
|
channels.close.publish({
|
|
websocket: ws,
|
|
code,
|
|
reason
|
|
});
|
|
}
|
|
}
|
|
function onSocketError(error) {
|
|
const { ws } = this;
|
|
ws[kReadyState] = states.CLOSING;
|
|
if (channels.socketError.hasSubscribers) {
|
|
channels.socketError.publish(error);
|
|
}
|
|
this.destroy();
|
|
}
|
|
module2.exports = {
|
|
establishWebSocketConnection
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/frame.js
|
|
var require_frame = __commonJS({
|
|
"node_modules/undici/lib/websocket/frame.js"(exports2, module2) {
|
|
"use strict";
|
|
var { maxUnsigned16Bit } = require_constants5();
|
|
var crypto;
|
|
try {
|
|
crypto = require("crypto");
|
|
} catch {
|
|
}
|
|
var WebsocketFrameSend = class {
|
|
/**
|
|
* @param {Buffer|undefined} data
|
|
*/
|
|
constructor(data) {
|
|
this.frameData = data;
|
|
this.maskKey = crypto.randomBytes(4);
|
|
}
|
|
createFrame(opcode) {
|
|
const bodyLength = this.frameData?.byteLength ?? 0;
|
|
let payloadLength = bodyLength;
|
|
let offset = 6;
|
|
if (bodyLength > maxUnsigned16Bit) {
|
|
offset += 8;
|
|
payloadLength = 127;
|
|
} else if (bodyLength > 125) {
|
|
offset += 2;
|
|
payloadLength = 126;
|
|
}
|
|
const buffer = Buffer.allocUnsafe(bodyLength + offset);
|
|
buffer[0] = buffer[1] = 0;
|
|
buffer[0] |= 128;
|
|
buffer[0] = (buffer[0] & 240) + opcode;
|
|
buffer[offset - 4] = this.maskKey[0];
|
|
buffer[offset - 3] = this.maskKey[1];
|
|
buffer[offset - 2] = this.maskKey[2];
|
|
buffer[offset - 1] = this.maskKey[3];
|
|
buffer[1] = payloadLength;
|
|
if (payloadLength === 126) {
|
|
buffer.writeUInt16BE(bodyLength, 2);
|
|
} else if (payloadLength === 127) {
|
|
buffer[2] = buffer[3] = 0;
|
|
buffer.writeUIntBE(bodyLength, 4, 6);
|
|
}
|
|
buffer[1] |= 128;
|
|
for (let i2 = 0; i2 < bodyLength; i2++) {
|
|
buffer[offset + i2] = this.frameData[i2] ^ this.maskKey[i2 % 4];
|
|
}
|
|
return buffer;
|
|
}
|
|
};
|
|
module2.exports = {
|
|
WebsocketFrameSend
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/receiver.js
|
|
var require_receiver = __commonJS({
|
|
"node_modules/undici/lib/websocket/receiver.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Writable } = require("stream");
|
|
var diagnosticsChannel = require("diagnostics_channel");
|
|
var { parserStates, opcodes, states, emptyBuffer } = require_constants5();
|
|
var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5();
|
|
var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7();
|
|
var { WebsocketFrameSend } = require_frame();
|
|
var channels = {};
|
|
channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
|
|
channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
|
|
var ByteParser = class extends Writable {
|
|
#buffers = [];
|
|
#byteOffset = 0;
|
|
#state = parserStates.INFO;
|
|
#info = {};
|
|
#fragments = [];
|
|
constructor(ws) {
|
|
super();
|
|
this.ws = ws;
|
|
}
|
|
/**
|
|
* @param {Buffer} chunk
|
|
* @param {() => void} callback
|
|
*/
|
|
_write(chunk, _, callback) {
|
|
this.#buffers.push(chunk);
|
|
this.#byteOffset += chunk.length;
|
|
this.run(callback);
|
|
}
|
|
/**
|
|
* Runs whenever a new chunk is received.
|
|
* Callback is called whenever there are no more chunks buffering,
|
|
* or not enough bytes are buffered to parse.
|
|
*/
|
|
run(callback) {
|
|
while (true) {
|
|
if (this.#state === parserStates.INFO) {
|
|
if (this.#byteOffset < 2) {
|
|
return callback();
|
|
}
|
|
const buffer = this.consume(2);
|
|
this.#info.fin = (buffer[0] & 128) !== 0;
|
|
this.#info.opcode = buffer[0] & 15;
|
|
this.#info.originalOpcode ??= this.#info.opcode;
|
|
this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
|
|
if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
|
|
failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
|
|
return;
|
|
}
|
|
const payloadLength = buffer[1] & 127;
|
|
if (payloadLength <= 125) {
|
|
this.#info.payloadLength = payloadLength;
|
|
this.#state = parserStates.READ_DATA;
|
|
} else if (payloadLength === 126) {
|
|
this.#state = parserStates.PAYLOADLENGTH_16;
|
|
} else if (payloadLength === 127) {
|
|
this.#state = parserStates.PAYLOADLENGTH_64;
|
|
}
|
|
if (this.#info.fragmented && payloadLength > 125) {
|
|
failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
|
|
return;
|
|
} else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
|
|
failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
|
|
return;
|
|
} else if (this.#info.opcode === opcodes.CLOSE) {
|
|
if (payloadLength === 1) {
|
|
failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
|
|
return;
|
|
}
|
|
const body = this.consume(payloadLength);
|
|
this.#info.closeInfo = this.parseCloseBody(false, body);
|
|
if (!this.ws[kSentClose]) {
|
|
const body2 = Buffer.allocUnsafe(2);
|
|
body2.writeUInt16BE(this.#info.closeInfo.code, 0);
|
|
const closeFrame = new WebsocketFrameSend(body2);
|
|
this.ws[kResponse].socket.write(
|
|
closeFrame.createFrame(opcodes.CLOSE),
|
|
(err) => {
|
|
if (!err) {
|
|
this.ws[kSentClose] = true;
|
|
}
|
|
}
|
|
);
|
|
}
|
|
this.ws[kReadyState] = states.CLOSING;
|
|
this.ws[kReceivedClose] = true;
|
|
this.end();
|
|
return;
|
|
} else if (this.#info.opcode === opcodes.PING) {
|
|
const body = this.consume(payloadLength);
|
|
if (!this.ws[kReceivedClose]) {
|
|
const frame = new WebsocketFrameSend(body);
|
|
this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
|
|
if (channels.ping.hasSubscribers) {
|
|
channels.ping.publish({
|
|
payload: body
|
|
});
|
|
}
|
|
}
|
|
this.#state = parserStates.INFO;
|
|
if (this.#byteOffset > 0) {
|
|
continue;
|
|
} else {
|
|
callback();
|
|
return;
|
|
}
|
|
} else if (this.#info.opcode === opcodes.PONG) {
|
|
const body = this.consume(payloadLength);
|
|
if (channels.pong.hasSubscribers) {
|
|
channels.pong.publish({
|
|
payload: body
|
|
});
|
|
}
|
|
if (this.#byteOffset > 0) {
|
|
continue;
|
|
} else {
|
|
callback();
|
|
return;
|
|
}
|
|
}
|
|
} else if (this.#state === parserStates.PAYLOADLENGTH_16) {
|
|
if (this.#byteOffset < 2) {
|
|
return callback();
|
|
}
|
|
const buffer = this.consume(2);
|
|
this.#info.payloadLength = buffer.readUInt16BE(0);
|
|
this.#state = parserStates.READ_DATA;
|
|
} else if (this.#state === parserStates.PAYLOADLENGTH_64) {
|
|
if (this.#byteOffset < 8) {
|
|
return callback();
|
|
}
|
|
const buffer = this.consume(8);
|
|
const upper = buffer.readUInt32BE(0);
|
|
if (upper > 2 ** 31 - 1) {
|
|
failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
|
|
return;
|
|
}
|
|
const lower2 = buffer.readUInt32BE(4);
|
|
this.#info.payloadLength = (upper << 8) + lower2;
|
|
this.#state = parserStates.READ_DATA;
|
|
} else if (this.#state === parserStates.READ_DATA) {
|
|
if (this.#byteOffset < this.#info.payloadLength) {
|
|
return callback();
|
|
} else if (this.#byteOffset >= this.#info.payloadLength) {
|
|
const body = this.consume(this.#info.payloadLength);
|
|
this.#fragments.push(body);
|
|
if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
|
|
const fullMessage = Buffer.concat(this.#fragments);
|
|
websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
|
|
this.#info = {};
|
|
this.#fragments.length = 0;
|
|
}
|
|
this.#state = parserStates.INFO;
|
|
}
|
|
}
|
|
if (this.#byteOffset > 0) {
|
|
continue;
|
|
} else {
|
|
callback();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Take n bytes from the buffered Buffers
|
|
* @param {number} n
|
|
* @returns {Buffer|null}
|
|
*/
|
|
consume(n) {
|
|
if (n > this.#byteOffset) {
|
|
return null;
|
|
} else if (n === 0) {
|
|
return emptyBuffer;
|
|
}
|
|
if (this.#buffers[0].length === n) {
|
|
this.#byteOffset -= this.#buffers[0].length;
|
|
return this.#buffers.shift();
|
|
}
|
|
const buffer = Buffer.allocUnsafe(n);
|
|
let offset = 0;
|
|
while (offset !== n) {
|
|
const next = this.#buffers[0];
|
|
const { length } = next;
|
|
if (length + offset === n) {
|
|
buffer.set(this.#buffers.shift(), offset);
|
|
break;
|
|
} else if (length + offset > n) {
|
|
buffer.set(next.subarray(0, n - offset), offset);
|
|
this.#buffers[0] = next.subarray(n - offset);
|
|
break;
|
|
} else {
|
|
buffer.set(this.#buffers.shift(), offset);
|
|
offset += next.length;
|
|
}
|
|
}
|
|
this.#byteOffset -= n;
|
|
return buffer;
|
|
}
|
|
parseCloseBody(onlyCode, data) {
|
|
let code;
|
|
if (data.length >= 2) {
|
|
code = data.readUInt16BE(0);
|
|
}
|
|
if (onlyCode) {
|
|
if (!isValidStatusCode(code)) {
|
|
return null;
|
|
}
|
|
return { code };
|
|
}
|
|
let reason = data.subarray(2);
|
|
if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
|
|
reason = reason.subarray(3);
|
|
}
|
|
if (code !== void 0 && !isValidStatusCode(code)) {
|
|
return null;
|
|
}
|
|
try {
|
|
reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
|
|
} catch {
|
|
return null;
|
|
}
|
|
return { code, reason };
|
|
}
|
|
get closingInfo() {
|
|
return this.#info.closeInfo;
|
|
}
|
|
};
|
|
module2.exports = {
|
|
ByteParser
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/lib/websocket/websocket.js
|
|
var require_websocket = __commonJS({
|
|
"node_modules/undici/lib/websocket/websocket.js"(exports2, module2) {
|
|
"use strict";
|
|
var { webidl } = require_webidl();
|
|
var { DOMException: DOMException3 } = require_constants2();
|
|
var { URLSerializer } = require_dataURL();
|
|
var { getGlobalOrigin } = require_global();
|
|
var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants5();
|
|
var {
|
|
kWebSocketURL,
|
|
kReadyState,
|
|
kController,
|
|
kBinaryType,
|
|
kResponse,
|
|
kSentClose,
|
|
kByteParser
|
|
} = require_symbols5();
|
|
var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7();
|
|
var { establishWebSocketConnection } = require_connection();
|
|
var { WebsocketFrameSend } = require_frame();
|
|
var { ByteParser } = require_receiver();
|
|
var { kEnumerableProperty, isBlobLike } = require_util();
|
|
var { getGlobalDispatcher } = require_global2();
|
|
var { types: types3 } = require("util");
|
|
var experimentalWarned = false;
|
|
var WebSocket = class _WebSocket extends EventTarget {
|
|
#events = {
|
|
open: null,
|
|
error: null,
|
|
close: null,
|
|
message: null
|
|
};
|
|
#bufferedAmount = 0;
|
|
#protocol = "";
|
|
#extensions = "";
|
|
/**
|
|
* @param {string} url
|
|
* @param {string|string[]} protocols
|
|
*/
|
|
constructor(url, protocols = []) {
|
|
super();
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
|
|
if (!experimentalWarned) {
|
|
experimentalWarned = true;
|
|
process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
|
|
code: "UNDICI-WS"
|
|
});
|
|
}
|
|
const options = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols);
|
|
url = webidl.converters.USVString(url);
|
|
protocols = options.protocols;
|
|
const baseURL = getGlobalOrigin();
|
|
let urlRecord;
|
|
try {
|
|
urlRecord = new URL(url, baseURL);
|
|
} catch (e2) {
|
|
throw new DOMException3(e2, "SyntaxError");
|
|
}
|
|
if (urlRecord.protocol === "http:") {
|
|
urlRecord.protocol = "ws:";
|
|
} else if (urlRecord.protocol === "https:") {
|
|
urlRecord.protocol = "wss:";
|
|
}
|
|
if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
|
|
throw new DOMException3(
|
|
`Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
|
|
"SyntaxError"
|
|
);
|
|
}
|
|
if (urlRecord.hash || urlRecord.href.endsWith("#")) {
|
|
throw new DOMException3("Got fragment", "SyntaxError");
|
|
}
|
|
if (typeof protocols === "string") {
|
|
protocols = [protocols];
|
|
}
|
|
if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) {
|
|
throw new DOMException3("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
|
|
}
|
|
if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) {
|
|
throw new DOMException3("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
|
|
}
|
|
this[kWebSocketURL] = new URL(urlRecord.href);
|
|
this[kController] = establishWebSocketConnection(
|
|
urlRecord,
|
|
protocols,
|
|
this,
|
|
(response) => this.#onConnectionEstablished(response),
|
|
options
|
|
);
|
|
this[kReadyState] = _WebSocket.CONNECTING;
|
|
this[kBinaryType] = "blob";
|
|
}
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#dom-websocket-close
|
|
* @param {number|undefined} code
|
|
* @param {string|undefined} reason
|
|
*/
|
|
close(code = void 0, reason = void 0) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (code !== void 0) {
|
|
code = webidl.converters["unsigned short"](code, { clamp: true });
|
|
}
|
|
if (reason !== void 0) {
|
|
reason = webidl.converters.USVString(reason);
|
|
}
|
|
if (code !== void 0) {
|
|
if (code !== 1e3 && (code < 3e3 || code > 4999)) {
|
|
throw new DOMException3("invalid code", "InvalidAccessError");
|
|
}
|
|
}
|
|
let reasonByteLength = 0;
|
|
if (reason !== void 0) {
|
|
reasonByteLength = Buffer.byteLength(reason);
|
|
if (reasonByteLength > 123) {
|
|
throw new DOMException3(
|
|
`Reason must be less than 123 bytes; received ${reasonByteLength}`,
|
|
"SyntaxError"
|
|
);
|
|
}
|
|
}
|
|
if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) {
|
|
} else if (!isEstablished(this)) {
|
|
failWebsocketConnection(this, "Connection was closed before it was established.");
|
|
this[kReadyState] = _WebSocket.CLOSING;
|
|
} else if (!isClosing(this)) {
|
|
const frame = new WebsocketFrameSend();
|
|
if (code !== void 0 && reason === void 0) {
|
|
frame.frameData = Buffer.allocUnsafe(2);
|
|
frame.frameData.writeUInt16BE(code, 0);
|
|
} else if (code !== void 0 && reason !== void 0) {
|
|
frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
|
|
frame.frameData.writeUInt16BE(code, 0);
|
|
frame.frameData.write(reason, 2, "utf-8");
|
|
} else {
|
|
frame.frameData = emptyBuffer;
|
|
}
|
|
const socket = this[kResponse].socket;
|
|
socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
|
|
if (!err) {
|
|
this[kSentClose] = true;
|
|
}
|
|
});
|
|
this[kReadyState] = states.CLOSING;
|
|
} else {
|
|
this[kReadyState] = _WebSocket.CLOSING;
|
|
}
|
|
}
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#dom-websocket-send
|
|
* @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
|
|
*/
|
|
send(data) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
|
|
data = webidl.converters.WebSocketSendData(data);
|
|
if (this[kReadyState] === _WebSocket.CONNECTING) {
|
|
throw new DOMException3("Sent before connected.", "InvalidStateError");
|
|
}
|
|
if (!isEstablished(this) || isClosing(this)) {
|
|
return;
|
|
}
|
|
const socket = this[kResponse].socket;
|
|
if (typeof data === "string") {
|
|
const value = Buffer.from(data);
|
|
const frame = new WebsocketFrameSend(value);
|
|
const buffer = frame.createFrame(opcodes.TEXT);
|
|
this.#bufferedAmount += value.byteLength;
|
|
socket.write(buffer, () => {
|
|
this.#bufferedAmount -= value.byteLength;
|
|
});
|
|
} else if (types3.isArrayBuffer(data)) {
|
|
const value = Buffer.from(data);
|
|
const frame = new WebsocketFrameSend(value);
|
|
const buffer = frame.createFrame(opcodes.BINARY);
|
|
this.#bufferedAmount += value.byteLength;
|
|
socket.write(buffer, () => {
|
|
this.#bufferedAmount -= value.byteLength;
|
|
});
|
|
} else if (ArrayBuffer.isView(data)) {
|
|
const ab = Buffer.from(data, data.byteOffset, data.byteLength);
|
|
const frame = new WebsocketFrameSend(ab);
|
|
const buffer = frame.createFrame(opcodes.BINARY);
|
|
this.#bufferedAmount += ab.byteLength;
|
|
socket.write(buffer, () => {
|
|
this.#bufferedAmount -= ab.byteLength;
|
|
});
|
|
} else if (isBlobLike(data)) {
|
|
const frame = new WebsocketFrameSend();
|
|
data.arrayBuffer().then((ab) => {
|
|
const value = Buffer.from(ab);
|
|
frame.frameData = value;
|
|
const buffer = frame.createFrame(opcodes.BINARY);
|
|
this.#bufferedAmount += value.byteLength;
|
|
socket.write(buffer, () => {
|
|
this.#bufferedAmount -= value.byteLength;
|
|
});
|
|
});
|
|
}
|
|
}
|
|
get readyState() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this[kReadyState];
|
|
}
|
|
get bufferedAmount() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#bufferedAmount;
|
|
}
|
|
get url() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return URLSerializer(this[kWebSocketURL]);
|
|
}
|
|
get extensions() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#extensions;
|
|
}
|
|
get protocol() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#protocol;
|
|
}
|
|
get onopen() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#events.open;
|
|
}
|
|
set onopen(fn) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (this.#events.open) {
|
|
this.removeEventListener("open", this.#events.open);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this.#events.open = fn;
|
|
this.addEventListener("open", fn);
|
|
} else {
|
|
this.#events.open = null;
|
|
}
|
|
}
|
|
get onerror() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#events.error;
|
|
}
|
|
set onerror(fn) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (this.#events.error) {
|
|
this.removeEventListener("error", this.#events.error);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this.#events.error = fn;
|
|
this.addEventListener("error", fn);
|
|
} else {
|
|
this.#events.error = null;
|
|
}
|
|
}
|
|
get onclose() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#events.close;
|
|
}
|
|
set onclose(fn) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (this.#events.close) {
|
|
this.removeEventListener("close", this.#events.close);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this.#events.close = fn;
|
|
this.addEventListener("close", fn);
|
|
} else {
|
|
this.#events.close = null;
|
|
}
|
|
}
|
|
get onmessage() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this.#events.message;
|
|
}
|
|
set onmessage(fn) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (this.#events.message) {
|
|
this.removeEventListener("message", this.#events.message);
|
|
}
|
|
if (typeof fn === "function") {
|
|
this.#events.message = fn;
|
|
this.addEventListener("message", fn);
|
|
} else {
|
|
this.#events.message = null;
|
|
}
|
|
}
|
|
get binaryType() {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
return this[kBinaryType];
|
|
}
|
|
set binaryType(type) {
|
|
webidl.brandCheck(this, _WebSocket);
|
|
if (type !== "blob" && type !== "arraybuffer") {
|
|
this[kBinaryType] = "blob";
|
|
} else {
|
|
this[kBinaryType] = type;
|
|
}
|
|
}
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
|
|
*/
|
|
#onConnectionEstablished(response) {
|
|
this[kResponse] = response;
|
|
const parser = new ByteParser(this);
|
|
parser.on("drain", function onParserDrain() {
|
|
this.ws[kResponse].socket.resume();
|
|
});
|
|
response.socket.ws = this;
|
|
this[kByteParser] = parser;
|
|
this[kReadyState] = states.OPEN;
|
|
const extensions = response.headersList.get("sec-websocket-extensions");
|
|
if (extensions !== null) {
|
|
this.#extensions = extensions;
|
|
}
|
|
const protocol = response.headersList.get("sec-websocket-protocol");
|
|
if (protocol !== null) {
|
|
this.#protocol = protocol;
|
|
}
|
|
fireEvent("open", this);
|
|
}
|
|
};
|
|
WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING;
|
|
WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN;
|
|
WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING;
|
|
WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED;
|
|
Object.defineProperties(WebSocket.prototype, {
|
|
CONNECTING: staticPropertyDescriptors,
|
|
OPEN: staticPropertyDescriptors,
|
|
CLOSING: staticPropertyDescriptors,
|
|
CLOSED: staticPropertyDescriptors,
|
|
url: kEnumerableProperty,
|
|
readyState: kEnumerableProperty,
|
|
bufferedAmount: kEnumerableProperty,
|
|
onopen: kEnumerableProperty,
|
|
onerror: kEnumerableProperty,
|
|
onclose: kEnumerableProperty,
|
|
close: kEnumerableProperty,
|
|
onmessage: kEnumerableProperty,
|
|
binaryType: kEnumerableProperty,
|
|
send: kEnumerableProperty,
|
|
extensions: kEnumerableProperty,
|
|
protocol: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: "WebSocket",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperties(WebSocket, {
|
|
CONNECTING: staticPropertyDescriptors,
|
|
OPEN: staticPropertyDescriptors,
|
|
CLOSING: staticPropertyDescriptors,
|
|
CLOSED: staticPropertyDescriptors
|
|
});
|
|
webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(
|
|
webidl.converters.DOMString
|
|
);
|
|
webidl.converters["DOMString or sequence<DOMString>"] = function(V) {
|
|
if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) {
|
|
return webidl.converters["sequence<DOMString>"](V);
|
|
}
|
|
return webidl.converters.DOMString(V);
|
|
};
|
|
webidl.converters.WebSocketInit = webidl.dictionaryConverter([
|
|
{
|
|
key: "protocols",
|
|
converter: webidl.converters["DOMString or sequence<DOMString>"],
|
|
get defaultValue() {
|
|
return [];
|
|
}
|
|
},
|
|
{
|
|
key: "dispatcher",
|
|
converter: (V) => V,
|
|
get defaultValue() {
|
|
return getGlobalDispatcher();
|
|
}
|
|
},
|
|
{
|
|
key: "headers",
|
|
converter: webidl.nullableConverter(webidl.converters.HeadersInit)
|
|
}
|
|
]);
|
|
webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V) {
|
|
if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) {
|
|
return webidl.converters.WebSocketInit(V);
|
|
}
|
|
return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V) };
|
|
};
|
|
webidl.converters.WebSocketSendData = function(V) {
|
|
if (webidl.util.Type(V) === "Object") {
|
|
if (isBlobLike(V)) {
|
|
return webidl.converters.Blob(V, { strict: false });
|
|
}
|
|
if (ArrayBuffer.isView(V) || types3.isAnyArrayBuffer(V)) {
|
|
return webidl.converters.BufferSource(V);
|
|
}
|
|
}
|
|
return webidl.converters.USVString(V);
|
|
};
|
|
module2.exports = {
|
|
WebSocket
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/undici/index.js
|
|
var require_undici = __commonJS({
|
|
"node_modules/undici/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var Client = require_client();
|
|
var Dispatcher = require_dispatcher();
|
|
var errors = require_errors();
|
|
var Pool = require_pool();
|
|
var BalancedPool = require_balanced_pool();
|
|
var Agent = require_agent();
|
|
var util = require_util();
|
|
var { InvalidArgumentError } = errors;
|
|
var api = require_api();
|
|
var buildConnector = require_connect();
|
|
var MockClient = require_mock_client();
|
|
var MockAgent = require_mock_agent();
|
|
var MockPool = require_mock_pool();
|
|
var mockErrors = require_mock_errors();
|
|
var ProxyAgent = require_proxy_agent();
|
|
var RetryHandler = require_RetryHandler();
|
|
var { getGlobalDispatcher, setGlobalDispatcher } = require_global2();
|
|
var DecoratorHandler = require_DecoratorHandler();
|
|
var RedirectHandler = require_RedirectHandler();
|
|
var createRedirectInterceptor = require_redirectInterceptor();
|
|
var hasCrypto;
|
|
try {
|
|
require("crypto");
|
|
hasCrypto = true;
|
|
} catch {
|
|
hasCrypto = false;
|
|
}
|
|
Object.assign(Dispatcher.prototype, api);
|
|
module2.exports.Dispatcher = Dispatcher;
|
|
module2.exports.Client = Client;
|
|
module2.exports.Pool = Pool;
|
|
module2.exports.BalancedPool = BalancedPool;
|
|
module2.exports.Agent = Agent;
|
|
module2.exports.ProxyAgent = ProxyAgent;
|
|
module2.exports.RetryHandler = RetryHandler;
|
|
module2.exports.DecoratorHandler = DecoratorHandler;
|
|
module2.exports.RedirectHandler = RedirectHandler;
|
|
module2.exports.createRedirectInterceptor = createRedirectInterceptor;
|
|
module2.exports.buildConnector = buildConnector;
|
|
module2.exports.errors = errors;
|
|
function makeDispatcher(fn) {
|
|
return (url, opts, handler) => {
|
|
if (typeof opts === "function") {
|
|
handler = opts;
|
|
opts = null;
|
|
}
|
|
if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) {
|
|
throw new InvalidArgumentError("invalid url");
|
|
}
|
|
if (opts != null && typeof opts !== "object") {
|
|
throw new InvalidArgumentError("invalid opts");
|
|
}
|
|
if (opts && opts.path != null) {
|
|
if (typeof opts.path !== "string") {
|
|
throw new InvalidArgumentError("invalid opts.path");
|
|
}
|
|
let path3 = opts.path;
|
|
if (!opts.path.startsWith("/")) {
|
|
path3 = `/${path3}`;
|
|
}
|
|
url = new URL(util.parseOrigin(url).origin + path3);
|
|
} else {
|
|
if (!opts) {
|
|
opts = typeof url === "object" ? url : {};
|
|
}
|
|
url = util.parseURL(url);
|
|
}
|
|
const { agent, dispatcher = getGlobalDispatcher() } = opts;
|
|
if (agent) {
|
|
throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
|
|
}
|
|
return fn.call(dispatcher, {
|
|
...opts,
|
|
origin: url.origin,
|
|
path: url.search ? `${url.pathname}${url.search}` : url.pathname,
|
|
method: opts.method || (opts.body ? "PUT" : "GET")
|
|
}, handler);
|
|
};
|
|
}
|
|
module2.exports.setGlobalDispatcher = setGlobalDispatcher;
|
|
module2.exports.getGlobalDispatcher = getGlobalDispatcher;
|
|
if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) {
|
|
let fetchImpl = null;
|
|
module2.exports.fetch = async function fetch2(resource) {
|
|
if (!fetchImpl) {
|
|
fetchImpl = require_fetch().fetch;
|
|
}
|
|
try {
|
|
return await fetchImpl(...arguments);
|
|
} catch (err) {
|
|
if (typeof err === "object") {
|
|
Error.captureStackTrace(err, this);
|
|
}
|
|
throw err;
|
|
}
|
|
};
|
|
module2.exports.Headers = require_headers().Headers;
|
|
module2.exports.Response = require_response().Response;
|
|
module2.exports.Request = require_request2().Request;
|
|
module2.exports.FormData = require_formdata().FormData;
|
|
module2.exports.File = require_file().File;
|
|
module2.exports.FileReader = require_filereader().FileReader;
|
|
const { setGlobalOrigin, getGlobalOrigin } = require_global();
|
|
module2.exports.setGlobalOrigin = setGlobalOrigin;
|
|
module2.exports.getGlobalOrigin = getGlobalOrigin;
|
|
const { CacheStorage } = require_cachestorage();
|
|
const { kConstruct } = require_symbols4();
|
|
module2.exports.caches = new CacheStorage(kConstruct);
|
|
}
|
|
if (util.nodeMajor >= 16) {
|
|
const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies();
|
|
module2.exports.deleteCookie = deleteCookie;
|
|
module2.exports.getCookies = getCookies;
|
|
module2.exports.getSetCookies = getSetCookies;
|
|
module2.exports.setCookie = setCookie;
|
|
const { parseMIMEType, serializeAMimeType } = require_dataURL();
|
|
module2.exports.parseMIMEType = parseMIMEType;
|
|
module2.exports.serializeAMimeType = serializeAMimeType;
|
|
}
|
|
if (util.nodeMajor >= 18 && hasCrypto) {
|
|
const { WebSocket } = require_websocket();
|
|
module2.exports.WebSocket = WebSocket;
|
|
}
|
|
module2.exports.request = makeDispatcher(api.request);
|
|
module2.exports.stream = makeDispatcher(api.stream);
|
|
module2.exports.pipeline = makeDispatcher(api.pipeline);
|
|
module2.exports.connect = makeDispatcher(api.connect);
|
|
module2.exports.upgrade = makeDispatcher(api.upgrade);
|
|
module2.exports.MockClient = MockClient;
|
|
module2.exports.MockPool = MockPool;
|
|
module2.exports.MockAgent = MockAgent;
|
|
module2.exports.mockErrors = mockErrors;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"node_modules/@actions/http-client/lib/index.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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 __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.HttpClient = exports2.isHttps = exports2.HttpClientResponse = exports2.HttpClientError = exports2.getProxyUrl = exports2.MediaTypes = exports2.Headers = exports2.HttpCodes = void 0;
|
|
var http3 = __importStar(require("http"));
|
|
var https2 = __importStar(require("https"));
|
|
var pm = __importStar(require_proxy());
|
|
var tunnel = __importStar(require_tunnel2());
|
|
var undici_1 = require_undici();
|
|
var HttpCodes;
|
|
(function(HttpCodes2) {
|
|
HttpCodes2[HttpCodes2["OK"] = 200] = "OK";
|
|
HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices";
|
|
HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently";
|
|
HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved";
|
|
HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther";
|
|
HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified";
|
|
HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy";
|
|
HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy";
|
|
HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
|
HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect";
|
|
HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest";
|
|
HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized";
|
|
HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired";
|
|
HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden";
|
|
HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound";
|
|
HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
|
HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable";
|
|
HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
|
HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout";
|
|
HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict";
|
|
HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone";
|
|
HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests";
|
|
HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError";
|
|
HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented";
|
|
HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway";
|
|
HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
|
HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout";
|
|
})(HttpCodes || (exports2.HttpCodes = HttpCodes = {}));
|
|
var Headers2;
|
|
(function(Headers3) {
|
|
Headers3["Accept"] = "accept";
|
|
Headers3["ContentType"] = "content-type";
|
|
})(Headers2 || (exports2.Headers = Headers2 = {}));
|
|
var MediaTypes;
|
|
(function(MediaTypes2) {
|
|
MediaTypes2["ApplicationJson"] = "application/json";
|
|
})(MediaTypes || (exports2.MediaTypes = MediaTypes = {}));
|
|
function getProxyUrl(serverUrl) {
|
|
const proxyUrl = pm.getProxyUrl(new URL(serverUrl));
|
|
return proxyUrl ? proxyUrl.href : "";
|
|
}
|
|
exports2.getProxyUrl = getProxyUrl;
|
|
var HttpRedirectCodes = [
|
|
HttpCodes.MovedPermanently,
|
|
HttpCodes.ResourceMoved,
|
|
HttpCodes.SeeOther,
|
|
HttpCodes.TemporaryRedirect,
|
|
HttpCodes.PermanentRedirect
|
|
];
|
|
var HttpResponseRetryCodes = [
|
|
HttpCodes.BadGateway,
|
|
HttpCodes.ServiceUnavailable,
|
|
HttpCodes.GatewayTimeout
|
|
];
|
|
var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"];
|
|
var ExponentialBackoffCeiling = 10;
|
|
var ExponentialBackoffTimeSlice = 5;
|
|
var HttpClientError = class _HttpClientError extends Error {
|
|
constructor(message, statusCode) {
|
|
super(message);
|
|
this.name = "HttpClientError";
|
|
this.statusCode = statusCode;
|
|
Object.setPrototypeOf(this, _HttpClientError.prototype);
|
|
}
|
|
};
|
|
exports2.HttpClientError = HttpClientError;
|
|
var HttpClientResponse = class {
|
|
constructor(message) {
|
|
this.message = message;
|
|
}
|
|
readBody() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
let output = Buffer.alloc(0);
|
|
this.message.on("data", (chunk) => {
|
|
output = Buffer.concat([output, chunk]);
|
|
});
|
|
this.message.on("end", () => {
|
|
resolve(output.toString());
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
readBodyBuffer() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
const chunks = [];
|
|
this.message.on("data", (chunk) => {
|
|
chunks.push(chunk);
|
|
});
|
|
this.message.on("end", () => {
|
|
resolve(Buffer.concat(chunks));
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
};
|
|
exports2.HttpClientResponse = HttpClientResponse;
|
|
function isHttps(requestUrl) {
|
|
const parsedUrl = new URL(requestUrl);
|
|
return parsedUrl.protocol === "https:";
|
|
}
|
|
exports2.isHttps = isHttps;
|
|
var HttpClient = class {
|
|
constructor(userAgent, handlers, requestOptions) {
|
|
this._ignoreSslError = false;
|
|
this._allowRedirects = true;
|
|
this._allowRedirectDowngrade = false;
|
|
this._maxRedirects = 50;
|
|
this._allowRetries = false;
|
|
this._maxRetries = 1;
|
|
this._keepAlive = false;
|
|
this._disposed = false;
|
|
this.userAgent = userAgent;
|
|
this.handlers = handlers || [];
|
|
this.requestOptions = requestOptions;
|
|
if (requestOptions) {
|
|
if (requestOptions.ignoreSslError != null) {
|
|
this._ignoreSslError = requestOptions.ignoreSslError;
|
|
}
|
|
this._socketTimeout = requestOptions.socketTimeout;
|
|
if (requestOptions.allowRedirects != null) {
|
|
this._allowRedirects = requestOptions.allowRedirects;
|
|
}
|
|
if (requestOptions.allowRedirectDowngrade != null) {
|
|
this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
|
|
}
|
|
if (requestOptions.maxRedirects != null) {
|
|
this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
|
|
}
|
|
if (requestOptions.keepAlive != null) {
|
|
this._keepAlive = requestOptions.keepAlive;
|
|
}
|
|
if (requestOptions.allowRetries != null) {
|
|
this._allowRetries = requestOptions.allowRetries;
|
|
}
|
|
if (requestOptions.maxRetries != null) {
|
|
this._maxRetries = requestOptions.maxRetries;
|
|
}
|
|
}
|
|
}
|
|
options(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("OPTIONS", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
get(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("GET", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
del(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("DELETE", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
post(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("POST", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
patch(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("PATCH", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
put(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("PUT", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
head(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request("HEAD", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
sendStream(verb, requestUrl, stream, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request(verb, requestUrl, stream, additionalHeaders);
|
|
});
|
|
}
|
|
/**
|
|
* Gets a typed object from an endpoint
|
|
* Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise
|
|
*/
|
|
getJson(requestUrl, additionalHeaders = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson);
|
|
const res = yield this.get(requestUrl, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
postJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.post(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
putJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.put(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
patchJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.patch(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
/**
|
|
* Makes a raw http request.
|
|
* All other methods such as get, post, patch, and request ultimately call this.
|
|
* Prefer get, del, post and patch
|
|
*/
|
|
request(verb, requestUrl, data, headers) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (this._disposed) {
|
|
throw new Error("Client has already been disposed.");
|
|
}
|
|
const parsedUrl = new URL(requestUrl);
|
|
let info4 = this._prepareRequest(verb, parsedUrl, headers);
|
|
const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;
|
|
let numTries = 0;
|
|
let response;
|
|
do {
|
|
response = yield this.requestRaw(info4, data);
|
|
if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) {
|
|
let authenticationHandler;
|
|
for (const handler of this.handlers) {
|
|
if (handler.canHandleAuthentication(response)) {
|
|
authenticationHandler = handler;
|
|
break;
|
|
}
|
|
}
|
|
if (authenticationHandler) {
|
|
return authenticationHandler.handleAuthentication(this, info4, data);
|
|
} else {
|
|
return response;
|
|
}
|
|
}
|
|
let redirectsRemaining = this._maxRedirects;
|
|
while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) {
|
|
const redirectUrl = response.message.headers["location"];
|
|
if (!redirectUrl) {
|
|
break;
|
|
}
|
|
const parsedRedirectUrl = new URL(redirectUrl);
|
|
if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) {
|
|
throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.");
|
|
}
|
|
yield response.readBody();
|
|
if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
|
|
for (const header in headers) {
|
|
if (header.toLowerCase() === "authorization") {
|
|
delete headers[header];
|
|
}
|
|
}
|
|
}
|
|
info4 = this._prepareRequest(verb, parsedRedirectUrl, headers);
|
|
response = yield this.requestRaw(info4, data);
|
|
redirectsRemaining--;
|
|
}
|
|
if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) {
|
|
return response;
|
|
}
|
|
numTries += 1;
|
|
if (numTries < maxTries) {
|
|
yield response.readBody();
|
|
yield this._performExponentialBackoff(numTries);
|
|
}
|
|
} while (numTries < maxTries);
|
|
return response;
|
|
});
|
|
}
|
|
/**
|
|
* Needs to be called if keepAlive is set to true in request options.
|
|
*/
|
|
dispose() {
|
|
if (this._agent) {
|
|
this._agent.destroy();
|
|
}
|
|
this._disposed = true;
|
|
}
|
|
/**
|
|
* Raw request.
|
|
* @param info
|
|
* @param data
|
|
*/
|
|
requestRaw(info4, data) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => {
|
|
function callbackForResult(err, res) {
|
|
if (err) {
|
|
reject(err);
|
|
} else if (!res) {
|
|
reject(new Error("Unknown error"));
|
|
} else {
|
|
resolve(res);
|
|
}
|
|
}
|
|
this.requestRawWithCallback(info4, data, callbackForResult);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Raw request with callback.
|
|
* @param info
|
|
* @param data
|
|
* @param onResult
|
|
*/
|
|
requestRawWithCallback(info4, data, onResult) {
|
|
if (typeof data === "string") {
|
|
if (!info4.options.headers) {
|
|
info4.options.headers = {};
|
|
}
|
|
info4.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
|
|
}
|
|
let callbackCalled = false;
|
|
function handleResult(err, res) {
|
|
if (!callbackCalled) {
|
|
callbackCalled = true;
|
|
onResult(err, res);
|
|
}
|
|
}
|
|
const req = info4.httpModule.request(info4.options, (msg) => {
|
|
const res = new HttpClientResponse(msg);
|
|
handleResult(void 0, res);
|
|
});
|
|
let socket;
|
|
req.on("socket", (sock) => {
|
|
socket = sock;
|
|
});
|
|
req.setTimeout(this._socketTimeout || 3 * 6e4, () => {
|
|
if (socket) {
|
|
socket.end();
|
|
}
|
|
handleResult(new Error(`Request timeout: ${info4.options.path}`));
|
|
});
|
|
req.on("error", function(err) {
|
|
handleResult(err);
|
|
});
|
|
if (data && typeof data === "string") {
|
|
req.write(data, "utf8");
|
|
}
|
|
if (data && typeof data !== "string") {
|
|
data.on("close", function() {
|
|
req.end();
|
|
});
|
|
data.pipe(req);
|
|
} else {
|
|
req.end();
|
|
}
|
|
}
|
|
/**
|
|
* Gets an http agent. This function is useful when you need an http agent that handles
|
|
* routing through a proxy server - depending upon the url and proxy environment variables.
|
|
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
|
*/
|
|
getAgent(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
return this._getAgent(parsedUrl);
|
|
}
|
|
getAgentDispatcher(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (!useProxy) {
|
|
return;
|
|
}
|
|
return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
|
|
}
|
|
_prepareRequest(method, requestUrl, headers) {
|
|
const info4 = {};
|
|
info4.parsedUrl = requestUrl;
|
|
const usingSsl = info4.parsedUrl.protocol === "https:";
|
|
info4.httpModule = usingSsl ? https2 : http3;
|
|
const defaultPort = usingSsl ? 443 : 80;
|
|
info4.options = {};
|
|
info4.options.host = info4.parsedUrl.hostname;
|
|
info4.options.port = info4.parsedUrl.port ? parseInt(info4.parsedUrl.port) : defaultPort;
|
|
info4.options.path = (info4.parsedUrl.pathname || "") + (info4.parsedUrl.search || "");
|
|
info4.options.method = method;
|
|
info4.options.headers = this._mergeHeaders(headers);
|
|
if (this.userAgent != null) {
|
|
info4.options.headers["user-agent"] = this.userAgent;
|
|
}
|
|
info4.options.agent = this._getAgent(info4.parsedUrl);
|
|
if (this.handlers) {
|
|
for (const handler of this.handlers) {
|
|
handler.prepareRequest(info4.options);
|
|
}
|
|
}
|
|
return info4;
|
|
}
|
|
_mergeHeaders(headers) {
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {}));
|
|
}
|
|
return lowercaseKeys(headers || {});
|
|
}
|
|
_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
|
|
}
|
|
return additionalHeaders[header] || clientHeader || _default;
|
|
}
|
|
_getAgent(parsedUrl) {
|
|
let agent;
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (this._keepAlive && useProxy) {
|
|
agent = this._proxyAgent;
|
|
}
|
|
if (!useProxy) {
|
|
agent = this._agent;
|
|
}
|
|
if (agent) {
|
|
return agent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === "https:";
|
|
let maxSockets = 100;
|
|
if (this.requestOptions) {
|
|
maxSockets = this.requestOptions.maxSockets || http3.globalAgent.maxSockets;
|
|
}
|
|
if (proxyUrl && proxyUrl.hostname) {
|
|
const agentOptions = {
|
|
maxSockets,
|
|
keepAlive: this._keepAlive,
|
|
proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && {
|
|
proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
|
|
}), { host: proxyUrl.hostname, port: proxyUrl.port })
|
|
};
|
|
let tunnelAgent;
|
|
const overHttps = proxyUrl.protocol === "https:";
|
|
if (usingSsl) {
|
|
tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
|
|
} else {
|
|
tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
|
|
}
|
|
agent = tunnelAgent(agentOptions);
|
|
this._proxyAgent = agent;
|
|
}
|
|
if (!agent) {
|
|
const options = { keepAlive: this._keepAlive, maxSockets };
|
|
agent = usingSsl ? new https2.Agent(options) : new http3.Agent(options);
|
|
this._agent = agent;
|
|
}
|
|
if (usingSsl && this._ignoreSslError) {
|
|
agent.options = Object.assign(agent.options || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return agent;
|
|
}
|
|
_getProxyAgentDispatcher(parsedUrl, proxyUrl) {
|
|
let proxyAgent;
|
|
if (this._keepAlive) {
|
|
proxyAgent = this._proxyAgentDispatcher;
|
|
}
|
|
if (proxyAgent) {
|
|
return proxyAgent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === "https:";
|
|
proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, (proxyUrl.username || proxyUrl.password) && {
|
|
token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}`
|
|
}));
|
|
this._proxyAgentDispatcher = proxyAgent;
|
|
if (usingSsl && this._ignoreSslError) {
|
|
proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return proxyAgent;
|
|
}
|
|
_performExponentialBackoff(retryNumber) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
|
|
const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
|
|
return new Promise((resolve) => setTimeout(() => resolve(), ms));
|
|
});
|
|
}
|
|
_processResponse(res, options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
|
const statusCode = res.message.statusCode || 0;
|
|
const response = {
|
|
statusCode,
|
|
result: null,
|
|
headers: {}
|
|
};
|
|
if (statusCode === HttpCodes.NotFound) {
|
|
resolve(response);
|
|
}
|
|
function dateTimeDeserializer(key, value) {
|
|
if (typeof value === "string") {
|
|
const a = new Date(value);
|
|
if (!isNaN(a.valueOf())) {
|
|
return a;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
let obj;
|
|
let contents;
|
|
try {
|
|
contents = yield res.readBody();
|
|
if (contents && contents.length > 0) {
|
|
if (options && options.deserializeDates) {
|
|
obj = JSON.parse(contents, dateTimeDeserializer);
|
|
} else {
|
|
obj = JSON.parse(contents);
|
|
}
|
|
response.result = obj;
|
|
}
|
|
response.headers = res.message.headers;
|
|
} catch (err) {
|
|
}
|
|
if (statusCode > 299) {
|
|
let msg;
|
|
if (obj && obj.message) {
|
|
msg = obj.message;
|
|
} else if (contents && contents.length > 0) {
|
|
msg = contents;
|
|
} else {
|
|
msg = `Failed request: (${statusCode})`;
|
|
}
|
|
const err = new HttpClientError(msg, statusCode);
|
|
err.result = response.result;
|
|
reject(err);
|
|
} else {
|
|
resolve(response);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
};
|
|
exports2.HttpClient = HttpClient;
|
|
var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {});
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/auth.js
|
|
var require_auth = __commonJS({
|
|
"node_modules/@actions/http-client/lib/auth.js"(exports2) {
|
|
"use strict";
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.PersonalAccessTokenCredentialHandler = exports2.BearerCredentialHandler = exports2.BasicCredentialHandler = void 0;
|
|
var BasicCredentialHandler = class {
|
|
constructor(username, password) {
|
|
this.username = username;
|
|
this.password = password;
|
|
}
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error("The request has no headers");
|
|
}
|
|
options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
};
|
|
exports2.BasicCredentialHandler = BasicCredentialHandler;
|
|
var BearerCredentialHandler = class {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
// currently implements pre-authorization
|
|
// TODO: support preAuth = false where it hooks on 401
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error("The request has no headers");
|
|
}
|
|
options.headers["Authorization"] = `Bearer ${this.token}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
};
|
|
exports2.BearerCredentialHandler = BearerCredentialHandler;
|
|
var PersonalAccessTokenCredentialHandler = class {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
// currently implements pre-authorization
|
|
// TODO: support preAuth = false where it hooks on 401
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error("The request has no headers");
|
|
}
|
|
options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
};
|
|
exports2.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/oidc-utils.js
|
|
var require_oidc_utils = __commonJS({
|
|
"node_modules/@actions/core/lib/oidc-utils.js"(exports2) {
|
|
"use strict";
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.OidcClient = void 0;
|
|
var http_client_1 = require_lib();
|
|
var auth_1 = require_auth();
|
|
var core_1 = require_core();
|
|
var OidcClient = class _OidcClient {
|
|
static createHttpClient(allowRetry = true, maxRetry = 10) {
|
|
const requestOptions = {
|
|
allowRetries: allowRetry,
|
|
maxRetries: maxRetry
|
|
};
|
|
return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(_OidcClient.getRequestToken())], requestOptions);
|
|
}
|
|
static getRequestToken() {
|
|
const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"];
|
|
if (!token) {
|
|
throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable");
|
|
}
|
|
return token;
|
|
}
|
|
static getIDTokenUrl() {
|
|
const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"];
|
|
if (!runtimeUrl) {
|
|
throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable");
|
|
}
|
|
return runtimeUrl;
|
|
}
|
|
static getCall(id_token_url) {
|
|
var _a;
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const httpclient = _OidcClient.createHttpClient();
|
|
const res = yield httpclient.getJson(id_token_url).catch((error) => {
|
|
throw new Error(`Failed to get ID Token.
|
|
|
|
Error Code : ${error.statusCode}
|
|
|
|
Error Message: ${error.message}`);
|
|
});
|
|
const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;
|
|
if (!id_token) {
|
|
throw new Error("Response json body do not have ID Token field");
|
|
}
|
|
return id_token;
|
|
});
|
|
}
|
|
static getIDToken(audience) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
let id_token_url = _OidcClient.getIDTokenUrl();
|
|
if (audience) {
|
|
const encodedAudience = encodeURIComponent(audience);
|
|
id_token_url = `${id_token_url}&audience=${encodedAudience}`;
|
|
}
|
|
(0, core_1.debug)(`ID token url is ${id_token_url}`);
|
|
const id_token = yield _OidcClient.getCall(id_token_url);
|
|
(0, core_1.setSecret)(id_token);
|
|
return id_token;
|
|
} catch (error) {
|
|
throw new Error(`Error message: ${error.message}`);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
exports2.OidcClient = OidcClient;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/summary.js
|
|
var require_summary = __commonJS({
|
|
"node_modules/@actions/core/lib/summary.js"(exports2) {
|
|
"use strict";
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.summary = exports2.markdownSummary = exports2.SUMMARY_DOCS_URL = exports2.SUMMARY_ENV_VAR = void 0;
|
|
var os_1 = require("os");
|
|
var fs_1 = require("fs");
|
|
var { access, appendFile, writeFile } = fs_1.promises;
|
|
exports2.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY";
|
|
exports2.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary";
|
|
var Summary = class {
|
|
constructor() {
|
|
this._buffer = "";
|
|
}
|
|
/**
|
|
* Finds the summary file path from the environment, rejects if env var is not found or file does not exist
|
|
* Also checks r/w permissions.
|
|
*
|
|
* @returns step summary file path
|
|
*/
|
|
filePath() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (this._filePath) {
|
|
return this._filePath;
|
|
}
|
|
const pathFromEnv = process.env[exports2.SUMMARY_ENV_VAR];
|
|
if (!pathFromEnv) {
|
|
throw new Error(`Unable to find environment variable for $${exports2.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`);
|
|
}
|
|
try {
|
|
yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK);
|
|
} catch (_a) {
|
|
throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
|
|
}
|
|
this._filePath = pathFromEnv;
|
|
return this._filePath;
|
|
});
|
|
}
|
|
/**
|
|
* Wraps content in an HTML tag, adding any HTML attributes
|
|
*
|
|
* @param {string} tag HTML tag to wrap
|
|
* @param {string | null} content content within the tag
|
|
* @param {[attribute: string]: string} attrs key-value list of HTML attributes to add
|
|
*
|
|
* @returns {string} content wrapped in HTML element
|
|
*/
|
|
wrap(tag, content, attrs = {}) {
|
|
const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join("");
|
|
if (!content) {
|
|
return `<${tag}${htmlAttrs}>`;
|
|
}
|
|
return `<${tag}${htmlAttrs}>${content}</${tag}>`;
|
|
}
|
|
/**
|
|
* Writes text in the buffer to the summary buffer file and empties buffer. Will append by default.
|
|
*
|
|
* @param {SummaryWriteOptions} [options] (optional) options for write operation
|
|
*
|
|
* @returns {Promise<Summary>} summary instance
|
|
*/
|
|
write(options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);
|
|
const filePath = yield this.filePath();
|
|
const writeFunc = overwrite ? writeFile : appendFile;
|
|
yield writeFunc(filePath, this._buffer, { encoding: "utf8" });
|
|
return this.emptyBuffer();
|
|
});
|
|
}
|
|
/**
|
|
* Clears the summary buffer and wipes the summary file
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
clear() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.emptyBuffer().write({ overwrite: true });
|
|
});
|
|
}
|
|
/**
|
|
* Returns the current summary buffer as a string
|
|
*
|
|
* @returns {string} string of summary buffer
|
|
*/
|
|
stringify() {
|
|
return this._buffer;
|
|
}
|
|
/**
|
|
* If the summary buffer is empty
|
|
*
|
|
* @returns {boolen} true if the buffer is empty
|
|
*/
|
|
isEmptyBuffer() {
|
|
return this._buffer.length === 0;
|
|
}
|
|
/**
|
|
* Resets the summary buffer without writing to summary file
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
emptyBuffer() {
|
|
this._buffer = "";
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds raw text to the summary buffer
|
|
*
|
|
* @param {string} text content to add
|
|
* @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false)
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addRaw(text, addEOL = false) {
|
|
this._buffer += text;
|
|
return addEOL ? this.addEOL() : this;
|
|
}
|
|
/**
|
|
* Adds the operating system-specific end-of-line marker to the buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addEOL() {
|
|
return this.addRaw(os_1.EOL);
|
|
}
|
|
/**
|
|
* Adds an HTML codeblock to the summary buffer
|
|
*
|
|
* @param {string} code content to render within fenced code block
|
|
* @param {string} lang (optional) language to syntax highlight code
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addCodeBlock(code, lang) {
|
|
const attrs = Object.assign({}, lang && { lang });
|
|
const element = this.wrap("pre", this.wrap("code", code), attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML list to the summary buffer
|
|
*
|
|
* @param {string[]} items list of items to render
|
|
* @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false)
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addList(items, ordered = false) {
|
|
const tag = ordered ? "ol" : "ul";
|
|
const listItems = items.map((item) => this.wrap("li", item)).join("");
|
|
const element = this.wrap(tag, listItems);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML table to the summary buffer
|
|
*
|
|
* @param {SummaryTableCell[]} rows table rows
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addTable(rows) {
|
|
const tableBody = rows.map((row) => {
|
|
const cells = row.map((cell) => {
|
|
if (typeof cell === "string") {
|
|
return this.wrap("td", cell);
|
|
}
|
|
const { header, data, colspan, rowspan } = cell;
|
|
const tag = header ? "th" : "td";
|
|
const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan });
|
|
return this.wrap(tag, data, attrs);
|
|
}).join("");
|
|
return this.wrap("tr", cells);
|
|
}).join("");
|
|
const element = this.wrap("table", tableBody);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds a collapsable HTML details element to the summary buffer
|
|
*
|
|
* @param {string} label text for the closed state
|
|
* @param {string} content collapsable content
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addDetails(label, content) {
|
|
const element = this.wrap("details", this.wrap("summary", label) + content);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML image tag to the summary buffer
|
|
*
|
|
* @param {string} src path to the image you to embed
|
|
* @param {string} alt text description of the image
|
|
* @param {SummaryImageOptions} options (optional) addition image attributes
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addImage(src, alt, options) {
|
|
const { width, height } = options || {};
|
|
const attrs = Object.assign(Object.assign({}, width && { width }), height && { height });
|
|
const element = this.wrap("img", null, Object.assign({ src, alt }, attrs));
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML section heading element
|
|
*
|
|
* @param {string} text heading text
|
|
* @param {number | string} [level=1] (optional) the heading level, default: 1
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addHeading(text, level) {
|
|
const tag = `h${level}`;
|
|
const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1";
|
|
const element = this.wrap(allowedTag, text);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML thematic break (<hr>) to the summary buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addSeparator() {
|
|
const element = this.wrap("hr", null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML line break (<br>) to the summary buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addBreak() {
|
|
const element = this.wrap("br", null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML blockquote to the summary buffer
|
|
*
|
|
* @param {string} text quote text
|
|
* @param {string} cite (optional) citation url
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addQuote(text, cite) {
|
|
const attrs = Object.assign({}, cite && { cite });
|
|
const element = this.wrap("blockquote", text, attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML anchor tag to the summary buffer
|
|
*
|
|
* @param {string} text link text/content
|
|
* @param {string} href hyperlink
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addLink(text, href) {
|
|
const element = this.wrap("a", text, { href });
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
};
|
|
var _summary = new Summary();
|
|
exports2.markdownSummary = _summary;
|
|
exports2.summary = _summary;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/path-utils.js
|
|
var require_path_utils = __commonJS({
|
|
"node_modules/@actions/core/lib/path-utils.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
|
|
exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0;
|
|
var path3 = __importStar(require("path"));
|
|
function toPosixPath(pth) {
|
|
return pth.replace(/[\\]/g, "/");
|
|
}
|
|
exports2.toPosixPath = toPosixPath;
|
|
function toWin32Path(pth) {
|
|
return pth.replace(/[/]/g, "\\");
|
|
}
|
|
exports2.toWin32Path = toWin32Path;
|
|
function toPlatformPath(pth) {
|
|
return pth.replace(/[/\\]/g, path3.sep);
|
|
}
|
|
exports2.toPlatformPath = toPlatformPath;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/io/lib/io-util.js
|
|
var require_io_util = __commonJS({
|
|
"node_modules/@actions/io/lib/io-util.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
Object.defineProperty(o, k2, { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} });
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__importStar || function(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var _a;
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0;
|
|
var fs6 = __importStar(require("fs"));
|
|
var path3 = __importStar(require("path"));
|
|
_a = fs6.promises, exports2.chmod = _a.chmod, exports2.copyFile = _a.copyFile, exports2.lstat = _a.lstat, exports2.mkdir = _a.mkdir, exports2.open = _a.open, exports2.readdir = _a.readdir, exports2.readlink = _a.readlink, exports2.rename = _a.rename, exports2.rm = _a.rm, exports2.rmdir = _a.rmdir, exports2.stat = _a.stat, exports2.symlink = _a.symlink, exports2.unlink = _a.unlink;
|
|
exports2.IS_WINDOWS = process.platform === "win32";
|
|
exports2.UV_FS_O_EXLOCK = 268435456;
|
|
exports2.READONLY = fs6.constants.O_RDONLY;
|
|
function exists(fsPath) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
yield exports2.stat(fsPath);
|
|
} catch (err) {
|
|
if (err.code === "ENOENT") {
|
|
return false;
|
|
}
|
|
throw err;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
exports2.exists = exists;
|
|
function isDirectory(fsPath, useStat = false) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const stats = useStat ? yield exports2.stat(fsPath) : yield exports2.lstat(fsPath);
|
|
return stats.isDirectory();
|
|
});
|
|
}
|
|
exports2.isDirectory = isDirectory;
|
|
function isRooted(p) {
|
|
p = normalizeSeparators(p);
|
|
if (!p) {
|
|
throw new Error('isRooted() parameter "p" cannot be empty');
|
|
}
|
|
if (exports2.IS_WINDOWS) {
|
|
return p.startsWith("\\") || /^[A-Z]:/i.test(p);
|
|
}
|
|
return p.startsWith("/");
|
|
}
|
|
exports2.isRooted = isRooted;
|
|
function tryGetExecutablePath(filePath, extensions) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let stats = void 0;
|
|
try {
|
|
stats = yield exports2.stat(filePath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT") {
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (exports2.IS_WINDOWS) {
|
|
const upperExt = path3.extname(filePath).toUpperCase();
|
|
if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) {
|
|
return filePath;
|
|
}
|
|
} else {
|
|
if (isUnixExecutable(stats)) {
|
|
return filePath;
|
|
}
|
|
}
|
|
}
|
|
const originalFilePath = filePath;
|
|
for (const extension of extensions) {
|
|
filePath = originalFilePath + extension;
|
|
stats = void 0;
|
|
try {
|
|
stats = yield exports2.stat(filePath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT") {
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (exports2.IS_WINDOWS) {
|
|
try {
|
|
const directory = path3.dirname(filePath);
|
|
const upperName = path3.basename(filePath).toUpperCase();
|
|
for (const actualName of yield exports2.readdir(directory)) {
|
|
if (upperName === actualName.toUpperCase()) {
|
|
filePath = path3.join(directory, actualName);
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
|
|
}
|
|
return filePath;
|
|
} else {
|
|
if (isUnixExecutable(stats)) {
|
|
return filePath;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return "";
|
|
});
|
|
}
|
|
exports2.tryGetExecutablePath = tryGetExecutablePath;
|
|
function normalizeSeparators(p) {
|
|
p = p || "";
|
|
if (exports2.IS_WINDOWS) {
|
|
p = p.replace(/\//g, "\\");
|
|
return p.replace(/\\\\+/g, "\\");
|
|
}
|
|
return p.replace(/\/\/+/g, "/");
|
|
}
|
|
function isUnixExecutable(stats) {
|
|
return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid();
|
|
}
|
|
function getCmdPath() {
|
|
var _a2;
|
|
return (_a2 = process.env["COMSPEC"]) !== null && _a2 !== void 0 ? _a2 : `cmd.exe`;
|
|
}
|
|
exports2.getCmdPath = getCmdPath;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/io/lib/io.js
|
|
var require_io = __commonJS({
|
|
"node_modules/@actions/io/lib/io.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
Object.defineProperty(o, k2, { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} });
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__importStar || function(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0;
|
|
var assert_1 = require("assert");
|
|
var path3 = __importStar(require("path"));
|
|
var ioUtil = __importStar(require_io_util());
|
|
function cp(source, dest, options = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const { force, recursive, copySourceDirectory } = readCopyOptions(options);
|
|
const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
|
|
if (destStat && destStat.isFile() && !force) {
|
|
return;
|
|
}
|
|
const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path3.join(dest, path3.basename(source)) : dest;
|
|
if (!(yield ioUtil.exists(source))) {
|
|
throw new Error(`no such file or directory: ${source}`);
|
|
}
|
|
const sourceStat = yield ioUtil.stat(source);
|
|
if (sourceStat.isDirectory()) {
|
|
if (!recursive) {
|
|
throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
|
|
} else {
|
|
yield cpDirRecursive(source, newDest, 0, force);
|
|
}
|
|
} else {
|
|
if (path3.relative(source, newDest) === "") {
|
|
throw new Error(`'${newDest}' and '${source}' are the same file`);
|
|
}
|
|
yield copyFile(source, newDest, force);
|
|
}
|
|
});
|
|
}
|
|
exports2.cp = cp;
|
|
function mv(source, dest, options = {}) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (yield ioUtil.exists(dest)) {
|
|
let destExists = true;
|
|
if (yield ioUtil.isDirectory(dest)) {
|
|
dest = path3.join(dest, path3.basename(source));
|
|
destExists = yield ioUtil.exists(dest);
|
|
}
|
|
if (destExists) {
|
|
if (options.force == null || options.force) {
|
|
yield rmRF(dest);
|
|
} else {
|
|
throw new Error("Destination already exists");
|
|
}
|
|
}
|
|
}
|
|
yield mkdirP(path3.dirname(dest));
|
|
yield ioUtil.rename(source, dest);
|
|
});
|
|
}
|
|
exports2.mv = mv;
|
|
function rmRF(inputPath) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (ioUtil.IS_WINDOWS) {
|
|
if (/[*"<>|]/.test(inputPath)) {
|
|
throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows');
|
|
}
|
|
}
|
|
try {
|
|
yield ioUtil.rm(inputPath, {
|
|
force: true,
|
|
maxRetries: 3,
|
|
recursive: true,
|
|
retryDelay: 300
|
|
});
|
|
} catch (err) {
|
|
throw new Error(`File was unable to be removed ${err}`);
|
|
}
|
|
});
|
|
}
|
|
exports2.rmRF = rmRF;
|
|
function mkdirP(fsPath) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
assert_1.ok(fsPath, "a path argument must be provided");
|
|
yield ioUtil.mkdir(fsPath, { recursive: true });
|
|
});
|
|
}
|
|
exports2.mkdirP = mkdirP;
|
|
function which(tool, check) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!tool) {
|
|
throw new Error("parameter 'tool' is required");
|
|
}
|
|
if (check) {
|
|
const result = yield which(tool, false);
|
|
if (!result) {
|
|
if (ioUtil.IS_WINDOWS) {
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
|
|
} else {
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
const matches = yield findInPath(tool);
|
|
if (matches && matches.length > 0) {
|
|
return matches[0];
|
|
}
|
|
return "";
|
|
});
|
|
}
|
|
exports2.which = which;
|
|
function findInPath(tool) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!tool) {
|
|
throw new Error("parameter 'tool' is required");
|
|
}
|
|
const extensions = [];
|
|
if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) {
|
|
for (const extension of process.env["PATHEXT"].split(path3.delimiter)) {
|
|
if (extension) {
|
|
extensions.push(extension);
|
|
}
|
|
}
|
|
}
|
|
if (ioUtil.isRooted(tool)) {
|
|
const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
|
|
if (filePath) {
|
|
return [filePath];
|
|
}
|
|
return [];
|
|
}
|
|
if (tool.includes(path3.sep)) {
|
|
return [];
|
|
}
|
|
const directories = [];
|
|
if (process.env.PATH) {
|
|
for (const p of process.env.PATH.split(path3.delimiter)) {
|
|
if (p) {
|
|
directories.push(p);
|
|
}
|
|
}
|
|
}
|
|
const matches = [];
|
|
for (const directory of directories) {
|
|
const filePath = yield ioUtil.tryGetExecutablePath(path3.join(directory, tool), extensions);
|
|
if (filePath) {
|
|
matches.push(filePath);
|
|
}
|
|
}
|
|
return matches;
|
|
});
|
|
}
|
|
exports2.findInPath = findInPath;
|
|
function readCopyOptions(options) {
|
|
const force = options.force == null ? true : options.force;
|
|
const recursive = Boolean(options.recursive);
|
|
const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory);
|
|
return { force, recursive, copySourceDirectory };
|
|
}
|
|
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (currentDepth >= 255)
|
|
return;
|
|
currentDepth++;
|
|
yield mkdirP(destDir);
|
|
const files = yield ioUtil.readdir(sourceDir);
|
|
for (const fileName of files) {
|
|
const srcFile = `${sourceDir}/${fileName}`;
|
|
const destFile = `${destDir}/${fileName}`;
|
|
const srcFileStat = yield ioUtil.lstat(srcFile);
|
|
if (srcFileStat.isDirectory()) {
|
|
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
|
|
} else {
|
|
yield copyFile(srcFile, destFile, force);
|
|
}
|
|
}
|
|
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
|
|
});
|
|
}
|
|
function copyFile(srcFile, destFile, force) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
|
|
try {
|
|
yield ioUtil.lstat(destFile);
|
|
yield ioUtil.unlink(destFile);
|
|
} catch (e2) {
|
|
if (e2.code === "EPERM") {
|
|
yield ioUtil.chmod(destFile, "0666");
|
|
yield ioUtil.unlink(destFile);
|
|
}
|
|
}
|
|
const symlinkFull = yield ioUtil.readlink(srcFile);
|
|
yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? "junction" : null);
|
|
} else if (!(yield ioUtil.exists(destFile)) || force) {
|
|
yield ioUtil.copyFile(srcFile, destFile);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/exec/lib/toolrunner.js
|
|
var require_toolrunner = __commonJS({
|
|
"node_modules/@actions/exec/lib/toolrunner.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
Object.defineProperty(o, k2, { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} });
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__importStar || function(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.argStringToArray = exports2.ToolRunner = void 0;
|
|
var os3 = __importStar(require("os"));
|
|
var events = __importStar(require("events"));
|
|
var child = __importStar(require("child_process"));
|
|
var path3 = __importStar(require("path"));
|
|
var io = __importStar(require_io());
|
|
var ioUtil = __importStar(require_io_util());
|
|
var timers_1 = require("timers");
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
var ToolRunner = class extends events.EventEmitter {
|
|
constructor(toolPath, args, options) {
|
|
super();
|
|
if (!toolPath) {
|
|
throw new Error("Parameter 'toolPath' cannot be null or empty.");
|
|
}
|
|
this.toolPath = toolPath;
|
|
this.args = args || [];
|
|
this.options = options || {};
|
|
}
|
|
_debug(message) {
|
|
if (this.options.listeners && this.options.listeners.debug) {
|
|
this.options.listeners.debug(message);
|
|
}
|
|
}
|
|
_getCommandString(options, noPrefix) {
|
|
const toolPath = this._getSpawnFileName();
|
|
const args = this._getSpawnArgs(options);
|
|
let cmd = noPrefix ? "" : "[command]";
|
|
if (IS_WINDOWS) {
|
|
if (this._isCmdFile()) {
|
|
cmd += toolPath;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
} else if (options.windowsVerbatimArguments) {
|
|
cmd += `"${toolPath}"`;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
} else {
|
|
cmd += this._windowsQuoteCmdArg(toolPath);
|
|
for (const a of args) {
|
|
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
|
}
|
|
}
|
|
} else {
|
|
cmd += toolPath;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
}
|
|
return cmd;
|
|
}
|
|
_processLineBuffer(data, strBuffer, onLine) {
|
|
try {
|
|
let s2 = strBuffer + data.toString();
|
|
let n = s2.indexOf(os3.EOL);
|
|
while (n > -1) {
|
|
const line = s2.substring(0, n);
|
|
onLine(line);
|
|
s2 = s2.substring(n + os3.EOL.length);
|
|
n = s2.indexOf(os3.EOL);
|
|
}
|
|
return s2;
|
|
} catch (err) {
|
|
this._debug(`error processing line. Failed with error ${err}`);
|
|
return "";
|
|
}
|
|
}
|
|
_getSpawnFileName() {
|
|
if (IS_WINDOWS) {
|
|
if (this._isCmdFile()) {
|
|
return process.env["COMSPEC"] || "cmd.exe";
|
|
}
|
|
}
|
|
return this.toolPath;
|
|
}
|
|
_getSpawnArgs(options) {
|
|
if (IS_WINDOWS) {
|
|
if (this._isCmdFile()) {
|
|
let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
|
|
for (const a of this.args) {
|
|
argline += " ";
|
|
argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a);
|
|
}
|
|
argline += '"';
|
|
return [argline];
|
|
}
|
|
}
|
|
return this.args;
|
|
}
|
|
_endsWith(str, end) {
|
|
return str.endsWith(end);
|
|
}
|
|
_isCmdFile() {
|
|
const upperToolPath = this.toolPath.toUpperCase();
|
|
return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT");
|
|
}
|
|
_windowsQuoteCmdArg(arg) {
|
|
if (!this._isCmdFile()) {
|
|
return this._uvQuoteCmdArg(arg);
|
|
}
|
|
if (!arg) {
|
|
return '""';
|
|
}
|
|
const cmdSpecialChars = [
|
|
" ",
|
|
" ",
|
|
"&",
|
|
"(",
|
|
")",
|
|
"[",
|
|
"]",
|
|
"{",
|
|
"}",
|
|
"^",
|
|
"=",
|
|
";",
|
|
"!",
|
|
"'",
|
|
"+",
|
|
",",
|
|
"`",
|
|
"~",
|
|
"|",
|
|
"<",
|
|
">",
|
|
'"'
|
|
];
|
|
let needsQuotes = false;
|
|
for (const char of arg) {
|
|
if (cmdSpecialChars.some((x2) => x2 === char)) {
|
|
needsQuotes = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!needsQuotes) {
|
|
return arg;
|
|
}
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i2 = arg.length; i2 > 0; i2--) {
|
|
reverse += arg[i2 - 1];
|
|
if (quoteHit && arg[i2 - 1] === "\\") {
|
|
reverse += "\\";
|
|
} else if (arg[i2 - 1] === '"') {
|
|
quoteHit = true;
|
|
reverse += '"';
|
|
} else {
|
|
quoteHit = false;
|
|
}
|
|
}
|
|
reverse += '"';
|
|
return reverse.split("").reverse().join("");
|
|
}
|
|
_uvQuoteCmdArg(arg) {
|
|
if (!arg) {
|
|
return '""';
|
|
}
|
|
if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) {
|
|
return arg;
|
|
}
|
|
if (!arg.includes('"') && !arg.includes("\\")) {
|
|
return `"${arg}"`;
|
|
}
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i2 = arg.length; i2 > 0; i2--) {
|
|
reverse += arg[i2 - 1];
|
|
if (quoteHit && arg[i2 - 1] === "\\") {
|
|
reverse += "\\";
|
|
} else if (arg[i2 - 1] === '"') {
|
|
quoteHit = true;
|
|
reverse += "\\";
|
|
} else {
|
|
quoteHit = false;
|
|
}
|
|
}
|
|
reverse += '"';
|
|
return reverse.split("").reverse().join("");
|
|
}
|
|
_cloneExecOptions(options) {
|
|
options = options || {};
|
|
const result = {
|
|
cwd: options.cwd || process.cwd(),
|
|
env: options.env || process.env,
|
|
silent: options.silent || false,
|
|
windowsVerbatimArguments: options.windowsVerbatimArguments || false,
|
|
failOnStdErr: options.failOnStdErr || false,
|
|
ignoreReturnCode: options.ignoreReturnCode || false,
|
|
delay: options.delay || 1e4
|
|
};
|
|
result.outStream = options.outStream || process.stdout;
|
|
result.errStream = options.errStream || process.stderr;
|
|
return result;
|
|
}
|
|
_getSpawnOptions(options, toolPath) {
|
|
options = options || {};
|
|
const result = {};
|
|
result.cwd = options.cwd;
|
|
result.env = options.env;
|
|
result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile();
|
|
if (options.windowsVerbatimArguments) {
|
|
result.argv0 = `"${toolPath}"`;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Exec a tool.
|
|
* Output will be streamed to the live console.
|
|
* Returns promise with return code
|
|
*
|
|
* @param tool path to tool to exec
|
|
* @param options optional exec options. See ExecOptions
|
|
* @returns number
|
|
*/
|
|
exec() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) {
|
|
this.toolPath = path3.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
|
|
}
|
|
this.toolPath = yield io.which(this.toolPath, true);
|
|
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
|
this._debug(`exec tool: ${this.toolPath}`);
|
|
this._debug("arguments:");
|
|
for (const arg of this.args) {
|
|
this._debug(` ${arg}`);
|
|
}
|
|
const optionsNonNull = this._cloneExecOptions(this.options);
|
|
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
|
optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os3.EOL);
|
|
}
|
|
const state = new ExecState(optionsNonNull, this.toolPath);
|
|
state.on("debug", (message) => {
|
|
this._debug(message);
|
|
});
|
|
if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) {
|
|
return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`));
|
|
}
|
|
const fileName = this._getSpawnFileName();
|
|
const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
|
|
let stdbuffer = "";
|
|
if (cp.stdout) {
|
|
cp.stdout.on("data", (data) => {
|
|
if (this.options.listeners && this.options.listeners.stdout) {
|
|
this.options.listeners.stdout(data);
|
|
}
|
|
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
|
optionsNonNull.outStream.write(data);
|
|
}
|
|
stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => {
|
|
if (this.options.listeners && this.options.listeners.stdline) {
|
|
this.options.listeners.stdline(line);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
let errbuffer = "";
|
|
if (cp.stderr) {
|
|
cp.stderr.on("data", (data) => {
|
|
state.processStderr = true;
|
|
if (this.options.listeners && this.options.listeners.stderr) {
|
|
this.options.listeners.stderr(data);
|
|
}
|
|
if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) {
|
|
const s2 = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
|
|
s2.write(data);
|
|
}
|
|
errbuffer = this._processLineBuffer(data, errbuffer, (line) => {
|
|
if (this.options.listeners && this.options.listeners.errline) {
|
|
this.options.listeners.errline(line);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
cp.on("error", (err) => {
|
|
state.processError = err.message;
|
|
state.processExited = true;
|
|
state.processClosed = true;
|
|
state.CheckComplete();
|
|
});
|
|
cp.on("exit", (code) => {
|
|
state.processExitCode = code;
|
|
state.processExited = true;
|
|
this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
|
|
state.CheckComplete();
|
|
});
|
|
cp.on("close", (code) => {
|
|
state.processExitCode = code;
|
|
state.processExited = true;
|
|
state.processClosed = true;
|
|
this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
|
|
state.CheckComplete();
|
|
});
|
|
state.on("done", (error, exitCode) => {
|
|
if (stdbuffer.length > 0) {
|
|
this.emit("stdline", stdbuffer);
|
|
}
|
|
if (errbuffer.length > 0) {
|
|
this.emit("errline", errbuffer);
|
|
}
|
|
cp.removeAllListeners();
|
|
if (error) {
|
|
reject(error);
|
|
} else {
|
|
resolve(exitCode);
|
|
}
|
|
});
|
|
if (this.options.input) {
|
|
if (!cp.stdin) {
|
|
throw new Error("child process missing stdin");
|
|
}
|
|
cp.stdin.end(this.options.input);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
};
|
|
exports2.ToolRunner = ToolRunner;
|
|
function argStringToArray(argString) {
|
|
const args = [];
|
|
let inQuotes = false;
|
|
let escaped = false;
|
|
let arg = "";
|
|
function append(c) {
|
|
if (escaped && c !== '"') {
|
|
arg += "\\";
|
|
}
|
|
arg += c;
|
|
escaped = false;
|
|
}
|
|
for (let i2 = 0; i2 < argString.length; i2++) {
|
|
const c = argString.charAt(i2);
|
|
if (c === '"') {
|
|
if (!escaped) {
|
|
inQuotes = !inQuotes;
|
|
} else {
|
|
append(c);
|
|
}
|
|
continue;
|
|
}
|
|
if (c === "\\" && escaped) {
|
|
append(c);
|
|
continue;
|
|
}
|
|
if (c === "\\" && inQuotes) {
|
|
escaped = true;
|
|
continue;
|
|
}
|
|
if (c === " " && !inQuotes) {
|
|
if (arg.length > 0) {
|
|
args.push(arg);
|
|
arg = "";
|
|
}
|
|
continue;
|
|
}
|
|
append(c);
|
|
}
|
|
if (arg.length > 0) {
|
|
args.push(arg.trim());
|
|
}
|
|
return args;
|
|
}
|
|
exports2.argStringToArray = argStringToArray;
|
|
var ExecState = class _ExecState extends events.EventEmitter {
|
|
constructor(options, toolPath) {
|
|
super();
|
|
this.processClosed = false;
|
|
this.processError = "";
|
|
this.processExitCode = 0;
|
|
this.processExited = false;
|
|
this.processStderr = false;
|
|
this.delay = 1e4;
|
|
this.done = false;
|
|
this.timeout = null;
|
|
if (!toolPath) {
|
|
throw new Error("toolPath must not be empty");
|
|
}
|
|
this.options = options;
|
|
this.toolPath = toolPath;
|
|
if (options.delay) {
|
|
this.delay = options.delay;
|
|
}
|
|
}
|
|
CheckComplete() {
|
|
if (this.done) {
|
|
return;
|
|
}
|
|
if (this.processClosed) {
|
|
this._setResult();
|
|
} else if (this.processExited) {
|
|
this.timeout = timers_1.setTimeout(_ExecState.HandleTimeout, this.delay, this);
|
|
}
|
|
}
|
|
_debug(message) {
|
|
this.emit("debug", message);
|
|
}
|
|
_setResult() {
|
|
let error;
|
|
if (this.processExited) {
|
|
if (this.processError) {
|
|
error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
|
|
} else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
|
|
error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
|
|
} else if (this.processStderr && this.options.failOnStdErr) {
|
|
error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
|
|
}
|
|
}
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
this.timeout = null;
|
|
}
|
|
this.done = true;
|
|
this.emit("done", error, this.processExitCode);
|
|
}
|
|
static HandleTimeout(state) {
|
|
if (state.done) {
|
|
return;
|
|
}
|
|
if (!state.processClosed && state.processExited) {
|
|
const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
|
|
state._debug(message);
|
|
}
|
|
state._setResult();
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/exec/lib/exec.js
|
|
var require_exec = __commonJS({
|
|
"node_modules/@actions/exec/lib/exec.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
Object.defineProperty(o, k2, { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} });
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__importStar || function(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.getExecOutput = exports2.exec = void 0;
|
|
var string_decoder_1 = require("string_decoder");
|
|
var tr = __importStar(require_toolrunner());
|
|
function exec2(commandLine, args, options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const commandArgs = tr.argStringToArray(commandLine);
|
|
if (commandArgs.length === 0) {
|
|
throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
|
|
}
|
|
const toolPath = commandArgs[0];
|
|
args = commandArgs.slice(1).concat(args || []);
|
|
const runner = new tr.ToolRunner(toolPath, args, options);
|
|
return runner.exec();
|
|
});
|
|
}
|
|
exports2.exec = exec2;
|
|
function getExecOutput(commandLine, args, options) {
|
|
var _a, _b;
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let stdout = "";
|
|
let stderr = "";
|
|
const stdoutDecoder = new string_decoder_1.StringDecoder("utf8");
|
|
const stderrDecoder = new string_decoder_1.StringDecoder("utf8");
|
|
const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout;
|
|
const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr;
|
|
const stdErrListener = (data) => {
|
|
stderr += stderrDecoder.write(data);
|
|
if (originalStdErrListener) {
|
|
originalStdErrListener(data);
|
|
}
|
|
};
|
|
const stdOutListener = (data) => {
|
|
stdout += stdoutDecoder.write(data);
|
|
if (originalStdoutListener) {
|
|
originalStdoutListener(data);
|
|
}
|
|
};
|
|
const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener });
|
|
const exitCode = yield exec2(commandLine, args, Object.assign(Object.assign({}, options), { listeners }));
|
|
stdout += stdoutDecoder.end();
|
|
stderr += stderrDecoder.end();
|
|
return {
|
|
exitCode,
|
|
stdout,
|
|
stderr
|
|
};
|
|
});
|
|
}
|
|
exports2.getExecOutput = getExecOutput;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/platform.js
|
|
var require_platform = __commonJS({
|
|
"node_modules/@actions/core/lib/platform.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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 __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __importDefault = exports2 && exports2.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.getDetails = exports2.isLinux = exports2.isMacOS = exports2.isWindows = exports2.arch = exports2.platform = void 0;
|
|
var os_1 = __importDefault(require("os"));
|
|
var exec2 = __importStar(require_exec());
|
|
var getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () {
|
|
const { stdout: version } = yield exec2.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', void 0, {
|
|
silent: true
|
|
});
|
|
const { stdout: name } = yield exec2.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', void 0, {
|
|
silent: true
|
|
});
|
|
return {
|
|
name: name.trim(),
|
|
version: version.trim()
|
|
};
|
|
});
|
|
var getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () {
|
|
var _a, _b, _c, _d;
|
|
const { stdout } = yield exec2.getExecOutput("sw_vers", void 0, {
|
|
silent: true
|
|
});
|
|
const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "";
|
|
const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "";
|
|
return {
|
|
name,
|
|
version
|
|
};
|
|
});
|
|
var getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () {
|
|
const { stdout } = yield exec2.getExecOutput("lsb_release", ["-i", "-r", "-s"], {
|
|
silent: true
|
|
});
|
|
const [name, version] = stdout.trim().split("\n");
|
|
return {
|
|
name,
|
|
version
|
|
};
|
|
});
|
|
exports2.platform = os_1.default.platform();
|
|
exports2.arch = os_1.default.arch();
|
|
exports2.isWindows = exports2.platform === "win32";
|
|
exports2.isMacOS = exports2.platform === "darwin";
|
|
exports2.isLinux = exports2.platform === "linux";
|
|
function getDetails() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return Object.assign(Object.assign({}, yield exports2.isWindows ? getWindowsInfo() : exports2.isMacOS ? getMacOsInfo() : getLinuxInfo()), {
|
|
platform: exports2.platform,
|
|
arch: exports2.arch,
|
|
isWindows: exports2.isWindows,
|
|
isMacOS: exports2.isMacOS,
|
|
isLinux: exports2.isLinux
|
|
});
|
|
});
|
|
}
|
|
exports2.getDetails = getDetails;
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/core.js
|
|
var require_core = __commonJS({
|
|
"node_modules/@actions/core/lib/core.js"(exports2) {
|
|
"use strict";
|
|
var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m2, k);
|
|
if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m2[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m2, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m2[k];
|
|
});
|
|
var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports2 && exports2.__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 __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.platform = exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = exports2.markdownSummary = exports2.summary = exports2.getIDToken = exports2.getState = exports2.saveState = exports2.group = exports2.endGroup = exports2.startGroup = exports2.info = exports2.notice = exports2.warning = exports2.error = exports2.debug = exports2.isDebug = exports2.setFailed = exports2.setCommandEcho = exports2.setOutput = exports2.getBooleanInput = exports2.getMultilineInput = exports2.getInput = exports2.addPath = exports2.setSecret = exports2.exportVariable = exports2.ExitCode = void 0;
|
|
var command_1 = require_command();
|
|
var file_command_1 = require_file_command();
|
|
var utils_1 = require_utils();
|
|
var os3 = __importStar(require("os"));
|
|
var path3 = __importStar(require("path"));
|
|
var oidc_utils_1 = require_oidc_utils();
|
|
var ExitCode;
|
|
(function(ExitCode2) {
|
|
ExitCode2[ExitCode2["Success"] = 0] = "Success";
|
|
ExitCode2[ExitCode2["Failure"] = 1] = "Failure";
|
|
})(ExitCode || (exports2.ExitCode = ExitCode = {}));
|
|
function exportVariable(name, val) {
|
|
const convertedVal = (0, utils_1.toCommandValue)(val);
|
|
process.env[name] = convertedVal;
|
|
const filePath = process.env["GITHUB_ENV"] || "";
|
|
if (filePath) {
|
|
return (0, file_command_1.issueFileCommand)("ENV", (0, file_command_1.prepareKeyValueMessage)(name, val));
|
|
}
|
|
(0, command_1.issueCommand)("set-env", { name }, convertedVal);
|
|
}
|
|
exports2.exportVariable = exportVariable;
|
|
function setSecret(secret) {
|
|
(0, command_1.issueCommand)("add-mask", {}, secret);
|
|
}
|
|
exports2.setSecret = setSecret;
|
|
function addPath(inputPath) {
|
|
const filePath = process.env["GITHUB_PATH"] || "";
|
|
if (filePath) {
|
|
(0, file_command_1.issueFileCommand)("PATH", inputPath);
|
|
} else {
|
|
(0, command_1.issueCommand)("add-path", {}, inputPath);
|
|
}
|
|
process.env["PATH"] = `${inputPath}${path3.delimiter}${process.env["PATH"]}`;
|
|
}
|
|
exports2.addPath = addPath;
|
|
function getInput2(name, options) {
|
|
const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
|
|
if (options && options.required && !val) {
|
|
throw new Error(`Input required and not supplied: ${name}`);
|
|
}
|
|
if (options && options.trimWhitespace === false) {
|
|
return val;
|
|
}
|
|
return val.trim();
|
|
}
|
|
exports2.getInput = getInput2;
|
|
function getMultilineInput2(name, options) {
|
|
const inputs = getInput2(name, options).split("\n").filter((x2) => x2 !== "");
|
|
if (options && options.trimWhitespace === false) {
|
|
return inputs;
|
|
}
|
|
return inputs.map((input) => input.trim());
|
|
}
|
|
exports2.getMultilineInput = getMultilineInput2;
|
|
function getBooleanInput(name, options) {
|
|
const trueValue = ["true", "True", "TRUE"];
|
|
const falseValue = ["false", "False", "FALSE"];
|
|
const val = getInput2(name, options);
|
|
if (trueValue.includes(val))
|
|
return true;
|
|
if (falseValue.includes(val))
|
|
return false;
|
|
throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}
|
|
Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
|
|
}
|
|
exports2.getBooleanInput = getBooleanInput;
|
|
function setOutput2(name, value) {
|
|
const filePath = process.env["GITHUB_OUTPUT"] || "";
|
|
if (filePath) {
|
|
return (0, file_command_1.issueFileCommand)("OUTPUT", (0, file_command_1.prepareKeyValueMessage)(name, value));
|
|
}
|
|
process.stdout.write(os3.EOL);
|
|
(0, command_1.issueCommand)("set-output", { name }, (0, utils_1.toCommandValue)(value));
|
|
}
|
|
exports2.setOutput = setOutput2;
|
|
function setCommandEcho(enabled) {
|
|
(0, command_1.issue)("echo", enabled ? "on" : "off");
|
|
}
|
|
exports2.setCommandEcho = setCommandEcho;
|
|
function setFailed2(message) {
|
|
process.exitCode = ExitCode.Failure;
|
|
error(message);
|
|
}
|
|
exports2.setFailed = setFailed2;
|
|
function isDebug() {
|
|
return process.env["RUNNER_DEBUG"] === "1";
|
|
}
|
|
exports2.isDebug = isDebug;
|
|
function debug(message) {
|
|
(0, command_1.issueCommand)("debug", {}, message);
|
|
}
|
|
exports2.debug = debug;
|
|
function error(message, properties = {}) {
|
|
(0, command_1.issueCommand)("error", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
exports2.error = error;
|
|
function warning4(message, properties = {}) {
|
|
(0, command_1.issueCommand)("warning", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
exports2.warning = warning4;
|
|
function notice(message, properties = {}) {
|
|
(0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
exports2.notice = notice;
|
|
function info4(message) {
|
|
process.stdout.write(message + os3.EOL);
|
|
}
|
|
exports2.info = info4;
|
|
function startGroup(name) {
|
|
(0, command_1.issue)("group", name);
|
|
}
|
|
exports2.startGroup = startGroup;
|
|
function endGroup() {
|
|
(0, command_1.issue)("endgroup");
|
|
}
|
|
exports2.endGroup = endGroup;
|
|
function group(name, fn) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
startGroup(name);
|
|
let result;
|
|
try {
|
|
result = yield fn();
|
|
} finally {
|
|
endGroup();
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
exports2.group = group;
|
|
function saveState2(name, value) {
|
|
const filePath = process.env["GITHUB_STATE"] || "";
|
|
if (filePath) {
|
|
return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value));
|
|
}
|
|
(0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value));
|
|
}
|
|
exports2.saveState = saveState2;
|
|
function getState2(name) {
|
|
return process.env[`STATE_${name}`] || "";
|
|
}
|
|
exports2.getState = getState2;
|
|
function getIDToken(aud) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return yield oidc_utils_1.OidcClient.getIDToken(aud);
|
|
});
|
|
}
|
|
exports2.getIDToken = getIDToken;
|
|
var summary_1 = require_summary();
|
|
Object.defineProperty(exports2, "summary", { enumerable: true, get: function() {
|
|
return summary_1.summary;
|
|
} });
|
|
var summary_2 = require_summary();
|
|
Object.defineProperty(exports2, "markdownSummary", { enumerable: true, get: function() {
|
|
return summary_2.markdownSummary;
|
|
} });
|
|
var path_utils_1 = require_path_utils();
|
|
Object.defineProperty(exports2, "toPosixPath", { enumerable: true, get: function() {
|
|
return path_utils_1.toPosixPath;
|
|
} });
|
|
Object.defineProperty(exports2, "toWin32Path", { enumerable: true, get: function() {
|
|
return path_utils_1.toWin32Path;
|
|
} });
|
|
Object.defineProperty(exports2, "toPlatformPath", { enumerable: true, get: function() {
|
|
return path_utils_1.toPlatformPath;
|
|
} });
|
|
exports2.platform = __importStar(require_platform());
|
|
}
|
|
});
|
|
|
|
// node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
|
|
var require_ponyfill_es2018 = __commonJS({
|
|
"node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module2) {
|
|
(function(global2, factory) {
|
|
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
|
|
})(exports2, function(exports3) {
|
|
"use strict";
|
|
function noop2() {
|
|
return void 0;
|
|
}
|
|
function typeIsObject(x2) {
|
|
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
|
|
}
|
|
const rethrowAssertionErrorRejection = noop2;
|
|
function setFunctionName(fn, name) {
|
|
try {
|
|
Object.defineProperty(fn, "name", {
|
|
value: name,
|
|
configurable: true
|
|
});
|
|
} catch (_a2) {
|
|
}
|
|
}
|
|
const originalPromise = Promise;
|
|
const originalPromiseThen = Promise.prototype.then;
|
|
const originalPromiseReject = Promise.reject.bind(originalPromise);
|
|
function newPromise(executor) {
|
|
return new originalPromise(executor);
|
|
}
|
|
function promiseResolvedWith(value) {
|
|
return newPromise((resolve) => resolve(value));
|
|
}
|
|
function promiseRejectedWith(reason) {
|
|
return originalPromiseReject(reason);
|
|
}
|
|
function PerformPromiseThen(promise, onFulfilled, onRejected) {
|
|
return originalPromiseThen.call(promise, onFulfilled, onRejected);
|
|
}
|
|
function uponPromise(promise, onFulfilled, onRejected) {
|
|
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
|
|
}
|
|
function uponFulfillment(promise, onFulfilled) {
|
|
uponPromise(promise, onFulfilled);
|
|
}
|
|
function uponRejection(promise, onRejected) {
|
|
uponPromise(promise, void 0, onRejected);
|
|
}
|
|
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
|
|
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
|
|
}
|
|
function setPromiseIsHandledToTrue(promise) {
|
|
PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
|
|
}
|
|
let _queueMicrotask = (callback) => {
|
|
if (typeof queueMicrotask === "function") {
|
|
_queueMicrotask = queueMicrotask;
|
|
} else {
|
|
const resolvedPromise = promiseResolvedWith(void 0);
|
|
_queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
|
|
}
|
|
return _queueMicrotask(callback);
|
|
};
|
|
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);
|
|
}
|
|
function promiseCall(F2, V, args) {
|
|
try {
|
|
return promiseResolvedWith(reflectCall(F2, V, args));
|
|
} catch (value) {
|
|
return promiseRejectedWith(value);
|
|
}
|
|
}
|
|
const QUEUE_MAX_ARRAY_SIZE = 16384;
|
|
class 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 element;
|
|
}
|
|
// The tricky thing about forEach() is that it can be called
|
|
// re-entrantly. The queue may be mutated inside the callback. It is easy to
|
|
// see that push() within the callback has no negative effects since the end
|
|
// of the queue is checked for on every iteration. If shift() is called
|
|
// repeatedly within the callback then the next iteration may return an
|
|
// element that has been removed. In this case the callback will be called
|
|
// with undefined values until we either "catch up" with elements that still
|
|
// exist or reach the back of the queue.
|
|
forEach(callback) {
|
|
let i2 = this._cursor;
|
|
let node = this._front;
|
|
let elements = node._elements;
|
|
while (i2 !== elements.length || node._next !== void 0) {
|
|
if (i2 === elements.length) {
|
|
node = node._next;
|
|
elements = node._elements;
|
|
i2 = 0;
|
|
if (elements.length === 0) {
|
|
break;
|
|
}
|
|
}
|
|
callback(elements[i2]);
|
|
++i2;
|
|
}
|
|
}
|
|
// Return the element that would be returned if shift() was called now,
|
|
// without modifying the queue.
|
|
peek() {
|
|
const front = this._front;
|
|
const cursor = this._cursor;
|
|
return front._elements[cursor];
|
|
}
|
|
}
|
|
const AbortSteps = Symbol("[[AbortSteps]]");
|
|
const ErrorSteps = Symbol("[[ErrorSteps]]");
|
|
const CancelSteps = Symbol("[[CancelSteps]]");
|
|
const PullSteps = Symbol("[[PullSteps]]");
|
|
const ReleaseSteps = Symbol("[[ReleaseSteps]]");
|
|
function ReadableStreamReaderGenericInitialize(reader, stream) {
|
|
reader._ownerReadableStream = stream;
|
|
stream._reader = reader;
|
|
if (stream._state === "readable") {
|
|
defaultReaderClosedPromiseInitialize(reader);
|
|
} else if (stream._state === "closed") {
|
|
defaultReaderClosedPromiseInitializeAsResolved(reader);
|
|
} else {
|
|
defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
|
|
}
|
|
}
|
|
function ReadableStreamReaderGenericCancel(reader, reason) {
|
|
const stream = reader._ownerReadableStream;
|
|
return ReadableStreamCancel(stream, reason);
|
|
}
|
|
function ReadableStreamReaderGenericRelease(reader) {
|
|
const stream = reader._ownerReadableStream;
|
|
if (stream._state === "readable") {
|
|
defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
|
|
} else {
|
|
defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
|
|
}
|
|
stream._readableStreamController[ReleaseSteps]();
|
|
stream._reader = void 0;
|
|
reader._ownerReadableStream = void 0;
|
|
}
|
|
function readerLockException(name) {
|
|
return new TypeError("Cannot " + name + " a stream using a released reader");
|
|
}
|
|
function defaultReaderClosedPromiseInitialize(reader) {
|
|
reader._closedPromise = newPromise((resolve, reject) => {
|
|
reader._closedPromise_resolve = resolve;
|
|
reader._closedPromise_reject = reject;
|
|
});
|
|
}
|
|
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
|
|
defaultReaderClosedPromiseInitialize(reader);
|
|
defaultReaderClosedPromiseReject(reader, reason);
|
|
}
|
|
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
|
|
defaultReaderClosedPromiseInitialize(reader);
|
|
defaultReaderClosedPromiseResolve(reader);
|
|
}
|
|
function defaultReaderClosedPromiseReject(reader, reason) {
|
|
if (reader._closedPromise_reject === void 0) {
|
|
return;
|
|
}
|
|
setPromiseIsHandledToTrue(reader._closedPromise);
|
|
reader._closedPromise_reject(reason);
|
|
reader._closedPromise_resolve = void 0;
|
|
reader._closedPromise_reject = void 0;
|
|
}
|
|
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
|
|
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
|
|
}
|
|
function defaultReaderClosedPromiseResolve(reader) {
|
|
if (reader._closedPromise_resolve === void 0) {
|
|
return;
|
|
}
|
|
reader._closedPromise_resolve(void 0);
|
|
reader._closedPromise_resolve = void 0;
|
|
reader._closedPromise_reject = void 0;
|
|
}
|
|
const NumberIsFinite = Number.isFinite || function(x2) {
|
|
return typeof x2 === "number" && isFinite(x2);
|
|
};
|
|
const MathTrunc = Math.trunc || function(v) {
|
|
return v < 0 ? Math.ceil(v) : Math.floor(v);
|
|
};
|
|
function isDictionary(x2) {
|
|
return typeof x2 === "object" || typeof x2 === "function";
|
|
}
|
|
function assertDictionary(obj, context) {
|
|
if (obj !== void 0 && !isDictionary(obj)) {
|
|
throw new TypeError(`${context} is not an object.`);
|
|
}
|
|
}
|
|
function assertFunction(x2, context) {
|
|
if (typeof x2 !== "function") {
|
|
throw new TypeError(`${context} is not a function.`);
|
|
}
|
|
}
|
|
function isObject(x2) {
|
|
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
|
|
}
|
|
function assertObject(x2, context) {
|
|
if (!isObject(x2)) {
|
|
throw new TypeError(`${context} is not an object.`);
|
|
}
|
|
}
|
|
function assertRequiredArgument(x2, position, context) {
|
|
if (x2 === void 0) {
|
|
throw new TypeError(`Parameter ${position} is required in '${context}'.`);
|
|
}
|
|
}
|
|
function assertRequiredField(x2, field, context) {
|
|
if (x2 === void 0) {
|
|
throw new TypeError(`${field} is required in '${context}'.`);
|
|
}
|
|
}
|
|
function convertUnrestrictedDouble(value) {
|
|
return Number(value);
|
|
}
|
|
function censorNegativeZero(x2) {
|
|
return x2 === 0 ? 0 : x2;
|
|
}
|
|
function integerPart(x2) {
|
|
return censorNegativeZero(MathTrunc(x2));
|
|
}
|
|
function convertUnsignedLongLongWithEnforceRange(value, context) {
|
|
const lowerBound = 0;
|
|
const upperBound = Number.MAX_SAFE_INTEGER;
|
|
let x2 = Number(value);
|
|
x2 = censorNegativeZero(x2);
|
|
if (!NumberIsFinite(x2)) {
|
|
throw new TypeError(`${context} is not a finite number`);
|
|
}
|
|
x2 = integerPart(x2);
|
|
if (x2 < lowerBound || x2 > upperBound) {
|
|
throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
|
|
}
|
|
if (!NumberIsFinite(x2) || x2 === 0) {
|
|
return 0;
|
|
}
|
|
return x2;
|
|
}
|
|
function assertReadableStream(x2, context) {
|
|
if (!IsReadableStream(x2)) {
|
|
throw new TypeError(`${context} is not a ReadableStream.`);
|
|
}
|
|
}
|
|
function AcquireReadableStreamDefaultReader(stream) {
|
|
return new ReadableStreamDefaultReader(stream);
|
|
}
|
|
function ReadableStreamAddReadRequest(stream, readRequest) {
|
|
stream._reader._readRequests.push(readRequest);
|
|
}
|
|
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
|
|
const reader = stream._reader;
|
|
const readRequest = reader._readRequests.shift();
|
|
if (done) {
|
|
readRequest._closeSteps();
|
|
} else {
|
|
readRequest._chunkSteps(chunk);
|
|
}
|
|
}
|
|
function ReadableStreamGetNumReadRequests(stream) {
|
|
return stream._reader._readRequests.length;
|
|
}
|
|
function ReadableStreamHasDefaultReader(stream) {
|
|
const reader = stream._reader;
|
|
if (reader === void 0) {
|
|
return false;
|
|
}
|
|
if (!IsReadableStreamDefaultReader(reader)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
class ReadableStreamDefaultReader {
|
|
constructor(stream) {
|
|
assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader");
|
|
assertReadableStream(stream, "First parameter");
|
|
if (IsReadableStreamLocked(stream)) {
|
|
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
|
|
}
|
|
ReadableStreamReaderGenericInitialize(this, stream);
|
|
this._readRequests = new SimpleQueue();
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed,
|
|
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
|
|
*/
|
|
get closed() {
|
|
if (!IsReadableStreamDefaultReader(this)) {
|
|
return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
|
|
}
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
|
|
*/
|
|
cancel(reason = void 0) {
|
|
if (!IsReadableStreamDefaultReader(this)) {
|
|
return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return promiseRejectedWith(readerLockException("cancel"));
|
|
}
|
|
return ReadableStreamReaderGenericCancel(this, reason);
|
|
}
|
|
/**
|
|
* Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
|
|
*
|
|
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
|
|
*/
|
|
read() {
|
|
if (!IsReadableStreamDefaultReader(this)) {
|
|
return promiseRejectedWith(defaultReaderBrandCheckException("read"));
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return promiseRejectedWith(readerLockException("read from"));
|
|
}
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject) => {
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readRequest = {
|
|
_chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }),
|
|
_closeSteps: () => resolvePromise({ value: void 0, done: true }),
|
|
_errorSteps: (e2) => rejectPromise(e2)
|
|
};
|
|
ReadableStreamDefaultReaderRead(this, readRequest);
|
|
return promise;
|
|
}
|
|
/**
|
|
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
|
|
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
|
|
* from now on; otherwise, the reader will appear closed.
|
|
*
|
|
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
|
|
* the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
|
|
* do so will throw a `TypeError` and leave the reader locked to the stream.
|
|
*/
|
|
releaseLock() {
|
|
if (!IsReadableStreamDefaultReader(this)) {
|
|
throw defaultReaderBrandCheckException("releaseLock");
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return;
|
|
}
|
|
ReadableStreamDefaultReaderRelease(this);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
|
|
cancel: { enumerable: true },
|
|
read: { enumerable: true },
|
|
releaseLock: { enumerable: true },
|
|
closed: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
|
|
setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
|
|
setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
|
|
value: "ReadableStreamDefaultReader",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsReadableStreamDefaultReader(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_readRequests")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableStreamDefaultReader;
|
|
}
|
|
function ReadableStreamDefaultReaderRead(reader, readRequest) {
|
|
const stream = reader._ownerReadableStream;
|
|
stream._disturbed = true;
|
|
if (stream._state === "closed") {
|
|
readRequest._closeSteps();
|
|
} else if (stream._state === "errored") {
|
|
readRequest._errorSteps(stream._storedError);
|
|
} else {
|
|
stream._readableStreamController[PullSteps](readRequest);
|
|
}
|
|
}
|
|
function ReadableStreamDefaultReaderRelease(reader) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
const e2 = new TypeError("Reader was released");
|
|
ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
|
|
}
|
|
function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
|
|
const readRequests = reader._readRequests;
|
|
reader._readRequests = new SimpleQueue();
|
|
readRequests.forEach((readRequest) => {
|
|
readRequest._errorSteps(e2);
|
|
});
|
|
}
|
|
function defaultReaderBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
|
|
}
|
|
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
|
|
}).prototype);
|
|
class ReadableStreamAsyncIteratorImpl {
|
|
constructor(reader, preventCancel) {
|
|
this._ongoingPromise = void 0;
|
|
this._isFinished = false;
|
|
this._reader = reader;
|
|
this._preventCancel = preventCancel;
|
|
}
|
|
next() {
|
|
const nextSteps = () => this._nextSteps();
|
|
this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
|
|
return this._ongoingPromise;
|
|
}
|
|
return(value) {
|
|
const returnSteps = () => this._returnSteps(value);
|
|
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
|
|
}
|
|
_nextSteps() {
|
|
if (this._isFinished) {
|
|
return Promise.resolve({ value: void 0, done: true });
|
|
}
|
|
const reader = this._reader;
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject) => {
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readRequest = {
|
|
_chunkSteps: (chunk) => {
|
|
this._ongoingPromise = void 0;
|
|
_queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
|
|
},
|
|
_closeSteps: () => {
|
|
this._ongoingPromise = void 0;
|
|
this._isFinished = true;
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
resolvePromise({ value: void 0, done: true });
|
|
},
|
|
_errorSteps: (reason) => {
|
|
this._ongoingPromise = void 0;
|
|
this._isFinished = true;
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
rejectPromise(reason);
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
return promise;
|
|
}
|
|
_returnSteps(value) {
|
|
if (this._isFinished) {
|
|
return Promise.resolve({ value, done: true });
|
|
}
|
|
this._isFinished = true;
|
|
const reader = this._reader;
|
|
if (!this._preventCancel) {
|
|
const result = ReadableStreamReaderGenericCancel(reader, value);
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
return transformPromiseWith(result, () => ({ value, done: true }));
|
|
}
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
return promiseResolvedWith({ value, done: true });
|
|
}
|
|
}
|
|
const ReadableStreamAsyncIteratorPrototype = {
|
|
next() {
|
|
if (!IsReadableStreamAsyncIterator(this)) {
|
|
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
|
|
}
|
|
return this._asyncIteratorImpl.next();
|
|
},
|
|
return(value) {
|
|
if (!IsReadableStreamAsyncIterator(this)) {
|
|
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
|
|
}
|
|
return this._asyncIteratorImpl.return(value);
|
|
}
|
|
};
|
|
Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
|
|
function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
|
|
const reader = AcquireReadableStreamDefaultReader(stream);
|
|
const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
|
|
const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
|
|
iterator._asyncIteratorImpl = impl;
|
|
return iterator;
|
|
}
|
|
function IsReadableStreamAsyncIterator(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_asyncIteratorImpl")) {
|
|
return false;
|
|
}
|
|
try {
|
|
return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
|
|
} catch (_a2) {
|
|
return false;
|
|
}
|
|
}
|
|
function streamAsyncIteratorBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
|
|
}
|
|
const NumberIsNaN = Number.isNaN || function(x2) {
|
|
return x2 !== x2;
|
|
};
|
|
var _a, _b, _c;
|
|
function CreateArrayFromList(elements) {
|
|
return elements.slice();
|
|
}
|
|
function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
|
|
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
|
|
}
|
|
let TransferArrayBuffer = (O) => {
|
|
if (typeof O.transfer === "function") {
|
|
TransferArrayBuffer = (buffer) => buffer.transfer();
|
|
} else if (typeof structuredClone === "function") {
|
|
TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
|
|
} else {
|
|
TransferArrayBuffer = (buffer) => buffer;
|
|
}
|
|
return TransferArrayBuffer(O);
|
|
};
|
|
let IsDetachedBuffer = (O) => {
|
|
if (typeof O.detached === "boolean") {
|
|
IsDetachedBuffer = (buffer) => buffer.detached;
|
|
} else {
|
|
IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
|
|
}
|
|
return IsDetachedBuffer(O);
|
|
};
|
|
function ArrayBufferSlice(buffer, begin, end) {
|
|
if (buffer.slice) {
|
|
return buffer.slice(begin, end);
|
|
}
|
|
const length = end - begin;
|
|
const slice = new ArrayBuffer(length);
|
|
CopyDataBlockBytes(slice, 0, buffer, begin, length);
|
|
return slice;
|
|
}
|
|
function GetMethod(receiver, prop) {
|
|
const func = receiver[prop];
|
|
if (func === void 0 || func === null) {
|
|
return void 0;
|
|
}
|
|
if (typeof func !== "function") {
|
|
throw new TypeError(`${String(prop)} is not a function`);
|
|
}
|
|
return func;
|
|
}
|
|
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
|
|
const syncIterable = {
|
|
[Symbol.iterator]: () => syncIteratorRecord.iterator
|
|
};
|
|
const asyncIterator = async function* () {
|
|
return yield* syncIterable;
|
|
}();
|
|
const nextMethod = asyncIterator.next;
|
|
return { iterator: asyncIterator, nextMethod, done: false };
|
|
}
|
|
const SymbolAsyncIterator = (_c = (_a = Symbol.asyncIterator) !== null && _a !== void 0 ? _a : (_b = Symbol.for) === null || _b === void 0 ? void 0 : _b.call(Symbol, "Symbol.asyncIterator")) !== null && _c !== void 0 ? _c : "@@asyncIterator";
|
|
function GetIterator(obj, hint = "sync", method) {
|
|
if (method === void 0) {
|
|
if (hint === "async") {
|
|
method = GetMethod(obj, SymbolAsyncIterator);
|
|
if (method === void 0) {
|
|
const syncMethod = GetMethod(obj, Symbol.iterator);
|
|
const syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
|
|
return CreateAsyncFromSyncIterator(syncIteratorRecord);
|
|
}
|
|
} else {
|
|
method = GetMethod(obj, Symbol.iterator);
|
|
}
|
|
}
|
|
if (method === void 0) {
|
|
throw new TypeError("The object is not iterable");
|
|
}
|
|
const iterator = reflectCall(method, obj, []);
|
|
if (!typeIsObject(iterator)) {
|
|
throw new TypeError("The iterator method must return an object");
|
|
}
|
|
const nextMethod = iterator.next;
|
|
return { iterator, nextMethod, done: false };
|
|
}
|
|
function IteratorNext(iteratorRecord) {
|
|
const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
|
|
if (!typeIsObject(result)) {
|
|
throw new TypeError("The iterator.next() method must return an object");
|
|
}
|
|
return result;
|
|
}
|
|
function IteratorComplete(iterResult) {
|
|
return Boolean(iterResult.done);
|
|
}
|
|
function IteratorValue(iterResult) {
|
|
return iterResult.value;
|
|
}
|
|
function IsNonNegativeNumber(v) {
|
|
if (typeof v !== "number") {
|
|
return false;
|
|
}
|
|
if (NumberIsNaN(v)) {
|
|
return false;
|
|
}
|
|
if (v < 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function CloneAsUint8Array(O) {
|
|
const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
|
|
return new Uint8Array(buffer);
|
|
}
|
|
function DequeueValue(container) {
|
|
const pair = container._queue.shift();
|
|
container._queueTotalSize -= pair.size;
|
|
if (container._queueTotalSize < 0) {
|
|
container._queueTotalSize = 0;
|
|
}
|
|
return pair.value;
|
|
}
|
|
function EnqueueValueWithSize(container, value, size) {
|
|
if (!IsNonNegativeNumber(size) || size === Infinity) {
|
|
throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
|
|
}
|
|
container._queue.push({ value, size });
|
|
container._queueTotalSize += size;
|
|
}
|
|
function PeekQueueValue(container) {
|
|
const pair = container._queue.peek();
|
|
return pair.value;
|
|
}
|
|
function ResetQueue(container) {
|
|
container._queue = new SimpleQueue();
|
|
container._queueTotalSize = 0;
|
|
}
|
|
function isDataViewConstructor(ctor) {
|
|
return ctor === DataView;
|
|
}
|
|
function isDataView(view) {
|
|
return isDataViewConstructor(view.constructor);
|
|
}
|
|
function arrayBufferViewElementSize(ctor) {
|
|
if (isDataViewConstructor(ctor)) {
|
|
return 1;
|
|
}
|
|
return ctor.BYTES_PER_ELEMENT;
|
|
}
|
|
class ReadableStreamBYOBRequest {
|
|
constructor() {
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
|
|
*/
|
|
get view() {
|
|
if (!IsReadableStreamBYOBRequest(this)) {
|
|
throw byobRequestBrandCheckException("view");
|
|
}
|
|
return this._view;
|
|
}
|
|
respond(bytesWritten) {
|
|
if (!IsReadableStreamBYOBRequest(this)) {
|
|
throw byobRequestBrandCheckException("respond");
|
|
}
|
|
assertRequiredArgument(bytesWritten, 1, "respond");
|
|
bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter");
|
|
if (this._associatedReadableByteStreamController === void 0) {
|
|
throw new TypeError("This BYOB request has been invalidated");
|
|
}
|
|
if (IsDetachedBuffer(this._view.buffer)) {
|
|
throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
|
|
}
|
|
ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
|
|
}
|
|
respondWithNewView(view) {
|
|
if (!IsReadableStreamBYOBRequest(this)) {
|
|
throw byobRequestBrandCheckException("respondWithNewView");
|
|
}
|
|
assertRequiredArgument(view, 1, "respondWithNewView");
|
|
if (!ArrayBuffer.isView(view)) {
|
|
throw new TypeError("You can only respond with array buffer views");
|
|
}
|
|
if (this._associatedReadableByteStreamController === void 0) {
|
|
throw new TypeError("This BYOB request has been invalidated");
|
|
}
|
|
if (IsDetachedBuffer(view.buffer)) {
|
|
throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
|
|
}
|
|
ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
|
|
respond: { enumerable: true },
|
|
respondWithNewView: { enumerable: true },
|
|
view: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
|
|
setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
|
|
value: "ReadableStreamBYOBRequest",
|
|
configurable: true
|
|
});
|
|
}
|
|
class ReadableByteStreamController {
|
|
constructor() {
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the current BYOB pull request, or `null` if there isn't one.
|
|
*/
|
|
get byobRequest() {
|
|
if (!IsReadableByteStreamController(this)) {
|
|
throw byteStreamControllerBrandCheckException("byobRequest");
|
|
}
|
|
return ReadableByteStreamControllerGetBYOBRequest(this);
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
|
|
* over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
|
|
*/
|
|
get desiredSize() {
|
|
if (!IsReadableByteStreamController(this)) {
|
|
throw byteStreamControllerBrandCheckException("desiredSize");
|
|
}
|
|
return ReadableByteStreamControllerGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
|
|
* the stream, but once those are read, the stream will become closed.
|
|
*/
|
|
close() {
|
|
if (!IsReadableByteStreamController(this)) {
|
|
throw byteStreamControllerBrandCheckException("close");
|
|
}
|
|
if (this._closeRequested) {
|
|
throw new TypeError("The stream has already been closed; do not close it again!");
|
|
}
|
|
const state = this._controlledReadableByteStream._state;
|
|
if (state !== "readable") {
|
|
throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);
|
|
}
|
|
ReadableByteStreamControllerClose(this);
|
|
}
|
|
enqueue(chunk) {
|
|
if (!IsReadableByteStreamController(this)) {
|
|
throw byteStreamControllerBrandCheckException("enqueue");
|
|
}
|
|
assertRequiredArgument(chunk, 1, "enqueue");
|
|
if (!ArrayBuffer.isView(chunk)) {
|
|
throw new TypeError("chunk must be an array buffer view");
|
|
}
|
|
if (chunk.byteLength === 0) {
|
|
throw new TypeError("chunk must have non-zero byteLength");
|
|
}
|
|
if (chunk.buffer.byteLength === 0) {
|
|
throw new TypeError(`chunk's buffer must have non-zero byteLength`);
|
|
}
|
|
if (this._closeRequested) {
|
|
throw new TypeError("stream is closed or draining");
|
|
}
|
|
const state = this._controlledReadableByteStream._state;
|
|
if (state !== "readable") {
|
|
throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);
|
|
}
|
|
ReadableByteStreamControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
|
|
*/
|
|
error(e2 = void 0) {
|
|
if (!IsReadableByteStreamController(this)) {
|
|
throw byteStreamControllerBrandCheckException("error");
|
|
}
|
|
ReadableByteStreamControllerError(this, e2);
|
|
}
|
|
/** @internal */
|
|
[CancelSteps](reason) {
|
|
ReadableByteStreamControllerClearPendingPullIntos(this);
|
|
ResetQueue(this);
|
|
const result = this._cancelAlgorithm(reason);
|
|
ReadableByteStreamControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */
|
|
[PullSteps](readRequest) {
|
|
const stream = this._controlledReadableByteStream;
|
|
if (this._queueTotalSize > 0) {
|
|
ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
|
|
return;
|
|
}
|
|
const autoAllocateChunkSize = this._autoAllocateChunkSize;
|
|
if (autoAllocateChunkSize !== void 0) {
|
|
let buffer;
|
|
try {
|
|
buffer = new ArrayBuffer(autoAllocateChunkSize);
|
|
} catch (bufferE) {
|
|
readRequest._errorSteps(bufferE);
|
|
return;
|
|
}
|
|
const pullIntoDescriptor = {
|
|
buffer,
|
|
bufferByteLength: autoAllocateChunkSize,
|
|
byteOffset: 0,
|
|
byteLength: autoAllocateChunkSize,
|
|
bytesFilled: 0,
|
|
minimumFill: 1,
|
|
elementSize: 1,
|
|
viewConstructor: Uint8Array,
|
|
readerType: "default"
|
|
};
|
|
this._pendingPullIntos.push(pullIntoDescriptor);
|
|
}
|
|
ReadableStreamAddReadRequest(stream, readRequest);
|
|
ReadableByteStreamControllerCallPullIfNeeded(this);
|
|
}
|
|
/** @internal */
|
|
[ReleaseSteps]() {
|
|
if (this._pendingPullIntos.length > 0) {
|
|
const firstPullInto = this._pendingPullIntos.peek();
|
|
firstPullInto.readerType = "none";
|
|
this._pendingPullIntos = new SimpleQueue();
|
|
this._pendingPullIntos.push(firstPullInto);
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableByteStreamController.prototype, {
|
|
close: { enumerable: true },
|
|
enqueue: { enumerable: true },
|
|
error: { enumerable: true },
|
|
byobRequest: { enumerable: true },
|
|
desiredSize: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableByteStreamController.prototype.close, "close");
|
|
setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
|
|
setFunctionName(ReadableByteStreamController.prototype.error, "error");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
|
|
value: "ReadableByteStreamController",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsReadableByteStreamController(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_controlledReadableByteStream")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableByteStreamController;
|
|
}
|
|
function IsReadableStreamBYOBRequest(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_associatedReadableByteStreamController")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableStreamBYOBRequest;
|
|
}
|
|
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
|
|
const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
|
|
if (!shouldPull) {
|
|
return;
|
|
}
|
|
if (controller._pulling) {
|
|
controller._pullAgain = true;
|
|
return;
|
|
}
|
|
controller._pulling = true;
|
|
const pullPromise = controller._pullAlgorithm();
|
|
uponPromise(pullPromise, () => {
|
|
controller._pulling = false;
|
|
if (controller._pullAgain) {
|
|
controller._pullAgain = false;
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
return null;
|
|
}, (e2) => {
|
|
ReadableByteStreamControllerError(controller, e2);
|
|
return null;
|
|
});
|
|
}
|
|
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
controller._pendingPullIntos = new SimpleQueue();
|
|
}
|
|
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
|
|
let done = false;
|
|
if (stream._state === "closed") {
|
|
done = true;
|
|
}
|
|
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
|
if (pullIntoDescriptor.readerType === "default") {
|
|
ReadableStreamFulfillReadRequest(stream, filledView, done);
|
|
} else {
|
|
ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
|
|
const bytesFilled = pullIntoDescriptor.bytesFilled;
|
|
const elementSize = pullIntoDescriptor.elementSize;
|
|
return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
|
|
}
|
|
function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
|
|
controller._queue.push({ buffer, byteOffset, byteLength });
|
|
controller._queueTotalSize += byteLength;
|
|
}
|
|
function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
|
|
let clonedChunk;
|
|
try {
|
|
clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
|
|
} catch (cloneE) {
|
|
ReadableByteStreamControllerError(controller, cloneE);
|
|
throw cloneE;
|
|
}
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
|
|
}
|
|
function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
|
|
if (firstDescriptor.bytesFilled > 0) {
|
|
ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
|
|
}
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
}
|
|
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
|
|
const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
|
|
const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
|
|
let totalBytesToCopyRemaining = maxBytesToCopy;
|
|
let ready = false;
|
|
const remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
|
|
const maxAlignedBytes = maxBytesFilled - remainderBytes;
|
|
if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
|
|
totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
|
|
ready = true;
|
|
}
|
|
const queue = controller._queue;
|
|
while (totalBytesToCopyRemaining > 0) {
|
|
const headOfQueue = queue.peek();
|
|
const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
|
|
const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
|
CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
|
|
if (headOfQueue.byteLength === bytesToCopy) {
|
|
queue.shift();
|
|
} else {
|
|
headOfQueue.byteOffset += bytesToCopy;
|
|
headOfQueue.byteLength -= bytesToCopy;
|
|
}
|
|
controller._queueTotalSize -= bytesToCopy;
|
|
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
|
|
totalBytesToCopyRemaining -= bytesToCopy;
|
|
}
|
|
return ready;
|
|
}
|
|
function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
|
|
pullIntoDescriptor.bytesFilled += size;
|
|
}
|
|
function ReadableByteStreamControllerHandleQueueDrain(controller) {
|
|
if (controller._queueTotalSize === 0 && controller._closeRequested) {
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(controller._controlledReadableByteStream);
|
|
} else {
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
|
|
if (controller._byobRequest === null) {
|
|
return;
|
|
}
|
|
controller._byobRequest._associatedReadableByteStreamController = void 0;
|
|
controller._byobRequest._view = null;
|
|
controller._byobRequest = null;
|
|
}
|
|
function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
|
|
while (controller._pendingPullIntos.length > 0) {
|
|
if (controller._queueTotalSize === 0) {
|
|
return;
|
|
}
|
|
const pullIntoDescriptor = controller._pendingPullIntos.peek();
|
|
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
|
|
}
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
|
|
const reader = controller._controlledReadableByteStream._reader;
|
|
while (reader._readRequests.length > 0) {
|
|
if (controller._queueTotalSize === 0) {
|
|
return;
|
|
}
|
|
const readRequest = reader._readRequests.shift();
|
|
ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
const ctor = view.constructor;
|
|
const elementSize = arrayBufferViewElementSize(ctor);
|
|
const { byteOffset, byteLength } = view;
|
|
const minimumFill = min * elementSize;
|
|
let buffer;
|
|
try {
|
|
buffer = TransferArrayBuffer(view.buffer);
|
|
} catch (e2) {
|
|
readIntoRequest._errorSteps(e2);
|
|
return;
|
|
}
|
|
const pullIntoDescriptor = {
|
|
buffer,
|
|
bufferByteLength: buffer.byteLength,
|
|
byteOffset,
|
|
byteLength,
|
|
bytesFilled: 0,
|
|
minimumFill,
|
|
elementSize,
|
|
viewConstructor: ctor,
|
|
readerType: "byob"
|
|
};
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
controller._pendingPullIntos.push(pullIntoDescriptor);
|
|
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
|
|
return;
|
|
}
|
|
if (stream._state === "closed") {
|
|
const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
|
|
readIntoRequest._closeSteps(emptyView);
|
|
return;
|
|
}
|
|
if (controller._queueTotalSize > 0) {
|
|
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
|
|
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
|
ReadableByteStreamControllerHandleQueueDrain(controller);
|
|
readIntoRequest._chunkSteps(filledView);
|
|
return;
|
|
}
|
|
if (controller._closeRequested) {
|
|
const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
|
|
ReadableByteStreamControllerError(controller, e2);
|
|
readIntoRequest._errorSteps(e2);
|
|
return;
|
|
}
|
|
}
|
|
controller._pendingPullIntos.push(pullIntoDescriptor);
|
|
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
|
|
if (firstDescriptor.readerType === "none") {
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
}
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (ReadableStreamHasBYOBReader(stream)) {
|
|
while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
|
|
const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
|
|
}
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
|
|
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
|
|
if (pullIntoDescriptor.readerType === "none") {
|
|
ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
|
|
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
|
return;
|
|
}
|
|
if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) {
|
|
return;
|
|
}
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
|
|
if (remainderSize > 0) {
|
|
const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
|
ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
|
|
}
|
|
pullIntoDescriptor.bytesFilled -= remainderSize;
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
|
|
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
|
}
|
|
function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") {
|
|
ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
|
|
} else {
|
|
ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
|
|
}
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerShiftPendingPullInto(controller) {
|
|
const descriptor = controller._pendingPullIntos.shift();
|
|
return descriptor;
|
|
}
|
|
function ReadableByteStreamControllerShouldCallPull(controller) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (stream._state !== "readable") {
|
|
return false;
|
|
}
|
|
if (controller._closeRequested) {
|
|
return false;
|
|
}
|
|
if (!controller._started) {
|
|
return false;
|
|
}
|
|
if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
|
|
return true;
|
|
}
|
|
if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
|
|
return true;
|
|
}
|
|
const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
|
|
if (desiredSize > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function ReadableByteStreamControllerClearAlgorithms(controller) {
|
|
controller._pullAlgorithm = void 0;
|
|
controller._cancelAlgorithm = void 0;
|
|
}
|
|
function ReadableByteStreamControllerClose(controller) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (controller._closeRequested || stream._state !== "readable") {
|
|
return;
|
|
}
|
|
if (controller._queueTotalSize > 0) {
|
|
controller._closeRequested = true;
|
|
return;
|
|
}
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
const firstPendingPullInto = controller._pendingPullIntos.peek();
|
|
if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
|
|
const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
|
|
ReadableByteStreamControllerError(controller, e2);
|
|
throw e2;
|
|
}
|
|
}
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(stream);
|
|
}
|
|
function ReadableByteStreamControllerEnqueue(controller, chunk) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (controller._closeRequested || stream._state !== "readable") {
|
|
return;
|
|
}
|
|
const { buffer, byteOffset, byteLength } = chunk;
|
|
if (IsDetachedBuffer(buffer)) {
|
|
throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
|
|
}
|
|
const transferredBuffer = TransferArrayBuffer(buffer);
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
const firstPendingPullInto = controller._pendingPullIntos.peek();
|
|
if (IsDetachedBuffer(firstPendingPullInto.buffer)) {
|
|
throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
|
|
}
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
|
|
if (firstPendingPullInto.readerType === "none") {
|
|
ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
|
|
}
|
|
}
|
|
if (ReadableStreamHasDefaultReader(stream)) {
|
|
ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
|
|
if (ReadableStreamGetNumReadRequests(stream) === 0) {
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
} else {
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
}
|
|
const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
|
|
ReadableStreamFulfillReadRequest(stream, transferredView, false);
|
|
}
|
|
} else if (ReadableStreamHasBYOBReader(stream)) {
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
|
} else {
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
}
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerError(controller, e2) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (stream._state !== "readable") {
|
|
return;
|
|
}
|
|
ReadableByteStreamControllerClearPendingPullIntos(controller);
|
|
ResetQueue(controller);
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamError(stream, e2);
|
|
}
|
|
function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
|
|
const entry = controller._queue.shift();
|
|
controller._queueTotalSize -= entry.byteLength;
|
|
ReadableByteStreamControllerHandleQueueDrain(controller);
|
|
const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
|
|
readRequest._chunkSteps(view);
|
|
}
|
|
function ReadableByteStreamControllerGetBYOBRequest(controller) {
|
|
if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
|
|
const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
|
|
SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
|
|
controller._byobRequest = byobRequest;
|
|
}
|
|
return controller._byobRequest;
|
|
}
|
|
function ReadableByteStreamControllerGetDesiredSize(controller) {
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "errored") {
|
|
return null;
|
|
}
|
|
if (state === "closed") {
|
|
return 0;
|
|
}
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
function ReadableByteStreamControllerRespond(controller, bytesWritten) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") {
|
|
if (bytesWritten !== 0) {
|
|
throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
|
|
}
|
|
} else {
|
|
if (bytesWritten === 0) {
|
|
throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
|
|
}
|
|
if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
|
|
throw new RangeError("bytesWritten out of range");
|
|
}
|
|
}
|
|
firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
|
|
ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
|
|
}
|
|
function ReadableByteStreamControllerRespondWithNewView(controller, view) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") {
|
|
if (view.byteLength !== 0) {
|
|
throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
|
|
}
|
|
} else {
|
|
if (view.byteLength === 0) {
|
|
throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
|
|
}
|
|
}
|
|
if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
|
|
throw new RangeError("The region specified by view does not match byobRequest");
|
|
}
|
|
if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {
|
|
throw new RangeError("The buffer of view has different capacity than byobRequest");
|
|
}
|
|
if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
|
|
throw new RangeError("The region specified by view is larger than byobRequest");
|
|
}
|
|
const viewByteLength = view.byteLength;
|
|
firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
|
|
ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
|
|
}
|
|
function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
|
|
controller._controlledReadableByteStream = stream;
|
|
controller._pullAgain = false;
|
|
controller._pulling = false;
|
|
controller._byobRequest = null;
|
|
controller._queue = controller._queueTotalSize = void 0;
|
|
ResetQueue(controller);
|
|
controller._closeRequested = false;
|
|
controller._started = false;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._pullAlgorithm = pullAlgorithm;
|
|
controller._cancelAlgorithm = cancelAlgorithm;
|
|
controller._autoAllocateChunkSize = autoAllocateChunkSize;
|
|
controller._pendingPullIntos = new SimpleQueue();
|
|
stream._readableStreamController = controller;
|
|
const startResult = startAlgorithm();
|
|
uponPromise(promiseResolvedWith(startResult), () => {
|
|
controller._started = true;
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
return null;
|
|
}, (r2) => {
|
|
ReadableByteStreamControllerError(controller, r2);
|
|
return null;
|
|
});
|
|
}
|
|
function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
|
|
const controller = Object.create(ReadableByteStreamController.prototype);
|
|
let startAlgorithm;
|
|
let pullAlgorithm;
|
|
let cancelAlgorithm;
|
|
if (underlyingByteSource.start !== void 0) {
|
|
startAlgorithm = () => underlyingByteSource.start(controller);
|
|
} else {
|
|
startAlgorithm = () => void 0;
|
|
}
|
|
if (underlyingByteSource.pull !== void 0) {
|
|
pullAlgorithm = () => underlyingByteSource.pull(controller);
|
|
} else {
|
|
pullAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
if (underlyingByteSource.cancel !== void 0) {
|
|
cancelAlgorithm = (reason) => underlyingByteSource.cancel(reason);
|
|
} else {
|
|
cancelAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
|
|
if (autoAllocateChunkSize === 0) {
|
|
throw new TypeError("autoAllocateChunkSize must be greater than 0");
|
|
}
|
|
SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
|
|
}
|
|
function SetUpReadableStreamBYOBRequest(request, controller, view) {
|
|
request._associatedReadableByteStreamController = controller;
|
|
request._view = view;
|
|
}
|
|
function byobRequestBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
|
|
}
|
|
function byteStreamControllerBrandCheckException(name) {
|
|
return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
|
|
}
|
|
function convertReaderOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const mode = options === null || options === void 0 ? void 0 : options.mode;
|
|
return {
|
|
mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
|
|
};
|
|
}
|
|
function convertReadableStreamReaderMode(mode, context) {
|
|
mode = `${mode}`;
|
|
if (mode !== "byob") {
|
|
throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
|
|
}
|
|
return mode;
|
|
}
|
|
function convertByobReadOptions(options, context) {
|
|
var _a2;
|
|
assertDictionary(options, context);
|
|
const min = (_a2 = options === null || options === void 0 ? void 0 : options.min) !== null && _a2 !== void 0 ? _a2 : 1;
|
|
return {
|
|
min: convertUnsignedLongLongWithEnforceRange(min, `${context} has member 'min' that`)
|
|
};
|
|
}
|
|
function AcquireReadableStreamBYOBReader(stream) {
|
|
return new ReadableStreamBYOBReader(stream);
|
|
}
|
|
function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {
|
|
stream._reader._readIntoRequests.push(readIntoRequest);
|
|
}
|
|
function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
|
|
const reader = stream._reader;
|
|
const readIntoRequest = reader._readIntoRequests.shift();
|
|
if (done) {
|
|
readIntoRequest._closeSteps(chunk);
|
|
} else {
|
|
readIntoRequest._chunkSteps(chunk);
|
|
}
|
|
}
|
|
function ReadableStreamGetNumReadIntoRequests(stream) {
|
|
return stream._reader._readIntoRequests.length;
|
|
}
|
|
function ReadableStreamHasBYOBReader(stream) {
|
|
const reader = stream._reader;
|
|
if (reader === void 0) {
|
|
return false;
|
|
}
|
|
if (!IsReadableStreamBYOBReader(reader)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
class ReadableStreamBYOBReader {
|
|
constructor(stream) {
|
|
assertRequiredArgument(stream, 1, "ReadableStreamBYOBReader");
|
|
assertReadableStream(stream, "First parameter");
|
|
if (IsReadableStreamLocked(stream)) {
|
|
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
|
|
}
|
|
if (!IsReadableByteStreamController(stream._readableStreamController)) {
|
|
throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
|
|
}
|
|
ReadableStreamReaderGenericInitialize(this, stream);
|
|
this._readIntoRequests = new SimpleQueue();
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
|
|
* the reader's lock is released before the stream finishes closing.
|
|
*/
|
|
get closed() {
|
|
if (!IsReadableStreamBYOBReader(this)) {
|
|
return promiseRejectedWith(byobReaderBrandCheckException("closed"));
|
|
}
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
|
|
*/
|
|
cancel(reason = void 0) {
|
|
if (!IsReadableStreamBYOBReader(this)) {
|
|
return promiseRejectedWith(byobReaderBrandCheckException("cancel"));
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return promiseRejectedWith(readerLockException("cancel"));
|
|
}
|
|
return ReadableStreamReaderGenericCancel(this, reason);
|
|
}
|
|
read(view, rawOptions = {}) {
|
|
if (!IsReadableStreamBYOBReader(this)) {
|
|
return promiseRejectedWith(byobReaderBrandCheckException("read"));
|
|
}
|
|
if (!ArrayBuffer.isView(view)) {
|
|
return promiseRejectedWith(new TypeError("view must be an array buffer view"));
|
|
}
|
|
if (view.byteLength === 0) {
|
|
return promiseRejectedWith(new TypeError("view must have non-zero byteLength"));
|
|
}
|
|
if (view.buffer.byteLength === 0) {
|
|
return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
|
|
}
|
|
if (IsDetachedBuffer(view.buffer)) {
|
|
return promiseRejectedWith(new TypeError("view's buffer has been detached"));
|
|
}
|
|
let options;
|
|
try {
|
|
options = convertByobReadOptions(rawOptions, "options");
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
const min = options.min;
|
|
if (min === 0) {
|
|
return promiseRejectedWith(new TypeError("options.min must be greater than 0"));
|
|
}
|
|
if (!isDataView(view)) {
|
|
if (min > view.length) {
|
|
return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's length"));
|
|
}
|
|
} else if (min > view.byteLength) {
|
|
return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's byteLength"));
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return promiseRejectedWith(readerLockException("read from"));
|
|
}
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject) => {
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readIntoRequest = {
|
|
_chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }),
|
|
_closeSteps: (chunk) => resolvePromise({ value: chunk, done: true }),
|
|
_errorSteps: (e2) => rejectPromise(e2)
|
|
};
|
|
ReadableStreamBYOBReaderRead(this, view, min, readIntoRequest);
|
|
return promise;
|
|
}
|
|
/**
|
|
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
|
|
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
|
|
* from now on; otherwise, the reader will appear closed.
|
|
*
|
|
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
|
|
* the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
|
|
* do so will throw a `TypeError` and leave the reader locked to the stream.
|
|
*/
|
|
releaseLock() {
|
|
if (!IsReadableStreamBYOBReader(this)) {
|
|
throw byobReaderBrandCheckException("releaseLock");
|
|
}
|
|
if (this._ownerReadableStream === void 0) {
|
|
return;
|
|
}
|
|
ReadableStreamBYOBReaderRelease(this);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamBYOBReader.prototype, {
|
|
cancel: { enumerable: true },
|
|
read: { enumerable: true },
|
|
releaseLock: { enumerable: true },
|
|
closed: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableStreamBYOBReader.prototype.cancel, "cancel");
|
|
setFunctionName(ReadableStreamBYOBReader.prototype.read, "read");
|
|
setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {
|
|
value: "ReadableStreamBYOBReader",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsReadableStreamBYOBReader(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_readIntoRequests")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableStreamBYOBReader;
|
|
}
|
|
function ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) {
|
|
const stream = reader._ownerReadableStream;
|
|
stream._disturbed = true;
|
|
if (stream._state === "errored") {
|
|
readIntoRequest._errorSteps(stream._storedError);
|
|
} else {
|
|
ReadableByteStreamControllerPullInto(stream._readableStreamController, view, min, readIntoRequest);
|
|
}
|
|
}
|
|
function ReadableStreamBYOBReaderRelease(reader) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
const e2 = new TypeError("Reader was released");
|
|
ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
|
|
}
|
|
function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2) {
|
|
const readIntoRequests = reader._readIntoRequests;
|
|
reader._readIntoRequests = new SimpleQueue();
|
|
readIntoRequests.forEach((readIntoRequest) => {
|
|
readIntoRequest._errorSteps(e2);
|
|
});
|
|
}
|
|
function byobReaderBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
|
|
}
|
|
function ExtractHighWaterMark(strategy, defaultHWM) {
|
|
const { highWaterMark } = strategy;
|
|
if (highWaterMark === void 0) {
|
|
return defaultHWM;
|
|
}
|
|
if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
|
|
throw new RangeError("Invalid highWaterMark");
|
|
}
|
|
return highWaterMark;
|
|
}
|
|
function ExtractSizeAlgorithm(strategy) {
|
|
const { size } = strategy;
|
|
if (!size) {
|
|
return () => 1;
|
|
}
|
|
return size;
|
|
}
|
|
function convertQueuingStrategy(init, context) {
|
|
assertDictionary(init, context);
|
|
const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
|
|
const size = init === null || init === void 0 ? void 0 : init.size;
|
|
return {
|
|
highWaterMark: highWaterMark === void 0 ? void 0 : convertUnrestrictedDouble(highWaterMark),
|
|
size: size === void 0 ? void 0 : convertQueuingStrategySize(size, `${context} has member 'size' that`)
|
|
};
|
|
}
|
|
function convertQueuingStrategySize(fn, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk) => convertUnrestrictedDouble(fn(chunk));
|
|
}
|
|
function convertUnderlyingSink(original, context) {
|
|
assertDictionary(original, context);
|
|
const abort = original === null || original === void 0 ? void 0 : original.abort;
|
|
const close = original === null || original === void 0 ? void 0 : original.close;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const type = original === null || original === void 0 ? void 0 : original.type;
|
|
const write = original === null || original === void 0 ? void 0 : original.write;
|
|
return {
|
|
abort: abort === void 0 ? void 0 : convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`),
|
|
close: close === void 0 ? void 0 : convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),
|
|
start: start === void 0 ? void 0 : convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`),
|
|
write: write === void 0 ? void 0 : convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`),
|
|
type
|
|
};
|
|
}
|
|
function convertUnderlyingSinkAbortCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (reason) => promiseCall(fn, original, [reason]);
|
|
}
|
|
function convertUnderlyingSinkCloseCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return () => promiseCall(fn, original, []);
|
|
}
|
|
function convertUnderlyingSinkStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller) => reflectCall(fn, original, [controller]);
|
|
}
|
|
function convertUnderlyingSinkWriteCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
|
|
}
|
|
function assertWritableStream(x2, context) {
|
|
if (!IsWritableStream(x2)) {
|
|
throw new TypeError(`${context} is not a WritableStream.`);
|
|
}
|
|
}
|
|
function isAbortSignal2(value) {
|
|
if (typeof value !== "object" || value === null) {
|
|
return false;
|
|
}
|
|
try {
|
|
return typeof value.aborted === "boolean";
|
|
} catch (_a2) {
|
|
return false;
|
|
}
|
|
}
|
|
const supportsAbortController = typeof AbortController === "function";
|
|
function createAbortController() {
|
|
if (supportsAbortController) {
|
|
return new AbortController();
|
|
}
|
|
return void 0;
|
|
}
|
|
class WritableStream {
|
|
constructor(rawUnderlyingSink = {}, rawStrategy = {}) {
|
|
if (rawUnderlyingSink === void 0) {
|
|
rawUnderlyingSink = null;
|
|
} else {
|
|
assertObject(rawUnderlyingSink, "First parameter");
|
|
}
|
|
const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
|
|
const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, "First parameter");
|
|
InitializeWritableStream(this);
|
|
const type = underlyingSink.type;
|
|
if (type !== void 0) {
|
|
throw new RangeError("Invalid type is specified");
|
|
}
|
|
const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 1);
|
|
SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
|
|
}
|
|
/**
|
|
* Returns whether or not the writable stream is locked to a writer.
|
|
*/
|
|
get locked() {
|
|
if (!IsWritableStream(this)) {
|
|
throw streamBrandCheckException$2("locked");
|
|
}
|
|
return IsWritableStreamLocked(this);
|
|
}
|
|
/**
|
|
* Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
|
|
* immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
|
|
* mechanism of the underlying sink.
|
|
*
|
|
* The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
|
|
* that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
|
|
* the stream) if the stream is currently locked.
|
|
*/
|
|
abort(reason = void 0) {
|
|
if (!IsWritableStream(this)) {
|
|
return promiseRejectedWith(streamBrandCheckException$2("abort"));
|
|
}
|
|
if (IsWritableStreamLocked(this)) {
|
|
return promiseRejectedWith(new TypeError("Cannot abort a stream that already has a writer"));
|
|
}
|
|
return WritableStreamAbort(this, reason);
|
|
}
|
|
/**
|
|
* Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
|
|
* close behavior. During this time any further attempts to write will fail (without erroring the stream).
|
|
*
|
|
* The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
|
|
* successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
|
|
* a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
|
|
*/
|
|
close() {
|
|
if (!IsWritableStream(this)) {
|
|
return promiseRejectedWith(streamBrandCheckException$2("close"));
|
|
}
|
|
if (IsWritableStreamLocked(this)) {
|
|
return promiseRejectedWith(new TypeError("Cannot close a stream that already has a writer"));
|
|
}
|
|
if (WritableStreamCloseQueuedOrInFlight(this)) {
|
|
return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
|
|
}
|
|
return WritableStreamClose(this);
|
|
}
|
|
/**
|
|
* Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
|
|
* is locked, no other writer can be acquired until this one is released.
|
|
*
|
|
* This functionality is especially useful for creating abstractions that desire the ability to write to a stream
|
|
* without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
|
|
* the same time, which would cause the resulting written data to be unpredictable and probably useless.
|
|
*/
|
|
getWriter() {
|
|
if (!IsWritableStream(this)) {
|
|
throw streamBrandCheckException$2("getWriter");
|
|
}
|
|
return AcquireWritableStreamDefaultWriter(this);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStream.prototype, {
|
|
abort: { enumerable: true },
|
|
close: { enumerable: true },
|
|
getWriter: { enumerable: true },
|
|
locked: { enumerable: true }
|
|
});
|
|
setFunctionName(WritableStream.prototype.abort, "abort");
|
|
setFunctionName(WritableStream.prototype.close, "close");
|
|
setFunctionName(WritableStream.prototype.getWriter, "getWriter");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {
|
|
value: "WritableStream",
|
|
configurable: true
|
|
});
|
|
}
|
|
function AcquireWritableStreamDefaultWriter(stream) {
|
|
return new WritableStreamDefaultWriter(stream);
|
|
}
|
|
function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
|
|
const stream = Object.create(WritableStream.prototype);
|
|
InitializeWritableStream(stream);
|
|
const controller = Object.create(WritableStreamDefaultController.prototype);
|
|
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
|
|
return stream;
|
|
}
|
|
function InitializeWritableStream(stream) {
|
|
stream._state = "writable";
|
|
stream._storedError = void 0;
|
|
stream._writer = void 0;
|
|
stream._writableStreamController = void 0;
|
|
stream._writeRequests = new SimpleQueue();
|
|
stream._inFlightWriteRequest = void 0;
|
|
stream._closeRequest = void 0;
|
|
stream._inFlightCloseRequest = void 0;
|
|
stream._pendingAbortRequest = void 0;
|
|
stream._backpressure = false;
|
|
}
|
|
function IsWritableStream(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_writableStreamController")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof WritableStream;
|
|
}
|
|
function IsWritableStreamLocked(stream) {
|
|
if (stream._writer === void 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function WritableStreamAbort(stream, reason) {
|
|
var _a2;
|
|
if (stream._state === "closed" || stream._state === "errored") {
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
stream._writableStreamController._abortReason = reason;
|
|
(_a2 = stream._writableStreamController._abortController) === null || _a2 === void 0 ? void 0 : _a2.abort(reason);
|
|
const state = stream._state;
|
|
if (state === "closed" || state === "errored") {
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
if (stream._pendingAbortRequest !== void 0) {
|
|
return stream._pendingAbortRequest._promise;
|
|
}
|
|
let wasAlreadyErroring = false;
|
|
if (state === "erroring") {
|
|
wasAlreadyErroring = true;
|
|
reason = void 0;
|
|
}
|
|
const promise = newPromise((resolve, reject) => {
|
|
stream._pendingAbortRequest = {
|
|
_promise: void 0,
|
|
_resolve: resolve,
|
|
_reject: reject,
|
|
_reason: reason,
|
|
_wasAlreadyErroring: wasAlreadyErroring
|
|
};
|
|
});
|
|
stream._pendingAbortRequest._promise = promise;
|
|
if (!wasAlreadyErroring) {
|
|
WritableStreamStartErroring(stream, reason);
|
|
}
|
|
return promise;
|
|
}
|
|
function WritableStreamClose(stream) {
|
|
const state = stream._state;
|
|
if (state === "closed" || state === "errored") {
|
|
return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
|
|
}
|
|
const promise = newPromise((resolve, reject) => {
|
|
const closeRequest = {
|
|
_resolve: resolve,
|
|
_reject: reject
|
|
};
|
|
stream._closeRequest = closeRequest;
|
|
});
|
|
const writer = stream._writer;
|
|
if (writer !== void 0 && stream._backpressure && state === "writable") {
|
|
defaultWriterReadyPromiseResolve(writer);
|
|
}
|
|
WritableStreamDefaultControllerClose(stream._writableStreamController);
|
|
return promise;
|
|
}
|
|
function WritableStreamAddWriteRequest(stream) {
|
|
const promise = newPromise((resolve, reject) => {
|
|
const writeRequest = {
|
|
_resolve: resolve,
|
|
_reject: reject
|
|
};
|
|
stream._writeRequests.push(writeRequest);
|
|
});
|
|
return promise;
|
|
}
|
|
function WritableStreamDealWithRejection(stream, error) {
|
|
const state = stream._state;
|
|
if (state === "writable") {
|
|
WritableStreamStartErroring(stream, error);
|
|
return;
|
|
}
|
|
WritableStreamFinishErroring(stream);
|
|
}
|
|
function WritableStreamStartErroring(stream, reason) {
|
|
const controller = stream._writableStreamController;
|
|
stream._state = "erroring";
|
|
stream._storedError = reason;
|
|
const writer = stream._writer;
|
|
if (writer !== void 0) {
|
|
WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
|
|
}
|
|
if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {
|
|
WritableStreamFinishErroring(stream);
|
|
}
|
|
}
|
|
function WritableStreamFinishErroring(stream) {
|
|
stream._state = "errored";
|
|
stream._writableStreamController[ErrorSteps]();
|
|
const storedError = stream._storedError;
|
|
stream._writeRequests.forEach((writeRequest) => {
|
|
writeRequest._reject(storedError);
|
|
});
|
|
stream._writeRequests = new SimpleQueue();
|
|
if (stream._pendingAbortRequest === void 0) {
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return;
|
|
}
|
|
const abortRequest = stream._pendingAbortRequest;
|
|
stream._pendingAbortRequest = void 0;
|
|
if (abortRequest._wasAlreadyErroring) {
|
|
abortRequest._reject(storedError);
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return;
|
|
}
|
|
const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
|
|
uponPromise(promise, () => {
|
|
abortRequest._resolve();
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return null;
|
|
}, (reason) => {
|
|
abortRequest._reject(reason);
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return null;
|
|
});
|
|
}
|
|
function WritableStreamFinishInFlightWrite(stream) {
|
|
stream._inFlightWriteRequest._resolve(void 0);
|
|
stream._inFlightWriteRequest = void 0;
|
|
}
|
|
function WritableStreamFinishInFlightWriteWithError(stream, error) {
|
|
stream._inFlightWriteRequest._reject(error);
|
|
stream._inFlightWriteRequest = void 0;
|
|
WritableStreamDealWithRejection(stream, error);
|
|
}
|
|
function WritableStreamFinishInFlightClose(stream) {
|
|
stream._inFlightCloseRequest._resolve(void 0);
|
|
stream._inFlightCloseRequest = void 0;
|
|
const state = stream._state;
|
|
if (state === "erroring") {
|
|
stream._storedError = void 0;
|
|
if (stream._pendingAbortRequest !== void 0) {
|
|
stream._pendingAbortRequest._resolve();
|
|
stream._pendingAbortRequest = void 0;
|
|
}
|
|
}
|
|
stream._state = "closed";
|
|
const writer = stream._writer;
|
|
if (writer !== void 0) {
|
|
defaultWriterClosedPromiseResolve(writer);
|
|
}
|
|
}
|
|
function WritableStreamFinishInFlightCloseWithError(stream, error) {
|
|
stream._inFlightCloseRequest._reject(error);
|
|
stream._inFlightCloseRequest = void 0;
|
|
if (stream._pendingAbortRequest !== void 0) {
|
|
stream._pendingAbortRequest._reject(error);
|
|
stream._pendingAbortRequest = void 0;
|
|
}
|
|
WritableStreamDealWithRejection(stream, error);
|
|
}
|
|
function WritableStreamCloseQueuedOrInFlight(stream) {
|
|
if (stream._closeRequest === void 0 && stream._inFlightCloseRequest === void 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function WritableStreamHasOperationMarkedInFlight(stream) {
|
|
if (stream._inFlightWriteRequest === void 0 && stream._inFlightCloseRequest === void 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function WritableStreamMarkCloseRequestInFlight(stream) {
|
|
stream._inFlightCloseRequest = stream._closeRequest;
|
|
stream._closeRequest = void 0;
|
|
}
|
|
function WritableStreamMarkFirstWriteRequestInFlight(stream) {
|
|
stream._inFlightWriteRequest = stream._writeRequests.shift();
|
|
}
|
|
function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
|
|
if (stream._closeRequest !== void 0) {
|
|
stream._closeRequest._reject(stream._storedError);
|
|
stream._closeRequest = void 0;
|
|
}
|
|
const writer = stream._writer;
|
|
if (writer !== void 0) {
|
|
defaultWriterClosedPromiseReject(writer, stream._storedError);
|
|
}
|
|
}
|
|
function WritableStreamUpdateBackpressure(stream, backpressure) {
|
|
const writer = stream._writer;
|
|
if (writer !== void 0 && backpressure !== stream._backpressure) {
|
|
if (backpressure) {
|
|
defaultWriterReadyPromiseReset(writer);
|
|
} else {
|
|
defaultWriterReadyPromiseResolve(writer);
|
|
}
|
|
}
|
|
stream._backpressure = backpressure;
|
|
}
|
|
class WritableStreamDefaultWriter {
|
|
constructor(stream) {
|
|
assertRequiredArgument(stream, 1, "WritableStreamDefaultWriter");
|
|
assertWritableStream(stream, "First parameter");
|
|
if (IsWritableStreamLocked(stream)) {
|
|
throw new TypeError("This stream has already been locked for exclusive writing by another writer");
|
|
}
|
|
this._ownerWritableStream = stream;
|
|
stream._writer = this;
|
|
const state = stream._state;
|
|
if (state === "writable") {
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {
|
|
defaultWriterReadyPromiseInitialize(this);
|
|
} else {
|
|
defaultWriterReadyPromiseInitializeAsResolved(this);
|
|
}
|
|
defaultWriterClosedPromiseInitialize(this);
|
|
} else if (state === "erroring") {
|
|
defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
|
|
defaultWriterClosedPromiseInitialize(this);
|
|
} else if (state === "closed") {
|
|
defaultWriterReadyPromiseInitializeAsResolved(this);
|
|
defaultWriterClosedPromiseInitializeAsResolved(this);
|
|
} else {
|
|
const storedError = stream._storedError;
|
|
defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
|
|
defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
|
|
}
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
|
|
* the writer’s lock is released before the stream finishes closing.
|
|
*/
|
|
get closed() {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
return promiseRejectedWith(defaultWriterBrandCheckException("closed"));
|
|
}
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
|
|
* A producer can use this information to determine the right amount of data to write.
|
|
*
|
|
* It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
|
|
* queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
|
|
* the writer’s lock is released.
|
|
*/
|
|
get desiredSize() {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
throw defaultWriterBrandCheckException("desiredSize");
|
|
}
|
|
if (this._ownerWritableStream === void 0) {
|
|
throw defaultWriterLockException("desiredSize");
|
|
}
|
|
return WritableStreamDefaultWriterGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
|
|
* from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
|
|
* back to zero or below, the getter will return a new promise that stays pending until the next transition.
|
|
*
|
|
* If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
|
|
* rejected.
|
|
*/
|
|
get ready() {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
return promiseRejectedWith(defaultWriterBrandCheckException("ready"));
|
|
}
|
|
return this._readyPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
|
|
*/
|
|
abort(reason = void 0) {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
return promiseRejectedWith(defaultWriterBrandCheckException("abort"));
|
|
}
|
|
if (this._ownerWritableStream === void 0) {
|
|
return promiseRejectedWith(defaultWriterLockException("abort"));
|
|
}
|
|
return WritableStreamDefaultWriterAbort(this, reason);
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
|
|
*/
|
|
close() {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
return promiseRejectedWith(defaultWriterBrandCheckException("close"));
|
|
}
|
|
const stream = this._ownerWritableStream;
|
|
if (stream === void 0) {
|
|
return promiseRejectedWith(defaultWriterLockException("close"));
|
|
}
|
|
if (WritableStreamCloseQueuedOrInFlight(stream)) {
|
|
return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
|
|
}
|
|
return WritableStreamDefaultWriterClose(this);
|
|
}
|
|
/**
|
|
* Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
|
|
* If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
|
|
* now on; otherwise, the writer will appear closed.
|
|
*
|
|
* Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
|
|
* promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
|
|
* It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
|
|
* other producers from writing in an interleaved manner.
|
|
*/
|
|
releaseLock() {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
throw defaultWriterBrandCheckException("releaseLock");
|
|
}
|
|
const stream = this._ownerWritableStream;
|
|
if (stream === void 0) {
|
|
return;
|
|
}
|
|
WritableStreamDefaultWriterRelease(this);
|
|
}
|
|
write(chunk = void 0) {
|
|
if (!IsWritableStreamDefaultWriter(this)) {
|
|
return promiseRejectedWith(defaultWriterBrandCheckException("write"));
|
|
}
|
|
if (this._ownerWritableStream === void 0) {
|
|
return promiseRejectedWith(defaultWriterLockException("write to"));
|
|
}
|
|
return WritableStreamDefaultWriterWrite(this, chunk);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStreamDefaultWriter.prototype, {
|
|
abort: { enumerable: true },
|
|
close: { enumerable: true },
|
|
releaseLock: { enumerable: true },
|
|
write: { enumerable: true },
|
|
closed: { enumerable: true },
|
|
desiredSize: { enumerable: true },
|
|
ready: { enumerable: true }
|
|
});
|
|
setFunctionName(WritableStreamDefaultWriter.prototype.abort, "abort");
|
|
setFunctionName(WritableStreamDefaultWriter.prototype.close, "close");
|
|
setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock");
|
|
setFunctionName(WritableStreamDefaultWriter.prototype.write, "write");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {
|
|
value: "WritableStreamDefaultWriter",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsWritableStreamDefaultWriter(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_ownerWritableStream")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof WritableStreamDefaultWriter;
|
|
}
|
|
function WritableStreamDefaultWriterAbort(writer, reason) {
|
|
const stream = writer._ownerWritableStream;
|
|
return WritableStreamAbort(stream, reason);
|
|
}
|
|
function WritableStreamDefaultWriterClose(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
return WritableStreamClose(stream);
|
|
}
|
|
function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const state = stream._state;
|
|
if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
if (state === "errored") {
|
|
return promiseRejectedWith(stream._storedError);
|
|
}
|
|
return WritableStreamDefaultWriterClose(writer);
|
|
}
|
|
function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
|
|
if (writer._closedPromiseState === "pending") {
|
|
defaultWriterClosedPromiseReject(writer, error);
|
|
} else {
|
|
defaultWriterClosedPromiseResetToRejected(writer, error);
|
|
}
|
|
}
|
|
function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
|
|
if (writer._readyPromiseState === "pending") {
|
|
defaultWriterReadyPromiseReject(writer, error);
|
|
} else {
|
|
defaultWriterReadyPromiseResetToRejected(writer, error);
|
|
}
|
|
}
|
|
function WritableStreamDefaultWriterGetDesiredSize(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const state = stream._state;
|
|
if (state === "errored" || state === "erroring") {
|
|
return null;
|
|
}
|
|
if (state === "closed") {
|
|
return 0;
|
|
}
|
|
return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
|
|
}
|
|
function WritableStreamDefaultWriterRelease(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);
|
|
WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
|
|
WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
|
|
stream._writer = void 0;
|
|
writer._ownerWritableStream = void 0;
|
|
}
|
|
function WritableStreamDefaultWriterWrite(writer, chunk) {
|
|
const stream = writer._ownerWritableStream;
|
|
const controller = stream._writableStreamController;
|
|
const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
|
|
if (stream !== writer._ownerWritableStream) {
|
|
return promiseRejectedWith(defaultWriterLockException("write to"));
|
|
}
|
|
const state = stream._state;
|
|
if (state === "errored") {
|
|
return promiseRejectedWith(stream._storedError);
|
|
}
|
|
if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
|
|
return promiseRejectedWith(new TypeError("The stream is closing or closed and cannot be written to"));
|
|
}
|
|
if (state === "erroring") {
|
|
return promiseRejectedWith(stream._storedError);
|
|
}
|
|
const promise = WritableStreamAddWriteRequest(stream);
|
|
WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
|
|
return promise;
|
|
}
|
|
const closeSentinel = {};
|
|
class WritableStreamDefaultController {
|
|
constructor() {
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
|
|
*
|
|
* @deprecated
|
|
* This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
|
|
* Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
|
|
*/
|
|
get abortReason() {
|
|
if (!IsWritableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$2("abortReason");
|
|
}
|
|
return this._abortReason;
|
|
}
|
|
/**
|
|
* An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
|
|
*/
|
|
get signal() {
|
|
if (!IsWritableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$2("signal");
|
|
}
|
|
if (this._abortController === void 0) {
|
|
throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
|
|
}
|
|
return this._abortController.signal;
|
|
}
|
|
/**
|
|
* Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
|
|
*
|
|
* This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
|
|
* sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
|
|
* normal lifecycle of interactions with the underlying sink.
|
|
*/
|
|
error(e2 = void 0) {
|
|
if (!IsWritableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$2("error");
|
|
}
|
|
const state = this._controlledWritableStream._state;
|
|
if (state !== "writable") {
|
|
return;
|
|
}
|
|
WritableStreamDefaultControllerError(this, e2);
|
|
}
|
|
/** @internal */
|
|
[AbortSteps](reason) {
|
|
const result = this._abortAlgorithm(reason);
|
|
WritableStreamDefaultControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */
|
|
[ErrorSteps]() {
|
|
ResetQueue(this);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStreamDefaultController.prototype, {
|
|
abortReason: { enumerable: true },
|
|
signal: { enumerable: true },
|
|
error: { enumerable: true }
|
|
});
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {
|
|
value: "WritableStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsWritableStreamDefaultController(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_controlledWritableStream")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof WritableStreamDefaultController;
|
|
}
|
|
function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
|
|
controller._controlledWritableStream = stream;
|
|
stream._writableStreamController = controller;
|
|
controller._queue = void 0;
|
|
controller._queueTotalSize = void 0;
|
|
ResetQueue(controller);
|
|
controller._abortReason = void 0;
|
|
controller._abortController = createAbortController();
|
|
controller._started = false;
|
|
controller._strategySizeAlgorithm = sizeAlgorithm;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._writeAlgorithm = writeAlgorithm;
|
|
controller._closeAlgorithm = closeAlgorithm;
|
|
controller._abortAlgorithm = abortAlgorithm;
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
const startResult = startAlgorithm();
|
|
const startPromise = promiseResolvedWith(startResult);
|
|
uponPromise(startPromise, () => {
|
|
controller._started = true;
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
return null;
|
|
}, (r2) => {
|
|
controller._started = true;
|
|
WritableStreamDealWithRejection(stream, r2);
|
|
return null;
|
|
});
|
|
}
|
|
function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
|
|
const controller = Object.create(WritableStreamDefaultController.prototype);
|
|
let startAlgorithm;
|
|
let writeAlgorithm;
|
|
let closeAlgorithm;
|
|
let abortAlgorithm;
|
|
if (underlyingSink.start !== void 0) {
|
|
startAlgorithm = () => underlyingSink.start(controller);
|
|
} else {
|
|
startAlgorithm = () => void 0;
|
|
}
|
|
if (underlyingSink.write !== void 0) {
|
|
writeAlgorithm = (chunk) => underlyingSink.write(chunk, controller);
|
|
} else {
|
|
writeAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
if (underlyingSink.close !== void 0) {
|
|
closeAlgorithm = () => underlyingSink.close();
|
|
} else {
|
|
closeAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
if (underlyingSink.abort !== void 0) {
|
|
abortAlgorithm = (reason) => underlyingSink.abort(reason);
|
|
} else {
|
|
abortAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
|
|
}
|
|
function WritableStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._writeAlgorithm = void 0;
|
|
controller._closeAlgorithm = void 0;
|
|
controller._abortAlgorithm = void 0;
|
|
controller._strategySizeAlgorithm = void 0;
|
|
}
|
|
function WritableStreamDefaultControllerClose(controller) {
|
|
EnqueueValueWithSize(controller, closeSentinel, 0);
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}
|
|
function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
|
|
try {
|
|
return controller._strategySizeAlgorithm(chunk);
|
|
} catch (chunkSizeE) {
|
|
WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
|
|
return 1;
|
|
}
|
|
}
|
|
function WritableStreamDefaultControllerGetDesiredSize(controller) {
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
|
|
try {
|
|
EnqueueValueWithSize(controller, chunk, chunkSize);
|
|
} catch (enqueueE) {
|
|
WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
|
|
return;
|
|
}
|
|
const stream = controller._controlledWritableStream;
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === "writable") {
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
}
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}
|
|
function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
|
|
const stream = controller._controlledWritableStream;
|
|
if (!controller._started) {
|
|
return;
|
|
}
|
|
if (stream._inFlightWriteRequest !== void 0) {
|
|
return;
|
|
}
|
|
const state = stream._state;
|
|
if (state === "erroring") {
|
|
WritableStreamFinishErroring(stream);
|
|
return;
|
|
}
|
|
if (controller._queue.length === 0) {
|
|
return;
|
|
}
|
|
const value = PeekQueueValue(controller);
|
|
if (value === closeSentinel) {
|
|
WritableStreamDefaultControllerProcessClose(controller);
|
|
} else {
|
|
WritableStreamDefaultControllerProcessWrite(controller, value);
|
|
}
|
|
}
|
|
function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
|
|
if (controller._controlledWritableStream._state === "writable") {
|
|
WritableStreamDefaultControllerError(controller, error);
|
|
}
|
|
}
|
|
function WritableStreamDefaultControllerProcessClose(controller) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamMarkCloseRequestInFlight(stream);
|
|
DequeueValue(controller);
|
|
const sinkClosePromise = controller._closeAlgorithm();
|
|
WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
uponPromise(sinkClosePromise, () => {
|
|
WritableStreamFinishInFlightClose(stream);
|
|
return null;
|
|
}, (reason) => {
|
|
WritableStreamFinishInFlightCloseWithError(stream, reason);
|
|
return null;
|
|
});
|
|
}
|
|
function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamMarkFirstWriteRequestInFlight(stream);
|
|
const sinkWritePromise = controller._writeAlgorithm(chunk);
|
|
uponPromise(sinkWritePromise, () => {
|
|
WritableStreamFinishInFlightWrite(stream);
|
|
const state = stream._state;
|
|
DequeueValue(controller);
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && state === "writable") {
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
}
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
return null;
|
|
}, (reason) => {
|
|
if (stream._state === "writable") {
|
|
WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
}
|
|
WritableStreamFinishInFlightWriteWithError(stream, reason);
|
|
return null;
|
|
});
|
|
}
|
|
function WritableStreamDefaultControllerGetBackpressure(controller) {
|
|
const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
|
|
return desiredSize <= 0;
|
|
}
|
|
function WritableStreamDefaultControllerError(controller, error) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
WritableStreamStartErroring(stream, error);
|
|
}
|
|
function streamBrandCheckException$2(name) {
|
|
return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);
|
|
}
|
|
function defaultControllerBrandCheckException$2(name) {
|
|
return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
|
|
}
|
|
function defaultWriterBrandCheckException(name) {
|
|
return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);
|
|
}
|
|
function defaultWriterLockException(name) {
|
|
return new TypeError("Cannot " + name + " a stream using a released writer");
|
|
}
|
|
function defaultWriterClosedPromiseInitialize(writer) {
|
|
writer._closedPromise = newPromise((resolve, reject) => {
|
|
writer._closedPromise_resolve = resolve;
|
|
writer._closedPromise_reject = reject;
|
|
writer._closedPromiseState = "pending";
|
|
});
|
|
}
|
|
function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
|
|
defaultWriterClosedPromiseInitialize(writer);
|
|
defaultWriterClosedPromiseReject(writer, reason);
|
|
}
|
|
function defaultWriterClosedPromiseInitializeAsResolved(writer) {
|
|
defaultWriterClosedPromiseInitialize(writer);
|
|
defaultWriterClosedPromiseResolve(writer);
|
|
}
|
|
function defaultWriterClosedPromiseReject(writer, reason) {
|
|
if (writer._closedPromise_reject === void 0) {
|
|
return;
|
|
}
|
|
setPromiseIsHandledToTrue(writer._closedPromise);
|
|
writer._closedPromise_reject(reason);
|
|
writer._closedPromise_resolve = void 0;
|
|
writer._closedPromise_reject = void 0;
|
|
writer._closedPromiseState = "rejected";
|
|
}
|
|
function defaultWriterClosedPromiseResetToRejected(writer, reason) {
|
|
defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
|
|
}
|
|
function defaultWriterClosedPromiseResolve(writer) {
|
|
if (writer._closedPromise_resolve === void 0) {
|
|
return;
|
|
}
|
|
writer._closedPromise_resolve(void 0);
|
|
writer._closedPromise_resolve = void 0;
|
|
writer._closedPromise_reject = void 0;
|
|
writer._closedPromiseState = "resolved";
|
|
}
|
|
function defaultWriterReadyPromiseInitialize(writer) {
|
|
writer._readyPromise = newPromise((resolve, reject) => {
|
|
writer._readyPromise_resolve = resolve;
|
|
writer._readyPromise_reject = reject;
|
|
});
|
|
writer._readyPromiseState = "pending";
|
|
}
|
|
function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
defaultWriterReadyPromiseReject(writer, reason);
|
|
}
|
|
function defaultWriterReadyPromiseInitializeAsResolved(writer) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
defaultWriterReadyPromiseResolve(writer);
|
|
}
|
|
function defaultWriterReadyPromiseReject(writer, reason) {
|
|
if (writer._readyPromise_reject === void 0) {
|
|
return;
|
|
}
|
|
setPromiseIsHandledToTrue(writer._readyPromise);
|
|
writer._readyPromise_reject(reason);
|
|
writer._readyPromise_resolve = void 0;
|
|
writer._readyPromise_reject = void 0;
|
|
writer._readyPromiseState = "rejected";
|
|
}
|
|
function defaultWriterReadyPromiseReset(writer) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
}
|
|
function defaultWriterReadyPromiseResetToRejected(writer, reason) {
|
|
defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
|
|
}
|
|
function defaultWriterReadyPromiseResolve(writer) {
|
|
if (writer._readyPromise_resolve === void 0) {
|
|
return;
|
|
}
|
|
writer._readyPromise_resolve(void 0);
|
|
writer._readyPromise_resolve = void 0;
|
|
writer._readyPromise_reject = void 0;
|
|
writer._readyPromiseState = "fulfilled";
|
|
}
|
|
function getGlobals() {
|
|
if (typeof globalThis !== "undefined") {
|
|
return globalThis;
|
|
} else if (typeof self !== "undefined") {
|
|
return self;
|
|
} else if (typeof global !== "undefined") {
|
|
return global;
|
|
}
|
|
return void 0;
|
|
}
|
|
const globals = getGlobals();
|
|
function isDOMExceptionConstructor(ctor) {
|
|
if (!(typeof ctor === "function" || typeof ctor === "object")) {
|
|
return false;
|
|
}
|
|
if (ctor.name !== "DOMException") {
|
|
return false;
|
|
}
|
|
try {
|
|
new ctor();
|
|
return true;
|
|
} catch (_a2) {
|
|
return false;
|
|
}
|
|
}
|
|
function getFromGlobal() {
|
|
const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
|
|
return isDOMExceptionConstructor(ctor) ? ctor : void 0;
|
|
}
|
|
function createPolyfill() {
|
|
const ctor = function DOMException4(message, name) {
|
|
this.message = message || "";
|
|
this.name = name || "Error";
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
};
|
|
setFunctionName(ctor, "DOMException");
|
|
ctor.prototype = Object.create(Error.prototype);
|
|
Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true });
|
|
return ctor;
|
|
}
|
|
const DOMException3 = getFromGlobal() || createPolyfill();
|
|
function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
|
|
const reader = AcquireReadableStreamDefaultReader(source);
|
|
const writer = AcquireWritableStreamDefaultWriter(dest);
|
|
source._disturbed = true;
|
|
let shuttingDown = false;
|
|
let currentWrite = promiseResolvedWith(void 0);
|
|
return newPromise((resolve, reject) => {
|
|
let abortAlgorithm;
|
|
if (signal !== void 0) {
|
|
abortAlgorithm = () => {
|
|
const error = signal.reason !== void 0 ? signal.reason : new DOMException3("Aborted", "AbortError");
|
|
const actions = [];
|
|
if (!preventAbort) {
|
|
actions.push(() => {
|
|
if (dest._state === "writable") {
|
|
return WritableStreamAbort(dest, error);
|
|
}
|
|
return promiseResolvedWith(void 0);
|
|
});
|
|
}
|
|
if (!preventCancel) {
|
|
actions.push(() => {
|
|
if (source._state === "readable") {
|
|
return ReadableStreamCancel(source, error);
|
|
}
|
|
return promiseResolvedWith(void 0);
|
|
});
|
|
}
|
|
shutdownWithAction(() => Promise.all(actions.map((action) => action())), true, error);
|
|
};
|
|
if (signal.aborted) {
|
|
abortAlgorithm();
|
|
return;
|
|
}
|
|
signal.addEventListener("abort", abortAlgorithm);
|
|
}
|
|
function pipeLoop() {
|
|
return newPromise((resolveLoop, rejectLoop) => {
|
|
function next(done) {
|
|
if (done) {
|
|
resolveLoop();
|
|
} else {
|
|
PerformPromiseThen(pipeStep(), next, rejectLoop);
|
|
}
|
|
}
|
|
next(false);
|
|
});
|
|
}
|
|
function pipeStep() {
|
|
if (shuttingDown) {
|
|
return promiseResolvedWith(true);
|
|
}
|
|
return PerformPromiseThen(writer._readyPromise, () => {
|
|
return newPromise((resolveRead, rejectRead) => {
|
|
ReadableStreamDefaultReaderRead(reader, {
|
|
_chunkSteps: (chunk) => {
|
|
currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop2);
|
|
resolveRead(false);
|
|
},
|
|
_closeSteps: () => resolveRead(true),
|
|
_errorSteps: rejectRead
|
|
});
|
|
});
|
|
});
|
|
}
|
|
isOrBecomesErrored(source, reader._closedPromise, (storedError) => {
|
|
if (!preventAbort) {
|
|
shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);
|
|
} else {
|
|
shutdown(true, storedError);
|
|
}
|
|
return null;
|
|
});
|
|
isOrBecomesErrored(dest, writer._closedPromise, (storedError) => {
|
|
if (!preventCancel) {
|
|
shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);
|
|
} else {
|
|
shutdown(true, storedError);
|
|
}
|
|
return null;
|
|
});
|
|
isOrBecomesClosed(source, reader._closedPromise, () => {
|
|
if (!preventClose) {
|
|
shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
|
|
} else {
|
|
shutdown();
|
|
}
|
|
return null;
|
|
});
|
|
if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") {
|
|
const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it");
|
|
if (!preventCancel) {
|
|
shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed);
|
|
} else {
|
|
shutdown(true, destClosed);
|
|
}
|
|
}
|
|
setPromiseIsHandledToTrue(pipeLoop());
|
|
function waitForWritesToFinish() {
|
|
const oldCurrentWrite = currentWrite;
|
|
return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : void 0);
|
|
}
|
|
function isOrBecomesErrored(stream, promise, action) {
|
|
if (stream._state === "errored") {
|
|
action(stream._storedError);
|
|
} else {
|
|
uponRejection(promise, action);
|
|
}
|
|
}
|
|
function isOrBecomesClosed(stream, promise, action) {
|
|
if (stream._state === "closed") {
|
|
action();
|
|
} else {
|
|
uponFulfillment(promise, action);
|
|
}
|
|
}
|
|
function shutdownWithAction(action, originalIsError, originalError) {
|
|
if (shuttingDown) {
|
|
return;
|
|
}
|
|
shuttingDown = true;
|
|
if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) {
|
|
uponFulfillment(waitForWritesToFinish(), doTheRest);
|
|
} else {
|
|
doTheRest();
|
|
}
|
|
function doTheRest() {
|
|
uponPromise(action(), () => finalize(originalIsError, originalError), (newError) => finalize(true, newError));
|
|
return null;
|
|
}
|
|
}
|
|
function shutdown(isError, error) {
|
|
if (shuttingDown) {
|
|
return;
|
|
}
|
|
shuttingDown = true;
|
|
if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) {
|
|
uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error));
|
|
} else {
|
|
finalize(isError, error);
|
|
}
|
|
}
|
|
function finalize(isError, error) {
|
|
WritableStreamDefaultWriterRelease(writer);
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
if (signal !== void 0) {
|
|
signal.removeEventListener("abort", abortAlgorithm);
|
|
}
|
|
if (isError) {
|
|
reject(error);
|
|
} else {
|
|
resolve(void 0);
|
|
}
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
class ReadableStreamDefaultController {
|
|
constructor() {
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
|
|
* over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
|
|
*/
|
|
get desiredSize() {
|
|
if (!IsReadableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$1("desiredSize");
|
|
}
|
|
return ReadableStreamDefaultControllerGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
|
|
* the stream, but once those are read, the stream will become closed.
|
|
*/
|
|
close() {
|
|
if (!IsReadableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$1("close");
|
|
}
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
|
|
throw new TypeError("The stream is not in a state that permits close");
|
|
}
|
|
ReadableStreamDefaultControllerClose(this);
|
|
}
|
|
enqueue(chunk = void 0) {
|
|
if (!IsReadableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$1("enqueue");
|
|
}
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
|
|
throw new TypeError("The stream is not in a state that permits enqueue");
|
|
}
|
|
return ReadableStreamDefaultControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
|
|
*/
|
|
error(e2 = void 0) {
|
|
if (!IsReadableStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException$1("error");
|
|
}
|
|
ReadableStreamDefaultControllerError(this, e2);
|
|
}
|
|
/** @internal */
|
|
[CancelSteps](reason) {
|
|
ResetQueue(this);
|
|
const result = this._cancelAlgorithm(reason);
|
|
ReadableStreamDefaultControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */
|
|
[PullSteps](readRequest) {
|
|
const stream = this._controlledReadableStream;
|
|
if (this._queue.length > 0) {
|
|
const chunk = DequeueValue(this);
|
|
if (this._closeRequested && this._queue.length === 0) {
|
|
ReadableStreamDefaultControllerClearAlgorithms(this);
|
|
ReadableStreamClose(stream);
|
|
} else {
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
|
}
|
|
readRequest._chunkSteps(chunk);
|
|
} else {
|
|
ReadableStreamAddReadRequest(stream, readRequest);
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
|
}
|
|
}
|
|
/** @internal */
|
|
[ReleaseSteps]() {
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamDefaultController.prototype, {
|
|
close: { enumerable: true },
|
|
enqueue: { enumerable: true },
|
|
error: { enumerable: true },
|
|
desiredSize: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableStreamDefaultController.prototype.close, "close");
|
|
setFunctionName(ReadableStreamDefaultController.prototype.enqueue, "enqueue");
|
|
setFunctionName(ReadableStreamDefaultController.prototype.error, "error");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {
|
|
value: "ReadableStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsReadableStreamDefaultController(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_controlledReadableStream")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableStreamDefaultController;
|
|
}
|
|
function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
|
|
const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
|
|
if (!shouldPull) {
|
|
return;
|
|
}
|
|
if (controller._pulling) {
|
|
controller._pullAgain = true;
|
|
return;
|
|
}
|
|
controller._pulling = true;
|
|
const pullPromise = controller._pullAlgorithm();
|
|
uponPromise(pullPromise, () => {
|
|
controller._pulling = false;
|
|
if (controller._pullAgain) {
|
|
controller._pullAgain = false;
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
}
|
|
return null;
|
|
}, (e2) => {
|
|
ReadableStreamDefaultControllerError(controller, e2);
|
|
return null;
|
|
});
|
|
}
|
|
function ReadableStreamDefaultControllerShouldCallPull(controller) {
|
|
const stream = controller._controlledReadableStream;
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
|
|
return false;
|
|
}
|
|
if (!controller._started) {
|
|
return false;
|
|
}
|
|
if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
|
|
return true;
|
|
}
|
|
const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
|
|
if (desiredSize > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function ReadableStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._pullAlgorithm = void 0;
|
|
controller._cancelAlgorithm = void 0;
|
|
controller._strategySizeAlgorithm = void 0;
|
|
}
|
|
function ReadableStreamDefaultControllerClose(controller) {
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
|
|
return;
|
|
}
|
|
const stream = controller._controlledReadableStream;
|
|
controller._closeRequested = true;
|
|
if (controller._queue.length === 0) {
|
|
ReadableStreamDefaultControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(stream);
|
|
}
|
|
}
|
|
function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
|
|
return;
|
|
}
|
|
const stream = controller._controlledReadableStream;
|
|
if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
|
|
ReadableStreamFulfillReadRequest(stream, chunk, false);
|
|
} else {
|
|
let chunkSize;
|
|
try {
|
|
chunkSize = controller._strategySizeAlgorithm(chunk);
|
|
} catch (chunkSizeE) {
|
|
ReadableStreamDefaultControllerError(controller, chunkSizeE);
|
|
throw chunkSizeE;
|
|
}
|
|
try {
|
|
EnqueueValueWithSize(controller, chunk, chunkSize);
|
|
} catch (enqueueE) {
|
|
ReadableStreamDefaultControllerError(controller, enqueueE);
|
|
throw enqueueE;
|
|
}
|
|
}
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableStreamDefaultControllerError(controller, e2) {
|
|
const stream = controller._controlledReadableStream;
|
|
if (stream._state !== "readable") {
|
|
return;
|
|
}
|
|
ResetQueue(controller);
|
|
ReadableStreamDefaultControllerClearAlgorithms(controller);
|
|
ReadableStreamError(stream, e2);
|
|
}
|
|
function ReadableStreamDefaultControllerGetDesiredSize(controller) {
|
|
const state = controller._controlledReadableStream._state;
|
|
if (state === "errored") {
|
|
return null;
|
|
}
|
|
if (state === "closed") {
|
|
return 0;
|
|
}
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
function ReadableStreamDefaultControllerHasBackpressure(controller) {
|
|
if (ReadableStreamDefaultControllerShouldCallPull(controller)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
|
|
const state = controller._controlledReadableStream._state;
|
|
if (!controller._closeRequested && state === "readable") {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
|
|
controller._controlledReadableStream = stream;
|
|
controller._queue = void 0;
|
|
controller._queueTotalSize = void 0;
|
|
ResetQueue(controller);
|
|
controller._started = false;
|
|
controller._closeRequested = false;
|
|
controller._pullAgain = false;
|
|
controller._pulling = false;
|
|
controller._strategySizeAlgorithm = sizeAlgorithm;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._pullAlgorithm = pullAlgorithm;
|
|
controller._cancelAlgorithm = cancelAlgorithm;
|
|
stream._readableStreamController = controller;
|
|
const startResult = startAlgorithm();
|
|
uponPromise(promiseResolvedWith(startResult), () => {
|
|
controller._started = true;
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
return null;
|
|
}, (r2) => {
|
|
ReadableStreamDefaultControllerError(controller, r2);
|
|
return null;
|
|
});
|
|
}
|
|
function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
|
|
const controller = Object.create(ReadableStreamDefaultController.prototype);
|
|
let startAlgorithm;
|
|
let pullAlgorithm;
|
|
let cancelAlgorithm;
|
|
if (underlyingSource.start !== void 0) {
|
|
startAlgorithm = () => underlyingSource.start(controller);
|
|
} else {
|
|
startAlgorithm = () => void 0;
|
|
}
|
|
if (underlyingSource.pull !== void 0) {
|
|
pullAlgorithm = () => underlyingSource.pull(controller);
|
|
} else {
|
|
pullAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
if (underlyingSource.cancel !== void 0) {
|
|
cancelAlgorithm = (reason) => underlyingSource.cancel(reason);
|
|
} else {
|
|
cancelAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
|
|
}
|
|
function defaultControllerBrandCheckException$1(name) {
|
|
return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);
|
|
}
|
|
function ReadableStreamTee(stream, cloneForBranch2) {
|
|
if (IsReadableByteStreamController(stream._readableStreamController)) {
|
|
return ReadableByteStreamTee(stream);
|
|
}
|
|
return ReadableStreamDefaultTee(stream);
|
|
}
|
|
function ReadableStreamDefaultTee(stream, cloneForBranch2) {
|
|
const reader = AcquireReadableStreamDefaultReader(stream);
|
|
let reading = false;
|
|
let readAgain = false;
|
|
let canceled1 = false;
|
|
let canceled2 = false;
|
|
let reason1;
|
|
let reason2;
|
|
let branch1;
|
|
let branch2;
|
|
let resolveCancelPromise;
|
|
const cancelPromise = newPromise((resolve) => {
|
|
resolveCancelPromise = resolve;
|
|
});
|
|
function pullAlgorithm() {
|
|
if (reading) {
|
|
readAgain = true;
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
reading = true;
|
|
const readRequest = {
|
|
_chunkSteps: (chunk) => {
|
|
_queueMicrotask(() => {
|
|
readAgain = false;
|
|
const chunk1 = chunk;
|
|
const chunk2 = chunk;
|
|
if (!canceled1) {
|
|
ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
|
|
}
|
|
if (!canceled2) {
|
|
ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
|
|
}
|
|
reading = false;
|
|
if (readAgain) {
|
|
pullAlgorithm();
|
|
}
|
|
});
|
|
},
|
|
_closeSteps: () => {
|
|
reading = false;
|
|
if (!canceled1) {
|
|
ReadableStreamDefaultControllerClose(branch1._readableStreamController);
|
|
}
|
|
if (!canceled2) {
|
|
ReadableStreamDefaultControllerClose(branch2._readableStreamController);
|
|
}
|
|
if (!canceled1 || !canceled2) {
|
|
resolveCancelPromise(void 0);
|
|
}
|
|
},
|
|
_errorSteps: () => {
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
function cancel1Algorithm(reason) {
|
|
canceled1 = true;
|
|
reason1 = reason;
|
|
if (canceled2) {
|
|
const compositeReason = CreateArrayFromList([reason1, reason2]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function cancel2Algorithm(reason) {
|
|
canceled2 = true;
|
|
reason2 = reason;
|
|
if (canceled1) {
|
|
const compositeReason = CreateArrayFromList([reason1, reason2]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function startAlgorithm() {
|
|
}
|
|
branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
|
|
branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
|
|
uponRejection(reader._closedPromise, (r2) => {
|
|
ReadableStreamDefaultControllerError(branch1._readableStreamController, r2);
|
|
ReadableStreamDefaultControllerError(branch2._readableStreamController, r2);
|
|
if (!canceled1 || !canceled2) {
|
|
resolveCancelPromise(void 0);
|
|
}
|
|
return null;
|
|
});
|
|
return [branch1, branch2];
|
|
}
|
|
function ReadableByteStreamTee(stream) {
|
|
let reader = AcquireReadableStreamDefaultReader(stream);
|
|
let reading = false;
|
|
let readAgainForBranch1 = false;
|
|
let readAgainForBranch2 = false;
|
|
let canceled1 = false;
|
|
let canceled2 = false;
|
|
let reason1;
|
|
let reason2;
|
|
let branch1;
|
|
let branch2;
|
|
let resolveCancelPromise;
|
|
const cancelPromise = newPromise((resolve) => {
|
|
resolveCancelPromise = resolve;
|
|
});
|
|
function forwardReaderError(thisReader) {
|
|
uponRejection(thisReader._closedPromise, (r2) => {
|
|
if (thisReader !== reader) {
|
|
return null;
|
|
}
|
|
ReadableByteStreamControllerError(branch1._readableStreamController, r2);
|
|
ReadableByteStreamControllerError(branch2._readableStreamController, r2);
|
|
if (!canceled1 || !canceled2) {
|
|
resolveCancelPromise(void 0);
|
|
}
|
|
return null;
|
|
});
|
|
}
|
|
function pullWithDefaultReader() {
|
|
if (IsReadableStreamBYOBReader(reader)) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
reader = AcquireReadableStreamDefaultReader(stream);
|
|
forwardReaderError(reader);
|
|
}
|
|
const readRequest = {
|
|
_chunkSteps: (chunk) => {
|
|
_queueMicrotask(() => {
|
|
readAgainForBranch1 = false;
|
|
readAgainForBranch2 = false;
|
|
const chunk1 = chunk;
|
|
let chunk2 = chunk;
|
|
if (!canceled1 && !canceled2) {
|
|
try {
|
|
chunk2 = CloneAsUint8Array(chunk);
|
|
} catch (cloneE) {
|
|
ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
|
|
ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
|
|
resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
|
|
return;
|
|
}
|
|
}
|
|
if (!canceled1) {
|
|
ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
|
|
}
|
|
if (!canceled2) {
|
|
ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
|
|
}
|
|
reading = false;
|
|
if (readAgainForBranch1) {
|
|
pull1Algorithm();
|
|
} else if (readAgainForBranch2) {
|
|
pull2Algorithm();
|
|
}
|
|
});
|
|
},
|
|
_closeSteps: () => {
|
|
reading = false;
|
|
if (!canceled1) {
|
|
ReadableByteStreamControllerClose(branch1._readableStreamController);
|
|
}
|
|
if (!canceled2) {
|
|
ReadableByteStreamControllerClose(branch2._readableStreamController);
|
|
}
|
|
if (branch1._readableStreamController._pendingPullIntos.length > 0) {
|
|
ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
|
|
}
|
|
if (branch2._readableStreamController._pendingPullIntos.length > 0) {
|
|
ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
|
|
}
|
|
if (!canceled1 || !canceled2) {
|
|
resolveCancelPromise(void 0);
|
|
}
|
|
},
|
|
_errorSteps: () => {
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
}
|
|
function pullWithBYOBReader(view, forBranch2) {
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
reader = AcquireReadableStreamBYOBReader(stream);
|
|
forwardReaderError(reader);
|
|
}
|
|
const byobBranch = forBranch2 ? branch2 : branch1;
|
|
const otherBranch = forBranch2 ? branch1 : branch2;
|
|
const readIntoRequest = {
|
|
_chunkSteps: (chunk) => {
|
|
_queueMicrotask(() => {
|
|
readAgainForBranch1 = false;
|
|
readAgainForBranch2 = false;
|
|
const byobCanceled = forBranch2 ? canceled2 : canceled1;
|
|
const otherCanceled = forBranch2 ? canceled1 : canceled2;
|
|
if (!otherCanceled) {
|
|
let clonedChunk;
|
|
try {
|
|
clonedChunk = CloneAsUint8Array(chunk);
|
|
} catch (cloneE) {
|
|
ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
|
|
ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
|
|
resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
|
|
return;
|
|
}
|
|
if (!byobCanceled) {
|
|
ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
}
|
|
ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
|
|
} else if (!byobCanceled) {
|
|
ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
}
|
|
reading = false;
|
|
if (readAgainForBranch1) {
|
|
pull1Algorithm();
|
|
} else if (readAgainForBranch2) {
|
|
pull2Algorithm();
|
|
}
|
|
});
|
|
},
|
|
_closeSteps: (chunk) => {
|
|
reading = false;
|
|
const byobCanceled = forBranch2 ? canceled2 : canceled1;
|
|
const otherCanceled = forBranch2 ? canceled1 : canceled2;
|
|
if (!byobCanceled) {
|
|
ReadableByteStreamControllerClose(byobBranch._readableStreamController);
|
|
}
|
|
if (!otherCanceled) {
|
|
ReadableByteStreamControllerClose(otherBranch._readableStreamController);
|
|
}
|
|
if (chunk !== void 0) {
|
|
if (!byobCanceled) {
|
|
ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
}
|
|
if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
|
|
ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
|
|
}
|
|
}
|
|
if (!byobCanceled || !otherCanceled) {
|
|
resolveCancelPromise(void 0);
|
|
}
|
|
},
|
|
_errorSteps: () => {
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
|
|
}
|
|
function pull1Algorithm() {
|
|
if (reading) {
|
|
readAgainForBranch1 = true;
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
reading = true;
|
|
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
|
|
if (byobRequest === null) {
|
|
pullWithDefaultReader();
|
|
} else {
|
|
pullWithBYOBReader(byobRequest._view, false);
|
|
}
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
function pull2Algorithm() {
|
|
if (reading) {
|
|
readAgainForBranch2 = true;
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
reading = true;
|
|
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
|
|
if (byobRequest === null) {
|
|
pullWithDefaultReader();
|
|
} else {
|
|
pullWithBYOBReader(byobRequest._view, true);
|
|
}
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
function cancel1Algorithm(reason) {
|
|
canceled1 = true;
|
|
reason1 = reason;
|
|
if (canceled2) {
|
|
const compositeReason = CreateArrayFromList([reason1, reason2]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function cancel2Algorithm(reason) {
|
|
canceled2 = true;
|
|
reason2 = reason;
|
|
if (canceled1) {
|
|
const compositeReason = CreateArrayFromList([reason1, reason2]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function startAlgorithm() {
|
|
return;
|
|
}
|
|
branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
|
|
branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
|
|
forwardReaderError(reader);
|
|
return [branch1, branch2];
|
|
}
|
|
function isReadableStreamLike(stream) {
|
|
return typeIsObject(stream) && typeof stream.getReader !== "undefined";
|
|
}
|
|
function ReadableStreamFrom(source) {
|
|
if (isReadableStreamLike(source)) {
|
|
return ReadableStreamFromDefaultReader(source.getReader());
|
|
}
|
|
return ReadableStreamFromIterable(source);
|
|
}
|
|
function ReadableStreamFromIterable(asyncIterable) {
|
|
let stream;
|
|
const iteratorRecord = GetIterator(asyncIterable, "async");
|
|
const startAlgorithm = noop2;
|
|
function pullAlgorithm() {
|
|
let nextResult;
|
|
try {
|
|
nextResult = IteratorNext(iteratorRecord);
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
const nextPromise = promiseResolvedWith(nextResult);
|
|
return transformPromiseWith(nextPromise, (iterResult) => {
|
|
if (!typeIsObject(iterResult)) {
|
|
throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
|
|
}
|
|
const done = IteratorComplete(iterResult);
|
|
if (done) {
|
|
ReadableStreamDefaultControllerClose(stream._readableStreamController);
|
|
} else {
|
|
const value = IteratorValue(iterResult);
|
|
ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
|
|
}
|
|
});
|
|
}
|
|
function cancelAlgorithm(reason) {
|
|
const iterator = iteratorRecord.iterator;
|
|
let returnMethod;
|
|
try {
|
|
returnMethod = GetMethod(iterator, "return");
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
if (returnMethod === void 0) {
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
let returnResult;
|
|
try {
|
|
returnResult = reflectCall(returnMethod, iterator, [reason]);
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
const returnPromise = promiseResolvedWith(returnResult);
|
|
return transformPromiseWith(returnPromise, (iterResult) => {
|
|
if (!typeIsObject(iterResult)) {
|
|
throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
|
|
}
|
|
return void 0;
|
|
});
|
|
}
|
|
stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
|
|
return stream;
|
|
}
|
|
function ReadableStreamFromDefaultReader(reader) {
|
|
let stream;
|
|
const startAlgorithm = noop2;
|
|
function pullAlgorithm() {
|
|
let readPromise;
|
|
try {
|
|
readPromise = reader.read();
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
return transformPromiseWith(readPromise, (readResult) => {
|
|
if (!typeIsObject(readResult)) {
|
|
throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
|
|
}
|
|
if (readResult.done) {
|
|
ReadableStreamDefaultControllerClose(stream._readableStreamController);
|
|
} else {
|
|
const value = readResult.value;
|
|
ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
|
|
}
|
|
});
|
|
}
|
|
function cancelAlgorithm(reason) {
|
|
try {
|
|
return promiseResolvedWith(reader.cancel(reason));
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
}
|
|
stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
|
|
return stream;
|
|
}
|
|
function convertUnderlyingDefaultOrByteSource(source, context) {
|
|
assertDictionary(source, context);
|
|
const original = source;
|
|
const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;
|
|
const cancel = original === null || original === void 0 ? void 0 : original.cancel;
|
|
const pull = original === null || original === void 0 ? void 0 : original.pull;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const type = original === null || original === void 0 ? void 0 : original.type;
|
|
return {
|
|
autoAllocateChunkSize: autoAllocateChunkSize === void 0 ? void 0 : convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),
|
|
cancel: cancel === void 0 ? void 0 : convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),
|
|
pull: pull === void 0 ? void 0 : convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),
|
|
start: start === void 0 ? void 0 : convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`),
|
|
type: type === void 0 ? void 0 : convertReadableStreamType(type, `${context} has member 'type' that`)
|
|
};
|
|
}
|
|
function convertUnderlyingSourceCancelCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (reason) => promiseCall(fn, original, [reason]);
|
|
}
|
|
function convertUnderlyingSourcePullCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller) => promiseCall(fn, original, [controller]);
|
|
}
|
|
function convertUnderlyingSourceStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller) => reflectCall(fn, original, [controller]);
|
|
}
|
|
function convertReadableStreamType(type, context) {
|
|
type = `${type}`;
|
|
if (type !== "bytes") {
|
|
throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);
|
|
}
|
|
return type;
|
|
}
|
|
function convertIteratorOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
|
|
return { preventCancel: Boolean(preventCancel) };
|
|
}
|
|
function convertPipeOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;
|
|
const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
|
|
const preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
|
|
const signal = options === null || options === void 0 ? void 0 : options.signal;
|
|
if (signal !== void 0) {
|
|
assertAbortSignal(signal, `${context} has member 'signal' that`);
|
|
}
|
|
return {
|
|
preventAbort: Boolean(preventAbort),
|
|
preventCancel: Boolean(preventCancel),
|
|
preventClose: Boolean(preventClose),
|
|
signal
|
|
};
|
|
}
|
|
function assertAbortSignal(signal, context) {
|
|
if (!isAbortSignal2(signal)) {
|
|
throw new TypeError(`${context} is not an AbortSignal.`);
|
|
}
|
|
}
|
|
function convertReadableWritablePair(pair, context) {
|
|
assertDictionary(pair, context);
|
|
const readable = pair === null || pair === void 0 ? void 0 : pair.readable;
|
|
assertRequiredField(readable, "readable", "ReadableWritablePair");
|
|
assertReadableStream(readable, `${context} has member 'readable' that`);
|
|
const writable = pair === null || pair === void 0 ? void 0 : pair.writable;
|
|
assertRequiredField(writable, "writable", "ReadableWritablePair");
|
|
assertWritableStream(writable, `${context} has member 'writable' that`);
|
|
return { readable, writable };
|
|
}
|
|
class ReadableStream2 {
|
|
constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
|
|
if (rawUnderlyingSource === void 0) {
|
|
rawUnderlyingSource = null;
|
|
} else {
|
|
assertObject(rawUnderlyingSource, "First parameter");
|
|
}
|
|
const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
|
|
const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, "First parameter");
|
|
InitializeReadableStream(this);
|
|
if (underlyingSource.type === "bytes") {
|
|
if (strategy.size !== void 0) {
|
|
throw new RangeError("The strategy for a byte stream cannot have a size function");
|
|
}
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 0);
|
|
SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
|
|
} else {
|
|
const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 1);
|
|
SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
|
|
}
|
|
}
|
|
/**
|
|
* Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
|
|
*/
|
|
get locked() {
|
|
if (!IsReadableStream(this)) {
|
|
throw streamBrandCheckException$1("locked");
|
|
}
|
|
return IsReadableStreamLocked(this);
|
|
}
|
|
/**
|
|
* Cancels the stream, signaling a loss of interest in the stream by a consumer.
|
|
*
|
|
* The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
|
|
* method, which might or might not use it.
|
|
*/
|
|
cancel(reason = void 0) {
|
|
if (!IsReadableStream(this)) {
|
|
return promiseRejectedWith(streamBrandCheckException$1("cancel"));
|
|
}
|
|
if (IsReadableStreamLocked(this)) {
|
|
return promiseRejectedWith(new TypeError("Cannot cancel a stream that already has a reader"));
|
|
}
|
|
return ReadableStreamCancel(this, reason);
|
|
}
|
|
getReader(rawOptions = void 0) {
|
|
if (!IsReadableStream(this)) {
|
|
throw streamBrandCheckException$1("getReader");
|
|
}
|
|
const options = convertReaderOptions(rawOptions, "First parameter");
|
|
if (options.mode === void 0) {
|
|
return AcquireReadableStreamDefaultReader(this);
|
|
}
|
|
return AcquireReadableStreamBYOBReader(this);
|
|
}
|
|
pipeThrough(rawTransform, rawOptions = {}) {
|
|
if (!IsReadableStream(this)) {
|
|
throw streamBrandCheckException$1("pipeThrough");
|
|
}
|
|
assertRequiredArgument(rawTransform, 1, "pipeThrough");
|
|
const transform = convertReadableWritablePair(rawTransform, "First parameter");
|
|
const options = convertPipeOptions(rawOptions, "Second parameter");
|
|
if (IsReadableStreamLocked(this)) {
|
|
throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
|
|
}
|
|
if (IsWritableStreamLocked(transform.writable)) {
|
|
throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
|
|
}
|
|
const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
|
|
setPromiseIsHandledToTrue(promise);
|
|
return transform.readable;
|
|
}
|
|
pipeTo(destination, rawOptions = {}) {
|
|
if (!IsReadableStream(this)) {
|
|
return promiseRejectedWith(streamBrandCheckException$1("pipeTo"));
|
|
}
|
|
if (destination === void 0) {
|
|
return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);
|
|
}
|
|
if (!IsWritableStream(destination)) {
|
|
return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));
|
|
}
|
|
let options;
|
|
try {
|
|
options = convertPipeOptions(rawOptions, "Second parameter");
|
|
} catch (e2) {
|
|
return promiseRejectedWith(e2);
|
|
}
|
|
if (IsReadableStreamLocked(this)) {
|
|
return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream"));
|
|
}
|
|
if (IsWritableStreamLocked(destination)) {
|
|
return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream"));
|
|
}
|
|
return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
|
|
}
|
|
/**
|
|
* Tees this readable stream, returning a two-element array containing the two resulting branches as
|
|
* new {@link ReadableStream} instances.
|
|
*
|
|
* Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
|
|
* To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
|
|
* propagated to the stream's underlying source.
|
|
*
|
|
* Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
|
|
* this could allow interference between the two branches.
|
|
*/
|
|
tee() {
|
|
if (!IsReadableStream(this)) {
|
|
throw streamBrandCheckException$1("tee");
|
|
}
|
|
const branches = ReadableStreamTee(this);
|
|
return CreateArrayFromList(branches);
|
|
}
|
|
values(rawOptions = void 0) {
|
|
if (!IsReadableStream(this)) {
|
|
throw streamBrandCheckException$1("values");
|
|
}
|
|
const options = convertIteratorOptions(rawOptions, "First parameter");
|
|
return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
|
|
}
|
|
[SymbolAsyncIterator](options) {
|
|
return this.values(options);
|
|
}
|
|
/**
|
|
* Creates a new ReadableStream wrapping the provided iterable or async iterable.
|
|
*
|
|
* This can be used to adapt various kinds of objects into a readable stream,
|
|
* such as an array, an async generator, or a Node.js readable stream.
|
|
*/
|
|
static from(asyncIterable) {
|
|
return ReadableStreamFrom(asyncIterable);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStream2, {
|
|
from: { enumerable: true }
|
|
});
|
|
Object.defineProperties(ReadableStream2.prototype, {
|
|
cancel: { enumerable: true },
|
|
getReader: { enumerable: true },
|
|
pipeThrough: { enumerable: true },
|
|
pipeTo: { enumerable: true },
|
|
tee: { enumerable: true },
|
|
values: { enumerable: true },
|
|
locked: { enumerable: true }
|
|
});
|
|
setFunctionName(ReadableStream2.from, "from");
|
|
setFunctionName(ReadableStream2.prototype.cancel, "cancel");
|
|
setFunctionName(ReadableStream2.prototype.getReader, "getReader");
|
|
setFunctionName(ReadableStream2.prototype.pipeThrough, "pipeThrough");
|
|
setFunctionName(ReadableStream2.prototype.pipeTo, "pipeTo");
|
|
setFunctionName(ReadableStream2.prototype.tee, "tee");
|
|
setFunctionName(ReadableStream2.prototype.values, "values");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ReadableStream2.prototype, Symbol.toStringTag, {
|
|
value: "ReadableStream",
|
|
configurable: true
|
|
});
|
|
}
|
|
Object.defineProperty(ReadableStream2.prototype, SymbolAsyncIterator, {
|
|
value: ReadableStream2.prototype.values,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
|
|
const stream = Object.create(ReadableStream2.prototype);
|
|
InitializeReadableStream(stream);
|
|
const controller = Object.create(ReadableStreamDefaultController.prototype);
|
|
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
|
|
return stream;
|
|
}
|
|
function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
|
|
const stream = Object.create(ReadableStream2.prototype);
|
|
InitializeReadableStream(stream);
|
|
const controller = Object.create(ReadableByteStreamController.prototype);
|
|
SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, void 0);
|
|
return stream;
|
|
}
|
|
function InitializeReadableStream(stream) {
|
|
stream._state = "readable";
|
|
stream._reader = void 0;
|
|
stream._storedError = void 0;
|
|
stream._disturbed = false;
|
|
}
|
|
function IsReadableStream(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_readableStreamController")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ReadableStream2;
|
|
}
|
|
function IsReadableStreamLocked(stream) {
|
|
if (stream._reader === void 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function ReadableStreamCancel(stream, reason) {
|
|
stream._disturbed = true;
|
|
if (stream._state === "closed") {
|
|
return promiseResolvedWith(void 0);
|
|
}
|
|
if (stream._state === "errored") {
|
|
return promiseRejectedWith(stream._storedError);
|
|
}
|
|
ReadableStreamClose(stream);
|
|
const reader = stream._reader;
|
|
if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) {
|
|
const readIntoRequests = reader._readIntoRequests;
|
|
reader._readIntoRequests = new SimpleQueue();
|
|
readIntoRequests.forEach((readIntoRequest) => {
|
|
readIntoRequest._closeSteps(void 0);
|
|
});
|
|
}
|
|
const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
|
|
return transformPromiseWith(sourceCancelPromise, noop2);
|
|
}
|
|
function ReadableStreamClose(stream) {
|
|
stream._state = "closed";
|
|
const reader = stream._reader;
|
|
if (reader === void 0) {
|
|
return;
|
|
}
|
|
defaultReaderClosedPromiseResolve(reader);
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
const readRequests = reader._readRequests;
|
|
reader._readRequests = new SimpleQueue();
|
|
readRequests.forEach((readRequest) => {
|
|
readRequest._closeSteps();
|
|
});
|
|
}
|
|
}
|
|
function ReadableStreamError(stream, e2) {
|
|
stream._state = "errored";
|
|
stream._storedError = e2;
|
|
const reader = stream._reader;
|
|
if (reader === void 0) {
|
|
return;
|
|
}
|
|
defaultReaderClosedPromiseReject(reader, e2);
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
|
|
} else {
|
|
ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
|
|
}
|
|
}
|
|
function streamBrandCheckException$1(name) {
|
|
return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);
|
|
}
|
|
function convertQueuingStrategyInit(init, context) {
|
|
assertDictionary(init, context);
|
|
const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
|
|
assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit");
|
|
return {
|
|
highWaterMark: convertUnrestrictedDouble(highWaterMark)
|
|
};
|
|
}
|
|
const byteLengthSizeFunction = (chunk) => {
|
|
return chunk.byteLength;
|
|
};
|
|
setFunctionName(byteLengthSizeFunction, "size");
|
|
class ByteLengthQueuingStrategy {
|
|
constructor(options) {
|
|
assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy");
|
|
options = convertQueuingStrategyInit(options, "First parameter");
|
|
this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
|
|
}
|
|
/**
|
|
* Returns the high water mark provided to the constructor.
|
|
*/
|
|
get highWaterMark() {
|
|
if (!IsByteLengthQueuingStrategy(this)) {
|
|
throw byteLengthBrandCheckException("highWaterMark");
|
|
}
|
|
return this._byteLengthQueuingStrategyHighWaterMark;
|
|
}
|
|
/**
|
|
* Measures the size of `chunk` by returning the value of its `byteLength` property.
|
|
*/
|
|
get size() {
|
|
if (!IsByteLengthQueuingStrategy(this)) {
|
|
throw byteLengthBrandCheckException("size");
|
|
}
|
|
return byteLengthSizeFunction;
|
|
}
|
|
}
|
|
Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
|
|
highWaterMark: { enumerable: true },
|
|
size: { enumerable: true }
|
|
});
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {
|
|
value: "ByteLengthQueuingStrategy",
|
|
configurable: true
|
|
});
|
|
}
|
|
function byteLengthBrandCheckException(name) {
|
|
return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);
|
|
}
|
|
function IsByteLengthQueuingStrategy(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_byteLengthQueuingStrategyHighWaterMark")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof ByteLengthQueuingStrategy;
|
|
}
|
|
const countSizeFunction = () => {
|
|
return 1;
|
|
};
|
|
setFunctionName(countSizeFunction, "size");
|
|
class CountQueuingStrategy {
|
|
constructor(options) {
|
|
assertRequiredArgument(options, 1, "CountQueuingStrategy");
|
|
options = convertQueuingStrategyInit(options, "First parameter");
|
|
this._countQueuingStrategyHighWaterMark = options.highWaterMark;
|
|
}
|
|
/**
|
|
* Returns the high water mark provided to the constructor.
|
|
*/
|
|
get highWaterMark() {
|
|
if (!IsCountQueuingStrategy(this)) {
|
|
throw countBrandCheckException("highWaterMark");
|
|
}
|
|
return this._countQueuingStrategyHighWaterMark;
|
|
}
|
|
/**
|
|
* Measures the size of `chunk` by always returning 1.
|
|
* This ensures that the total queue size is a count of the number of chunks in the queue.
|
|
*/
|
|
get size() {
|
|
if (!IsCountQueuingStrategy(this)) {
|
|
throw countBrandCheckException("size");
|
|
}
|
|
return countSizeFunction;
|
|
}
|
|
}
|
|
Object.defineProperties(CountQueuingStrategy.prototype, {
|
|
highWaterMark: { enumerable: true },
|
|
size: { enumerable: true }
|
|
});
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {
|
|
value: "CountQueuingStrategy",
|
|
configurable: true
|
|
});
|
|
}
|
|
function countBrandCheckException(name) {
|
|
return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);
|
|
}
|
|
function IsCountQueuingStrategy(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_countQueuingStrategyHighWaterMark")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof CountQueuingStrategy;
|
|
}
|
|
function convertTransformer(original, context) {
|
|
assertDictionary(original, context);
|
|
const cancel = original === null || original === void 0 ? void 0 : original.cancel;
|
|
const flush = original === null || original === void 0 ? void 0 : original.flush;
|
|
const readableType = original === null || original === void 0 ? void 0 : original.readableType;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const transform = original === null || original === void 0 ? void 0 : original.transform;
|
|
const writableType = original === null || original === void 0 ? void 0 : original.writableType;
|
|
return {
|
|
cancel: cancel === void 0 ? void 0 : convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
|
|
flush: flush === void 0 ? void 0 : convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
|
|
readableType,
|
|
start: start === void 0 ? void 0 : convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
|
|
transform: transform === void 0 ? void 0 : convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`),
|
|
writableType
|
|
};
|
|
}
|
|
function convertTransformerFlushCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller) => promiseCall(fn, original, [controller]);
|
|
}
|
|
function convertTransformerStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller) => reflectCall(fn, original, [controller]);
|
|
}
|
|
function convertTransformerTransformCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
|
|
}
|
|
function convertTransformerCancelCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (reason) => promiseCall(fn, original, [reason]);
|
|
}
|
|
class TransformStream {
|
|
constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
|
|
if (rawTransformer === void 0) {
|
|
rawTransformer = null;
|
|
}
|
|
const writableStrategy = convertQueuingStrategy(rawWritableStrategy, "Second parameter");
|
|
const readableStrategy = convertQueuingStrategy(rawReadableStrategy, "Third parameter");
|
|
const transformer = convertTransformer(rawTransformer, "First parameter");
|
|
if (transformer.readableType !== void 0) {
|
|
throw new RangeError("Invalid readableType specified");
|
|
}
|
|
if (transformer.writableType !== void 0) {
|
|
throw new RangeError("Invalid writableType specified");
|
|
}
|
|
const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
|
|
const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
|
|
const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
|
|
const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
|
|
let startPromise_resolve;
|
|
const startPromise = newPromise((resolve) => {
|
|
startPromise_resolve = resolve;
|
|
});
|
|
InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
|
|
SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
|
|
if (transformer.start !== void 0) {
|
|
startPromise_resolve(transformer.start(this._transformStreamController));
|
|
} else {
|
|
startPromise_resolve(void 0);
|
|
}
|
|
}
|
|
/**
|
|
* The readable side of the transform stream.
|
|
*/
|
|
get readable() {
|
|
if (!IsTransformStream(this)) {
|
|
throw streamBrandCheckException("readable");
|
|
}
|
|
return this._readable;
|
|
}
|
|
/**
|
|
* The writable side of the transform stream.
|
|
*/
|
|
get writable() {
|
|
if (!IsTransformStream(this)) {
|
|
throw streamBrandCheckException("writable");
|
|
}
|
|
return this._writable;
|
|
}
|
|
}
|
|
Object.defineProperties(TransformStream.prototype, {
|
|
readable: { enumerable: true },
|
|
writable: { enumerable: true }
|
|
});
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, {
|
|
value: "TransformStream",
|
|
configurable: true
|
|
});
|
|
}
|
|
function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
|
|
function startAlgorithm() {
|
|
return startPromise;
|
|
}
|
|
function writeAlgorithm(chunk) {
|
|
return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
|
|
}
|
|
function abortAlgorithm(reason) {
|
|
return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
|
|
}
|
|
function closeAlgorithm() {
|
|
return TransformStreamDefaultSinkCloseAlgorithm(stream);
|
|
}
|
|
stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
|
|
function pullAlgorithm() {
|
|
return TransformStreamDefaultSourcePullAlgorithm(stream);
|
|
}
|
|
function cancelAlgorithm(reason) {
|
|
return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
|
|
}
|
|
stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
|
|
stream._backpressure = void 0;
|
|
stream._backpressureChangePromise = void 0;
|
|
stream._backpressureChangePromise_resolve = void 0;
|
|
TransformStreamSetBackpressure(stream, true);
|
|
stream._transformStreamController = void 0;
|
|
}
|
|
function IsTransformStream(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_transformStreamController")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof TransformStream;
|
|
}
|
|
function TransformStreamError(stream, e2) {
|
|
ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e2);
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, e2);
|
|
}
|
|
function TransformStreamErrorWritableAndUnblockWrite(stream, e2) {
|
|
TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
|
|
WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e2);
|
|
TransformStreamUnblockWrite(stream);
|
|
}
|
|
function TransformStreamUnblockWrite(stream) {
|
|
if (stream._backpressure) {
|
|
TransformStreamSetBackpressure(stream, false);
|
|
}
|
|
}
|
|
function TransformStreamSetBackpressure(stream, backpressure) {
|
|
if (stream._backpressureChangePromise !== void 0) {
|
|
stream._backpressureChangePromise_resolve();
|
|
}
|
|
stream._backpressureChangePromise = newPromise((resolve) => {
|
|
stream._backpressureChangePromise_resolve = resolve;
|
|
});
|
|
stream._backpressure = backpressure;
|
|
}
|
|
class TransformStreamDefaultController {
|
|
constructor() {
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
|
|
*/
|
|
get desiredSize() {
|
|
if (!IsTransformStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException("desiredSize");
|
|
}
|
|
const readableController = this._controlledTransformStream._readable._readableStreamController;
|
|
return ReadableStreamDefaultControllerGetDesiredSize(readableController);
|
|
}
|
|
enqueue(chunk = void 0) {
|
|
if (!IsTransformStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException("enqueue");
|
|
}
|
|
TransformStreamDefaultControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors both the readable side and the writable side of the controlled transform stream, making all future
|
|
* interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
|
|
*/
|
|
error(reason = void 0) {
|
|
if (!IsTransformStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException("error");
|
|
}
|
|
TransformStreamDefaultControllerError(this, reason);
|
|
}
|
|
/**
|
|
* Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
|
|
* transformer only needs to consume a portion of the chunks written to the writable side.
|
|
*/
|
|
terminate() {
|
|
if (!IsTransformStreamDefaultController(this)) {
|
|
throw defaultControllerBrandCheckException("terminate");
|
|
}
|
|
TransformStreamDefaultControllerTerminate(this);
|
|
}
|
|
}
|
|
Object.defineProperties(TransformStreamDefaultController.prototype, {
|
|
enqueue: { enumerable: true },
|
|
error: { enumerable: true },
|
|
terminate: { enumerable: true },
|
|
desiredSize: { enumerable: true }
|
|
});
|
|
setFunctionName(TransformStreamDefaultController.prototype.enqueue, "enqueue");
|
|
setFunctionName(TransformStreamDefaultController.prototype.error, "error");
|
|
setFunctionName(TransformStreamDefaultController.prototype.terminate, "terminate");
|
|
if (typeof Symbol.toStringTag === "symbol") {
|
|
Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {
|
|
value: "TransformStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
}
|
|
function IsTransformStreamDefaultController(x2) {
|
|
if (!typeIsObject(x2)) {
|
|
return false;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(x2, "_controlledTransformStream")) {
|
|
return false;
|
|
}
|
|
return x2 instanceof TransformStreamDefaultController;
|
|
}
|
|
function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
|
|
controller._controlledTransformStream = stream;
|
|
stream._transformStreamController = controller;
|
|
controller._transformAlgorithm = transformAlgorithm;
|
|
controller._flushAlgorithm = flushAlgorithm;
|
|
controller._cancelAlgorithm = cancelAlgorithm;
|
|
controller._finishPromise = void 0;
|
|
controller._finishPromise_resolve = void 0;
|
|
controller._finishPromise_reject = void 0;
|
|
}
|
|
function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
|
|
const controller = Object.create(TransformStreamDefaultController.prototype);
|
|
let transformAlgorithm;
|
|
let flushAlgorithm;
|
|
let cancelAlgorithm;
|
|
if (transformer.transform !== void 0) {
|
|
transformAlgorithm = (chunk) => transformer.transform(chunk, controller);
|
|
} else {
|
|
transformAlgorithm = (chunk) => {
|
|
try {
|
|
TransformStreamDefaultControllerEnqueue(controller, chunk);
|
|
return promiseResolvedWith(void 0);
|
|
} catch (transformResultE) {
|
|
return promiseRejectedWith(transformResultE);
|
|
}
|
|
};
|
|
}
|
|
if (transformer.flush !== void 0) {
|
|
flushAlgorithm = () => transformer.flush(controller);
|
|
} else {
|
|
flushAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
if (transformer.cancel !== void 0) {
|
|
cancelAlgorithm = (reason) => transformer.cancel(reason);
|
|
} else {
|
|
cancelAlgorithm = () => promiseResolvedWith(void 0);
|
|
}
|
|
SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
|
|
}
|
|
function TransformStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._transformAlgorithm = void 0;
|
|
controller._flushAlgorithm = void 0;
|
|
controller._cancelAlgorithm = void 0;
|
|
}
|
|
function TransformStreamDefaultControllerEnqueue(controller, chunk) {
|
|
const stream = controller._controlledTransformStream;
|
|
const readableController = stream._readable._readableStreamController;
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
|
|
throw new TypeError("Readable side is not in a state that permits enqueue");
|
|
}
|
|
try {
|
|
ReadableStreamDefaultControllerEnqueue(readableController, chunk);
|
|
} catch (e2) {
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, e2);
|
|
throw stream._readable._storedError;
|
|
}
|
|
const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
|
|
if (backpressure !== stream._backpressure) {
|
|
TransformStreamSetBackpressure(stream, true);
|
|
}
|
|
}
|
|
function TransformStreamDefaultControllerError(controller, e2) {
|
|
TransformStreamError(controller._controlledTransformStream, e2);
|
|
}
|
|
function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
|
|
const transformPromise = controller._transformAlgorithm(chunk);
|
|
return transformPromiseWith(transformPromise, void 0, (r2) => {
|
|
TransformStreamError(controller._controlledTransformStream, r2);
|
|
throw r2;
|
|
});
|
|
}
|
|
function TransformStreamDefaultControllerTerminate(controller) {
|
|
const stream = controller._controlledTransformStream;
|
|
const readableController = stream._readable._readableStreamController;
|
|
ReadableStreamDefaultControllerClose(readableController);
|
|
const error = new TypeError("TransformStream terminated");
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, error);
|
|
}
|
|
function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
|
|
const controller = stream._transformStreamController;
|
|
if (stream._backpressure) {
|
|
const backpressureChangePromise = stream._backpressureChangePromise;
|
|
return transformPromiseWith(backpressureChangePromise, () => {
|
|
const writable = stream._writable;
|
|
const state = writable._state;
|
|
if (state === "erroring") {
|
|
throw writable._storedError;
|
|
}
|
|
return TransformStreamDefaultControllerPerformTransform(controller, chunk);
|
|
});
|
|
}
|
|
return TransformStreamDefaultControllerPerformTransform(controller, chunk);
|
|
}
|
|
function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
|
|
const controller = stream._transformStreamController;
|
|
if (controller._finishPromise !== void 0) {
|
|
return controller._finishPromise;
|
|
}
|
|
const readable = stream._readable;
|
|
controller._finishPromise = newPromise((resolve, reject) => {
|
|
controller._finishPromise_resolve = resolve;
|
|
controller._finishPromise_reject = reject;
|
|
});
|
|
const cancelPromise = controller._cancelAlgorithm(reason);
|
|
TransformStreamDefaultControllerClearAlgorithms(controller);
|
|
uponPromise(cancelPromise, () => {
|
|
if (readable._state === "errored") {
|
|
defaultControllerFinishPromiseReject(controller, readable._storedError);
|
|
} else {
|
|
ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
|
|
defaultControllerFinishPromiseResolve(controller);
|
|
}
|
|
return null;
|
|
}, (r2) => {
|
|
ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
|
|
defaultControllerFinishPromiseReject(controller, r2);
|
|
return null;
|
|
});
|
|
return controller._finishPromise;
|
|
}
|
|
function TransformStreamDefaultSinkCloseAlgorithm(stream) {
|
|
const controller = stream._transformStreamController;
|
|
if (controller._finishPromise !== void 0) {
|
|
return controller._finishPromise;
|
|
}
|
|
const readable = stream._readable;
|
|
controller._finishPromise = newPromise((resolve, reject) => {
|
|
controller._finishPromise_resolve = resolve;
|
|
controller._finishPromise_reject = reject;
|
|
});
|
|
const flushPromise = controller._flushAlgorithm();
|
|
TransformStreamDefaultControllerClearAlgorithms(controller);
|
|
uponPromise(flushPromise, () => {
|
|
if (readable._state === "errored") {
|
|
defaultControllerFinishPromiseReject(controller, readable._storedError);
|
|
} else {
|
|
ReadableStreamDefaultControllerClose(readable._readableStreamController);
|
|
defaultControllerFinishPromiseResolve(controller);
|
|
}
|
|
return null;
|
|
}, (r2) => {
|
|
ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
|
|
defaultControllerFinishPromiseReject(controller, r2);
|
|
return null;
|
|
});
|
|
return controller._finishPromise;
|
|
}
|
|
function TransformStreamDefaultSourcePullAlgorithm(stream) {
|
|
TransformStreamSetBackpressure(stream, false);
|
|
return stream._backpressureChangePromise;
|
|
}
|
|
function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
|
|
const controller = stream._transformStreamController;
|
|
if (controller._finishPromise !== void 0) {
|
|
return controller._finishPromise;
|
|
}
|
|
const writable = stream._writable;
|
|
controller._finishPromise = newPromise((resolve, reject) => {
|
|
controller._finishPromise_resolve = resolve;
|
|
controller._finishPromise_reject = reject;
|
|
});
|
|
const cancelPromise = controller._cancelAlgorithm(reason);
|
|
TransformStreamDefaultControllerClearAlgorithms(controller);
|
|
uponPromise(cancelPromise, () => {
|
|
if (writable._state === "errored") {
|
|
defaultControllerFinishPromiseReject(controller, writable._storedError);
|
|
} else {
|
|
WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, reason);
|
|
TransformStreamUnblockWrite(stream);
|
|
defaultControllerFinishPromiseResolve(controller);
|
|
}
|
|
return null;
|
|
}, (r2) => {
|
|
WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r2);
|
|
TransformStreamUnblockWrite(stream);
|
|
defaultControllerFinishPromiseReject(controller, r2);
|
|
return null;
|
|
});
|
|
return controller._finishPromise;
|
|
}
|
|
function defaultControllerBrandCheckException(name) {
|
|
return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
|
|
}
|
|
function defaultControllerFinishPromiseResolve(controller) {
|
|
if (controller._finishPromise_resolve === void 0) {
|
|
return;
|
|
}
|
|
controller._finishPromise_resolve();
|
|
controller._finishPromise_resolve = void 0;
|
|
controller._finishPromise_reject = void 0;
|
|
}
|
|
function defaultControllerFinishPromiseReject(controller, reason) {
|
|
if (controller._finishPromise_reject === void 0) {
|
|
return;
|
|
}
|
|
setPromiseIsHandledToTrue(controller._finishPromise);
|
|
controller._finishPromise_reject(reason);
|
|
controller._finishPromise_resolve = void 0;
|
|
controller._finishPromise_reject = void 0;
|
|
}
|
|
function streamBrandCheckException(name) {
|
|
return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
|
|
}
|
|
exports3.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
|
|
exports3.CountQueuingStrategy = CountQueuingStrategy;
|
|
exports3.ReadableByteStreamController = ReadableByteStreamController;
|
|
exports3.ReadableStream = ReadableStream2;
|
|
exports3.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
|
|
exports3.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
|
|
exports3.ReadableStreamDefaultController = ReadableStreamDefaultController;
|
|
exports3.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
|
|
exports3.TransformStream = TransformStream;
|
|
exports3.TransformStreamDefaultController = TransformStreamDefaultController;
|
|
exports3.WritableStream = WritableStream;
|
|
exports3.WritableStreamDefaultController = WritableStreamDefaultController;
|
|
exports3.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/fetch-blob/streams.cjs
|
|
var require_streams = __commonJS({
|
|
"node_modules/fetch-blob/streams.cjs"() {
|
|
var POOL_SIZE2 = 65536;
|
|
if (!globalThis.ReadableStream) {
|
|
try {
|
|
const process2 = require("node:process");
|
|
const { emitWarning } = process2;
|
|
try {
|
|
process2.emitWarning = () => {
|
|
};
|
|
Object.assign(globalThis, require("node:stream/web"));
|
|
process2.emitWarning = emitWarning;
|
|
} catch (error) {
|
|
process2.emitWarning = emitWarning;
|
|
throw error;
|
|
}
|
|
} catch (error) {
|
|
Object.assign(globalThis, require_ponyfill_es2018());
|
|
}
|
|
}
|
|
try {
|
|
const { Blob: Blob4 } = require("buffer");
|
|
if (Blob4 && !Blob4.prototype.stream) {
|
|
Blob4.prototype.stream = function name(params) {
|
|
let position = 0;
|
|
const blob = this;
|
|
return new ReadableStream({
|
|
type: "bytes",
|
|
async pull(ctrl) {
|
|
const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE2));
|
|
const buffer = await chunk.arrayBuffer();
|
|
position += buffer.byteLength;
|
|
ctrl.enqueue(new Uint8Array(buffer));
|
|
if (position === blob.size) {
|
|
ctrl.close();
|
|
}
|
|
}
|
|
});
|
|
};
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/fetch-blob/index.js
|
|
async function* toIterator(parts, clone2 = true) {
|
|
for (const part of parts) {
|
|
if ("stream" in part) {
|
|
yield* (
|
|
/** @type {AsyncIterableIterator<Uint8Array>} */
|
|
part.stream()
|
|
);
|
|
} else if (ArrayBuffer.isView(part)) {
|
|
if (clone2) {
|
|
let position = part.byteOffset;
|
|
const end = part.byteOffset + part.byteLength;
|
|
while (position !== end) {
|
|
const size = Math.min(end - position, POOL_SIZE);
|
|
const chunk = part.buffer.slice(position, position + size);
|
|
position += chunk.byteLength;
|
|
yield new Uint8Array(chunk);
|
|
}
|
|
} else {
|
|
yield part;
|
|
}
|
|
} else {
|
|
let position = 0, b = (
|
|
/** @type {Blob} */
|
|
part
|
|
);
|
|
while (position !== b.size) {
|
|
const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
|
|
const buffer = await chunk.arrayBuffer();
|
|
position += buffer.byteLength;
|
|
yield new Uint8Array(buffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var import_streams, POOL_SIZE, _Blob, Blob3, fetch_blob_default;
|
|
var init_fetch_blob = __esm({
|
|
"node_modules/fetch-blob/index.js"() {
|
|
import_streams = __toESM(require_streams(), 1);
|
|
POOL_SIZE = 65536;
|
|
_Blob = class Blob2 {
|
|
/** @type {Array.<(Blob|Uint8Array)>} */
|
|
#parts = [];
|
|
#type = "";
|
|
#size = 0;
|
|
#endings = "transparent";
|
|
/**
|
|
* The Blob() constructor returns a new Blob object. The content
|
|
* of the blob consists of the concatenation of the values given
|
|
* in the parameter array.
|
|
*
|
|
* @param {*} blobParts
|
|
* @param {{ type?: string, endings?: string }} [options]
|
|
*/
|
|
constructor(blobParts = [], options = {}) {
|
|
if (typeof blobParts !== "object" || blobParts === null) {
|
|
throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
|
|
}
|
|
if (typeof blobParts[Symbol.iterator] !== "function") {
|
|
throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
|
|
}
|
|
if (typeof options !== "object" && typeof options !== "function") {
|
|
throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
|
|
}
|
|
if (options === null) options = {};
|
|
const encoder = new TextEncoder();
|
|
for (const element of blobParts) {
|
|
let part;
|
|
if (ArrayBuffer.isView(element)) {
|
|
part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
|
|
} else if (element instanceof ArrayBuffer) {
|
|
part = new Uint8Array(element.slice(0));
|
|
} else if (element instanceof Blob2) {
|
|
part = element;
|
|
} else {
|
|
part = encoder.encode(`${element}`);
|
|
}
|
|
this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
|
|
this.#parts.push(part);
|
|
}
|
|
this.#endings = `${options.endings === void 0 ? "transparent" : options.endings}`;
|
|
const type = options.type === void 0 ? "" : String(options.type);
|
|
this.#type = /^[\x20-\x7E]*$/.test(type) ? type : "";
|
|
}
|
|
/**
|
|
* The Blob interface's size property returns the
|
|
* size of the Blob in bytes.
|
|
*/
|
|
get size() {
|
|
return this.#size;
|
|
}
|
|
/**
|
|
* The type property of a Blob object returns the MIME type of the file.
|
|
*/
|
|
get type() {
|
|
return this.#type;
|
|
}
|
|
/**
|
|
* The text() method in the Blob interface returns a Promise
|
|
* that resolves with a string containing the contents of
|
|
* the blob, interpreted as UTF-8.
|
|
*
|
|
* @return {Promise<string>}
|
|
*/
|
|
async text() {
|
|
const decoder = new TextDecoder();
|
|
let str = "";
|
|
for await (const part of toIterator(this.#parts, false)) {
|
|
str += decoder.decode(part, { stream: true });
|
|
}
|
|
str += decoder.decode();
|
|
return str;
|
|
}
|
|
/**
|
|
* The arrayBuffer() method in the Blob interface returns a
|
|
* Promise that resolves with the contents of the blob as
|
|
* binary data contained in an ArrayBuffer.
|
|
*
|
|
* @return {Promise<ArrayBuffer>}
|
|
*/
|
|
async arrayBuffer() {
|
|
const data = new Uint8Array(this.size);
|
|
let offset = 0;
|
|
for await (const chunk of toIterator(this.#parts, false)) {
|
|
data.set(chunk, offset);
|
|
offset += chunk.length;
|
|
}
|
|
return data.buffer;
|
|
}
|
|
stream() {
|
|
const it = toIterator(this.#parts, true);
|
|
return new globalThis.ReadableStream({
|
|
// @ts-ignore
|
|
type: "bytes",
|
|
async pull(ctrl) {
|
|
const chunk = await it.next();
|
|
chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
|
|
},
|
|
async cancel() {
|
|
await it.return();
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* The Blob interface's slice() method creates and returns a
|
|
* new Blob object which contains data from a subset of the
|
|
* blob on which it's called.
|
|
*
|
|
* @param {number} [start]
|
|
* @param {number} [end]
|
|
* @param {string} [type]
|
|
*/
|
|
slice(start = 0, end = this.size, type = "") {
|
|
const { size } = this;
|
|
let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
|
|
let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
|
|
const span = Math.max(relativeEnd - relativeStart, 0);
|
|
const parts = this.#parts;
|
|
const blobParts = [];
|
|
let added = 0;
|
|
for (const part of parts) {
|
|
if (added >= span) {
|
|
break;
|
|
}
|
|
const size2 = ArrayBuffer.isView(part) ? part.byteLength : part.size;
|
|
if (relativeStart && size2 <= relativeStart) {
|
|
relativeStart -= size2;
|
|
relativeEnd -= size2;
|
|
} else {
|
|
let chunk;
|
|
if (ArrayBuffer.isView(part)) {
|
|
chunk = part.subarray(relativeStart, Math.min(size2, relativeEnd));
|
|
added += chunk.byteLength;
|
|
} else {
|
|
chunk = part.slice(relativeStart, Math.min(size2, relativeEnd));
|
|
added += chunk.size;
|
|
}
|
|
relativeEnd -= size2;
|
|
blobParts.push(chunk);
|
|
relativeStart = 0;
|
|
}
|
|
}
|
|
const blob = new Blob2([], { type: String(type).toLowerCase() });
|
|
blob.#size = span;
|
|
blob.#parts = blobParts;
|
|
return blob;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "Blob";
|
|
}
|
|
static [Symbol.hasInstance](object) {
|
|
return object && typeof object === "object" && typeof object.constructor === "function" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
|
|
}
|
|
};
|
|
Object.defineProperties(_Blob.prototype, {
|
|
size: { enumerable: true },
|
|
type: { enumerable: true },
|
|
slice: { enumerable: true }
|
|
});
|
|
Blob3 = _Blob;
|
|
fetch_blob_default = Blob3;
|
|
}
|
|
});
|
|
|
|
// node_modules/fetch-blob/file.js
|
|
var _File, File2, file_default;
|
|
var init_file = __esm({
|
|
"node_modules/fetch-blob/file.js"() {
|
|
init_fetch_blob();
|
|
_File = class File extends fetch_blob_default {
|
|
#lastModified = 0;
|
|
#name = "";
|
|
/**
|
|
* @param {*[]} fileBits
|
|
* @param {string} fileName
|
|
* @param {{lastModified?: number, type?: string}} options
|
|
*/
|
|
// @ts-ignore
|
|
constructor(fileBits, fileName, options = {}) {
|
|
if (arguments.length < 2) {
|
|
throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
|
|
}
|
|
super(fileBits, options);
|
|
if (options === null) options = {};
|
|
const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
|
|
if (!Number.isNaN(lastModified)) {
|
|
this.#lastModified = lastModified;
|
|
}
|
|
this.#name = String(fileName);
|
|
}
|
|
get name() {
|
|
return this.#name;
|
|
}
|
|
get lastModified() {
|
|
return this.#lastModified;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "File";
|
|
}
|
|
static [Symbol.hasInstance](object) {
|
|
return !!object && object instanceof fetch_blob_default && /^(File)$/.test(object[Symbol.toStringTag]);
|
|
}
|
|
};
|
|
File2 = _File;
|
|
file_default = File2;
|
|
}
|
|
});
|
|
|
|
// node_modules/formdata-polyfill/esm.min.js
|
|
function formDataToBlob(F2, B = fetch_blob_default) {
|
|
var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r
|
|
Content-Disposition: form-data; name="`;
|
|
F2.forEach((v, n) => typeof v == "string" ? c.push(p + e(n) + `"\r
|
|
\r
|
|
${v.replace(/\r(?!\n)|(?<!\r)\n/g, "\r\n")}\r
|
|
`) : c.push(p + e(n) + `"; filename="${e(v.name, 1)}"\r
|
|
Content-Type: ${v.type || "application/octet-stream"}\r
|
|
\r
|
|
`, v, "\r\n"));
|
|
c.push(`--${b}--`);
|
|
return new B(c, { type: "multipart/form-data; boundary=" + b });
|
|
}
|
|
var t, i, h, r, m, f, e, x, FormData;
|
|
var init_esm_min = __esm({
|
|
"node_modules/formdata-polyfill/esm.min.js"() {
|
|
init_fetch_blob();
|
|
init_file();
|
|
({ toStringTag: t, iterator: i, hasInstance: h } = Symbol);
|
|
r = Math.random;
|
|
m = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(",");
|
|
f = (a, b, c) => (a += "", /^(Blob|File)$/.test(b && b[t]) ? [(c = c !== void 0 ? c + "" : b[t] == "File" ? b.name : "blob", a), b.name !== c || b[t] == "blob" ? new file_default([b], c, b) : b] : [a, b + ""]);
|
|
e = (c, f3) => (f3 ? c : c.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
|
|
x = (n, a, e2) => {
|
|
if (a.length < e2) {
|
|
throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`);
|
|
}
|
|
};
|
|
FormData = class FormData2 {
|
|
#d = [];
|
|
constructor(...a) {
|
|
if (a.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
|
|
}
|
|
get [t]() {
|
|
return "FormData";
|
|
}
|
|
[i]() {
|
|
return this.entries();
|
|
}
|
|
static [h](o) {
|
|
return o && typeof o === "object" && o[t] === "FormData" && !m.some((m2) => typeof o[m2] != "function");
|
|
}
|
|
append(...a) {
|
|
x("append", arguments, 2);
|
|
this.#d.push(f(...a));
|
|
}
|
|
delete(a) {
|
|
x("delete", arguments, 1);
|
|
a += "";
|
|
this.#d = this.#d.filter(([b]) => b !== a);
|
|
}
|
|
get(a) {
|
|
x("get", arguments, 1);
|
|
a += "";
|
|
for (var b = this.#d, l = b.length, c = 0; c < l; c++) if (b[c][0] === a) return b[c][1];
|
|
return null;
|
|
}
|
|
getAll(a, b) {
|
|
x("getAll", arguments, 1);
|
|
b = [];
|
|
a += "";
|
|
this.#d.forEach((c) => c[0] === a && b.push(c[1]));
|
|
return b;
|
|
}
|
|
has(a) {
|
|
x("has", arguments, 1);
|
|
a += "";
|
|
return this.#d.some((b) => b[0] === a);
|
|
}
|
|
forEach(a, b) {
|
|
x("forEach", arguments, 1);
|
|
for (var [c, d] of this) a.call(b, d, c, this);
|
|
}
|
|
set(...a) {
|
|
x("set", arguments, 2);
|
|
var b = [], c = true;
|
|
a = f(...a);
|
|
this.#d.forEach((d) => {
|
|
d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
|
|
});
|
|
c && b.push(a);
|
|
this.#d = b;
|
|
}
|
|
*entries() {
|
|
yield* this.#d;
|
|
}
|
|
*keys() {
|
|
for (var [a] of this) yield a;
|
|
}
|
|
*values() {
|
|
for (var [, a] of this) yield a;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/node-domexception/index.js
|
|
var require_node_domexception = __commonJS({
|
|
"node_modules/node-domexception/index.js"(exports2, module2) {
|
|
if (!globalThis.DOMException) {
|
|
try {
|
|
const { MessageChannel } = require("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer();
|
|
port.postMessage(ab, [ab, ab]);
|
|
} catch (err) {
|
|
err.constructor.name === "DOMException" && (globalThis.DOMException = err.constructor);
|
|
}
|
|
}
|
|
module2.exports = globalThis.DOMException;
|
|
}
|
|
});
|
|
|
|
// node_modules/fetch-blob/from.js
|
|
var import_node_fs, import_node_domexception, stat;
|
|
var init_from = __esm({
|
|
"node_modules/fetch-blob/from.js"() {
|
|
import_node_fs = require("node:fs");
|
|
import_node_domexception = __toESM(require_node_domexception(), 1);
|
|
init_file();
|
|
init_fetch_blob();
|
|
({ stat } = import_node_fs.promises);
|
|
}
|
|
});
|
|
|
|
// node_modules/node-fetch/src/utils/multipart-parser.js
|
|
var multipart_parser_exports = {};
|
|
__export(multipart_parser_exports, {
|
|
toFormData: () => toFormData
|
|
});
|
|
function _fileName(headerValue) {
|
|
const m2 = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
|
|
if (!m2) {
|
|
return;
|
|
}
|
|
const match = m2[2] || m2[3] || "";
|
|
let filename = match.slice(match.lastIndexOf("\\") + 1);
|
|
filename = filename.replace(/%22/g, '"');
|
|
filename = filename.replace(/&#(\d{4});/g, (m3, code) => {
|
|
return String.fromCharCode(code);
|
|
});
|
|
return filename;
|
|
}
|
|
async function toFormData(Body2, ct) {
|
|
if (!/multipart/i.test(ct)) {
|
|
throw new TypeError("Failed to fetch");
|
|
}
|
|
const m2 = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
|
|
if (!m2) {
|
|
throw new TypeError("no or bad content-type header, no multipart boundary");
|
|
}
|
|
const parser = new MultipartParser(m2[1] || m2[2]);
|
|
let headerField;
|
|
let headerValue;
|
|
let entryValue;
|
|
let entryName;
|
|
let contentType;
|
|
let filename;
|
|
const entryChunks = [];
|
|
const formData = new FormData();
|
|
const onPartData = (ui8a) => {
|
|
entryValue += decoder.decode(ui8a, { stream: true });
|
|
};
|
|
const appendToFile = (ui8a) => {
|
|
entryChunks.push(ui8a);
|
|
};
|
|
const appendFileToFormData = () => {
|
|
const file = new file_default(entryChunks, filename, { type: contentType });
|
|
formData.append(entryName, file);
|
|
};
|
|
const appendEntryToFormData = () => {
|
|
formData.append(entryName, entryValue);
|
|
};
|
|
const decoder = new TextDecoder("utf-8");
|
|
decoder.decode();
|
|
parser.onPartBegin = function() {
|
|
parser.onPartData = onPartData;
|
|
parser.onPartEnd = appendEntryToFormData;
|
|
headerField = "";
|
|
headerValue = "";
|
|
entryValue = "";
|
|
entryName = "";
|
|
contentType = "";
|
|
filename = null;
|
|
entryChunks.length = 0;
|
|
};
|
|
parser.onHeaderField = function(ui8a) {
|
|
headerField += decoder.decode(ui8a, { stream: true });
|
|
};
|
|
parser.onHeaderValue = function(ui8a) {
|
|
headerValue += decoder.decode(ui8a, { stream: true });
|
|
};
|
|
parser.onHeaderEnd = function() {
|
|
headerValue += decoder.decode();
|
|
headerField = headerField.toLowerCase();
|
|
if (headerField === "content-disposition") {
|
|
const m3 = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
|
|
if (m3) {
|
|
entryName = m3[2] || m3[3] || "";
|
|
}
|
|
filename = _fileName(headerValue);
|
|
if (filename) {
|
|
parser.onPartData = appendToFile;
|
|
parser.onPartEnd = appendFileToFormData;
|
|
}
|
|
} else if (headerField === "content-type") {
|
|
contentType = headerValue;
|
|
}
|
|
headerValue = "";
|
|
headerField = "";
|
|
};
|
|
for await (const chunk of Body2) {
|
|
parser.write(chunk);
|
|
}
|
|
parser.end();
|
|
return formData;
|
|
}
|
|
var s, S, f2, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop, MultipartParser;
|
|
var init_multipart_parser = __esm({
|
|
"node_modules/node-fetch/src/utils/multipart-parser.js"() {
|
|
init_from();
|
|
init_esm_min();
|
|
s = 0;
|
|
S = {
|
|
START_BOUNDARY: s++,
|
|
HEADER_FIELD_START: s++,
|
|
HEADER_FIELD: s++,
|
|
HEADER_VALUE_START: s++,
|
|
HEADER_VALUE: s++,
|
|
HEADER_VALUE_ALMOST_DONE: s++,
|
|
HEADERS_ALMOST_DONE: s++,
|
|
PART_DATA_START: s++,
|
|
PART_DATA: s++,
|
|
END: s++
|
|
};
|
|
f2 = 1;
|
|
F = {
|
|
PART_BOUNDARY: f2,
|
|
LAST_BOUNDARY: f2 *= 2
|
|
};
|
|
LF = 10;
|
|
CR = 13;
|
|
SPACE = 32;
|
|
HYPHEN = 45;
|
|
COLON = 58;
|
|
A = 97;
|
|
Z = 122;
|
|
lower = (c) => c | 32;
|
|
noop = () => {
|
|
};
|
|
MultipartParser = class {
|
|
/**
|
|
* @param {string} boundary
|
|
*/
|
|
constructor(boundary) {
|
|
this.index = 0;
|
|
this.flags = 0;
|
|
this.onHeaderEnd = noop;
|
|
this.onHeaderField = noop;
|
|
this.onHeadersEnd = noop;
|
|
this.onHeaderValue = noop;
|
|
this.onPartBegin = noop;
|
|
this.onPartData = noop;
|
|
this.onPartEnd = noop;
|
|
this.boundaryChars = {};
|
|
boundary = "\r\n--" + boundary;
|
|
const ui8a = new Uint8Array(boundary.length);
|
|
for (let i2 = 0; i2 < boundary.length; i2++) {
|
|
ui8a[i2] = boundary.charCodeAt(i2);
|
|
this.boundaryChars[ui8a[i2]] = true;
|
|
}
|
|
this.boundary = ui8a;
|
|
this.lookbehind = new Uint8Array(this.boundary.length + 8);
|
|
this.state = S.START_BOUNDARY;
|
|
}
|
|
/**
|
|
* @param {Uint8Array} data
|
|
*/
|
|
write(data) {
|
|
let i2 = 0;
|
|
const length_ = data.length;
|
|
let previousIndex = this.index;
|
|
let { lookbehind, boundary, boundaryChars, index, state, flags } = this;
|
|
const boundaryLength = this.boundary.length;
|
|
const boundaryEnd = boundaryLength - 1;
|
|
const bufferLength = data.length;
|
|
let c;
|
|
let cl;
|
|
const mark = (name) => {
|
|
this[name + "Mark"] = i2;
|
|
};
|
|
const clear = (name) => {
|
|
delete this[name + "Mark"];
|
|
};
|
|
const callback = (callbackSymbol, start, end, ui8a) => {
|
|
if (start === void 0 || start !== end) {
|
|
this[callbackSymbol](ui8a && ui8a.subarray(start, end));
|
|
}
|
|
};
|
|
const dataCallback = (name, clear2) => {
|
|
const markSymbol = name + "Mark";
|
|
if (!(markSymbol in this)) {
|
|
return;
|
|
}
|
|
if (clear2) {
|
|
callback(name, this[markSymbol], i2, data);
|
|
delete this[markSymbol];
|
|
} else {
|
|
callback(name, this[markSymbol], data.length, data);
|
|
this[markSymbol] = 0;
|
|
}
|
|
};
|
|
for (i2 = 0; i2 < length_; i2++) {
|
|
c = data[i2];
|
|
switch (state) {
|
|
case S.START_BOUNDARY:
|
|
if (index === boundary.length - 2) {
|
|
if (c === HYPHEN) {
|
|
flags |= F.LAST_BOUNDARY;
|
|
} else if (c !== CR) {
|
|
return;
|
|
}
|
|
index++;
|
|
break;
|
|
} else if (index - 1 === boundary.length - 2) {
|
|
if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
|
|
state = S.END;
|
|
flags = 0;
|
|
} else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
|
|
index = 0;
|
|
callback("onPartBegin");
|
|
state = S.HEADER_FIELD_START;
|
|
} else {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if (c !== boundary[index + 2]) {
|
|
index = -2;
|
|
}
|
|
if (c === boundary[index + 2]) {
|
|
index++;
|
|
}
|
|
break;
|
|
case S.HEADER_FIELD_START:
|
|
state = S.HEADER_FIELD;
|
|
mark("onHeaderField");
|
|
index = 0;
|
|
// falls through
|
|
case S.HEADER_FIELD:
|
|
if (c === CR) {
|
|
clear("onHeaderField");
|
|
state = S.HEADERS_ALMOST_DONE;
|
|
break;
|
|
}
|
|
index++;
|
|
if (c === HYPHEN) {
|
|
break;
|
|
}
|
|
if (c === COLON) {
|
|
if (index === 1) {
|
|
return;
|
|
}
|
|
dataCallback("onHeaderField", true);
|
|
state = S.HEADER_VALUE_START;
|
|
break;
|
|
}
|
|
cl = lower(c);
|
|
if (cl < A || cl > Z) {
|
|
return;
|
|
}
|
|
break;
|
|
case S.HEADER_VALUE_START:
|
|
if (c === SPACE) {
|
|
break;
|
|
}
|
|
mark("onHeaderValue");
|
|
state = S.HEADER_VALUE;
|
|
// falls through
|
|
case S.HEADER_VALUE:
|
|
if (c === CR) {
|
|
dataCallback("onHeaderValue", true);
|
|
callback("onHeaderEnd");
|
|
state = S.HEADER_VALUE_ALMOST_DONE;
|
|
}
|
|
break;
|
|
case S.HEADER_VALUE_ALMOST_DONE:
|
|
if (c !== LF) {
|
|
return;
|
|
}
|
|
state = S.HEADER_FIELD_START;
|
|
break;
|
|
case S.HEADERS_ALMOST_DONE:
|
|
if (c !== LF) {
|
|
return;
|
|
}
|
|
callback("onHeadersEnd");
|
|
state = S.PART_DATA_START;
|
|
break;
|
|
case S.PART_DATA_START:
|
|
state = S.PART_DATA;
|
|
mark("onPartData");
|
|
// falls through
|
|
case S.PART_DATA:
|
|
previousIndex = index;
|
|
if (index === 0) {
|
|
i2 += boundaryEnd;
|
|
while (i2 < bufferLength && !(data[i2] in boundaryChars)) {
|
|
i2 += boundaryLength;
|
|
}
|
|
i2 -= boundaryEnd;
|
|
c = data[i2];
|
|
}
|
|
if (index < boundary.length) {
|
|
if (boundary[index] === c) {
|
|
if (index === 0) {
|
|
dataCallback("onPartData", true);
|
|
}
|
|
index++;
|
|
} else {
|
|
index = 0;
|
|
}
|
|
} else if (index === boundary.length) {
|
|
index++;
|
|
if (c === CR) {
|
|
flags |= F.PART_BOUNDARY;
|
|
} else if (c === HYPHEN) {
|
|
flags |= F.LAST_BOUNDARY;
|
|
} else {
|
|
index = 0;
|
|
}
|
|
} else if (index - 1 === boundary.length) {
|
|
if (flags & F.PART_BOUNDARY) {
|
|
index = 0;
|
|
if (c === LF) {
|
|
flags &= ~F.PART_BOUNDARY;
|
|
callback("onPartEnd");
|
|
callback("onPartBegin");
|
|
state = S.HEADER_FIELD_START;
|
|
break;
|
|
}
|
|
} else if (flags & F.LAST_BOUNDARY) {
|
|
if (c === HYPHEN) {
|
|
callback("onPartEnd");
|
|
state = S.END;
|
|
flags = 0;
|
|
} else {
|
|
index = 0;
|
|
}
|
|
} else {
|
|
index = 0;
|
|
}
|
|
}
|
|
if (index > 0) {
|
|
lookbehind[index - 1] = c;
|
|
} else if (previousIndex > 0) {
|
|
const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
|
|
callback("onPartData", 0, previousIndex, _lookbehind);
|
|
previousIndex = 0;
|
|
mark("onPartData");
|
|
i2--;
|
|
}
|
|
break;
|
|
case S.END:
|
|
break;
|
|
default:
|
|
throw new Error(`Unexpected state entered: ${state}`);
|
|
}
|
|
}
|
|
dataCallback("onHeaderField");
|
|
dataCallback("onHeaderValue");
|
|
dataCallback("onPartData");
|
|
this.index = index;
|
|
this.state = state;
|
|
this.flags = flags;
|
|
}
|
|
end() {
|
|
if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) {
|
|
this.onPartEnd();
|
|
} else if (this.state !== S.END) {
|
|
throw new Error("MultipartParser.end(): stream ended unexpectedly");
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// src/index.ts
|
|
var core4 = __toESM(require_core());
|
|
|
|
// src/save.ts
|
|
var core2 = __toESM(require_core());
|
|
var fs4 = __toESM(require("fs"));
|
|
|
|
// src/env.ts
|
|
var core = __toESM(require_core());
|
|
function getServerUrl() {
|
|
const url = process.env.CACHE_SERVER_URL || "http://cache:8080";
|
|
if (!url) {
|
|
core.warning("CACHE_SERVER_URL is not set \u2013 using default URL.");
|
|
}
|
|
return url;
|
|
}
|
|
function getToken() {
|
|
const token = process.env.ACTIONS_RUNTIME_TOKEN;
|
|
if (!token) {
|
|
core.warning("ACTIONS_RUNTIME_TOKEN is not set \u2013 skipping action.");
|
|
process.exit(0);
|
|
}
|
|
return token;
|
|
}
|
|
function getRepoInfo() {
|
|
const repository = process.env.GITHUB_REPOSITORY;
|
|
if (!repository) {
|
|
core.warning("GITHUB_REPOSITORY is not set \u2013 skipping action.");
|
|
process.exit(0);
|
|
}
|
|
const [owner, repo] = repository.split("/");
|
|
return { owner, repo };
|
|
}
|
|
|
|
// src/cache.ts
|
|
var fs2 = __toESM(require("fs"));
|
|
|
|
// node_modules/node-fetch/src/index.js
|
|
var import_node_http2 = __toESM(require("node:http"), 1);
|
|
var import_node_https = __toESM(require("node:https"), 1);
|
|
var import_node_zlib = __toESM(require("node:zlib"), 1);
|
|
var import_node_stream2 = __toESM(require("node:stream"), 1);
|
|
var import_node_buffer2 = require("node:buffer");
|
|
|
|
// node_modules/data-uri-to-buffer/dist/index.js
|
|
function dataUriToBuffer(uri) {
|
|
if (!/^data:/i.test(uri)) {
|
|
throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
|
|
}
|
|
uri = uri.replace(/\r?\n/g, "");
|
|
const firstComma = uri.indexOf(",");
|
|
if (firstComma === -1 || firstComma <= 4) {
|
|
throw new TypeError("malformed data: URI");
|
|
}
|
|
const meta = uri.substring(5, firstComma).split(";");
|
|
let charset = "";
|
|
let base64 = false;
|
|
const type = meta[0] || "text/plain";
|
|
let typeFull = type;
|
|
for (let i2 = 1; i2 < meta.length; i2++) {
|
|
if (meta[i2] === "base64") {
|
|
base64 = true;
|
|
} else if (meta[i2]) {
|
|
typeFull += `;${meta[i2]}`;
|
|
if (meta[i2].indexOf("charset=") === 0) {
|
|
charset = meta[i2].substring(8);
|
|
}
|
|
}
|
|
}
|
|
if (!meta[0] && !charset.length) {
|
|
typeFull += ";charset=US-ASCII";
|
|
charset = "US-ASCII";
|
|
}
|
|
const encoding = base64 ? "base64" : "ascii";
|
|
const data = unescape(uri.substring(firstComma + 1));
|
|
const buffer = Buffer.from(data, encoding);
|
|
buffer.type = type;
|
|
buffer.typeFull = typeFull;
|
|
buffer.charset = charset;
|
|
return buffer;
|
|
}
|
|
var dist_default = dataUriToBuffer;
|
|
|
|
// node_modules/node-fetch/src/body.js
|
|
var import_node_stream = __toESM(require("node:stream"), 1);
|
|
var import_node_util = require("node:util");
|
|
var import_node_buffer = require("node:buffer");
|
|
init_fetch_blob();
|
|
init_esm_min();
|
|
|
|
// node_modules/node-fetch/src/errors/base.js
|
|
var FetchBaseError = class extends Error {
|
|
constructor(message, type) {
|
|
super(message);
|
|
Error.captureStackTrace(this, this.constructor);
|
|
this.type = type;
|
|
}
|
|
get name() {
|
|
return this.constructor.name;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return this.constructor.name;
|
|
}
|
|
};
|
|
|
|
// node_modules/node-fetch/src/errors/fetch-error.js
|
|
var FetchError = class extends FetchBaseError {
|
|
/**
|
|
* @param {string} message - Error message for human
|
|
* @param {string} [type] - Error type for machine
|
|
* @param {SystemError} [systemError] - For Node.js system error
|
|
*/
|
|
constructor(message, type, systemError) {
|
|
super(message, type);
|
|
if (systemError) {
|
|
this.code = this.errno = systemError.code;
|
|
this.erroredSysCall = systemError.syscall;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/node-fetch/src/utils/is.js
|
|
var NAME = Symbol.toStringTag;
|
|
var isURLSearchParameters = (object) => {
|
|
return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams";
|
|
};
|
|
var isBlob = (object) => {
|
|
return object && typeof object === "object" && typeof object.arrayBuffer === "function" && typeof object.type === "string" && typeof object.stream === "function" && typeof object.constructor === "function" && /^(Blob|File)$/.test(object[NAME]);
|
|
};
|
|
var isAbortSignal = (object) => {
|
|
return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
|
|
};
|
|
var isDomainOrSubdomain = (destination, original) => {
|
|
const orig = new URL(original).hostname;
|
|
const dest = new URL(destination).hostname;
|
|
return orig === dest || orig.endsWith(`.${dest}`);
|
|
};
|
|
var isSameProtocol = (destination, original) => {
|
|
const orig = new URL(original).protocol;
|
|
const dest = new URL(destination).protocol;
|
|
return orig === dest;
|
|
};
|
|
|
|
// node_modules/node-fetch/src/body.js
|
|
var pipeline = (0, import_node_util.promisify)(import_node_stream.default.pipeline);
|
|
var INTERNALS = Symbol("Body internals");
|
|
var Body = class {
|
|
constructor(body, {
|
|
size = 0
|
|
} = {}) {
|
|
let boundary = null;
|
|
if (body === null) {
|
|
body = null;
|
|
} else if (isURLSearchParameters(body)) {
|
|
body = import_node_buffer.Buffer.from(body.toString());
|
|
} else if (isBlob(body)) {
|
|
} else if (import_node_buffer.Buffer.isBuffer(body)) {
|
|
} else if (import_node_util.types.isAnyArrayBuffer(body)) {
|
|
body = import_node_buffer.Buffer.from(body);
|
|
} else if (ArrayBuffer.isView(body)) {
|
|
body = import_node_buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
|
|
} else if (body instanceof import_node_stream.default) {
|
|
} else if (body instanceof FormData) {
|
|
body = formDataToBlob(body);
|
|
boundary = body.type.split("=")[1];
|
|
} else {
|
|
body = import_node_buffer.Buffer.from(String(body));
|
|
}
|
|
let stream = body;
|
|
if (import_node_buffer.Buffer.isBuffer(body)) {
|
|
stream = import_node_stream.default.Readable.from(body);
|
|
} else if (isBlob(body)) {
|
|
stream = import_node_stream.default.Readable.from(body.stream());
|
|
}
|
|
this[INTERNALS] = {
|
|
body,
|
|
stream,
|
|
boundary,
|
|
disturbed: false,
|
|
error: null
|
|
};
|
|
this.size = size;
|
|
if (body instanceof import_node_stream.default) {
|
|
body.on("error", (error_) => {
|
|
const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
|
|
this[INTERNALS].error = error;
|
|
});
|
|
}
|
|
}
|
|
get body() {
|
|
return this[INTERNALS].stream;
|
|
}
|
|
get bodyUsed() {
|
|
return this[INTERNALS].disturbed;
|
|
}
|
|
/**
|
|
* Decode response as ArrayBuffer
|
|
*
|
|
* @return Promise
|
|
*/
|
|
async arrayBuffer() {
|
|
const { buffer, byteOffset, byteLength } = await consumeBody(this);
|
|
return buffer.slice(byteOffset, byteOffset + byteLength);
|
|
}
|
|
async formData() {
|
|
const ct = this.headers.get("content-type");
|
|
if (ct.startsWith("application/x-www-form-urlencoded")) {
|
|
const formData = new FormData();
|
|
const parameters = new URLSearchParams(await this.text());
|
|
for (const [name, value] of parameters) {
|
|
formData.append(name, value);
|
|
}
|
|
return formData;
|
|
}
|
|
const { toFormData: toFormData2 } = await Promise.resolve().then(() => (init_multipart_parser(), multipart_parser_exports));
|
|
return toFormData2(this.body, ct);
|
|
}
|
|
/**
|
|
* Return raw response as Blob
|
|
*
|
|
* @return Promise
|
|
*/
|
|
async blob() {
|
|
const ct = this.headers && this.headers.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
|
|
const buf = await this.arrayBuffer();
|
|
return new fetch_blob_default([buf], {
|
|
type: ct
|
|
});
|
|
}
|
|
/**
|
|
* Decode response as json
|
|
*
|
|
* @return Promise
|
|
*/
|
|
async json() {
|
|
const text = await this.text();
|
|
return JSON.parse(text);
|
|
}
|
|
/**
|
|
* Decode response as text
|
|
*
|
|
* @return Promise
|
|
*/
|
|
async text() {
|
|
const buffer = await consumeBody(this);
|
|
return new TextDecoder().decode(buffer);
|
|
}
|
|
/**
|
|
* Decode response as buffer (non-spec api)
|
|
*
|
|
* @return Promise
|
|
*/
|
|
buffer() {
|
|
return consumeBody(this);
|
|
}
|
|
};
|
|
Body.prototype.buffer = (0, import_node_util.deprecate)(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
|
|
Object.defineProperties(Body.prototype, {
|
|
body: { enumerable: true },
|
|
bodyUsed: { enumerable: true },
|
|
arrayBuffer: { enumerable: true },
|
|
blob: { enumerable: true },
|
|
json: { enumerable: true },
|
|
text: { enumerable: true },
|
|
data: { get: (0, import_node_util.deprecate)(
|
|
() => {
|
|
},
|
|
"data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
|
|
"https://github.com/node-fetch/node-fetch/issues/1000 (response)"
|
|
) }
|
|
});
|
|
async function consumeBody(data) {
|
|
if (data[INTERNALS].disturbed) {
|
|
throw new TypeError(`body used already for: ${data.url}`);
|
|
}
|
|
data[INTERNALS].disturbed = true;
|
|
if (data[INTERNALS].error) {
|
|
throw data[INTERNALS].error;
|
|
}
|
|
const { body } = data;
|
|
if (body === null) {
|
|
return import_node_buffer.Buffer.alloc(0);
|
|
}
|
|
if (!(body instanceof import_node_stream.default)) {
|
|
return import_node_buffer.Buffer.alloc(0);
|
|
}
|
|
const accum = [];
|
|
let accumBytes = 0;
|
|
try {
|
|
for await (const chunk of body) {
|
|
if (data.size > 0 && accumBytes + chunk.length > data.size) {
|
|
const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
|
|
body.destroy(error);
|
|
throw error;
|
|
}
|
|
accumBytes += chunk.length;
|
|
accum.push(chunk);
|
|
}
|
|
} catch (error) {
|
|
const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
|
|
throw error_;
|
|
}
|
|
if (body.readableEnded === true || body._readableState.ended === true) {
|
|
try {
|
|
if (accum.every((c) => typeof c === "string")) {
|
|
return import_node_buffer.Buffer.from(accum.join(""));
|
|
}
|
|
return import_node_buffer.Buffer.concat(accum, accumBytes);
|
|
} catch (error) {
|
|
throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
|
|
}
|
|
} else {
|
|
throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
|
|
}
|
|
}
|
|
var clone = (instance, highWaterMark) => {
|
|
let p1;
|
|
let p2;
|
|
let { body } = instance[INTERNALS];
|
|
if (instance.bodyUsed) {
|
|
throw new Error("cannot clone body after it is used");
|
|
}
|
|
if (body instanceof import_node_stream.default && typeof body.getBoundary !== "function") {
|
|
p1 = new import_node_stream.PassThrough({ highWaterMark });
|
|
p2 = new import_node_stream.PassThrough({ highWaterMark });
|
|
body.pipe(p1);
|
|
body.pipe(p2);
|
|
instance[INTERNALS].stream = p1;
|
|
body = p2;
|
|
}
|
|
return body;
|
|
};
|
|
var getNonSpecFormDataBoundary = (0, import_node_util.deprecate)(
|
|
(body) => body.getBoundary(),
|
|
"form-data doesn't follow the spec and requires special treatment. Use alternative package",
|
|
"https://github.com/node-fetch/node-fetch/issues/1167"
|
|
);
|
|
var extractContentType = (body, request) => {
|
|
if (body === null) {
|
|
return null;
|
|
}
|
|
if (typeof body === "string") {
|
|
return "text/plain;charset=UTF-8";
|
|
}
|
|
if (isURLSearchParameters(body)) {
|
|
return "application/x-www-form-urlencoded;charset=UTF-8";
|
|
}
|
|
if (isBlob(body)) {
|
|
return body.type || null;
|
|
}
|
|
if (import_node_buffer.Buffer.isBuffer(body) || import_node_util.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
|
|
return null;
|
|
}
|
|
if (body instanceof FormData) {
|
|
return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
|
|
}
|
|
if (body && typeof body.getBoundary === "function") {
|
|
return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
|
|
}
|
|
if (body instanceof import_node_stream.default) {
|
|
return null;
|
|
}
|
|
return "text/plain;charset=UTF-8";
|
|
};
|
|
var getTotalBytes = (request) => {
|
|
const { body } = request[INTERNALS];
|
|
if (body === null) {
|
|
return 0;
|
|
}
|
|
if (isBlob(body)) {
|
|
return body.size;
|
|
}
|
|
if (import_node_buffer.Buffer.isBuffer(body)) {
|
|
return body.length;
|
|
}
|
|
if (body && typeof body.getLengthSync === "function") {
|
|
return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
|
|
}
|
|
return null;
|
|
};
|
|
var writeToStream = async (dest, { body }) => {
|
|
if (body === null) {
|
|
dest.end();
|
|
} else {
|
|
await pipeline(body, dest);
|
|
}
|
|
};
|
|
|
|
// node_modules/node-fetch/src/headers.js
|
|
var import_node_util2 = require("node:util");
|
|
var import_node_http = __toESM(require("node:http"), 1);
|
|
var validateHeaderName = typeof import_node_http.default.validateHeaderName === "function" ? import_node_http.default.validateHeaderName : (name) => {
|
|
if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
|
|
const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
|
|
Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
|
|
throw error;
|
|
}
|
|
};
|
|
var validateHeaderValue = typeof import_node_http.default.validateHeaderValue === "function" ? import_node_http.default.validateHeaderValue : (name, value) => {
|
|
if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
|
|
const error = new TypeError(`Invalid character in header content ["${name}"]`);
|
|
Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" });
|
|
throw error;
|
|
}
|
|
};
|
|
var Headers = class _Headers extends URLSearchParams {
|
|
/**
|
|
* Headers class
|
|
*
|
|
* @constructor
|
|
* @param {HeadersInit} [init] - Response headers
|
|
*/
|
|
constructor(init) {
|
|
let result = [];
|
|
if (init instanceof _Headers) {
|
|
const raw = init.raw();
|
|
for (const [name, values] of Object.entries(raw)) {
|
|
result.push(...values.map((value) => [name, value]));
|
|
}
|
|
} else if (init == null) {
|
|
} else if (typeof init === "object" && !import_node_util2.types.isBoxedPrimitive(init)) {
|
|
const method = init[Symbol.iterator];
|
|
if (method == null) {
|
|
result.push(...Object.entries(init));
|
|
} else {
|
|
if (typeof method !== "function") {
|
|
throw new TypeError("Header pairs must be iterable");
|
|
}
|
|
result = [...init].map((pair) => {
|
|
if (typeof pair !== "object" || import_node_util2.types.isBoxedPrimitive(pair)) {
|
|
throw new TypeError("Each header pair must be an iterable object");
|
|
}
|
|
return [...pair];
|
|
}).map((pair) => {
|
|
if (pair.length !== 2) {
|
|
throw new TypeError("Each header pair must be a name/value tuple");
|
|
}
|
|
return [...pair];
|
|
});
|
|
}
|
|
} else {
|
|
throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
|
|
}
|
|
result = result.length > 0 ? result.map(([name, value]) => {
|
|
validateHeaderName(name);
|
|
validateHeaderValue(name, String(value));
|
|
return [String(name).toLowerCase(), String(value)];
|
|
}) : void 0;
|
|
super(result);
|
|
return new Proxy(this, {
|
|
get(target, p, receiver) {
|
|
switch (p) {
|
|
case "append":
|
|
case "set":
|
|
return (name, value) => {
|
|
validateHeaderName(name);
|
|
validateHeaderValue(name, String(value));
|
|
return URLSearchParams.prototype[p].call(
|
|
target,
|
|
String(name).toLowerCase(),
|
|
String(value)
|
|
);
|
|
};
|
|
case "delete":
|
|
case "has":
|
|
case "getAll":
|
|
return (name) => {
|
|
validateHeaderName(name);
|
|
return URLSearchParams.prototype[p].call(
|
|
target,
|
|
String(name).toLowerCase()
|
|
);
|
|
};
|
|
case "keys":
|
|
return () => {
|
|
target.sort();
|
|
return new Set(URLSearchParams.prototype.keys.call(target)).keys();
|
|
};
|
|
default:
|
|
return Reflect.get(target, p, receiver);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return this.constructor.name;
|
|
}
|
|
toString() {
|
|
return Object.prototype.toString.call(this);
|
|
}
|
|
get(name) {
|
|
const values = this.getAll(name);
|
|
if (values.length === 0) {
|
|
return null;
|
|
}
|
|
let value = values.join(", ");
|
|
if (/^content-encoding$/i.test(name)) {
|
|
value = value.toLowerCase();
|
|
}
|
|
return value;
|
|
}
|
|
forEach(callback, thisArg = void 0) {
|
|
for (const name of this.keys()) {
|
|
Reflect.apply(callback, thisArg, [this.get(name), name, this]);
|
|
}
|
|
}
|
|
*values() {
|
|
for (const name of this.keys()) {
|
|
yield this.get(name);
|
|
}
|
|
}
|
|
/**
|
|
* @type {() => IterableIterator<[string, string]>}
|
|
*/
|
|
*entries() {
|
|
for (const name of this.keys()) {
|
|
yield [name, this.get(name)];
|
|
}
|
|
}
|
|
[Symbol.iterator]() {
|
|
return this.entries();
|
|
}
|
|
/**
|
|
* Node-fetch non-spec method
|
|
* returning all headers and their values as array
|
|
* @returns {Record<string, string[]>}
|
|
*/
|
|
raw() {
|
|
return [...this.keys()].reduce((result, key) => {
|
|
result[key] = this.getAll(key);
|
|
return result;
|
|
}, {});
|
|
}
|
|
/**
|
|
* For better console.log(headers) and also to convert Headers into Node.js Request compatible format
|
|
*/
|
|
[Symbol.for("nodejs.util.inspect.custom")]() {
|
|
return [...this.keys()].reduce((result, key) => {
|
|
const values = this.getAll(key);
|
|
if (key === "host") {
|
|
result[key] = values[0];
|
|
} else {
|
|
result[key] = values.length > 1 ? values : values[0];
|
|
}
|
|
return result;
|
|
}, {});
|
|
}
|
|
};
|
|
Object.defineProperties(
|
|
Headers.prototype,
|
|
["get", "entries", "forEach", "values"].reduce((result, property) => {
|
|
result[property] = { enumerable: true };
|
|
return result;
|
|
}, {})
|
|
);
|
|
function fromRawHeaders(headers = []) {
|
|
return new Headers(
|
|
headers.reduce((result, value, index, array) => {
|
|
if (index % 2 === 0) {
|
|
result.push(array.slice(index, index + 2));
|
|
}
|
|
return result;
|
|
}, []).filter(([name, value]) => {
|
|
try {
|
|
validateHeaderName(name);
|
|
validateHeaderValue(name, String(value));
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
// node_modules/node-fetch/src/utils/is-redirect.js
|
|
var redirectStatus = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
|
|
var isRedirect = (code) => {
|
|
return redirectStatus.has(code);
|
|
};
|
|
|
|
// node_modules/node-fetch/src/response.js
|
|
var INTERNALS2 = Symbol("Response internals");
|
|
var Response = class _Response extends Body {
|
|
constructor(body = null, options = {}) {
|
|
super(body, options);
|
|
const status = options.status != null ? options.status : 200;
|
|
const headers = new Headers(options.headers);
|
|
if (body !== null && !headers.has("Content-Type")) {
|
|
const contentType = extractContentType(body, this);
|
|
if (contentType) {
|
|
headers.append("Content-Type", contentType);
|
|
}
|
|
}
|
|
this[INTERNALS2] = {
|
|
type: "default",
|
|
url: options.url,
|
|
status,
|
|
statusText: options.statusText || "",
|
|
headers,
|
|
counter: options.counter,
|
|
highWaterMark: options.highWaterMark
|
|
};
|
|
}
|
|
get type() {
|
|
return this[INTERNALS2].type;
|
|
}
|
|
get url() {
|
|
return this[INTERNALS2].url || "";
|
|
}
|
|
get status() {
|
|
return this[INTERNALS2].status;
|
|
}
|
|
/**
|
|
* Convenience property representing if the request ended normally
|
|
*/
|
|
get ok() {
|
|
return this[INTERNALS2].status >= 200 && this[INTERNALS2].status < 300;
|
|
}
|
|
get redirected() {
|
|
return this[INTERNALS2].counter > 0;
|
|
}
|
|
get statusText() {
|
|
return this[INTERNALS2].statusText;
|
|
}
|
|
get headers() {
|
|
return this[INTERNALS2].headers;
|
|
}
|
|
get highWaterMark() {
|
|
return this[INTERNALS2].highWaterMark;
|
|
}
|
|
/**
|
|
* Clone this response
|
|
*
|
|
* @return Response
|
|
*/
|
|
clone() {
|
|
return new _Response(clone(this, this.highWaterMark), {
|
|
type: this.type,
|
|
url: this.url,
|
|
status: this.status,
|
|
statusText: this.statusText,
|
|
headers: this.headers,
|
|
ok: this.ok,
|
|
redirected: this.redirected,
|
|
size: this.size,
|
|
highWaterMark: this.highWaterMark
|
|
});
|
|
}
|
|
/**
|
|
* @param {string} url The URL that the new response is to originate from.
|
|
* @param {number} status An optional status code for the response (e.g., 302.)
|
|
* @returns {Response} A Response object.
|
|
*/
|
|
static redirect(url, status = 302) {
|
|
if (!isRedirect(status)) {
|
|
throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
|
|
}
|
|
return new _Response(null, {
|
|
headers: {
|
|
location: new URL(url).toString()
|
|
},
|
|
status
|
|
});
|
|
}
|
|
static error() {
|
|
const response = new _Response(null, { status: 0, statusText: "" });
|
|
response[INTERNALS2].type = "error";
|
|
return response;
|
|
}
|
|
static json(data = void 0, init = {}) {
|
|
const body = JSON.stringify(data);
|
|
if (body === void 0) {
|
|
throw new TypeError("data is not JSON serializable");
|
|
}
|
|
const headers = new Headers(init && init.headers);
|
|
if (!headers.has("content-type")) {
|
|
headers.set("content-type", "application/json");
|
|
}
|
|
return new _Response(body, {
|
|
...init,
|
|
headers
|
|
});
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "Response";
|
|
}
|
|
};
|
|
Object.defineProperties(Response.prototype, {
|
|
type: { enumerable: true },
|
|
url: { enumerable: true },
|
|
status: { enumerable: true },
|
|
ok: { enumerable: true },
|
|
redirected: { enumerable: true },
|
|
statusText: { enumerable: true },
|
|
headers: { enumerable: true },
|
|
clone: { enumerable: true }
|
|
});
|
|
|
|
// node_modules/node-fetch/src/request.js
|
|
var import_node_url = require("node:url");
|
|
var import_node_util3 = require("node:util");
|
|
|
|
// node_modules/node-fetch/src/utils/get-search.js
|
|
var getSearch = (parsedURL) => {
|
|
if (parsedURL.search) {
|
|
return parsedURL.search;
|
|
}
|
|
const lastOffset = parsedURL.href.length - 1;
|
|
const hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
|
|
return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
|
|
};
|
|
|
|
// node_modules/node-fetch/src/utils/referrer.js
|
|
var import_node_net = require("node:net");
|
|
function stripURLForUseAsAReferrer(url, originOnly = false) {
|
|
if (url == null) {
|
|
return "no-referrer";
|
|
}
|
|
url = new URL(url);
|
|
if (/^(about|blob|data):$/.test(url.protocol)) {
|
|
return "no-referrer";
|
|
}
|
|
url.username = "";
|
|
url.password = "";
|
|
url.hash = "";
|
|
if (originOnly) {
|
|
url.pathname = "";
|
|
url.search = "";
|
|
}
|
|
return url;
|
|
}
|
|
var ReferrerPolicy = /* @__PURE__ */ new Set([
|
|
"",
|
|
"no-referrer",
|
|
"no-referrer-when-downgrade",
|
|
"same-origin",
|
|
"origin",
|
|
"strict-origin",
|
|
"origin-when-cross-origin",
|
|
"strict-origin-when-cross-origin",
|
|
"unsafe-url"
|
|
]);
|
|
var DEFAULT_REFERRER_POLICY = "strict-origin-when-cross-origin";
|
|
function validateReferrerPolicy(referrerPolicy) {
|
|
if (!ReferrerPolicy.has(referrerPolicy)) {
|
|
throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
|
|
}
|
|
return referrerPolicy;
|
|
}
|
|
function isOriginPotentiallyTrustworthy(url) {
|
|
if (/^(http|ws)s:$/.test(url.protocol)) {
|
|
return true;
|
|
}
|
|
const hostIp = url.host.replace(/(^\[)|(]$)/g, "");
|
|
const hostIPVersion = (0, import_node_net.isIP)(hostIp);
|
|
if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
|
|
return true;
|
|
}
|
|
if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
|
|
return true;
|
|
}
|
|
if (url.host === "localhost" || url.host.endsWith(".localhost")) {
|
|
return false;
|
|
}
|
|
if (url.protocol === "file:") {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isUrlPotentiallyTrustworthy(url) {
|
|
if (/^about:(blank|srcdoc)$/.test(url)) {
|
|
return true;
|
|
}
|
|
if (url.protocol === "data:") {
|
|
return true;
|
|
}
|
|
if (/^(blob|filesystem):$/.test(url.protocol)) {
|
|
return true;
|
|
}
|
|
return isOriginPotentiallyTrustworthy(url);
|
|
}
|
|
function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
|
|
if (request.referrer === "no-referrer" || request.referrerPolicy === "") {
|
|
return null;
|
|
}
|
|
const policy = request.referrerPolicy;
|
|
if (request.referrer === "about:client") {
|
|
return "no-referrer";
|
|
}
|
|
const referrerSource = request.referrer;
|
|
let referrerURL = stripURLForUseAsAReferrer(referrerSource);
|
|
let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
|
|
if (referrerURL.toString().length > 4096) {
|
|
referrerURL = referrerOrigin;
|
|
}
|
|
if (referrerURLCallback) {
|
|
referrerURL = referrerURLCallback(referrerURL);
|
|
}
|
|
if (referrerOriginCallback) {
|
|
referrerOrigin = referrerOriginCallback(referrerOrigin);
|
|
}
|
|
const currentURL = new URL(request.url);
|
|
switch (policy) {
|
|
case "no-referrer":
|
|
return "no-referrer";
|
|
case "origin":
|
|
return referrerOrigin;
|
|
case "unsafe-url":
|
|
return referrerURL;
|
|
case "strict-origin":
|
|
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
|
|
return "no-referrer";
|
|
}
|
|
return referrerOrigin.toString();
|
|
case "strict-origin-when-cross-origin":
|
|
if (referrerURL.origin === currentURL.origin) {
|
|
return referrerURL;
|
|
}
|
|
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
|
|
return "no-referrer";
|
|
}
|
|
return referrerOrigin;
|
|
case "same-origin":
|
|
if (referrerURL.origin === currentURL.origin) {
|
|
return referrerURL;
|
|
}
|
|
return "no-referrer";
|
|
case "origin-when-cross-origin":
|
|
if (referrerURL.origin === currentURL.origin) {
|
|
return referrerURL;
|
|
}
|
|
return referrerOrigin;
|
|
case "no-referrer-when-downgrade":
|
|
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
|
|
return "no-referrer";
|
|
}
|
|
return referrerURL;
|
|
default:
|
|
throw new TypeError(`Invalid referrerPolicy: ${policy}`);
|
|
}
|
|
}
|
|
function parseReferrerPolicyFromHeader(headers) {
|
|
const policyTokens = (headers.get("referrer-policy") || "").split(/[,\s]+/);
|
|
let policy = "";
|
|
for (const token of policyTokens) {
|
|
if (token && ReferrerPolicy.has(token)) {
|
|
policy = token;
|
|
}
|
|
}
|
|
return policy;
|
|
}
|
|
|
|
// node_modules/node-fetch/src/request.js
|
|
var INTERNALS3 = Symbol("Request internals");
|
|
var isRequest = (object) => {
|
|
return typeof object === "object" && typeof object[INTERNALS3] === "object";
|
|
};
|
|
var doBadDataWarn = (0, import_node_util3.deprecate)(
|
|
() => {
|
|
},
|
|
".data is not a valid RequestInit property, use .body instead",
|
|
"https://github.com/node-fetch/node-fetch/issues/1000 (request)"
|
|
);
|
|
var Request = class _Request extends Body {
|
|
constructor(input, init = {}) {
|
|
let parsedURL;
|
|
if (isRequest(input)) {
|
|
parsedURL = new URL(input.url);
|
|
} else {
|
|
parsedURL = new URL(input);
|
|
input = {};
|
|
}
|
|
if (parsedURL.username !== "" || parsedURL.password !== "") {
|
|
throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
|
|
}
|
|
let method = init.method || input.method || "GET";
|
|
if (/^(delete|get|head|options|post|put)$/i.test(method)) {
|
|
method = method.toUpperCase();
|
|
}
|
|
if (!isRequest(init) && "data" in init) {
|
|
doBadDataWarn();
|
|
}
|
|
if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
|
|
throw new TypeError("Request with GET/HEAD method cannot have body");
|
|
}
|
|
const inputBody = init.body ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
|
|
super(inputBody, {
|
|
size: init.size || input.size || 0
|
|
});
|
|
const headers = new Headers(init.headers || input.headers || {});
|
|
if (inputBody !== null && !headers.has("Content-Type")) {
|
|
const contentType = extractContentType(inputBody, this);
|
|
if (contentType) {
|
|
headers.set("Content-Type", contentType);
|
|
}
|
|
}
|
|
let signal = isRequest(input) ? input.signal : null;
|
|
if ("signal" in init) {
|
|
signal = init.signal;
|
|
}
|
|
if (signal != null && !isAbortSignal(signal)) {
|
|
throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
|
|
}
|
|
let referrer = init.referrer == null ? input.referrer : init.referrer;
|
|
if (referrer === "") {
|
|
referrer = "no-referrer";
|
|
} else if (referrer) {
|
|
const parsedReferrer = new URL(referrer);
|
|
referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? "client" : parsedReferrer;
|
|
} else {
|
|
referrer = void 0;
|
|
}
|
|
this[INTERNALS3] = {
|
|
method,
|
|
redirect: init.redirect || input.redirect || "follow",
|
|
headers,
|
|
parsedURL,
|
|
signal,
|
|
referrer
|
|
};
|
|
this.follow = init.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init.follow;
|
|
this.compress = init.compress === void 0 ? input.compress === void 0 ? true : input.compress : init.compress;
|
|
this.counter = init.counter || input.counter || 0;
|
|
this.agent = init.agent || input.agent;
|
|
this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
|
|
this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
|
|
this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
|
|
}
|
|
/** @returns {string} */
|
|
get method() {
|
|
return this[INTERNALS3].method;
|
|
}
|
|
/** @returns {string} */
|
|
get url() {
|
|
return (0, import_node_url.format)(this[INTERNALS3].parsedURL);
|
|
}
|
|
/** @returns {Headers} */
|
|
get headers() {
|
|
return this[INTERNALS3].headers;
|
|
}
|
|
get redirect() {
|
|
return this[INTERNALS3].redirect;
|
|
}
|
|
/** @returns {AbortSignal} */
|
|
get signal() {
|
|
return this[INTERNALS3].signal;
|
|
}
|
|
// https://fetch.spec.whatwg.org/#dom-request-referrer
|
|
get referrer() {
|
|
if (this[INTERNALS3].referrer === "no-referrer") {
|
|
return "";
|
|
}
|
|
if (this[INTERNALS3].referrer === "client") {
|
|
return "about:client";
|
|
}
|
|
if (this[INTERNALS3].referrer) {
|
|
return this[INTERNALS3].referrer.toString();
|
|
}
|
|
return void 0;
|
|
}
|
|
get referrerPolicy() {
|
|
return this[INTERNALS3].referrerPolicy;
|
|
}
|
|
set referrerPolicy(referrerPolicy) {
|
|
this[INTERNALS3].referrerPolicy = validateReferrerPolicy(referrerPolicy);
|
|
}
|
|
/**
|
|
* Clone this request
|
|
*
|
|
* @return Request
|
|
*/
|
|
clone() {
|
|
return new _Request(this);
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "Request";
|
|
}
|
|
};
|
|
Object.defineProperties(Request.prototype, {
|
|
method: { enumerable: true },
|
|
url: { enumerable: true },
|
|
headers: { enumerable: true },
|
|
redirect: { enumerable: true },
|
|
clone: { enumerable: true },
|
|
signal: { enumerable: true },
|
|
referrer: { enumerable: true },
|
|
referrerPolicy: { enumerable: true }
|
|
});
|
|
var getNodeRequestOptions = (request) => {
|
|
const { parsedURL } = request[INTERNALS3];
|
|
const headers = new Headers(request[INTERNALS3].headers);
|
|
if (!headers.has("Accept")) {
|
|
headers.set("Accept", "*/*");
|
|
}
|
|
let contentLengthValue = null;
|
|
if (request.body === null && /^(post|put)$/i.test(request.method)) {
|
|
contentLengthValue = "0";
|
|
}
|
|
if (request.body !== null) {
|
|
const totalBytes = getTotalBytes(request);
|
|
if (typeof totalBytes === "number" && !Number.isNaN(totalBytes)) {
|
|
contentLengthValue = String(totalBytes);
|
|
}
|
|
}
|
|
if (contentLengthValue) {
|
|
headers.set("Content-Length", contentLengthValue);
|
|
}
|
|
if (request.referrerPolicy === "") {
|
|
request.referrerPolicy = DEFAULT_REFERRER_POLICY;
|
|
}
|
|
if (request.referrer && request.referrer !== "no-referrer") {
|
|
request[INTERNALS3].referrer = determineRequestsReferrer(request);
|
|
} else {
|
|
request[INTERNALS3].referrer = "no-referrer";
|
|
}
|
|
if (request[INTERNALS3].referrer instanceof URL) {
|
|
headers.set("Referer", request.referrer);
|
|
}
|
|
if (!headers.has("User-Agent")) {
|
|
headers.set("User-Agent", "node-fetch");
|
|
}
|
|
if (request.compress && !headers.has("Accept-Encoding")) {
|
|
headers.set("Accept-Encoding", "gzip, deflate, br");
|
|
}
|
|
let { agent } = request;
|
|
if (typeof agent === "function") {
|
|
agent = agent(parsedURL);
|
|
}
|
|
const search = getSearch(parsedURL);
|
|
const options = {
|
|
// Overwrite search to retain trailing ? (issue #776)
|
|
path: parsedURL.pathname + search,
|
|
// The following options are not expressed in the URL
|
|
method: request.method,
|
|
headers: headers[Symbol.for("nodejs.util.inspect.custom")](),
|
|
insecureHTTPParser: request.insecureHTTPParser,
|
|
agent
|
|
};
|
|
return {
|
|
/** @type {URL} */
|
|
parsedURL,
|
|
options
|
|
};
|
|
};
|
|
|
|
// node_modules/node-fetch/src/errors/abort-error.js
|
|
var AbortError = class extends FetchBaseError {
|
|
constructor(message, type = "aborted") {
|
|
super(message, type);
|
|
}
|
|
};
|
|
|
|
// node_modules/node-fetch/src/index.js
|
|
init_esm_min();
|
|
init_from();
|
|
var supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
|
|
async function fetch(url, options_) {
|
|
return new Promise((resolve, reject) => {
|
|
const request = new Request(url, options_);
|
|
const { parsedURL, options } = getNodeRequestOptions(request);
|
|
if (!supportedSchemas.has(parsedURL.protocol)) {
|
|
throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
|
|
}
|
|
if (parsedURL.protocol === "data:") {
|
|
const data = dist_default(request.url);
|
|
const response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
|
|
resolve(response2);
|
|
return;
|
|
}
|
|
const send = (parsedURL.protocol === "https:" ? import_node_https.default : import_node_http2.default).request;
|
|
const { signal } = request;
|
|
let response = null;
|
|
const abort = () => {
|
|
const error = new AbortError("The operation was aborted.");
|
|
reject(error);
|
|
if (request.body && request.body instanceof import_node_stream2.default.Readable) {
|
|
request.body.destroy(error);
|
|
}
|
|
if (!response || !response.body) {
|
|
return;
|
|
}
|
|
response.body.emit("error", error);
|
|
};
|
|
if (signal && signal.aborted) {
|
|
abort();
|
|
return;
|
|
}
|
|
const abortAndFinalize = () => {
|
|
abort();
|
|
finalize();
|
|
};
|
|
const request_ = send(parsedURL.toString(), options);
|
|
if (signal) {
|
|
signal.addEventListener("abort", abortAndFinalize);
|
|
}
|
|
const finalize = () => {
|
|
request_.abort();
|
|
if (signal) {
|
|
signal.removeEventListener("abort", abortAndFinalize);
|
|
}
|
|
};
|
|
request_.on("error", (error) => {
|
|
reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
|
|
finalize();
|
|
});
|
|
fixResponseChunkedTransferBadEnding(request_, (error) => {
|
|
if (response && response.body) {
|
|
response.body.destroy(error);
|
|
}
|
|
});
|
|
if (process.version < "v14") {
|
|
request_.on("socket", (s2) => {
|
|
let endedWithEventsCount;
|
|
s2.prependListener("end", () => {
|
|
endedWithEventsCount = s2._eventsCount;
|
|
});
|
|
s2.prependListener("close", (hadError) => {
|
|
if (response && endedWithEventsCount < s2._eventsCount && !hadError) {
|
|
const error = new Error("Premature close");
|
|
error.code = "ERR_STREAM_PREMATURE_CLOSE";
|
|
response.body.emit("error", error);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
request_.on("response", (response_) => {
|
|
request_.setTimeout(0);
|
|
const headers = fromRawHeaders(response_.rawHeaders);
|
|
if (isRedirect(response_.statusCode)) {
|
|
const location = headers.get("Location");
|
|
let locationURL = null;
|
|
try {
|
|
locationURL = location === null ? null : new URL(location, request.url);
|
|
} catch {
|
|
if (request.redirect !== "manual") {
|
|
reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
}
|
|
switch (request.redirect) {
|
|
case "error":
|
|
reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect"));
|
|
finalize();
|
|
return;
|
|
case "manual":
|
|
break;
|
|
case "follow": {
|
|
if (locationURL === null) {
|
|
break;
|
|
}
|
|
if (request.counter >= request.follow) {
|
|
reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
const requestOptions = {
|
|
headers: new Headers(request.headers),
|
|
follow: request.follow,
|
|
counter: request.counter + 1,
|
|
agent: request.agent,
|
|
compress: request.compress,
|
|
method: request.method,
|
|
body: clone(request),
|
|
signal: request.signal,
|
|
size: request.size,
|
|
referrer: request.referrer,
|
|
referrerPolicy: request.referrerPolicy
|
|
};
|
|
if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
|
|
for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
|
|
requestOptions.headers.delete(name);
|
|
}
|
|
}
|
|
if (response_.statusCode !== 303 && request.body && options_.body instanceof import_node_stream2.default.Readable) {
|
|
reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
if (response_.statusCode === 303 || (response_.statusCode === 301 || response_.statusCode === 302) && request.method === "POST") {
|
|
requestOptions.method = "GET";
|
|
requestOptions.body = void 0;
|
|
requestOptions.headers.delete("content-length");
|
|
}
|
|
const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
|
|
if (responseReferrerPolicy) {
|
|
requestOptions.referrerPolicy = responseReferrerPolicy;
|
|
}
|
|
resolve(fetch(new Request(locationURL, requestOptions)));
|
|
finalize();
|
|
return;
|
|
}
|
|
default:
|
|
return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
|
|
}
|
|
}
|
|
if (signal) {
|
|
response_.once("end", () => {
|
|
signal.removeEventListener("abort", abortAndFinalize);
|
|
});
|
|
}
|
|
let body = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
if (process.version < "v12.10") {
|
|
response_.on("aborted", abortAndFinalize);
|
|
}
|
|
const responseOptions = {
|
|
url: request.url,
|
|
status: response_.statusCode,
|
|
statusText: response_.statusMessage,
|
|
headers,
|
|
size: request.size,
|
|
counter: request.counter,
|
|
highWaterMark: request.highWaterMark
|
|
};
|
|
const codings = headers.get("Content-Encoding");
|
|
if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
const zlibOptions = {
|
|
flush: import_node_zlib.default.Z_SYNC_FLUSH,
|
|
finishFlush: import_node_zlib.default.Z_SYNC_FLUSH
|
|
};
|
|
if (codings === "gzip" || codings === "x-gzip") {
|
|
body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createGunzip(zlibOptions), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
if (codings === "deflate" || codings === "x-deflate") {
|
|
const raw = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
raw.once("data", (chunk) => {
|
|
if ((chunk[0] & 15) === 8) {
|
|
body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflate(), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
} else {
|
|
body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflateRaw(), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
});
|
|
raw.once("end", () => {
|
|
if (!response) {
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
if (codings === "br") {
|
|
body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createBrotliDecompress(), (error) => {
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
response = new Response(body, responseOptions);
|
|
resolve(response);
|
|
});
|
|
writeToStream(request_, request).catch(reject);
|
|
});
|
|
}
|
|
function fixResponseChunkedTransferBadEnding(request, errorCallback) {
|
|
const LAST_CHUNK = import_node_buffer2.Buffer.from("0\r\n\r\n");
|
|
let isChunkedTransfer = false;
|
|
let properLastChunkReceived = false;
|
|
let previousChunk;
|
|
request.on("response", (response) => {
|
|
const { headers } = response;
|
|
isChunkedTransfer = headers["transfer-encoding"] === "chunked" && !headers["content-length"];
|
|
});
|
|
request.on("socket", (socket) => {
|
|
const onSocketClose = () => {
|
|
if (isChunkedTransfer && !properLastChunkReceived) {
|
|
const error = new Error("Premature close");
|
|
error.code = "ERR_STREAM_PREMATURE_CLOSE";
|
|
errorCallback(error);
|
|
}
|
|
};
|
|
const onData = (buf) => {
|
|
properLastChunkReceived = import_node_buffer2.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
|
|
if (!properLastChunkReceived && previousChunk) {
|
|
properLastChunkReceived = import_node_buffer2.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 && import_node_buffer2.Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0;
|
|
}
|
|
previousChunk = buf;
|
|
};
|
|
socket.prependListener("close", onSocketClose);
|
|
socket.on("data", onData);
|
|
request.on("close", () => {
|
|
socket.removeListener("close", onSocketClose);
|
|
socket.removeListener("data", onData);
|
|
});
|
|
});
|
|
}
|
|
|
|
// src/cache.ts
|
|
var import_promises = require("stream/promises");
|
|
var import_fs = require("fs");
|
|
|
|
// src/util.ts
|
|
var os = __toESM(require("os"));
|
|
var import_path = __toESM(require("path"));
|
|
function formatSize(bytes) {
|
|
const units = ["B", "KiB", "MiB", "GiB", "TiB"];
|
|
let i2 = 0;
|
|
while (bytes >= 1024 && i2 < units.length - 1) {
|
|
bytes /= 1024;
|
|
i2++;
|
|
}
|
|
return `${bytes.toFixed(2)} ${units[i2]}`;
|
|
}
|
|
function formatSpeed(bytes, ms) {
|
|
if (ms <= 0) return "\u221E";
|
|
const seconds = ms / 1e3;
|
|
const speedBytesPerSec = bytes / seconds;
|
|
const units = ["B/s", "KiB/s", "MiB/s", "GiB/s"];
|
|
let i2 = 0;
|
|
let speed = speedBytesPerSec;
|
|
while (speed >= 1024 && i2 < units.length - 1) {
|
|
speed /= 1024;
|
|
i2++;
|
|
}
|
|
return `${speed.toFixed(2)} ${units[i2]}`;
|
|
}
|
|
function formatDuration(ms) {
|
|
const totalSeconds = Math.floor(ms / 1e3);
|
|
const seconds = totalSeconds % 60;
|
|
const minutes = Math.floor(totalSeconds % 3600 / 60);
|
|
const hours = Math.floor(totalSeconds / 3600);
|
|
const parts = [];
|
|
if (hours > 0) parts.push(`${hours}h`);
|
|
if (minutes > 0 || hours > 0) parts.push(`${minutes}m`);
|
|
parts.push(`${seconds}s`);
|
|
return parts.join(" ");
|
|
}
|
|
function expandPath(p) {
|
|
if (p === "~") {
|
|
p = os.homedir();
|
|
} else if (p.startsWith("~/") || p.startsWith("~\\")) {
|
|
p = import_path.default.join(os.homedir(), p.slice(2));
|
|
}
|
|
p = p.replace(
|
|
/\$([A-Z_][A-Z0-9_]+)|\$\{([A-Z_][A-Z0-9_]+)\}/gi,
|
|
(_, var1, var2) => {
|
|
const val = process.env[var1 || var2];
|
|
return val !== void 0 ? val : "";
|
|
}
|
|
);
|
|
return import_path.default.resolve(p);
|
|
}
|
|
function sanitizeKey(key) {
|
|
key = key.trim();
|
|
key = key.replace(/[^a-zA-Z0-9._-]/g, "_");
|
|
if (key.length === 0) {
|
|
throw new Error("Cache key cannot be empty after sanitization.");
|
|
}
|
|
return key;
|
|
}
|
|
|
|
// src/cache.ts
|
|
async function uploadCache(options, owner, repo, key, filePath) {
|
|
const url = `${options.serverUrl}/cache/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${encodeURIComponent(key)}`;
|
|
const fileStats = await fs2.promises.stat(filePath);
|
|
console.log(`
|
|
\u2B06\uFE0F Uploading cache: ${filePath}`);
|
|
const startTime = Date.now();
|
|
const stream = (0, import_fs.createReadStream)(filePath);
|
|
const res = await fetch(url, {
|
|
method: "PUT",
|
|
headers: {
|
|
"Authorization": `Bearer ${options.token}`,
|
|
"Content-Type": "application/gzip",
|
|
"Content-Length": fileStats.size.toString()
|
|
},
|
|
body: stream
|
|
});
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
const size = fileStats.size;
|
|
if (!res.ok) {
|
|
throw new Error(
|
|
`\u274C Failed to upload cache: ${res.status} ${res.statusText}`
|
|
);
|
|
}
|
|
console.log(`\u2705 Upload completed`);
|
|
console.log(`\u{1F4E6} Size: ${formatSize(fileStats.size)}`);
|
|
console.log(`\u23F1 Duration: ${formatDuration(duration)}`);
|
|
console.log(`\u26A1 Speed: ${formatSpeed(size, duration)}`);
|
|
}
|
|
async function downloadCache(options, owner, repo, key, destinationPath) {
|
|
const url = `${options.serverUrl}/cache/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${encodeURIComponent(key)}`;
|
|
console.log(`
|
|
\u2B07\uFE0F Downloading cache to: ${destinationPath}`);
|
|
const startTime = Date.now();
|
|
const res = await fetch(url, {
|
|
method: "GET",
|
|
headers: {
|
|
"Authorization": `Bearer ${options.token}`,
|
|
"Accept-Encoding": "identity"
|
|
}
|
|
});
|
|
if (res.status === 404) {
|
|
console.warn("\u26A0\uFE0F Cache not found.");
|
|
return false;
|
|
}
|
|
if (!res.ok || !res.body) {
|
|
throw new Error(
|
|
`\u274C Failed to download cache: ${res.status} ${res.statusText}`
|
|
);
|
|
}
|
|
const destStream = (0, import_fs.createWriteStream)(destinationPath);
|
|
await (0, import_promises.pipeline)(res.body, destStream);
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
const size = fs2.statSync(destinationPath).size;
|
|
console.log(`\u2705 Download completed`);
|
|
console.log(`\u{1F4E6} Size: ${formatSize(size)}`);
|
|
console.log(`\u23F1 Duration: ${formatDuration(duration)}`);
|
|
console.log(`\u26A1 Speed: ${formatSpeed(size, duration)}`);
|
|
return true;
|
|
}
|
|
|
|
// src/compress.ts
|
|
var import_child_process = require("child_process");
|
|
var import_util2 = require("util");
|
|
var fs3 = __toESM(require("fs"));
|
|
var path2 = __toESM(require("path"));
|
|
var os2 = __toESM(require("os"));
|
|
var execAsync = (0, import_util2.promisify)(import_child_process.exec);
|
|
async function createCompressedTar(key, paths, cmprss_lvl = 0) {
|
|
if (!paths || paths.length === 0) {
|
|
throw new Error("No paths specified for archiving.");
|
|
}
|
|
const tempDir = await fs3.promises.mkdtemp(path2.join(os2.tmpdir(), "cache-"));
|
|
const archivePath = path2.join(tempDir, `${sanitizeKey(key)}.tar.zst`);
|
|
const quotedPaths = paths.map((p) => `"${expandPath(p)}"`).join(" ");
|
|
const isCompressed = cmprss_lvl > 0;
|
|
const cmd = isCompressed ? `tar -cf - ${quotedPaths} | zstd -${cmprss_lvl} -o "${archivePath}"` : `tar -cf "${archivePath}" ${quotedPaths}`;
|
|
console.log(
|
|
isCompressed ? `
|
|
\u{1F504} Compressing with zstd (Level: ${cmprss_lvl})...` : `
|
|
\u{1F4E6} Creating uncompressed tar archive...`
|
|
);
|
|
const startTime = Date.now();
|
|
await execAsync(cmd, {
|
|
cwd: "/",
|
|
// Required for absolute paths
|
|
shell: "/bin/bash"
|
|
});
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
const size = fs3.statSync(archivePath).size;
|
|
console.log(`\u2705 Archive created: ${archivePath}`);
|
|
console.log(`\u23F1 Duration: ${formatDuration(duration)}`);
|
|
console.log(`\u{1F4E6} Size: ${formatSize(size)}`);
|
|
console.log(`\u26A1 Speed: ${formatSpeed(size, duration)}`);
|
|
return archivePath;
|
|
}
|
|
async function extractCompressedTar(archivePath, extractTo = "/") {
|
|
if (!fs3.existsSync(archivePath)) {
|
|
throw new Error(`Archive not found: ${archivePath}`);
|
|
}
|
|
const type = await detectArchiveType(archivePath);
|
|
if (type === "unknown") {
|
|
console.error(
|
|
`\u26A0\uFE0F Unknown archive type for ${archivePath}. Cannot extract.`
|
|
);
|
|
return;
|
|
}
|
|
const cmd = type === "zstd" ? `zstd -dc "${archivePath}" | tar -xf - -C "${extractTo}"` : `tar -xf "${archivePath}" -C "${extractTo}"`;
|
|
console.log(`
|
|
\u{1F4C2} Extracting archive: ${archivePath}`);
|
|
const startTime = Date.now();
|
|
await execAsync(cmd, {
|
|
shell: "/bin/bash"
|
|
});
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
const size = fs3.statSync(archivePath).size;
|
|
const speedMBs = size / 1024 / 1024 / duration;
|
|
console.log(`\u2705 Extraction completed`);
|
|
console.log(`\u23F1 Duration: ${formatDuration(duration)}`);
|
|
console.log(`\u{1F4E6} Archive size: ${formatSize(size)}`);
|
|
console.log(`\u26A1 Speed: ${formatSpeed(size, duration)}`);
|
|
}
|
|
async function detectArchiveType(path3) {
|
|
const { stdout } = await execAsync(`file --brief --mime-type "${path3}"`);
|
|
const type = stdout.trim();
|
|
if (type === "application/zstd") {
|
|
return "zstd";
|
|
}
|
|
if (type === "application/x-tar" || type === "application/x-ustar") {
|
|
return "tar";
|
|
}
|
|
const { stdout: fileOutput } = await execAsync(`file "${path3}"`);
|
|
if (/Zstandard compressed data/.test(fileOutput)) return "zstd";
|
|
if (/tar archive/.test(fileOutput)) return "tar";
|
|
return "unknown";
|
|
}
|
|
|
|
// src/save.ts
|
|
async function saveCache(key, paths, cmprss_lvl = 3) {
|
|
core2.info(`\u{1F4BE} Starting cache save for key: ${key}`);
|
|
const startTime = Date.now();
|
|
const archivePath = await createCompressedTar(key, paths, cmprss_lvl);
|
|
const archiveSize = fs4.statSync(archivePath).size;
|
|
const { owner, repo } = getRepoInfo();
|
|
await uploadCache(
|
|
{ serverUrl: getServerUrl(), token: getToken() },
|
|
owner,
|
|
repo,
|
|
key,
|
|
archivePath
|
|
);
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
core2.info(
|
|
`\u2705 Cache saved successfully (${formatSize(archiveSize)}, ${formatDuration(duration)})
|
|
`
|
|
);
|
|
}
|
|
|
|
// src/restore.ts
|
|
var core3 = __toESM(require_core());
|
|
var fs5 = __toESM(require("fs"));
|
|
async function restoreCache(key) {
|
|
core3.info(`\u{1F4E6} Starting cache restore for key: ${key}`);
|
|
const startTime = Date.now();
|
|
const zstPath = `/tmp/${sanitizeKey(key)}.tar.zst`;
|
|
const { owner, repo } = getRepoInfo();
|
|
const downloaded = await downloadCache(
|
|
{ serverUrl: getServerUrl(), token: getToken() },
|
|
owner,
|
|
repo,
|
|
key,
|
|
zstPath
|
|
);
|
|
if (!downloaded) {
|
|
core3.warning("\u26A0\uFE0F Cache archive not found, skipping restore.");
|
|
return false;
|
|
}
|
|
const archiveSize = fs5.statSync(zstPath).size;
|
|
await extractCompressedTar(zstPath);
|
|
const endTime = Date.now();
|
|
const duration = endTime - startTime;
|
|
core3.info(
|
|
`
|
|
\u2705 Cache restored successfully (${formatSize(archiveSize)}, ${formatDuration(duration)})
|
|
`
|
|
);
|
|
return true;
|
|
}
|
|
|
|
// src/index.ts
|
|
async function run() {
|
|
try {
|
|
if (core4.getState("isPost") === "true") {
|
|
core4.info("\n\u{1F9F9} Post-job: Saving cache...");
|
|
getToken();
|
|
const key = core4.getState("key");
|
|
const paths = JSON.parse(core4.getState("paths") || "[]");
|
|
const compression_level = parseInt(
|
|
core4.getState("compression-level") || "3",
|
|
10
|
|
);
|
|
if (!key) {
|
|
throw new Error("State 'key' not found during Post-Job.");
|
|
}
|
|
if (paths.length === 0) {
|
|
throw new Error("State 'paths' not found or empty during Post-Job.");
|
|
}
|
|
try {
|
|
await saveCache(key, paths, compression_level);
|
|
} catch (error) {
|
|
core4.warning(
|
|
`\u26A0\uFE0F Failed to save cache: ${error instanceof Error ? error.message : String(error)}`
|
|
);
|
|
}
|
|
} else {
|
|
core4.info("\u{1F680} Pre-job: Restoring cache...");
|
|
getToken();
|
|
const key = core4.getInput("key", { required: true });
|
|
const paths = core4.getMultilineInput("paths", { required: true }).filter(
|
|
(p) => p.trim() !== ""
|
|
);
|
|
let compression_level = parseInt(
|
|
core4.getInput("compression-level", { required: false }) || "0",
|
|
10
|
|
);
|
|
if (isNaN(compression_level) || compression_level < 0 || compression_level > 6) {
|
|
compression_level = 3;
|
|
}
|
|
core4.saveState("isPost", "true");
|
|
core4.saveState("key", key);
|
|
core4.saveState("paths", JSON.stringify(paths));
|
|
core4.saveState("compression-level", compression_level.toString());
|
|
try {
|
|
const restored = await restoreCache(key);
|
|
core4.setOutput("cache-hit", restored ? "true" : "false");
|
|
} catch (error) {
|
|
core4.warning(
|
|
`\u26A0\uFE0F Failed to restore cache: ${error instanceof Error ? error.message : String(error)}`
|
|
);
|
|
core4.setOutput("cache-hit", "false");
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
core4.setFailed(error.message);
|
|
} else {
|
|
core4.setFailed(String(error));
|
|
}
|
|
}
|
|
}
|
|
run();
|
|
/*! Bundled license information:
|
|
|
|
undici/lib/fetch/body.js:
|
|
formdata-polyfill/esm.min.js:
|
|
(*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
|
|
|
|
undici/lib/websocket/frame.js:
|
|
(*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
|
|
|
|
web-streams-polyfill/dist/ponyfill.es2018.js:
|
|
(**
|
|
* @license
|
|
* web-streams-polyfill v3.3.3
|
|
* Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
|
|
* This code is released under the MIT license.
|
|
* SPDX-License-Identifier: MIT
|
|
*)
|
|
|
|
fetch-blob/index.js:
|
|
(*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
|
|
|
|
node-domexception/index.js:
|
|
(*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
|
|
*/
|