denoify
Version:
For NPM module authors that would like to support Deno but do not want to write and maintain a port.
13,996 lines • 562 kB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 464:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const __1 = __nccwpck_require__(137);
const moduleName = "fast-xml-parser";
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
if (parsedImportExportStatement.isAsyncImport) {
throw new Error(`TODO, async import of ${moduleName} not supported yet`);
}
if (parsedImportExportStatement.statementType === "export") {
throw new Error(`TODO, exporting from ${moduleName} is not supported yet`);
}
if (parsedImportExportStatement.statementType === "declare module") {
throw new Error(`TODO, module augmentation for ${moduleName} not supported`);
}
const getUrlTypes = (version) => `https://raw.githubusercontent.com/NaturalIntelligence/fast-xml-parser/${version}/src/parser.d.ts`;
let urlTypes = getUrlTypes(version);
if (await (0, __1.is404)(urlTypes)) {
urlTypes = getUrlTypes("3.17.1");
}
const match = parsedImportExportStatement.target?.match(/^\*\s+as\s+(.*)$/);
if (!match) {
throw new Error("expect import fast-xml-parser as a namespace");
}
return [
`import __fastXMLParser from "https://dev.jspm.io/fast-xml-parser@${version}";`,
`import type * as __t_fastXMLParser from "${urlTypes}";`,
`const ${match[1]}= __fastXMLParser as typeof __t_fastXMLParser`
].join("\n");
};
exports.replacer = replacer;
/***/ }),
/***/ 8307:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const __1 = __nccwpck_require__(137);
const moduleName = "graphql";
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
return __1.ParsedImportExportStatement.stringify({
...parsedImportExportStatement,
"parsedArgument": {
"type": "URL",
"url": `https://cdn.skypack.dev/graphql@${version}?dts`
}
});
};
exports.replacer = replacer;
/***/ }),
/***/ 2381:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const moduleName = "ipaddr.js";
//NOTE: Type definitions not imported.
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
if (parsedImportExportStatement.isAsyncImport) {
throw new Error(`TODO, async import of ${moduleName} not supported yet`);
}
if (parsedImportExportStatement.statementType === "export") {
throw new Error(`TODO, exporting from ${moduleName} is not supported yet`);
}
if (parsedImportExportStatement.statementType === "declare module") {
throw new Error(`TODO, module augmentation for ${moduleName} not supported`);
}
const match = parsedImportExportStatement.target?.match(/^\*\s+as\s+(.*)$/);
if (!match) {
throw new Error(`expect import ${moduleName} as a namespace`);
}
//NOTE: Cosmetic, we could use " or '
const qs = parsedImportExportStatement.quoteSymbol;
return `import ${match[1]} from ${qs}https://jspm.dev/ipaddr.js@${version}${qs}`;
};
exports.replacer = replacer;
/***/ }),
/***/ 2132:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const ParsedImportExportStatement_1 = __nccwpck_require__(9832);
const moduleName = "react-dom";
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
if (parsedImportExportStatement.isAsyncImport) {
throw new Error(`TODO, async import of ${moduleName} not supported yet`);
}
if (parsedImportExportStatement.statementType === "export") {
throw new Error(`TODO, exporting from ${moduleName} is not supported yet`);
}
if (parsedImportExportStatement.statementType === "declare module") {
throw new Error(`TODO, module augmentation for ${moduleName} not supported`);
}
const target = (() => {
const { target } = parsedImportExportStatement;
if (!target) {
throw new Error(`Importing ${moduleName} without target?`);
}
const match = target.match(/^\*\s+as\s+(.*)$/);
if (!!match) {
return match[1];
}
if (target.includes("{")) {
const importArg = ParsedImportExportStatement_1.ParsedImportExportStatement.ParsedArgument.stringify(parsedImportExportStatement.parsedArgument);
throw new Error(`Use:
Instead of importing ${moduleName} like that:
import ${target} from "${importArg}"
You must import it like this:
import * as Xxx from "${importArg}"
or
import Xxx from "${importArg}"
then extract what you need from the default export.
( The denoify parser for ${moduleName} import is not very sophisticated )
`);
}
return target;
})();
switch (parsedImportExportStatement.parsedArgument.specificImportPath) {
case undefined: {
const commit = "02774811084fd4a85d91f73d27deffff2c6b8d02";
return [
`// @deno-types="https://raw.githubusercontent.com/Soremwar/deno_types/${commit}/react-dom/v16.13.1/react-dom.d.ts"`,
`import ${target} from "https://cdn.skypack.dev/react-dom@${version}";`
].join("\n");
}
case "server": {
const commit = "df2a75e38bf52fa0bf4bd29cd790478e3011fc0f";
return [
`// @deno-types="https://raw.githubusercontent.com/Soremwar/deno_types/${commit}/react-dom/v16.13.1/server.d.ts"`,
`import ${target} from "https://dev.jspm.io/react-dom@${version}/server.js";`
].join("\n");
}
default:
throw new Error(`Only support import from "${moduleName}" or "${moduleName}/server"`);
}
};
exports.replacer = replacer;
/***/ }),
/***/ 1057:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const ParsedImportExportStatement_1 = __nccwpck_require__(9832);
const moduleName = "react";
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
if (parsedImportExportStatement.isAsyncImport) {
throw new Error(`TODO, async import of ${moduleName} not supported yet`);
}
if (parsedImportExportStatement.statementType === "export") {
throw new Error(`TODO, exporting from ${moduleName} is not supported yet`);
}
if (parsedImportExportStatement.statementType === "declare module") {
throw new Error(`TODO, module augmentation for ${moduleName} not supported`);
}
const target = (() => {
const { target } = parsedImportExportStatement;
if (!target) {
throw new Error(`Importing ${moduleName} without target?`);
}
const match = target.match(/^\*\s+as\s+(.*)$/);
if (!!match) {
return match[1];
}
if (target.includes("{")) {
const importArg = ParsedImportExportStatement_1.ParsedImportExportStatement.ParsedArgument.stringify(parsedImportExportStatement.parsedArgument);
throw new Error(`Use:
Instead of importing ${moduleName} like that:
import ${target} from "${importArg}"
You must import it like this:
import * as Xxx from "${importArg}"
or
import Xxx from "${importArg}"
then extract what you need from the default export.
( The denoify parser for ${moduleName} import is not very sophisticated )
`);
}
return target;
})();
//const commit = "eb9b173f015a13569aa6dd5bee78bac2e43a14db";
return [
/*
TODO: Error when importing types of React and the types React DOM.
error: TS2300 [ERROR]: Duplicate identifier 'LibraryManagedAttributes'.
type LibraryManagedAttributes<C, P> = C extends
~~~~~~~~~~~~~~~~~~~~~~~~
at https://raw.githubusercontent.com/Soremwar/deno_types/eb9b173f015a13569aa6dd5bee78bac2e43a14db/react/v16.13.1/react.d.ts:3294:10
*/
//`// @deno-types="https://raw.githubusercontent.com/Soremwar/deno_types/${commit}/react/v16.13.1/react.d.ts"`,
`import ${target} from "https://dev.jspm.io/react@${version}";`
].join("\n");
};
exports.replacer = replacer;
/***/ }),
/***/ 2513:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.replacer = void 0;
const Version_1 = __nccwpck_require__(8165);
const moduleName = "rxjs";
const replacer = async (params) => {
const { parsedImportExportStatement, version } = params;
if (parsedImportExportStatement.parsedArgument.nodeModuleName !== moduleName) {
return undefined;
}
if (parsedImportExportStatement.isAsyncImport) {
throw new Error(`TODO, async import of ${moduleName} not supported yet`);
}
if (parsedImportExportStatement.statementType === "export") {
throw new Error(`TODO, exporting from ${moduleName} is not supported yet`);
}
if (parsedImportExportStatement.statementType === "declare module") {
throw new Error(`TODO, module augmentation for ${moduleName} not supported`);
}
switch (parsedImportExportStatement.parsedArgument.specificImportPath) {
case undefined: {
const commit = "07a52c868823928b792e870a572b24af36a4b665";
return [
...(Version_1.Version.parse(version).major === 6
? [`// @deno-types="https://raw.githubusercontent.com/Soremwar/deno_types/${commit}/rxjs/v6.5.5/rxjs.d.ts"`]
: []),
`import ${parsedImportExportStatement.target} from "https://cdn.skypack.dev/rxjs@${version}";`
].join("\n");
}
case "operators": {
const { target } = parsedImportExportStatement;
const url = `https://dev.jspm.io/rxjs@${version}/operators`;
if (target === undefined) {
//NOTE: More certainly useless to import like that
return `import "${url}";`;
}
const commit = "07a52c868823928b792e870a572b24af36a4b665";
return [
...(Version_1.Version.parse(version).major === 6
? [`// @deno-types="https://raw.githubusercontent.com/Soremwar/deno_types/${commit}/rxjs/v6.5.5/operators.d.ts"`]
: []),
...(() => {
walk: {
const match = target.match(/^\*\s+as\s+(.*)$/);
if (!match) {
break walk;
}
return [`import ${match[1]} from "${url}";`];
}
walk: {
if (!/^{[^}]+}$/.test(target)) {
break walk;
}
return [`import __rxjs_operators_ns from "${url}";`, `const ${target} = __rxjs_operators_ns;`];
}
walk: {
if (target.includes(",")) {
break walk;
}
return [`import ${target} from "${url}";`];
}
throw new Error(`Importing ${moduleName} as ${target} is not supported, (split in multiple import)`);
})()
].join("\n");
}
case "webSocket": {
const { target } = parsedImportExportStatement;
const url = `https://cdn.skypack.dev/rxjs@${version}/webSocket?dts`;
if (target === undefined) {
//NOTE: More certainly useless to import like that
return `import "${url}";`;
}
return `import ${target} from "${url}";`;
}
default:
throw new Error(`Only support import from "${moduleName}", "${moduleName}/operators", or "${moduleName}/webSocket`);
}
};
exports.replacer = replacer;
/***/ }),
/***/ 137:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 1107:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.consumeExecutableReplacerFactory = exports.makeThisModuleAnExecutableReplacer = exports.ParsedImportExportStatement = void 0;
const tsafe_1 = __nccwpck_require2_(4653);
const st = __nccwpck_require2_(7516);
const addCache_1 = __nccwpck_require2_(8590);
const ParsedImportExportStatement_1 = __nccwpck_require2_(9832);
var ParsedImportExportStatement;
(function (ParsedImportExportStatement) {
ParsedImportExportStatement.stringify = ParsedImportExportStatement_1.ParsedImportExportStatement.stringify;
})(ParsedImportExportStatement = exports.ParsedImportExportStatement || (exports.ParsedImportExportStatement = {}));
const exitCodeForUndefined = 153;
const separatorBetweenDebugAndResult = "\n===========>> | REPLACER RESULT | <<===========\n";
/**
* Assert the replacer never throws, if you do not want to override
* the normal module resolution just return undefined.
*/
async function makeThisModuleAnExecutableReplacer(replacer) {
process.once("unhandledRejection", error => {
throw error;
});
let [, , importExportStatement, version, destDirPath] = process.argv;
(0, tsafe_1.assert)(typeof version !== undefined, `expect: node ${process.argv[1]} '<importExportStatement>' <version>`);
const parsedImportExportStatement = ParsedImportExportStatement_1.ParsedImportExportStatement.parse(JSON.parse(`"${importExportStatement.replace(/"/g, '\\"')}"`));
(0, tsafe_1.assert)(parsedImportExportStatement.parsedArgument.type === "DEPENDENCY");
//NOTE: Should be inferable...
(0, tsafe_1.assert)((0, tsafe_1.is)(parsedImportExportStatement));
const result = await replacer({
parsedImportExportStatement,
importExportStatement,
version,
destDirPath
});
if (result === undefined) {
process.exit(exitCodeForUndefined);
}
process.stdout.write(separatorBetweenDebugAndResult + result);
process.exit(0);
}
exports.makeThisModuleAnExecutableReplacer = makeThisModuleAnExecutableReplacer;
function consumeExecutableReplacerFactory(params) {
const { executableFilePath } = params;
const consumeExecutableReplacer = (0, addCache_1.addCache)(async (params) => {
const { parsedImportExportStatement, version, destDirPath } = params;
let out;
try {
out = await st.exec(`"${process.argv[0]}" "${executableFilePath}" ${JSON.stringify(ParsedImportExportStatement_1.ParsedImportExportStatement.stringify(parsedImportExportStatement))} ${version} ${JSON.stringify(destDirPath)}`);
}
catch (error) {
(0, tsafe_1.assert)((0, tsafe_1.is)(error));
if (error.code === exitCodeForUndefined) {
return undefined;
}
throw error;
}
const [debugLog, result] = out.split(separatorBetweenDebugAndResult);
if (debugLog) {
process.stdout.write(debugLog);
}
return result;
});
return { consumeExecutableReplacer };
}
exports.consumeExecutableReplacerFactory = consumeExecutableReplacerFactory;
/***/ }),
/***/ 9832:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ParsedImportExportStatement = void 0;
const tsafe_1 = __nccwpck_require2_(4653);
var ParsedImportExportStatement;
(function (ParsedImportExportStatement) {
let ParsedArgument;
(function (ParsedArgument) {
function parse(argument) {
if (argument.startsWith(".")) {
return (0, tsafe_1.id)({
"type": "PROJECT LOCAL FILE",
"relativePath": argument
});
}
if (/^(https?:)?\/\//i.test(argument)) {
return (0, tsafe_1.id)({
"type": "URL",
"url": argument
});
}
{
let [nodeModuleName, ...rest] = argument.split("/");
if (nodeModuleName.startsWith("@") && rest.length !== 0) {
const [scopedNodeModuleName, ...restNew] = rest;
nodeModuleName = `${nodeModuleName}/${scopedNodeModuleName}`;
rest = restNew;
}
return (0, tsafe_1.id)({
"type": "DEPENDENCY",
nodeModuleName,
"specificImportPath": rest.join("/") || undefined
});
}
}
ParsedArgument.parse = parse;
function stringify(parsedArgument) {
switch (parsedArgument.type) {
case "PROJECT LOCAL FILE":
return parsedArgument.relativePath;
case "DEPENDENCY": {
const { nodeModuleName, specificImportPath } = parsedArgument;
return `${nodeModuleName}${specificImportPath ? `/${specificImportPath}` : ``}`;
}
case "URL":
return parsedArgument.url;
}
}
ParsedArgument.stringify = stringify;
})(ParsedArgument = ParsedImportExportStatement.ParsedArgument || (ParsedImportExportStatement.ParsedArgument = {}));
function parse(importExportStatement) {
importExportStatement = importExportStatement.replace(/\s+^/, "").replace(/$\s+/, "");
const isAsyncImport = importExportStatement.endsWith(")");
const quoteSymbol = importExportStatement.endsWith(`'${isAsyncImport ? ")" : ""}`) ? "'" : '"';
const parsedArgument = ParsedImportExportStatement.ParsedArgument.parse(importExportStatement.match(new RegExp(`^[^${quoteSymbol}]*${quoteSymbol}([^${quoteSymbol}]+)${quoteSymbol}[^${quoteSymbol}]*$`))[1]);
if (isAsyncImport) {
return (0, tsafe_1.id)({
"isAsyncImport": true,
quoteSymbol,
parsedArgument
});
}
if (new RegExp(`^declare\\s+module\\s+${quoteSymbol}`).test(importExportStatement)) {
return (0, tsafe_1.id)({
parsedArgument,
"isAsyncImport": false,
quoteSymbol,
"statementType": "declare module"
});
}
if (new RegExp(`^import\\s+${quoteSymbol}`).test(importExportStatement)) {
return (0, tsafe_1.id)({
parsedArgument,
"isAsyncImport": false,
quoteSymbol,
"statementType": "import",
"target": undefined
});
}
const statementType = importExportStatement.startsWith("import") ? "import" : "export";
const isTypeOnly = /^(?:import|export)\s+type/.test(importExportStatement);
const target = importExportStatement
.match(new RegExp(`^(?:import|export)(?:\\s+type)?\\s*([^${quoteSymbol}]+)${quoteSymbol}`))[1]
.replace(/\s*from\s*$/, "");
return (0, tsafe_1.id)({
"isAsyncImport": false,
parsedArgument,
isTypeOnly,
quoteSymbol,
statementType,
target
});
}
ParsedImportExportStatement.parse = parse;
function stringify(parsedImportExportStatement) {
const { quoteSymbol, parsedArgument } = parsedImportExportStatement;
const quotedArgument = `${quoteSymbol}${ParsedImportExportStatement.ParsedArgument.stringify(parsedArgument)}${quoteSymbol}`;
if (parsedImportExportStatement.isAsyncImport) {
return `import(${quotedArgument})`;
}
if (parsedImportExportStatement.statementType === "declare module") {
return `declare module ${quotedArgument}`;
}
if (parsedImportExportStatement.target === undefined) {
return `import ${quotedArgument}`;
}
const { statementType, isTypeOnly, target } = parsedImportExportStatement;
return [statementType, ...(isTypeOnly ? ["type"] : []), target, "from", quotedArgument].join(" ");
}
ParsedImportExportStatement.stringify = stringify;
})(ParsedImportExportStatement = exports.ParsedImportExportStatement || (exports.ParsedImportExportStatement = {}));
/***/ }),
/***/ 8165:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Version = void 0;
var Version;
(function (Version) {
function parse(versionStr) {
const match = versionStr.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
if (!match) {
throw new Error(`${versionStr} is not a valid NPM version`);
}
return {
"major": parseInt(match[1]),
"minor": parseInt(match[2]),
"patch": parseInt(match[3])
};
}
Version.parse = parse;
function stringify(v) {
return `${v.major}.${v.minor}.${v.patch}`;
}
Version.stringify = stringify;
/**
*
* v1 < v2 => -1
* v1 === v2 => 0
* v1 > v2 => 1
*
*/
function compare(v1, v2) {
const sign = (n) => (n === 0 ? 0 : n < 0 ? -1 : 1);
if (v1.major === v2.major) {
if (v1.minor === v2.minor) {
return sign(v1.patch - v2.patch);
}
else {
return sign(v1.minor - v2.minor);
}
}
else {
return sign(v1.major - v2.major);
}
}
Version.compare = compare;
function bumpType(params) {
const versionAhead = parse(params.versionAheadStr);
const versionBehind = parse(params.versionBehindStr);
if (compare(versionBehind, versionAhead) === 1) {
throw new Error(`Version regression ${versionBehind} -> ${versionAhead}`);
}
if (versionBehind.major !== versionAhead.major) {
return "MAJOR";
}
else if (versionBehind.minor !== versionAhead.minor) {
return "MINOR";
}
else if (versionBehind.patch !== versionAhead.patch) {
return "PATCH";
}
else {
return "SAME";
}
}
Version.bumpType = bumpType;
})(Version = exports.Version || (exports.Version = {}));
/***/ }),
/***/ 8590:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.addCache = void 0;
const fs = __nccwpck_require2_(9896);
/** Save results of anterior calls */
function addCache(f, params) {
const previousResults = params === undefined || !fs.existsSync(params.filePathForPersistanceAcrossRun)
? {}
: JSON.parse(fs.readFileSync(params.filePathForPersistanceAcrossRun).toString("utf8"));
if (params !== undefined) {
process.once("exit", () => fs.writeFileSync(params.filePathForPersistanceAcrossRun, Buffer.from(JSON.stringify(previousResults), "utf8") //TODO: reorder props
));
}
return async function callee(...args) {
const key = shallowEqualStringifyInvariant(args);
if (key in previousResults) {
return previousResults[key][0];
}
previousResults[key] = [await f(...args)];
//NOTE: So that JSON.parse restore it well.
if (previousResults[key][0] === undefined) {
previousResults[key].pop();
}
return callee(...args);
};
}
exports.addCache = addCache;
/**
Two shallow equal object will return the same string.
assert(
shallowEqualStringifyInvariant({ "p1": "foo", "p2": "bar" })
===
shallowEqualStringifyInvariant({ "p2": "bar", "p1": "foo" })
);
*/
function shallowEqualStringifyInvariant(o) {
const s1 = JSON.stringify(o);
const p1 = JSON.parse(s1);
const p2 = {};
Object.keys(p1)
.sort()
.forEach(key => (p2[key] = p1[key]));
return JSON.stringify(p2);
}
/***/ }),
/***/ 674:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.fetchWithTimeout = void 0;
const node_fetch_1 = __nccwpck_require2_(1485);
async function fetchWithTimeout(url, options) {
const controller = new AbortController();
const timer = setTimeout(() => {
controller.abort();
}, options.timeout); // Timeout set to 8000 ms
let fetchResponse;
try {
fetchResponse = await (0, node_fetch_1.default)(url, {
signal: controller.signal
});
}
catch (err) {
throw err;
}
finally {
clearTimeout(timer);
}
return fetchResponse;
}
exports.fetchWithTimeout = fetchWithTimeout;
/***/ }),
/***/ 6689:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.is404 = void 0;
const fetchWithTimeout_1 = __nccwpck_require2_(674);
/** Return true if 404 or 400 */
function is404(url) {
return (0, fetchWithTimeout_1.fetchWithTimeout)(url, { "timeout": 8000 }).then(({ status }) => status === 404 || status === 400);
}
exports.is404 = is404;
/***/ }),
/***/ 6748:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.urlJoin = void 0;
exports.urlJoin = __nccwpck_require2_(4106);
/***/ }),
/***/ 7666:
/***/ ((module, __unused_webpack_exports, __nccwpck_require2_) => {
/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
if (!globalThis.DOMException) {
try {
const { MessageChannel } = __nccwpck_require2_(8167),
port = new MessageChannel().port1,
ab = new ArrayBuffer()
port.postMessage(ab, [ab, ab])
} catch (err) {
err.constructor.name === 'DOMException' && (
globalThis.DOMException = err.constructor
)
}
}
module.exports = globalThis.DOMException
/***/ }),
/***/ 1199:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
/**
*
* Let's say we have this function declared somewhere.
*
* function get__filename(){
* return get_caller_file_path();
* }
*
* Then we can assert that:
*
* get__filename() === __filename
*
*
*/
function get_caller_file_path() {
//NOTE: Cannot be move to the index file.
//The function can't be declared and used
//in the same file.
var prepareStackTraceBackup = Error.prepareStackTrace;
var callerFile = "";
try {
var error = new Error();
Error.prepareStackTrace = function (_, stack) { return stack; };
error.stack.shift().getFileName();
var fileImportedFrom = error.stack.shift().getFileName();
while (error.stack.length) {
var fileName = error.stack.shift().getFileName();
if (fileName === callerFile) {
break;
}
callerFile = fileName;
if (fileImportedFrom !== callerFile) {
break;
}
}
}
catch (_a) { }
Error.prepareStackTrace = prepareStackTraceBackup;
return callerFile;
}
exports.get_caller_file_path = get_caller_file_path;
/***/ }),
/***/ 7516:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require2_) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
var child_process = __nccwpck_require2_(5317);
var readline = __nccwpck_require2_(3785);
var fs = __nccwpck_require2_(9896);
var path = __nccwpck_require2_(6928);
var https = __nccwpck_require2_(5692);
var http = __nccwpck_require2_(8611);
var util = __nccwpck_require2_(9023);
var os = __nccwpck_require2_(857);
var crypto = __nccwpck_require2_(6982);
/**
* After this function is called every call to execSync
* or exec will print the unix commands being executed.
* */
function enableCmdTrace() {
traceCmdIfEnabled.enabled = true;
}
exports.enableCmdTrace = enableCmdTrace;
function traceCmdIfEnabled(cmd, options) {
if (!traceCmdIfEnabled.enabled) {
return;
}
console.log(colorize("$ " + cmd + " ", "YELLOW") + (!!options ? JSON.stringify(options) + "\n" : ""));
}
(function (traceCmdIfEnabled) {
traceCmdIfEnabled.enabled = false;
})(traceCmdIfEnabled || (traceCmdIfEnabled = {}));
function get_uid(unix_user) {
return parseInt(sh_eval("id -u " + unix_user));
}
exports.get_uid = get_uid;
function get_gid(unix_user) {
return parseInt(sh_eval("id -g " + unix_user));
}
exports.get_gid = get_gid;
function colorize(str, color) {
var color_code = (function () {
switch (color) {
case "GREEN": return "\x1b[32m";
case "RED": return "\x1b[31m";
case "YELLOW": return "\x1b[33m";
}
})();
return "" + color_code + str + "\u001B[0m";
}
exports.colorize = colorize;
/**
*
* The stderr is forwarded to the console realtime.
*
* The returned value is the concatenated data received on stdout.
*
* If the return code of the cmd is not 0 an exception is thrown
* and the message cmd + the concatenated data received on stderr.
*
* If enableTrace() have been called the command called will be printed.
*
*/
function execSync(cmd, options) {
traceCmdIfEnabled(cmd, options);
return child_process.execSync(cmd, __assign({}, (options || {}), { "encoding": "utf8" }));
}
exports.execSync = execSync;
/**
*
* The cmd is printed before execution
* stdout and stderr are forwarded to the console realtime.
* Return nothing.
*
* stdio is set to "inherit" and thus should not be redefined.
*
*/
function execSyncTrace(cmd, options) {
traceCmdIfEnabled(cmd, options);
child_process.execSync(cmd, __assign({}, (options || {}), { "stdio": "inherit" }));
}
exports.execSyncTrace = execSyncTrace;
/** Same as execSync except that it dose not print cmd even if cmdTrace have been enabled */
var execSyncNoCmdTrace = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var enabled_back = traceCmdIfEnabled.enabled;
traceCmdIfEnabled.enabled = false;
try {
var out = execSync.apply(null, args);
traceCmdIfEnabled.enabled = enabled_back;
return out;
}
catch (error) {
traceCmdIfEnabled.enabled = enabled_back;
throw error;
}
};
/**
*
* Like execSync but stderr is not forwarded.
* WARNING: If mean that when the cmd return 0
* all data that may have been wrote on stderr
* are lost into oblivion.
*
* stdio is set to "pipe" and thus should not be redefined.
*
*/
function execSyncQuiet(cmd, options) {
return execSync(cmd, __assign({}, (options || {}), { "stdio": "pipe" }));
}
exports.execSyncQuiet = execSyncQuiet;
/** Same as execSync but async */
function exec(cmd, options) {
var _this = this;
traceCmdIfEnabled(cmd, options);
return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
child_process.exec(cmd, __assign({}, (options || {}), { "encoding": "utf8" }), function (error, stdout, stderr) {
if (!!error) {
error["stderr"] = stderr;
reject(error);
}
else {
resolve(stdout);
}
});
return [2 /*return*/];
});
}); });
}
exports.exec = exec;
/**
* Spawn a process that continue running after current process exit.
* This process will be ignored by stopSubProcessesAsapSync.
* If a logfile_path if provided stdout and stderr will be redirected to this file.
*
* detached, and stdio options should not be set as they are set internally.
* */
function spawnAndDetach(command, args, options, logfile_path) {
var out = !!logfile_path ? fs.openSync(logfile_path, "a") : "ignore";
var subprocess = child_process.spawn(command, args, __assign({}, (options || {}), { "detached": true, "stdio": ["ignore", out, out] }));
stopProcessSync.stopSubProcessesAsapSync.ignorePids.add(subprocess.pid);
subprocess.unref();
return subprocess;
}
exports.spawnAndDetach = spawnAndDetach;
/**
*
* Print a message and enable a moving loading bar.
* WARNING: Nothing should be printed to stdout until we stop showing the moving loading.
*
* returns:
* -exec: A proxy to the exec fnc that will call onError before it throw the error.
* -onSuccess: Stop showing the moving loading and pretty print a success message ("ok" by default)
* -onError: Stop showing the moving loading and pretty print error message.
*
*/
function start_long_running_process(message) {
process.stdout.write(message + "... ");
var moveBack = (function () {
var cp = message.length + 3;
return function () { return readline.cursorTo(process.stdout, cp); };
})();
var p = ["\\", "|", "/", "-"].map(function (i) { return colorize(i, "GREEN"); });
var x = 0;
var timer = setInterval(function () {
moveBack();
process.stdout.write(p[x++]);
x = x % p.length;
}, 250);
var onComplete = function (message) {
clearInterval(timer);
moveBack();
process.stdout.write(message + "\n");
};
var onError = function (errorMessage) { return onComplete(colorize(errorMessage, "RED")); };
var onSuccess = function (message) { return onComplete(colorize(message || "ok", "GREEN")); };
if (traceCmdIfEnabled.enabled) {
onComplete("");
onComplete = function (message) { return console.log(message); };
}
return {
onError: onError,
onSuccess: onSuccess,
"exec": function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4 /*yield*/, exec.apply(null, args)];
case 1: return [2 /*return*/, _a.sent()];
case 2:
error_1 = _a.sent();
onError(error_1.message);
throw error_1;
case 3: return [2 /*return*/];
}
});
});
}
};
}
exports.start_long_running_process = start_long_running_process;
;
/**
* Apt package if not already installed,
* if prog is provided and prog is in the PATH the package will not be installed
* */
function apt_get_install_if_missing(package_name, prog) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
process.stdout.write("Looking for " + package_name + " ... ");
if (!!prog && apt_get_install_if_missing.doesHaveProg(prog)) {
console.log(prog + " executable found. " + colorize("OK", "GREEN"));
return [2 /*return*/];
}
if (apt_get_install_if_missing.isPkgInstalled(package_name)) {
console.log(package_name + " is installed. " + colorize("OK", "GREEN"));
return [2 /*return*/];
}
readline.clearLine(process.stdout, 0);
process.stdout.write("\r");
return [4 /*yield*/, apt_get_install(package_name)];
case 1: return [2 /*return*/, _a.sent()];
}
});
});
}
exports.apt_get_install_if_missing = apt_get_install_if_missing;
(function (apt_get_install_if_missing) {
function isPkgInstalled(package_name) {
try {
console.assert(!!execSyncNoCmdTrace("dpkg-query -W -f='${Status}' " + package_name, { "stdio": "pipe" })
.match(/^install ok installed$/));
}
catch (_a) {
return false;
}
return true;
}
apt_get_install_if_missing.isPkgInstalled = isPkgInstalled;
function doesHaveProg(prog) {
try {
execSyncNoCmdTrace("which " + prog);
}
catch (_a) {
return false;
}
return true;
}
apt_get_install_if_missing.doesHaveProg = doesHaveProg;
})(apt_get_install_if_missing = exports.apt_get_install_if_missing || (exports.apt_get_install_if_missing = {}));
/** Install or upgrade package via APT */
function apt_get_install(package_name) {
return __awaiter(this, void 0, void 0, function () {
var _a, onSuccess, exec, was_installed_before, error_2;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_a = start_long_running_process("Installing or upgrading " + package_name + " package"), onSuccess = _a.onSuccess, exec = _a.exec;
_b.label = 1;
case 1:
_b.trys.push([1, 5, , 6]);
if (!apt_get_install.isFirst) return [3 /*break*/, 3];
return [4 /*yield*/, exec("apt-get update || true")];
case 2:
_b.sent();
apt_get_install.isFirst = false;
_b.label = 3;
case 3:
was_installed_before = apt_get_install_if_missing.isPkgInstalled(package_name);
return [4 /*yield*/, exec("apt-get -y install " + package_name)];
case 4:
_b.sent();
if (!was_installed_before) {
apt_get_install.onInstallSuccess(package_name);
}
return [3 /*break*/, 6];
case 5:
error_2 = _b.sent();
apt_get_install.onError(error_2);
return [3 /*break*/, 6];
case 6:
onSuccess("DONE");
return [2 /*return*/];
}
});
});
}
exports.apt_get_install = apt_get_install;
(function (apt_get_install) {
apt_get_install.isFirst = true;
function record_installed_package(file_json_path, package_name) {
execSyncNoCmdTrace("touch " + file_json_path);
var raw = fs.readFileSync(file_json_path).toString("utf8");
var list = raw === "" ? [] : JSON.parse(raw);
if (!list.find(function (p) { return p === package_name; })) {
list.push(package_name);
fs.writeFileSync(file_json_path, Buffer.from(JSON.stringify(list, null, 2), "utf8"));
}
}
apt_get_install.record_installed_package = record_installed_package;
apt_get_install.onError = function (error) { throw error; };
apt_get_install.onInstallSuccess = function (package_name) { };
})(apt_get_install = exports.apt_get_install || (exports.apt_get_install = {}));
function exit_if_not_root() {
if (process.getuid() !== 0) {
console.log(colorize("Error: root privilege required ", "RED"));
process.exit(1);
}
}
exports.exit_if_not_root = exit_if_not_root;
/**
*
* Locate a given module in a node_modules directory.
* If the module is required in different version and thus
* present multiple times will be returned the shorter path.
* This ensure that if a given module is in package.json 's dependencies
* section the returned path will be the one we looking for.
*
* @param module_name The name of the module.
* @param module_dir_path Path to the root of the module ( will search in ./node_modules ).
*
* Throw if the module is not found.
*
*/
function find_module_path(module_name, module_dir_path) {
if (module_dir_path.endsWith(module_name)) {
return module_dir_path;
}
var node_module_path = path.join(module_dir_path, "node_modules");
if (!fs.existsSync(node_module_path)) {
throw new Error("No node_modules in " + module_dir_path);
}
var _a = __read(fs.readdirSync(node_module_path)
.filter(function (file_or_dir_name) { return fs.statSync(path.join(node_module_path, file_or_dir_name)).isDirectory; })
.map(function (dir_name) {
return !dir_name.startsWith("@") ?
[path.join(node_module_path, dir_name)] :
fs.readdirSync(path.join(node_module_path, dir_name))
.map(function (file_or_dir_name) { return path.join(node_module_path, dir_name, file_or_dir_name); })
.filter(function (file_or_dir_path) { return fs.statSync(file_or_dir_path).isDirectory; });
})
.reduce(function (prev, curr) { return __spread(prev, curr); }, [])
.filter(function (file_or_dir_path) { return fs.existsSync(path.join(file_or_dir_path, "package.json")); })
.map(function (module_dir_path) {
try {
return find_module_path(module_name, module_dir_path);
}
catch (_a) {
return "";
}
})
.filter(function (module_dir_path) { return !!module_dir_path; })
.sort(function (a, b) { return a.length - b.length; }), 1), out = _a[0];
if (out === undefined) {
throw new Error("module " + module_name + " not installed in " + module_dir_path);
}
return out;
}
exports.find_module_path = find_module_path;
/**
*
* Test if two file of folder are same.
* Does not consider stat ( ownership and permission ).
* transparent handling of symlinks.
*
* Example
*
* /foo1/bar/file.txt
* /foo2/bar/file.txt
*
* to compare the two version of file.txt
* call with "/foo1", "/foo2", "./bar/file.txt";
* or with "/foo1/bar/file.txt", "/foo2/bar/file.txt"
*
* @param relative_from_path1 absolute path ex: '/foo1'
* @param relative_from_path2 absolute path ex: '/foo2'
* @param relative_to_path relative path ex: './bar/file.txt" or 'bar/file.txt'
* for convenience relative_to_path can be absolute as long as it has relative_from_path1
* or relative_from_path2 as parent.
*
*/
function fs_areSame(relative_from_path1, relative_from_path2, relative_to_path) {
if (relative_to_path === void 0) { relative_to_path = "."; }
relative_to_path = fs_areSame.get_relative_to_path(relative_from_path1, relative_from_path2, relative_to_path);
try {
execSyncNoCmdTrace([
"diff -r",
path.join(relative_from_path1, relative_to_path),
path.join(relative_from_path2, relative_to_path)
].join(" "), { "stdio": "pipe" });
}
catch (_a) {
return false;
}
return true;
}
exports.fs_areSame = fs_areSame;
(function (fs_areSame) {
function get_relative_to_path(dir_path1, dir_path2, to_path) {
if (path.isAbsolute(to_path)) {
var dir_path = [dir_path1, dir_path2]
.filter(function (v) { return to_path.startsWith(v); })
.sort(function (a, b) { return b.length - a.length; })[0];
if (!dir_path) {
throw new Error("Not relative!");
}
return path.relative(dir_path, to_path);
}
else {
return to_path;
}
}
fs_areSame.get_relative_to_path = get_relative_to_path;
})(fs_areSame = exports.fs_areSame || (exports.fs_areSame = {}));
/**
*
* Move or copy file of folder.
* -If dest is identical to source nothing is copied nor moved.
* -If dest exist and is different of source it will be deleted prior to proceeding with action.
* -In move mode if dest identical to source source will be removed.
* -When copy is effectively performed the stat are conserved.
* -If dirname of dest does not exist in fs, it will be created.
* -Unlike cp or mv "/src/file.txt" "/dest" will NOT place file.txt in dest but dest will become file.txt
*
* calling [action] "/src/foo" "/dst/foo" is equivalent
* to calling [action] "/src" "/dst" "./foo" ( or "foo" )
* or [action] "/src" "/dst" "src/foo"
* or [action] "/src" "/dst" "dst/foo"
*
*/
function fs_move(action, relative_from_path_src, relative_from_path_dest, relative_to_path) {
if (relative_to_path === void 0) { relative_to_path = "."; }
relative_to_path = fs_areSame.get_relative_to_path(relative_from_path_src, relative_from_path_dest, relative_to_path);
var src_path = path.join(relative_from_path_src, relative_to_path);
var dst_path = path.join(relative_from_path_dest, relative_to_path);
if (!fs_areSame(src_path, dst_path)) {
if (!fs.existsSync(dst_path)) {
execSyncNoCmdTrace("mkdir -p " + dst_path);
}
execSyncNoCmdTrace("rm -rf " + dst_path);
execSyncNoCmdTrace([
action === "COPY" ? "cp -rp" : "mv",
src_path,
dst_path
].join(" "));
}
else {
if (action === "MOVE") {
execSyncNoCmdTrace("rm -r " + src_path);
}
}
}
exports.fs_move = fs_move;
/**
* Download and extract a tarball. throws web_get.DownloadError and Error
*
* Example
*
* website.com/rel.tar.gz
* ./file1.txt
* ./dir/file2.txt
*
* /foo/
* ./file3.txt
* ./dir/file4.txt
*
* calling with "website.com/rel.tar.gz", "MERGE" will result in:
*
* /foo/
* ./file1.txt
* ./file3.txt
* ./dir/file4.txt
*
* calling with "website.com/rel.tar.gz", "OVERWRITE IF EXIST" will result in:
*
* /foo/
* ./file1.txt
* ./dir/file2.txt
*
*/
function download_and_extract_tarball(url, dest_dir_path, mode) {
return __awaiter(this, void 0, void 0, function () {
var _a, exec, onSuccess, onError, tarball_dir_path, tarball_path, error_3, _b, _c, name;
var e_1, _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
_a = start_long_running_process("Downloading " + url + " and extracting to " + dest_dir_path), exec = _a.exec, onSuccess = _a.onSuccess, onError = _a.onError;
tarball_dir_path = (function () {
var hash = crypto.createHash("sha1");
hash.write(url);
hash.end();
return "/tmp/_" + hash.read().toString("hex");
})();
tarball_path = tarball_dir_path + ".tar.gz";
if (!(fs.existsSync(tarball_dir_path) || fs.existsSync(tarball_path))) return [3 /*break*/, 2];
return [4 /*yield*/, exec("rm -rf " + tarball_dir_path + " " + tarball_path)];
case 1:
_e.sent();
_e.label = 2;
case 2:
_e.trys.push([2, 4, , 5]);
return [4 /*yield*/, web_get(url, tarball_path)];
case 3:
_e.sent();
return [3 /*break*/, 5];
case 4:
error_3 = _e.sent();
onError(error_3.message);
throw error_3;
case 5: return [4 /*yield*/, exec("mkdir " + tarball_dir_path)];
case 6:
_e.sent();
return [4 /*yield*/, exec("tar -xzf " + tarball_path + " -C " + tarball_dir_path)];
case 7:
_e.sent();
return [4 /*yield*/, exec("rm " + tarball_path)];
case 8:
_e.sent();
if (!(mode === "MERGE")) return [3 /*break*/, 10];
try {
for (_b = __values(fs_ls(tarball_dir_path)), _c = _b.next(); !_c.done; _c = _b.next()) {
name = _c.value;
fs_move("MOVE", tarball_dir_path, dest_dir_path, name);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return [4 /*yield*/, exec("rm -r " + tarball_dir_path)];
case 9:
_e.sent();
return [3 /*break*/, 11];
case 10:
fs_move("MOVE", tarball_dir_path, dest_dir_path);
_e.label = 11;
case 11:
onSuccess();
return [2 /*return*/];
}
});
});
}
exports.download_and_extract_tarball = download_and_extract_tarball;
function web_get(url, file_path) {
if (!url.startsWith("http")) {
url = "http://" + url;
}
return new Promise(function (resolve, reject) {
var get = url.startsWith("https") ?
https.get.bind(https) : http.get.bind(http);
var timer = setTimeout(function () {
clientRequest.abort();
reject(new web_get.DownloadError(url, "CONNECTION ERROR", "web_get connection error: timeout"));
}, 20000);
var clientRequest = get(url, function (res) {
clearTimeout(timer);
if (("" + res.statusCode).startsWith("30")) {
var url_redirect = res.headers.location;
if (!!url_redirect) {
web_get(url_redirect, file_path)
.then(function (out) { return resolve(out); })
.catch(function (error) { return reject(error); });
return;
}
}
if (!("" + res.statusCode).startsWith("2")) {
reject(new web_get.DownloadErrorHttpErrorCode(url, res.statusCode));
return;
}
var contentLength = undefined;
var receivedBytes = 0;
if (res.headers["content-length"] !== undefined) {
contentLength = parseInt(res.headers["content-length"]);
res.on("data", function (chunk) { return receivedBytes += chunk.length; });
(function () {
var resolve_src = resolve;
resolve = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (receivedBytes !== contentLength) {
reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes));
return;
}
resolve_src.apply(null, args);
};
})();
}
res.socket.setTimeout(60000, function () { return res.socket.destroy(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, "socket timeout")); });
if (!!file_path) {
(function () {
var reject_src = reject;
reject = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return fs.unlink(file_path, function () { return reject_src.apply(null, args); });
};
})();
fs.writeFileSync(file_path, new Buffer(0));
var fsWriteStream = fs.createWriteStream(file_path);
res.pipe(fsWriteStream);
fsWriteStream.once("finish", function () { return resolve(); });
res.once("error", function (error) { return reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, error.message)); });
fsWriteStream.once("error", function (error) { return reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, error.message)); });
}
else {
var data_1 = new Buffer(0);
res.on("data", function (chunk) { return data_1 = Buffer.concat([data_1, chunk]); });
res.once("end", function () { return resolve(data_1.toString("utf8")); });
}
});
clientRequest.once("error", function (error) {
clearTimeout(timer);
reject(new web_get.DownloadError(url, "CONNECTION ERROR", error.message));
});
});
}
exports.web_get = web_get;
(function (web_get) {
var DownloadError = /** @class */ (function (_super) {
__extends(DownloadError, _super);
function DownloadError(url, cause, message) {
var _newTarget = this.constructor;
var _this = _super.call(this, message) || this;
_this.url = url;
_this.cause = cause;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadError;
}(Error));
web_get.DownloadError = DownloadError;
var DownloadErrorIncomplete = /** @class */ (function (_super) {
__extends(DownloadErrorIncomplete, _super);
function DownloadErrorIncomplete(url, contentLength, receivedBytes, info) {
var _newTarget = this.constructor;
var _this = _super.call(this, url, "INCOMPLETE", "web_get failed, download incomplete " + receivedBytes + "/" + contentLength + ", " + (!!info ? info : "")) || this;
_this.contentLength = contentLength;
_this.receivedBytes = receivedBytes;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadErrorIncomplete;
}(DownloadError));
web_get.DownloadErrorIncomplete = DownloadErrorIncomplete;
var DownloadErrorHttpErrorCode = /** @class */ (function (_super) {
__extends(DownloadErrorHttpErrorCode, _super);
function DownloadErrorHttpErrorCode(url, code) {
var _newTarget = this.constructor;
var _this = _super.call(this, url, "HTTP ERROR CODE", "web_get failed, HTTP error code: " + code) || this;
_this.code = code;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadErrorHttpErrorCode;
}(DownloadError));
web_get.DownloadErrorHttpErrorCode = DownloadErrorHttpErrorCode;
})(web_get = exports.web_get || (exports.web_get = {}));
function fs_ls(dir_path, mode, showHidden) {
if (mode === void 0) { mode = "FILENAME"; }
if (showHidden === void 0) { showHidden = false; }
return execSyncNoCmdTrace("ls" + (showHidden ? " -a" : ""), { "cwd": dir_path })
.slice(0, -1)
.split("\n")
.map(function (name) { return mode === "ABSOLUTE PATH" ? path.join(dir_path, name) : name; });
}
exports.fs_ls = fs_ls;
/**
*
* Create a symbolic link.
* If dst exist it is removed.
* directories leading to dest are created if necessary.
*
*/
function createSymlink(src_path, dst_path) {
if (!fs.existsSync(dst_path)) {
execSyncNoCmdTrace("mkdir -p " + dst_path);
}
execSyncNoCmdTrace("rm -rf " + dst_path);
execSync("ln -s " + src_path + " " + dst_path);
}
exports.createSymlink = createSymlink;
/** Create a executable file */
function createScript(file_path, content) {
if (traceCmdIfEnabled.enabled) {
console.log("Creating script " + file_path);
}
fs.writeFileSync(file_path, Buffer.from(content, "utf8"));
execSyncNoCmdTrace("chmod +x " + file_path);
}
exports.createScript = createScript;
var unixUser;
(function (unixUser) {
function create(unix_user, home_dir_path) {
if (home_dir_path === void 0) { home_dir_path = "/tmp"; }
execSyncNoCmdTrace("useradd -M " + unix_user + " -s /bin/false -d " + home_dir_path);
}
unixUser.create = create;
function remove(unix_user) {
execSyncNoCmdTrace("userdel " + unix_user, { "stdio": "pipe" });
}
unixUser.remove = remove;
})(unixUser = exports.unixUser || (exports.unixUser = {}));
var get_caller_file_path_1 = __nccwpck_require2_(1199);
exports.get_caller_file_path = get_caller_file_path_1.get_caller_file_path;
var get_caller_file_path_2 = __nccwpck_require2_(1199);
/**
*
* DO NOT USE TEST PURPOSE ONLY
*
* return __filename
*
*/
function get__filename() {
return get_caller_file_path_2.get_caller_file_path();
}
exports.get__filename = get__filename;
/**
*
* Equivalent to the pattern $() in bash.
* Strip final LF if present.
* If cmd fail no error is thrown, an empty string is returned.
* Does not print to stdout.
*
* Typical usage: uname -r or which pkill
*
*/
function sh_eval(cmd) {
var res;
try {
res = execSyncNoCmdTrace(cmd, { "stdio": "pipe" });
}
catch (_a) {
return "";
}
return res.replace(/\n$/, "");
}
exports.sh_eval = sh_eval;
/**
* Run a command and return true if the return code was 0.
* Does not print to stdout.
*/
function sh_if(cmd) {
try {
execSyncNoCmdTrace(cmd, { "stdio": "pipe" });
}
catch (_a) {
return false;
}
return true;
}
exports.sh_if = sh_if;
/**
* Return a promise that resolve as the source promise when fulfilled
* or resolve with the error when reject.
* If a timeout is specified the returned promise resolve with an error after [timeout]ms
* if the source promise did not completed before.
* The message of the timeout error is safePr.timeoutErrorMessage
*/
function safePr(pr, timeout) {
var prSafe = pr.then(function (val) { return val; }, function (error) { return error; });
if (timeout !== undefined) {
var timer_1;
return Promise.race([
new Promise(function (resolve) { return timer_1 = setTimeout(function () { return resolve(new Error(safePr.timeoutErrorMessage)); }, timeout); }),
prSafe.then(function (val) {
clearTimeout(timer_1);
return val;
})
]);
}
else {
return prSafe;
}
}
exports.safePr = safePr;
;
(function (safePr) {
safePr.timeoutErrorMessage = "safePr timeout";
})(safePr = exports.safePr || (exports.safePr = {}));
/**
*
* Allow to schedule action function to perform before exiting.
*
* The task function will always be called before the process stop
* unless process.exit is explicitly called somewhere or
* if the process receive any signal other than the ones specified
* in the ExitCause.Signal["signal"] type.
*
* The process may stop for tree reasons:
* 1) If there is no more work scheduled ( natural termination ).
* 2) If an uncaught exception it thrown ( or a unhandled promise rejection )
* 3) If a signal ( one of the handled ) is sent to the process.
*
* To manually exit the process there is two option:
* - Call process.exit(X) but the task function will not be called.
* - Emit "beforeExit" on process object ( process.emit("beforeExit, process.exitCode= X) );
* Doing so you simulate 1st stop condition ( natural termination ).
*
* To define the return code set process.exitCode. The exit code can be set
* before emitting "beforeExit" or in the task function.
* If exitCode has not be defined the process will exit with 0 if
* there was nothing else to do and 1 otherwise.
*
* The task function can be synchronous or asynchronous.
* The task function has [timeout] ms to complete.
* If it has not completed within this delay the process will
* be terminated anyway. (Default 4000 ms )
* Setting [timeout] to a negative value will disable the timer.
* WARNING: It is important not to perform sync operation that can
* hang for a long time in the task function ( e.g. execSync("sleep 1000"); )
* because while the sync operation are performed the timeout can't be triggered.
*
* As soon as the task function is called all the other exitCause that
* may auccur will be ignored so that the task function have time to complete.
* Anyway the task function is called only once.
*
* Whether the task function complete by successfully or throw
* an exception the process will terminate with exit code set
* in process.exitCode at the time of the completion.
*
* Provide shouldExitIf function to filter what should be
* considered a case to terminate the process.
* Only exception and supported signals can be bypassed,
* Nothing else to do will always terminate the process.
* By default exiting on any signal or uncaught errors.
*
* Before exiting all subprocess will be killed.
*
*
*/
function setProcessExitHandler(task, timeout, shouldExitIf) {
var e_2, _a, e_3, _b;
var _this = this;
if (timeout === void 0) { timeout = 4000; }
if (shouldExitIf === void 0) { shouldExitIf = function () { return true; }; }
var log = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return setProcessExitHandler.log("[ exit handler ] " + util.format.apply(util, args));
};
var handler = function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var process_exit, actionOut, error_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (exitCause.type !== "NOTHING ELSE TO DO" && !shouldExitIf(exitCause)) {
log("Choosing ( c.f shouldExitIf ) not to terminate the process despite: ", exitCause);
return [2 /*return*/];
}
handler = function (exitCause) { return log("Ignored extra exit cause", exitCause); };
process_exit = function () {
if (typeof process.exitCode !== "number" || isNaN(process.exitCode)) {
if (exitCause.type === "NOTHING ELSE TO DO") {
process.exitCode = 0;
}
else {
log("Exit cause " + exitCause.type + " and not exitCode have been set, using exit code 1");
process.exitCode = 1;
}
}
else {
log("Exit code have been set to " + process.exitCode);
}
log("Stopping subprocess asap if any...");
stopProcessSync.stopSubProcessesAsapSync();
log("exiting now with code " + process.exitCode);
process.exit();
};
log("Cause of process termination: ", exitCause);
if (timeout >= 0) {
setTimeout(function () {
log("Exit task timeout");
process.exitCode = 1;
process_exit();
}, timeout);
}
try {
actionOut = task(exitCause);
}
catch (error) {
log("Exit task thrown error", error);
process_exit();
return [2 /*return*/];
}
if (!(actionOut instanceof Promise)) return [3 /*break*/, 4];
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, actionOut];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
error_4 = _a.sent();
log("Exit task returned a promise that rejected", error_4);
process_exit();
return [2 /*return*/];
case 4:
log("Exit task complete successfully.");
process_exit();
return [2 /*return*/];
}
});
}); };
var _loop_1 = function (signal) {
process.on(signal, function () { return handler({ "type": "SIGNAL", signal: signal }); });
};
try {
for (var _c = __values(setProcessExitHandler.ExitCause.Signal.list), _d = _c.next(); !_d.done; _d = _c.next()) {
var signal = _d.value;
_loop_1(signal);
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_2) throw e_2.error; }
}
try {
for (var _e = __values(["uncaughtException", "unhandledRejection"]), _f = _e.next(); !_f.done; _f = _e.next()) {
var eventName = _f.value;
process.on(eventName, function (error) { return handler({ "type": "EXCEPTION", error: error }); });
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
}
finally { if (e_3) throw e_3.error; }
}
process.on("beforeExit", function () { return handler({ "type": "NOTHING ELSE TO DO" }); });
}
exports.setProcessExitHandler = setProcessExitHandler;
(function (setProcessExitHandler) {
var ExitCause;
(function (ExitCause) {
var Signal;
(function (Signal) {
Signal._obj = { "SIGINT": null, "SIGUSR2": null, "SIGHUP": null };
Signal.list = Object.keys(Signal._obj);
})(Signal = ExitCause.Signal || (ExitCause.Signal = {}));
})(ExitCause = setProcessExitHandler.ExitCause || (setProcessExitHandler.ExitCause = {}));
setProcessExitHandler.log = function () { };
})(setProcessExitHandler = exports.setProcessExitHandler || (exports.setProcessExitHandler = {}));
/**
*
* Stop a process by sending a specific signal to a target process.
* When the function return the main process and all it's descendent processes are terminated.
*
* The default signal is SIGUSR2 which is the signal used to gracefully terminate
* Process created by the createService function.
*
* Optionally runfiles_path can be provided to define a set of files
* that should be suppressed before returning.
*
* If pid is provided under the form of a pidfile path it will
* be added to the runfiles set.
*
* If all the processes does not terminate within [delay_before_sigkill]ms
* (default 50000) then KILL signal will be sent to all processes still alive.
*
* If the PID provided is the same that the PID of the process running the function
* PidMatchCurrentProcessError will be thrown.
*
*/
function stopProcessSync(pidfile_path_or_pid, signal, delay_before_sigkill, runfiles_path) {
if (signal === void 0) { signal = "SIGUSR2"; }
if (delay_before_sigkill === void 0) { delay_before_sigkill = 5000; }
if (runfiles_path === void 0) { runfiles_path = []; }
var log = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return stopProcessSync.log("[ stop process sync ] " + util.format.apply(util, args));
};
var cleanupRunfiles = function () {
var e_4, _a;
try {
for (var runfiles_path_1 = __values(runfiles_path), runfiles_path_1_1 = runfiles_path_1.next(); !runfiles_path_1_1.done; runfiles_path_1_1 = runfiles_path_1.next()) {
var runfile_path = runfiles_path_1_1.value;
if (fs.existsSync(runfile_path)) {
try {
fs.unlinkSync(runfile_path);
log(path.basename(runfile_path) + " runfile manually cleaned up.");
}
catch (_b) {
log(colorize("Could not remove runfile " + runfile_path, "RED"));
}
}
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (runfiles_path_1_1 && !runfiles_path_1_1.done && (_a = runfiles_path_1.return)) _a.call(runfiles_path_1);
}
finally { if (e_4) throw e_4.error; }
}
};
var pid;
if (typeof pidfile_path_or_pid === "number") {
pid = pidfile_path_or_pid;
}
else {
var pidfile_path = pidfile_path_or_pid;
runfiles_path = __spread([pidfile_path], runfiles_path);
if (!fs.existsSync(pidfile_path)) {
log("Pidfile does not exist, assuming process not running");
cleanupRunfiles();
return;
}
try {
pid = parseInt(fs.readFileSync(pidfile_path).toString("utf8").replace(/\n$/, ""));
if (isNaN(pid)) {
throw new Error("pid is NaN");
}
}
catch (_a) {
log("Pidfile does does not contain pid");
cleanupRunfiles();
return;
}
}
if (pid === process.pid) {
throw new stopProcessSync.PidMatchCurrentProcessError(cleanupRunfiles);
}
var pids = __spread(stopProcessSync.getSubProcesses(pid, "FULL PROCESS TREE"), [
pid
]);
var startTime = Date.now();
if (stopProcessSync.isProcessRunning(pid)) {
log("Sending " + signal + " to target process (" + pid + ")");
stopProcessSync.kill(pid, signal);
}
else {
log("Target process (" + pid + ") is not running");
}
var _loop_2 = function () {
var e_5, _a;
var runningPids = pids.filter(function (pid) { return stopProcessSync.isProcessRunning(pid); });
if (runningPids.length === 0) {
log("Target process (" + pid + ") and all it's sub processes are now terminated");
return "break";
}
else if (Date.now() >= startTime + delay_before_sigkill) {
log((function () {
if (delay_before_sigkill === 0) {
return "Immediately sending SIGKILL to " + runningPids.length + " remaining sub processes of target process (" + pid + ")";
}
else {
return [
!!runningPids.find(function (_pid) { return _pid === pid; }) ?
"Target process (" + pid + ") and " + (runningPids.length - 1) + " of it's sub processes" :
runningPids.length + " sub processes of the target process (" + pid + ")",
"did not terminate in time, sending KILL signals."
].join(" ");
}
})());
try {
for (var runningPids_1 = (e_5 = void 0, __values(runningPids)), runningPids_1_1 = runningPids_1.next(); !runningPids_1_1.done; runningPids_1_1 = runningPids_1.next()) {
var pid_1 = runningPids_1_1.value;
stopProcessSync.kill(pid_1, "SIGKILL");
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (runningPids_1_1 && !runningPids_1_1.done && (_a = runningPids_1.return)) _a.call(runningPids_1);
}
finally { if (e_5) throw e_5.error; }
}
return "continue";
}
execSyncNoCmdTrace("sleep 0.1");
};
while (true) {
var state_1 = _loop_2();
if (state_1 === "break")
break;
}
cleanupRunfiles();
}
exports.stopProcessSync = stopProcessSync;
(function (stopProcessSync) {
var PidMatchCurrentProcessError = /** @class */ (function (_super) {
__extends(PidMatchCurrentProcessError, _super);
function PidMatchCurrentProcessError(cleanupRunfiles) {
var _newTarget = this.constructor;
var _this = _super.call(this, "StopProcessSync error, provided PID is the PID of the current process") || this;
_this.cleanupRunfiles = cleanupRunfiles;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return PidMatchCurrentProcessError;
}(Error));
stopProcessSync.PidMatchCurrentProcessError = PidMatchCurrentProcessError;
/**
* Stopping process As Soon As Possible,
* stopProcessSync with signal SIGKILL and timeout 0
* */
function stopProcessAsapSync(pidfile_path_or_pid, runfiles_path) {
if (runfiles_path === void 0) { runfiles_path = []; }
stopProcessSync(pidfile_path_or_pid, "SIGKILL", 0, runfiles_path);
}
stopProcessSync.stopProcessAsapSync = stopProcessAsapSync;
/**
* Terminate all child process of current process ASAP.
*
* NOTE: Directly after this function ( in the current tick )
* direct parents process that had sub processes will be Zombies.
* However they will be reaped by the current process on next tick.
*
*/
function stopSubProcessesAsapSync() {
var e_6, _a;
try {
for (var _b = __values(getSubProcesses(process.pid, "DIRECT SUB PROCESSES ONLY")), _c = _b.next(); !_c.done; _c = _b.next()) {
var pid = _c.value;
if (stopSubProcessesAsapSync.ignorePids.has(pid)) {
continue;
}
stopProcessSync(pid, "SIGKILL", 0);
}
}
catch (e_6_1) { e_6 = { error: e_6_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_6) throw e_6.error; }
}
}
stopProcessSync.stopSubProcessesAsapSync = stopSubProcessesAsapSync;
(function (stopSubProcessesAsapSync) {
stopSubProcessesAsapSync.ignorePids = new Set();
})(stopSubProcessesAsapSync = stopProcessSync.stopSubProcessesAsapSync || (stopProcessSync.stopSubProcessesAsapSync = {}));
/** Invoke kill, can't throw */
function kill(pid, signal) {
try {
execSyncNoCmdTrace("kill -" + signal + " " + pid, { "stdio": "pipe", "shell": "/bin/bash" });
}
catch (_a) {
}
}
stopProcessSync.kill = kill;
/**
* Get the list of subprocess of a process ( return a list of pid )
*/
function getSubProcesses(pid, depth) {
var _a = child_process.spawnSync("/bin/ps", ["--ppid", "" + pid, "-o", "pid,state"], { "shell": false }), stdout = _a.stdout, ps_pid = _a.pid, ps_exitCode = _a.status;
if (ps_exitCode !== 0) {
return [];
}
var pids = stdout
.toString("utf8")
.split("\n")
.filter(function (v) { return !v.match(/Z/); })
.map(function (v) { return v.replace(/[^0-9]/g, ""); })
.filter(function (v) { return !!v; })
.map(function (v) { return parseInt(v); })
.filter(function (pid) { return pid !== ps_pid; });
switch (depth) {
case "DIRECT SUB PROCESSES ONLY": return pids;
case "FULL PROCESS TREE": return (function () {
var e_7, _a;
var out = [];
try {
for (var pids_1 = __values(pids), pids_1_1 = pids_1.next(); !pids_1_1.done; pids_1_1 = pids_1.next()) {
var pid_2 = pids_1_1.value;
out = __spread(out, getSubProcesses(pid_2, "FULL PROCESS TREE"), [pid_2]);
}
}
catch (e_7_1) { e_7 = { error: e_7_1 }; }
finally {
try {
if (pids_1_1 && !pids_1_1.done && (_a = pids_1.return)) _a.call(pids_1);
}
finally { if (e_7) throw e_7.error; }
}
return out;
})();
}
}
stopProcessSync.getSubProcesses = getSubProcesses;
/** Return true only if exist and is not a daemon */
function isProcessRunning(pid) {
var psCmdOut;
try {
psCmdOut = execSyncNoCmdTrace("ps --pid " + pid + " -o state");
}
catch (_a) {
return false;
}
return !psCmdOut.match(/Z/);
}
stopProcessSync.isProcessRunning = isProcessRunning;
/** Debug function to print the process tree of the current process. */
function _printProcessTree(log) {
if (log === void 0) { log = console.log.bind(console); }
var rec = function (node) {
var e_8, _a;
var pids = getSubProcesses(node.pid, "DIRECT SUB PROCESSES ONLY");
if (pids.length === 0) {
return;
}
node.sub = [];
try {
for (var pids_2 = __values(pids), pids_2_1 = pids_2.next(); !pids_2_1.done; pids_2_1 = pids_2.next()) {
var pid = pids_2_1.value;
var sub_node = { pid: pid };
node.sub.push(sub_node);
rec(sub_node);
}
}
catch (e_8_1) { e_8 = { error: e_8_1 }; }
finally {
try {
if (pids_2_1 && !pids_2_1.done && (_a = pids_2.return)) _a.call(pids_2);
}
finally { if (e_8) throw e_8.error; }
}
};
var tree = { "pid": process.pid };
rec(tree);
log(JSON.stringify(tree, null, 3));
}
stopProcessSync._printProcessTree = _printProcessTree;
stopProcessSync.log = function () { };
})(stopProcessSync = exports.stopProcessSync || (exports.stopProcessSync = {}));
/**
*
* Function to create the entry point (main.js) of a node service that can:
* -Restart on crash (without relying on systemd to do so).
* -Execute as specific unix user but can perform tasks as root before start.
* -Be stopped gracefully by sending USR2 signal on the root process ( identified by pidfile ).
* -Be started via a shell and gracefully stopped with CTRL-C (INT signal).
* -Ensure only one instance of the service run at the same time.
* ( if at the time the main is called there is an other instance of the service
* running it is gracefully terminated )
* -Ensure that the process will terminate in at most [ stop_timeout ] ms after
* receiving INT or USR2 signal. (default 5second)
* -Forward daemon processes stdout to root process stdout.
* -Can fork multiple daemon process.
*
* The root process forward command line arguments and environnement variable to
* the daemon processes.
*
* => rootProcess function should return ( when not default ):
* -pidfile_path: where to store the pid of the root process.
* take to terminate after requested to exit gracefully.
* -srv_name: Name of the service to overwrite the process names. (Default: not overwriting)
* -stop_timeout: The maximum amount of time ( in ms ) the
* that beforeExitTask can take to complete before being killed by force by root process.
* After receiving USR2 signal or CTRL, the root process will be closed within [trop_timeout]+1000ms
* -assert_unix_user: enforce that the main be called by a specific user.
* -isQuiet?: set to true to disable process debug info logging on stdout. Prefixed by [ service ]. ( default false )
* -doForwardDaemonStdout?: set to true to forward everything the daemon
* process write to stdout to the root process stdout. ( default true )
* -daemon_unix_user?: User who should own the daemon process.
* -daemon_node_path?: Node.js executable that should be used to by the daemon process.
* -daemon_cwd?: working directory of the daemon process.
* -daemon_restart_after_crash_delay?: ( Default to 500ms. )Delay in ms before restarting the daemon
* after it terminate without being requested to. If set to a negative number the daemons
* will not be restarted after it terminate for the first time and :
* If all daemons process exited with 0 and there is no other daemon process the root process
* will end with a clean exit code.
* If any of the daemon exit with an unclean code the root process will be terminated with an error code
* even if there is some other daemon running.
* -daemon_count: Number of instance of daemon process that should be forked, default 1.
* -max_consecutive_restart: Number of time a daemon should be restarted after crashing right after start.
* (Default ~Infinity).
* -preForkTask: Task to perform before forking a daemon process.
* It is called just before forking the daemon process. ( called again on every restart. )
* If the function is async the daemon will not be forked until the returned promise resolve.
* If the function throw exception root process will exit with code 1.
* (pidfile will be deleted)
* If the function is async and if it need to spawn child processes then
* an implementation for terminateSubProcess ( passed as reference ) should be provided so that
* if when called it kill all the child processes then resolve once they are terminated.
* The to which the promise resolve will be used as exit code for the root process.
* Note that terminateSubProcess should never be called, it is a OUT parameter.
* However if the implementation provided is just to send a SIGKILL to the forked processes
* then there is no need to provide an implementation as all the root process's sub processes tree
* will be killed before exiting anyway.
*
* => daemonProcess
* It should return:
* -launch: the function that the daemon process need to call to start the actual job that the service is meant to perform.
* -beforeExitTask: function that should be called before the daemon process exit. ( e.g. creating crash report ).
* If the daemon process is terminating due to an error the error will be passed as argument.
* There is two scenario that will led to this function NOT being called:
* 1)The daemon process receive KILL or other deadly signal that can't be overridden.
* 2)The root process terminate.
* daemon_number represent the instance index of the daemon among the total of [damon_count] process forked.
* It can be user to use a different logfile for each daemon process instance.
*
* NOTE: If the root process receive a deadly signal other than INT, USR2 or HUP
* ( e.g. KILL or STOP ) the root and daemon processes will immediately terminate without
* executing beforeExit tasks or removing pidfile.
*
* NOTE: because setting listener on "message" and "disconnect" process event prevent the
* thread from terminating naturally where is nothing more to do if you wish to manually
* terminate the daemon process without termination being requested from the parent you can:
* 1) emit "beforeExit" on process setting the desired exit code ( process.emit("beforeExit", process.exitCode= X);
* 2) throw an exception.
*
*/
function createService(params) {
var _this = this;
var log = (function () { });
var getLog = function (prefix) {
return (function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return process.stdout.write(Buffer.from("[service] ( " + prefix + " ) " + util.format.apply(util, args) + "\n", "utf8"));
});
};
var rootProcess = params.rootProcess, daemonProcess = params.daemonProcess;
var main_root = function (main_js_path) { return __awaiter(_this, void 0, void 0, function () {
var _a, pidfile_path, srv_name, _stop_timeout, assert_unix_user, isQuiet, _doForwardDaemonStdout, daemon_unix_user, daemon_node_path, daemon_cwd, _daemon_restart_after_crash_delay, max_consecutive_restart, preForkTask, _daemon_count, stop_timeout, doForwardDaemonStdout, daemon_restart_after_crash_delay, daemon_count, daemonContexts, isTerminating, args, _b, daemon_uid, daemon_gid, makeForkOptions, forkDaemon, daemon_number;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0: return [4 /*yield*/, rootProcess()];
case 1:
_a = _c.sent(), pidfile_path = _a.pidfile_path, srv_name = _a.srv_name, _stop_timeout = _a.stop_timeout, assert_unix_user = _a.assert_unix_user, isQuiet = _a.isQuiet, _doForwardDaemonStdout = _a.doForwardDaemonStdout, daemon_unix_user = _a.daemon_unix_user, daemon_node_path = _a.daemon_node_path, daemon_cwd = _a.daemon_cwd, _daemon_restart_after_crash_delay = _a.daemon_restart_after_crash_delay, max_consecutive_restart = _a.max_consecutive_restart, preForkTask = _a.preForkTask, _daemon_count = _a.daemon_count;
if (srv_name !== undefined) {
process.title = srv_name + " root process";
}
stop_timeout = _stop_timeout !== undefined ?
_stop_timeout : 5000;
doForwardDaemonStdout = _doForwardDaemonStdout !== undefined ?
_doForwardDaemonStdout : true;
daemon_restart_after_crash_delay = _daemon_restart_after_crash_delay !== undefined ?
_daemon_restart_after_crash_delay : 500;
daemon_count = _daemon_count !== undefined ?
_daemon_count : 1;
if (assert_unix_user !== undefined && os.userInfo().username !== assert_unix_user) {
console.log(colorize("Must be run as " + assert_unix_user, "RED"));
process.exit(1);
return [2 /*return*/];
}
if (!isQuiet) {
log = getLog("root process");
}
stopProcessSync.log = log;
try {
stopProcessSync(pidfile_path);
}
catch (error) {
if (!(error instanceof stopProcessSync.PidMatchCurrentProcessError)) {
throw error;
}
error.cleanupRunfiles();
}
if (fs.existsSync(pidfile_path)) {
throw Error("Other instance launched simultaneously");
}
(function createPidfile() {
var pidfile_dir_path = path.dirname(pidfile_path);
if (!fs.existsSync(pidfile_dir_path)) {
execSyncNoCmdTrace("mkdir -p " + pidfile_dir_path);
}
fs.writeFileSync(pidfile_path, process.pid.toString());
})();
log("PID: " + process.pid);
daemonContexts = new Map((new Array(daemon_count))
.fill(null)
.map(function (_, index) {
var context = [
index + 1,
{
"daemonProcess": undefined,
"terminatePreForkChildProcesses": { "impl": function () { return Promise.resolve(); } },
"restart_attempt_remaining": max_consecutive_restart || NaN,
"reset_restart_attempt_timer": setTimeout(function () { }, 0)
}
];
return context;
}));
isTerminating = false;
setProcessExitHandler(function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var childProcessExitCode;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
isTerminating = true;
return [4 /*yield*/, (function terminateAllChildProcesses() {
return __awaiter(this, void 0, void 0, function () {
var terminateDaemonProcess, terminatePreForkChildProcessesSafeCall, tasks, _loop_3, _a, _b, _c, daemonProcess_1, terminatePreForkChildProcesses;
var e_9, _d;
var _this = this;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
terminateDaemonProcess = function (daemonProcess) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, new Promise(function (resolve) {
log("Attempt to gracefully terminate daemon process PID: " + daemonProcess.pid + "...");
daemonProcess.send(null);
var timer = setTimeout(function () { return doStopAsap(); }, stop_timeout + 500);
daemonProcess.once("error", function () { return doStopAsap(); });
daemonProcess.once("close", function (childProcessExitCode) {
clearTimeout(timer);
log("Daemon process PID: " + daemonProcess.pid + " exited with code " + childProcessExitCode);
if (typeof childProcessExitCode !== "number" || isNaN(childProcessExitCode)) {
childProcessExitCode = 1;
}
resolve(childProcessExitCode);
});
var doStopAsap = function () {
log("Daemon process PID:" + daemonProcess.pid + " not responding, force kill...");
clearTimeout(timer);
daemonProcess.removeAllListeners("error");
daemonProcess.removeAllListeners("close");
stopProcessSync.stopProcessAsapSync(daemonProcess.pid);
resolve(1);
};
})];
});
}); };
terminatePreForkChildProcessesSafeCall = function (impl) {
var timer;
return Promise.race([
new Promise(function (resolve) { return timer = setTimeout(function () { return resolve("TIMEOUT"); }, stop_timeout + 500); }),
(function () { return __awaiter(_this, void 0, void 0, function () {
var result, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_b.trys.push([0, 2, , 3]);
return [4 /*yield*/, impl()];
case 1:
_b.sent();
result = "SUCCESS";
return [3 /*break*/, 3];
case 2:
_a = _b.sent();
result = "ERROR";
return [3 /*break*/, 3];
case 3:
clearTimeout(timer);
return [2 /*return*/, result];
}
});
}); })()
]);
};
tasks = [];
_loop_3 = function (daemonProcess_1, terminatePreForkChildProcesses) {
tasks[tasks.length] = !daemonProcess_1 ? (new Promise(function (resolve) { return terminatePreForkChildProcessesSafeCall(terminatePreForkChildProcesses.impl)
.then(function (result) { return result === "SUCCESS" ? resolve(0) : resolve(1); }); })) : terminateDaemonProcess(daemonProcess_1);
};
try {
for (_a = __values(daemonContexts.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
_c = _b.value, daemonProcess_1 = _c.daemonProcess, terminatePreForkChildProcesses = _c.terminatePreForkChildProcesses;
_loop_3(daemonProcess_1, terminatePreForkChildProcesses);
}
}
catch (e_9_1) { e_9 = { error: e_9_1 }; }
finally {
try {
if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
}
finally { if (e_9) throw e_9.error; }
}
return [4 /*yield*/, Promise.all(tasks)];
case 1: return [2 /*return*/, (_e.sent()).reduce(function (accumulator, currentValue) { return accumulator === 0 ? currentValue : accumulator; }, 0)];
}
});
});
})()];
case 1:
childProcessExitCode = _a.sent();
if (exitCause.type === "EXCEPTION") {
/*
preForkTask throw or daemonProcess emit error or
one of the daemon exited with a non 0 code and
restart_delay was set <0
*/
log("Root process exception message: " + exitCause.error.message);
process.exitCode = 1;
}
else {
process.exitCode = childProcessExitCode;
}
fs.unlinkSync(pidfile_path);
log("pidfile deleted");
return [2 /*return*/];
}
});
}); }, stop_timeout + 1000);
setProcessExitHandler.log = log;
args = (function () {
var out = __spread(process.argv);
out.shift();
out.shift();
return out;
})();
_b = __read((function () {
if (!!daemon_unix_user) {
return [get_uid(daemon_unix_user), get_gid(daemon_unix_user)];
}
else {
return [undefined, undefined];
}
})(), 2), daemon_uid = _b[0], daemon_gid = _b[1];
makeForkOptions = function (daemon_number) { return ({
"uid": daemon_uid,
"gid": daemon_gid,
"silent": true,
"cwd": daemon_cwd,
"execPath": daemon_node_path,
"env": __assign({}, process.env, { daemon_number: daemon_number,
daemon_count: daemon_count,
srv_name: srv_name,
stop_timeout: stop_timeout, "isQuiet": isQuiet ? "1" : "0" })
}); };
forkDaemon = function (daemon_number) { return __awaiter(_this, void 0, void 0, function () {
var context, error_5, daemonProcess;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
context = daemonContexts.get(daemon_number);
clearTimeout(context.reset_restart_attempt_timer);
if (!!!preForkTask) return [3 /*break*/, 5];
log("performing pre fork tasks for daemon number " + daemon_number + "...");
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, preForkTask(context.terminatePreForkChildProcesses, daemon_number)];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
error_5 = _a.sent();
log("PreFork tasks for daemon number " + daemon_number + " raised an exception");
throw error_5;
case 4:
context.terminatePreForkChildProcesses.impl = function () { return Promise.resolve(); };
_a.label = 5;
case 5:
if (isTerminating) {
log("Not forking daemon because root process is terminating");
return [2 /*return*/];
}
if (max_consecutive_restart !== undefined) {
context.reset_restart_attempt_timer = setTimeout(function () { return context.restart_attempt_remaining = max_consecutive_restart; }, 10000);
}
log("Forking daemon process number " + daemon_number + " now.");
daemonProcess = child_process.fork(main_js_path, args, makeForkOptions(daemon_number));
context.daemonProcess = daemonProcess;
if (doForwardDaemonStdout) {
daemonProcess.stdout.on("data", function (data) {
return process.stdout.write(data);
});
}
daemonProcess.once("error", function (error) {
if (isTerminating) {
return;
}
context.daemonProcess = undefined;
log([
"Error evt emitted by daemon process number " + daemon_number,
"Meaning that: ",
"The process could not be spawned, or",
"The process could not be killed, or",
"Sending a message to the child process failed."
].join("\n"));
throw error;
});
daemonProcess.once("close", function (childProcessExitCode) {
if (isTerminating) {
return;
}
context.daemonProcess = undefined;
log("Daemon process " + daemon_number + " exited without being requested to.");
if (daemon_restart_after_crash_delay < 0) {
if (childProcessExitCode === null) {
childProcessExitCode = 1;
}
log("Daemon number " + daemon_number + " will not be restarted.");
clearTimeout(context.reset_restart_attempt_timer);
if (childProcessExitCode !== 0) {
throw new Error("Daemon number " + daemon_number + ", crashed");
}
else if (!Array.from(daemonContexts.values()).find(function (_a) {
var daemonProcess = _a.daemonProcess;
return !!daemonProcess;
})) {
log("As last remaining daemon process terminated cleanly we stop end root process");
process.emit("beforeExit", NaN);
}
return;
}
if (max_consecutive_restart !== undefined) {
if (context.restart_attempt_remaining-- === 0) {
throw new Error("Daemon process " + daemon_number + " is crashing over and over");
}
else {
log("Restart remaining: " + context.restart_attempt_remaining);
}
}
log("Daemon process " + daemon_number + " will be restarted");
setTimeout(function () { return forkDaemon(daemon_number); }, daemon_restart_after_crash_delay);
});
return [2 /*return*/];
}
});
}); };
for (daemon_number = 1; daemon_number <= daemon_count; daemon_number++) {
forkDaemon(daemon_number);
}
return [2 /*return*/];
}
});
}); };
var main_daemon = function () { return __awaiter(_this, void 0, void 0, function () {
var _a, daemon_number, daemon_count, stop_timeout, isQuiet, srv_name, _b, launch, beforeExitTask;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = __read(["daemon_number", "daemon_count", "stop_timeout", "isQuiet"].map(function (key) {
var value = parseInt(process.env[key]);
delete process.env[key];
return value;
}), 4), daemon_number = _a[0], daemon_count = _a[1], stop_timeout = _a[2], isQuiet = _a[3];
srv_name = (function () {
var key = "srv_name";
var value = process.env[key];
delete process.env[key];
if (value === "" + undefined) {
return undefined;
}
else {
return value;
}
})();
if (!isQuiet) {
log = getLog("daemon process " + daemon_number + "/" + daemon_count + ", PID: " + process.pid);
}
if (srv_name !== undefined) {
process.title = srv_name + " daemon " + (daemon_count === 1 ? "" : daemon_number);
}
return [4 /*yield*/, daemonProcess(daemon_number, daemon_count)];
case 1:
_b = _c.sent(), launch = _b.launch, beforeExitTask = _b.beforeExitTask;
process.once("message", function () { return process.emit("beforeExit", process.exitCode = 0); });
process.once("disconnect", function () { return process.exit(1); });
setProcessExitHandler(function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var error, prBeforeExitTask;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
error = exitCause.type === "EXCEPTION" ? exitCause.error : undefined;
if (!!!beforeExitTask) return [3 /*break*/, 2];
prBeforeExitTask = beforeExitTask(error);
if (!(prBeforeExitTask instanceof Promise)) return [3 /*break*/, 2];
return [4 /*yield*/, safePr(prBeforeExitTask, stop_timeout + 2000).then(function (error) {
if (error instanceof Error) {
//NOTE: Throwing does not overwrite the exit code.
if (error.message === safePr.timeoutErrorMessage) {
//NOTE: Throwing string to not have the log of setProcessExitHandler
//display the stack trace.
throw "beforeExitTask took too much time to complete.";
}
else {
throw error;
}
}
})];
case 1:
_a.sent();
_a.label = 2;
case 2: return [2 /*return*/];
}
});
}); }, -1, function (exitCause) { return exitCause.type !== "SIGNAL"; });
setProcessExitHandler.log = log;
launch();
return [2 /*return*/];
}
});
}); };
if (!process.send) {
main_root(get_caller_file_path_2.get_caller_file_path());
}
else {
main_daemon();
}
}
exports.createService = createService;
var systemd;
(function (systemd) {
var mkPath = function (srv_name) { return "/etc/systemd/system/" + srv_name + ".service"; };
/**
* Generate a systemd config file for a service created via "createService" function
* enable by default, start by default.
*/
function createConfigFile(srv_name, main_js_path, node_path, enable, start) {
if (node_path === void 0) { node_path = process.argv[0]; }
if (enable === void 0) { enable = "ENABLE"; }
if (start === void 0) { start = "START"; }
fs.writeFileSync(mkPath(srv_name), Buffer.from([
"[Unit]",
"After=network.target",
"",
"[Service]",
"ExecStart=" + node_path + " " + main_js_path,
"StandardOutput=inherit",
"KillMode=process",
"KillSignal=SIGUSR2",
"SendSIGKILL=no",
"Environment=NODE_ENV=production",
"",
"[Install]",
"WantedBy=multi-user.target",
""
].join("\n"), "utf8"));
execSyncNoCmdTrace("systemctl daemon-reload");
if (!!enable) {
execSyncNoCmdTrace("systemctl enable " + srv_name, { "stdio": "pipe" });
}
if (!!start) {
execSyncNoCmdTrace("systemctl start " + srv_name);
}
}
systemd.createConfigFile = createConfigFile;
/** Remove config file disable and reload daemon, never throw, stop is false by default */
function deleteConfigFile(srv_name, stop) {
if (stop === void 0) { stop = false; }
if (!!stop) {
execSyncNoCmdTrace("systemctl stop " + srv_name + " || true", { "stdio": "pipe" });
}
execSyncNoCmdTrace("systemctl disable " + srv_name + " || true", { "stdio": "pipe" });
try {
fs.unlinkSync(mkPath(srv_name));
}
catch (_a) { }
execSyncNoCmdTrace("systemctl daemon-reload || true", { "stdio": "pipe" });
}
systemd.deleteConfigFile = deleteConfigFile;
})(systemd = exports.systemd || (exports.systemd = {}));
/***/ }),
/***/ 6160:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Reflect = void 0;
/** Always return null but pretends it returns an object of type T */
function Reflect() {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return null;
}
exports.Reflect = Reflect;
//# sourceMappingURL=Reflect.js.map
/***/ }),
/***/ 2419:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require2_) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.assert = exports.AssertionError = void 0;
/* eslint-disable @typescript-eslint/no-unused-vars */
var overwriteReadonlyProp_1 = __nccwpck_require2_(43);
var assertIsRefWrapper_1 = __nccwpck_require2_(2918);
/** @see <https://docs.tsafe.dev/assert#error-thrown> */
var AssertionError = /** @class */ (function (_super) {
__extends(AssertionError, _super);
function AssertionError(msg) {
var _newTarget = this.constructor;
var _this = _super.call(this, "Wrong assertion encountered" + (!msg ? "" : ": \"".concat(msg, "\""))) || this;
Object.setPrototypeOf(_this, _newTarget.prototype);
if (!_this.stack) {
return _this;
}
try {
(0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this, "stack", _this.stack
.split("\n")
.filter(function () {
var _a = [];
for (var _i = 0; _i < arguments.length; _i++) {
_a[_i] = arguments[_i];
}
var _b = __read(_a, 2), i = _b[1];
return i !== 1 && i !== 2;
})
.join("\n"));
// eslint-disable-next-line no-empty
}
catch (_a) { }
return _this;
}
return AssertionError;
}(Error));
exports.AssertionError = AssertionError;
/** https://docs.tsafe.dev/assert */
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function assert(condition, msg) {
if (arguments.length === 0) {
condition = true;
}
if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== undefined) {
assertIsRefWrapper_1.assertIsRefWrapper.ref = undefined;
return;
}
if (!condition) {
throw new AssertionError(msg);
}
}
exports.assert = assert;
//# sourceMappingURL=assert.js.map
/***/ }),
/***/ 2655:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.capitalize = void 0;
/** @see <https://docs.tsafe.dev/capitalize> */
function capitalize(str) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (str.charAt(0).toUpperCase() + str.slice(1));
}
exports.capitalize = capitalize;
//# sourceMappingURL=capitalize.js.map
/***/ }),
/***/ 5567:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.exclude = void 0;
/** Return a function to use as Array.prototype.filter argument
* to exclude one or many primitive value element from the array.
* Ex: ([ "a", "b", "c" ] as const).filter(exclude("a")) return ("b" | "c")[]
* Ex: ([ "a", "b", "c", "d"] as const).filter(exclude(["a", "b"]) gives ("c" | "d")[]
*/
function exclude(target) {
var test = target instanceof Object
? function (element) { return target.indexOf(element) < 0; }
: function (element) { return element !== target; };
return function (elemnt) {
return test(elemnt);
};
}
exports.exclude = exclude;
//# sourceMappingURL=exclude.js.map
/***/ }),
/***/ 8534:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.flip = void 0;
/**
* Flip the value of a boolean without having to reference it twice
* after running flip(x.y, "z") x.y.z !== x.y.z,
* https://docs.tsafe.dev/flip
*/
function flip(object, prop) {
if (object[prop] === undefined) {
return;
}
return (object[prop] = !object[prop]);
}
exports.flip = flip;
//# sourceMappingURL=flip.js.map
/***/ }),
/***/ 2632:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.id = void 0;
/** https://docs.tsafe.dev/id */
var id = function (x) { return x; };
exports.id = id;
//# sourceMappingURL=id.js.map
/***/ }),
/***/ 4653:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require2_) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
__exportStar(__nccwpck_require2_(2419), exports);
__exportStar(__nccwpck_require2_(5567), exports);
__exportStar(__nccwpck_require2_(8534), exports);
__exportStar(__nccwpck_require2_(2632), exports);
__exportStar(__nccwpck_require2_(5639), exports);
__exportStar(__nccwpck_require2_(6958), exports);
__exportStar(__nccwpck_require2_(9980), exports);
__exportStar(__nccwpck_require2_(3069), exports);
__exportStar(__nccwpck_require2_(7937), exports);
__exportStar(__nccwpck_require2_(5656), exports);
__exportStar(__nccwpck_require2_(6640), exports);
__exportStar(__nccwpck_require2_(1184), exports);
__exportStar(__nccwpck_require2_(6160), exports);
__exportStar(__nccwpck_require2_(2655), exports);
__exportStar(__nccwpck_require2_(1392), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 3069:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.is = void 0;
var assertIsRefWrapper_1 = __nccwpck_require2_(2918);
var errorMessage = [
"Wrong usage of the ".concat(is.name, " function refer to"),
"https://docs.tsafe.dev/".concat(is.name.toLowerCase()),
].join(" ");
function is(_value) {
var ref = {};
if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== undefined) {
assertIsRefWrapper_1.assertIsRefWrapper.ref = undefined;
throw new Error(errorMessage);
}
assertIsRefWrapper_1.assertIsRefWrapper.ref = ref;
Promise.resolve().then(function () {
if (assertIsRefWrapper_1.assertIsRefWrapper.ref === ref) {
throw new Error(errorMessage);
}
});
return null;
}
exports.is = is;
//# sourceMappingURL=is.js.map
/***/ }),
/***/ 7937:
/***/ (function(__unused_webpack_module, exports) {
"use strict";
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isAmong = void 0;
/** https://docs.tsafe.dev/isamong */
function isAmong(names, value) {
var e_1, _a;
try {
for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
var name_1 = names_1_1.value;
if (name_1 === value) {
return true;
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
}
finally { if (e_1) throw e_1.error; }
}
return false;
}
exports.isAmong = isAmong;
//# sourceMappingURL=isAmong.js.map
/***/ }),
/***/ 5639:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isPromiseLike = void 0;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function isPromiseLike(o) {
return typeof o === "object" && o !== null && "then" in o && typeof o.then === "function";
}
exports.isPromiseLike = isPromiseLike;
//# sourceMappingURL=isPromiseLike.js.map
/***/ }),
/***/ 43:
/***/ (function(__unused_webpack_module, exports) {
"use strict";
/* eslint-disable no-empty */
/* eslint-disable @typescript-eslint/no-explicit-any */
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.overwriteReadonlyProp = void 0;
/**
* Assign a value to a property even if the object is freezed or if the property is not writable
* Throw if the assignation fail ( for example if the property is non configurable write: false )
* */
var overwriteReadonlyProp = function (obj, propertyName, value) {
try {
obj[propertyName] = value;
}
catch (_a) { }
if (obj[propertyName] === value) {
return value;
}
var errorDefineProperty = undefined;
var propertyDescriptor = Object.getOwnPropertyDescriptor(obj, propertyName) || {
"enumerable": true,
"configurable": true,
};
if (!!propertyDescriptor.get) {
throw new Error("Probably a wrong ides to overwrite ".concat(String(propertyName), " getter"));
}
try {
Object.defineProperty(obj, propertyName, __assign(__assign({}, propertyDescriptor), { value: value }));
}
catch (error) {
errorDefineProperty = error;
}
if (obj[propertyName] !== value) {
throw errorDefineProperty || new Error("Can't assign");
}
return value;
};
exports.overwriteReadonlyProp = overwriteReadonlyProp;
//# sourceMappingURL=overwriteReadonlyProp.js.map
/***/ }),
/***/ 1184:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/ban-types */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.noUndefined = void 0;
/**
* Removes the enumerable properties whose values are
* undefined.
*
* Example:
* noUndefined({ "foo": undefined, "bar": 3 }) returns
* a new object { "bar": 3 }
*/
function noUndefined(obj) {
var out = {};
for (var key in obj) {
if (obj[key] === undefined) {
continue;
}
out[key] = obj[key];
}
return out;
}
exports.noUndefined = noUndefined;
//# sourceMappingURL=noUndefined.js.map
/***/ }),
/***/ 5656:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectEntries = void 0;
/** https://docs.tsafe.dev/objectentries */
function objectEntries(o) {
return Object.entries(o);
}
exports.objectEntries = objectEntries;
//# sourceMappingURL=objectEntries.js.map
/***/ }),
/***/ 6640:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectFromEntries = void 0;
/** https://docs.tsafe.dev/objectFromEntries */
function objectFromEntries(entries) {
return Object.fromEntries(entries);
}
exports.objectFromEntries = objectFromEntries;
//# sourceMappingURL=objectFromEntries.js.map
/***/ }),
/***/ 6958:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectKeys = void 0;
/** https://docs.tsafe.dev/objectKeys */
function objectKeys(o) {
return Object.keys(o);
}
exports.objectKeys = objectKeys;
//# sourceMappingURL=objectKeys.js.map
/***/ }),
/***/ 9980:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.typeGuard = void 0;
/** https://docs.tsafe.dev/typeguard */
function typeGuard(_value, isMatched) {
return isMatched;
}
exports.typeGuard = typeGuard;
//# sourceMappingURL=typeGuard.js.map
/***/ }),
/***/ 1392:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.uncapitalize = void 0;
/** @see <https://docs.tsafe.dev/capitalize#uncapitalize> */
function uncapitalize(str) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (str.charAt(0).toLowerCase() + str.slice(1));
}
exports.uncapitalize = uncapitalize;
//# sourceMappingURL=uncapitalize.js.map
/***/ }),
/***/ 2918:
/***/ ((__unused_webpack_module, exports, __nccwpck_require2_) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.assertIsRefWrapper = void 0;
var id_1 = __nccwpck_require2_(2632);
exports.assertIsRefWrapper = {
"ref": (0, id_1.id)(undefined),
};
//# sourceMappingURL=assertIsRefWrapper.js.map
/***/ }),
/***/ 4106:
/***/ (function(module) {
(function (name, context, definition) {
if ( true && module.exports) module.exports = definition();
else if (typeof define === 'function' && define.amd) define(definition);
else context[name] = definition();
})('urljoin', this, function () {
function normalize (strArray) {
var resultArray = [];
if (strArray.length === 0) { return ''; }
if (typeof strArray[0] !== 'string') {
throw new TypeError('Url must be a string. Received ' + strArray[0]);
}
// If the first part is a plain protocol, we combine it with the next part.
if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
var first = strArray.shift();
strArray[0] = first + strArray[0];
}
// There must be two or three slashes in the file protocol, two slashes in anything else.
if (strArray[0].match(/^file:\/\/\//)) {
strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1:///');
} else {
strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1://');
}
for (var i = 0; i < strArray.length; i++) {
var component = strArray[i];
if (typeof component !== 'string') {
throw new TypeError('Url must be a string. Received ' + component);
}
if (component === '') { continue; }
if (i > 0) {
// Removing the starting slashes for each component but the first.
component = component.replace(/^[\/]+/, '');
}
if (i < strArray.length - 1) {
// Removing the ending slashes for each component but the last.
component = component.replace(/[\/]+$/, '');
} else {
// For the last component we will combine multiple slashes to a single one.
component = component.replace(/[\/]+$/, '/');
}
resultArray.push(component);
}
var str = resultArray.join('/');
// Each input component is now separated by a single slash except the possible first plain protocol part.
// remove trailing slash before parameters or hash
str = str.replace(/\/(\?|&|#[^!])/g, '$1');
// replace ? in parameters with &
var parts = str.split('?');
str = parts.shift() + (parts.length > 0 ? '?': '') + parts.join('&');
return str;
}
return function () {
var input;
if (typeof arguments[0] === 'object') {
input = arguments[0];
} else {
input = [].slice.call(arguments);
}
return normalize(input);
};
});
/***/ }),
/***/ 3585:
/***/ (function(__unused_webpack_module, exports) {
/**
* @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
*/
(function (global, factory) {
true ? factory(exports) :
0;
})(this, (function (exports) { 'use strict';
function noop() {
return undefined;
}
function typeIsObject(x) {
return (typeof x === 'object' && x !== null) || typeof x === 'function';
}
const rethrowAssertionErrorRejection = noop;
function setFunctionName(fn, name) {
try {
Object.defineProperty(fn, 'name', {
value: name,
configurable: true
});
}
catch (_a) {
// This property is non-configurable in older browsers, so ignore if this throws.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
}
}
const originalPromise = Promise;
const originalPromiseThen = Promise.prototype.then;
const originalPromiseReject = Promise.reject.bind(originalPromise);
// https://webidl.spec.whatwg.org/#a-new-promise
function newPromise(executor) {
return new originalPromise(executor);
}
// https://webidl.spec.whatwg.org/#a-promise-resolved-with
function promiseResolvedWith(value) {
return newPromise(resolve => resolve(value));
}
// https://webidl.spec.whatwg.org/#a-promise-rejected-with
function promiseRejectedWith(reason) {
return originalPromiseReject(reason);
}
function PerformPromiseThen(promise, onFulfilled, onRejected) {
// There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an
// approximation.
return originalPromiseThen.call(promise, onFulfilled, onRejected);
}
// Bluebird logs a warning when a promise is created within a fulfillment handler, but then isn't returned
// from that handler. To prevent this, return null instead of void from all handlers.
// http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it
function uponPromise(promise, onFulfilled, onRejected) {
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
}
function uponFulfillment(promise, onFulfilled) {
uponPromise(promise, onFulfilled);
}
function uponRejection(promise, onRejected) {
uponPromise(promise, undefined, onRejected);
}
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
}
function setPromiseIsHandledToTrue(promise) {
PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
}
let _queueMicrotask = callback => {
if (typeof queueMicrotask === 'function') {
_queueMicrotask = queueMicrotask;
}
else {
const resolvedPromise = promiseResolvedWith(undefined);
_queueMicrotask = cb => PerformPromiseThen(resolvedPromise, cb);
}
return _queueMicrotask(callback);
};
function reflectCall(F, V, args) {
if (typeof F !== 'function') {
throw new TypeError('Argument is not a function');
}
return Function.prototype.apply.call(F, V, args);
}
function promiseCall(F, V, args) {
try {
return promiseResolvedWith(reflectCall(F, V, args));
}
catch (value) {
return promiseRejectedWith(value);
}
}
// Original from Chromium
// https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js
const QUEUE_MAX_ARRAY_SIZE = 16384;
/**
* Simple queue structure.
*
* Avoids scalability issues with using a packed array directly by using
* multiple arrays in a linked list and keeping the array size bounded.
*/
class SimpleQueue {
constructor() {
this._cursor = 0;
this._size = 0;
// _front and _back are always defined.
this._front = {
_elements: [],
_next: undefined
};
this._back = this._front;
// The cursor is used to avoid calling Array.shift().
// It contains the index of the front element of the array inside the
// front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).
this._cursor = 0;
// When there is only one node, size === elements.length - cursor.
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: undefined
};
}
// push() is the mutation most likely to throw an exception, so it
// goes first.
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() { // must not be called on an empty queue
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;
}
// No mutations before this point.
--this._size;
this._cursor = newCursor;
if (oldFront !== newFront) {
this._front = newFront;
}
// Permit shifted element to be garbage collected.
elements[oldCursor] = undefined;
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 i = this._cursor;
let node = this._front;
let elements = node._elements;
while (i !== elements.length || node._next !== undefined) {
if (i === elements.length) {
node = node._next;
elements = node._elements;
i = 0;
if (elements.length === 0) {
break;
}
}
callback(elements[i]);
++i;
}
}
// Return the element that would be returned if shift() was called now,
// without modifying the queue.
peek() { // must not be called on an empty queue
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);
}
}
// A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state
// check.
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 = undefined;
reader._ownerReadableStream = undefined;
}
// Helper functions for the readers.
function readerLockException(name) {
return new TypeError('Cannot ' + name + ' a stream using a released reader');
}
// Helper functions for the ReadableStreamDefaultReader.
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 === undefined) {
return;
}
setPromiseIsHandledToTrue(reader._closedPromise);
reader._closedPromise_reject(reason);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
}
function defaultReaderClosedPromiseResolve(reader) {
if (reader._closedPromise_resolve === undefined) {
return;
}
reader._closedPromise_resolve(undefined);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
/// <reference lib="es2015.core" />
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
const NumberIsFinite = Number.isFinite || function (x) {
return typeof x === 'number' && isFinite(x);
};
/// <reference lib="es2015.core" />
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill
const MathTrunc = Math.trunc || function (v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
// https://heycam.github.io/webidl/#idl-dictionaries
function isDictionary(x) {
return typeof x === 'object' || typeof x === 'function';
}
function assertDictionary(obj, context) {
if (obj !== undefined && !isDictionary(obj)) {
throw new TypeError(`${context} is not an object.`);
}
}
// https://heycam.github.io/webidl/#idl-callback-functions
function assertFunction(x, context) {
if (typeof x !== 'function') {
throw new TypeError(`${context} is not a function.`);
}
}
// https://heycam.github.io/webidl/#idl-object
function isObject(x) {
return (typeof x === 'object' && x !== null) || typeof x === 'function';
}
function assertObject(x, context) {
if (!isObject(x)) {
throw new TypeError(`${context} is not an object.`);
}
}
function assertRequiredArgument(x, position, context) {
if (x === undefined) {
throw new TypeError(`Parameter ${position} is required in '${context}'.`);
}
}
function assertRequiredField(x, field, context) {
if (x === undefined) {
throw new TypeError(`${field} is required in '${context}'.`);
}
}
// https://heycam.github.io/webidl/#idl-unrestricted-double
function convertUnrestrictedDouble(value) {
return Number(value);
}
function censorNegativeZero(x) {
return x === 0 ? 0 : x;
}
function integerPart(x) {
return censorNegativeZero(MathTrunc(x));
}
// https://heycam.github.io/webidl/#idl-unsigned-long-long
function convertUnsignedLongLongWithEnforceRange(value, context) {
const lowerBound = 0;
const upperBound = Number.MAX_SAFE_INTEGER;
let x = Number(value);
x = censorNegativeZero(x);
if (!NumberIsFinite(x)) {
throw new TypeError(`${context} is not a finite number`);
}
x = integerPart(x);
if (x < lowerBound || x > upperBound) {
throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
}
if (!NumberIsFinite(x) || x === 0) {
return 0;
}
// TODO Use BigInt if supported?
// let xBigInt = BigInt(integerPart(x));
// xBigInt = BigInt.asUintN(64, xBigInt);
// return Number(xBigInt);
return x;
}
function assertReadableStream(x, context) {
if (!IsReadableStream(x)) {
throw new TypeError(`${context} is not a ReadableStream.`);
}
}
// Abstract operations for the ReadableStream.
function AcquireReadableStreamDefaultReader(stream) {
return new ReadableStreamDefaultReader(stream);
}
// ReadableStream API exposed for controllers.
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 === undefined) {
return false;
}
if (!IsReadableStreamDefaultReader(reader)) {
return false;
}
return true;
}
/**
* A default reader vended by a {@link ReadableStream}.
*
* @public
*/
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 = undefined) {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));
}
if (this._ownerReadableStream === undefined) {
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 === undefined) {
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: undefined, done: true }),
_errorSteps: e => rejectPromise(e)
};
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 === undefined) {
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
});
}
// Abstract operations for the readers.
function IsReadableStreamDefaultReader(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
return false;
}
return x 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 e = new TypeError('Reader was released');
ReadableStreamDefaultReaderErrorReadRequests(reader, e);
}
function ReadableStreamDefaultReaderErrorReadRequests(reader, e) {
const readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue();
readRequests.forEach(readRequest => {
readRequest._errorSteps(e);
});
}
// Helper functions for the ReadableStreamDefaultReader.
function defaultReaderBrandCheckException(name) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
}
/// <reference lib="es2018.asynciterable" />
/* eslint-disable @typescript-eslint/no-empty-function */
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () { }).prototype);
/// <reference lib="es2018.asynciterable" />
class ReadableStreamAsyncIteratorImpl {
constructor(reader, preventCancel) {
this._ongoingPromise = undefined;
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: undefined, 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 = undefined;
// This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.
// FIXME Is this a bug in the specification, or in the test?
_queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
},
_closeSteps: () => {
this._ongoingPromise = undefined;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
resolvePromise({ value: undefined, done: true });
},
_errorSteps: reason => {
this._ongoingPromise = undefined;
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);
// Abstract operations for the ReadableStream.
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(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
return false;
}
try {
// noinspection SuspiciousTypeOfGuard
return x._asyncIteratorImpl instanceof
ReadableStreamAsyncIteratorImpl;
}
catch (_a) {
return false;
}
}
// Helper functions for the ReadableStream.
function streamAsyncIteratorBrandCheckException(name) {
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
}
/// <reference lib="es2015.core" />
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill
const NumberIsNaN = Number.isNaN || function (x) {
// eslint-disable-next-line no-self-compare
return x !== x;
};
var _a, _b, _c;
function CreateArrayFromList(elements) {
// We use arrays to represent lists, so this is basically a no-op.
// Do a slice though just in case we happen to depend on the unique-ness.
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 {
// Not implemented correctly
TransferArrayBuffer = buffer => buffer;
}
return TransferArrayBuffer(O);
};
let IsDetachedBuffer = (O) => {
if (typeof O.detached === 'boolean') {
IsDetachedBuffer = buffer => buffer.detached;
}
else {
// Not implemented correctly
IsDetachedBuffer = buffer => buffer.byteLength === 0;
}
return IsDetachedBuffer(O);
};
function ArrayBufferSlice(buffer, begin, end) {
// ArrayBuffer.prototype.slice is not available on IE10
// https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
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 === undefined || func === null) {
return undefined;
}
if (typeof func !== 'function') {
throw new TypeError(`${String(prop)} is not a function`);
}
return func;
}
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
// Instead of re-implementing CreateAsyncFromSyncIterator and %AsyncFromSyncIteratorPrototype%,
// we use yield* inside an async generator function to achieve the same result.
// Wrap the sync iterator inside a sync iterable, so we can use it with yield*.
const syncIterable = {
[Symbol.iterator]: () => syncIteratorRecord.iterator
};
// Create an async generator function and immediately invoke it.
const asyncIterator = (async function* () {
return yield* syncIterable;
}());
// Return as an async iterator record.
const nextMethod = asyncIterator.next;
return { iterator: asyncIterator, nextMethod, done: false };
}
// Aligns with core-js/modules/es.symbol.async-iterator.js
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 === undefined) {
if (hint === 'async') {
method = GetMethod(obj, SymbolAsyncIterator);
if (method === undefined) {
const syncMethod = GetMethod(obj, Symbol.iterator);
const syncIteratorRecord = GetIterator(obj, 'sync', syncMethod);
return CreateAsyncFromSyncIterator(syncIteratorRecord);
}
}
else {
method = GetMethod(obj, Symbol.iterator);
}
}
if (method === undefined) {
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;
}
/**
* A pull-into request in a {@link ReadableByteStreamController}.
*
* @public
*/
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 === undefined) {
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 === undefined) {
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
});
}
/**
* Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
*
* @public
*/
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(e = undefined) {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException('error');
}
ReadableByteStreamControllerError(this, e);
}
/** @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 !== undefined) {
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
});
}
// Abstract operations for the ReadableByteStreamController.
function IsReadableByteStreamController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
return false;
}
return x instanceof ReadableByteStreamController;
}
function IsReadableStreamBYOBRequest(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
return false;
}
return x instanceof ReadableStreamBYOBRequest;
}
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
if (!shouldPull) {
return;
}
if (controller._pulling) {
controller._pullAgain = true;
return;
}
controller._pulling = true;
// TODO: Test controller argument
const pullPromise = controller._pullAlgorithm();
uponPromise(pullPromise, () => {
controller._pulling = false;
if (controller._pullAgain) {
controller._pullAgain = false;
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
return null;
}, e => {
ReadableByteStreamControllerError(controller, e);
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;
// A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
// of the queue, so the underlying source can keep filling it.
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 = undefined;
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 (e) {
readIntoRequest._errorSteps(e);
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);
// No ReadableByteStreamControllerCallPullIfNeeded() call since:
// - No change happens on desiredSize
// - The source has already been notified of that there's at least 1 pending read(view)
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 e = new TypeError('Insufficient bytes to fill elements in the given buffer');
ReadableByteStreamControllerError(controller, e);
readIntoRequest._errorSteps(e);
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) {
// A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
// of the queue, so the underlying source can keep filling it.
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 = undefined;
controller._cancelAlgorithm = undefined;
}
// A client of ReadableByteStreamController may use these functions directly to bypass state check.
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 e = new TypeError('Insufficient bytes to fill elements in the given buffer');
ReadableByteStreamControllerError(controller, e);
throw e;
}
}
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)) {
// TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
}
else {
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
}
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerError(controller, e) {
const stream = controller._controlledReadableByteStream;
if (stream._state !== 'readable') {
return;
}
ReadableByteStreamControllerClearPendingPullIntos(controller);
ResetQueue(controller);
ReadableByteStreamControllerClearAlgorithms(controller);
ReadableStreamError(stream, e);
}
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;
// Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
controller._queue = controller._queueTotalSize = undefined;
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;
}, r => {
ReadableByteStreamControllerError(controller, r);
return null;
});
}
function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
const controller = Object.create(ReadableByteStreamController.prototype);
let startAlgorithm;
let pullAlgorithm;
let cancelAlgorithm;
if (underlyingByteSource.start !== undefined) {
startAlgorithm = () => underlyingByteSource.start(controller);
}
else {
startAlgorithm = () => undefined;
}
if (underlyingByteSource.pull !== undefined) {
pullAlgorithm = () => underlyingByteSource.pull(controller);
}
else {
pullAlgorithm = () => promiseResolvedWith(undefined);
}
if (underlyingByteSource.cancel !== undefined) {
cancelAlgorithm = reason => underlyingByteSource.cancel(reason);
}
else {
cancelAlgorithm = () => promiseResolvedWith(undefined);
}
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;
}
// Helper functions for the ReadableStreamBYOBRequest.
function byobRequestBrandCheckException(name) {
return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
}
// Helper functions for the ReadableByteStreamController.
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 === undefined ? undefined : 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 _a;
assertDictionary(options, context);
const min = (_a = options === null || options === void 0 ? void 0 : options.min) !== null && _a !== void 0 ? _a : 1;
return {
min: convertUnsignedLongLongWithEnforceRange(min, `${context} has member 'min' that`)
};
}
// Abstract operations for the ReadableStream.
function AcquireReadableStreamBYOBReader(stream) {
return new ReadableStreamBYOBReader(stream);
}
// ReadableStream API exposed for controllers.
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 === undefined) {
return false;
}
if (!IsReadableStreamBYOBReader(reader)) {
return false;
}
return true;
}
/**
* A BYOB reader vended by a {@link ReadableStream}.
*
* @public
*/
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 = undefined) {
if (!IsReadableStreamBYOBReader(this)) {
return promiseRejectedWith(byobReaderBrandCheckException('cancel'));
}
if (this._ownerReadableStream === undefined) {
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 (e) {
return promiseRejectedWith(e);
}
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 === undefined) {
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: e => rejectPromise(e)
};
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 === undefined) {
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
});
}
// Abstract operations for the readers.
function IsReadableStreamBYOBReader(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
return false;
}
return x 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 e = new TypeError('Reader was released');
ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
}
function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e) {
const readIntoRequests = reader._readIntoRequests;
reader._readIntoRequests = new SimpleQueue();
readIntoRequests.forEach(readIntoRequest => {
readIntoRequest._errorSteps(e);
});
}
// Helper functions for the ReadableStreamBYOBReader.
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 === undefined) {
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 === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),
size: size === undefined ? undefined : 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 === undefined ?
undefined :
convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`),
close: close === undefined ?
undefined :
convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),
start: start === undefined ?
undefined :
convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`),
write: write === undefined ?
undefined :
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(x, context) {
if (!IsWritableStream(x)) {
throw new TypeError(`${context} is not a WritableStream.`);
}
}
function isAbortSignal(value) {
if (typeof value !== 'object' || value === null) {
return false;
}
try {
return typeof value.aborted === 'boolean';
}
catch (_a) {
// AbortSignal.prototype.aborted throws if its brand check fails
return false;
}
}
const supportsAbortController = typeof AbortController === 'function';
/**
* Construct a new AbortController, if supported by the platform.
*
* @internal
*/
function createAbortController() {
if (supportsAbortController) {
return new AbortController();
}
return undefined;
}
/**
* A writable stream represents a destination for data, into which you can write.
*
* @public
*/
class WritableStream {
constructor(rawUnderlyingSink = {}, rawStrategy = {}) {
if (rawUnderlyingSink === undefined) {
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 !== undefined) {
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 = undefined) {
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
});
}
// Abstract operations for the WritableStream.
function AcquireWritableStreamDefaultWriter(stream) {
return new WritableStreamDefaultWriter(stream);
}
// Throws if and only if startAlgorithm throws.
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';
// The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is
// 'erroring' or 'errored'. May be set to an undefined value.
stream._storedError = undefined;
stream._writer = undefined;
// Initialize to undefined first because the constructor of the controller checks this
// variable to validate the caller.
stream._writableStreamController = undefined;
// This queue is placed here instead of the writer class in order to allow for passing a writer to the next data
// producer without waiting for the queued writes to finish.
stream._writeRequests = new SimpleQueue();
// Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents
// them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.
stream._inFlightWriteRequest = undefined;
// The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer
// has been detached.
stream._closeRequest = undefined;
// Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it
// from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.
stream._inFlightCloseRequest = undefined;
// The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.
stream._pendingAbortRequest = undefined;
// The backpressure signal set by the controller.
stream._backpressure = false;
}
function IsWritableStream(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
return false;
}
return x instanceof WritableStream;
}
function IsWritableStreamLocked(stream) {
if (stream._writer === undefined) {
return false;
}
return true;
}
function WritableStreamAbort(stream, reason) {
var _a;
if (stream._state === 'closed' || stream._state === 'errored') {
return promiseResolvedWith(undefined);
}
stream._writableStreamController._abortReason = reason;
(_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort(reason);
// TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',
// but it doesn't know that signaling abort runs author code that might have changed the state.
// Widen the type again by casting to WritableStreamState.
const state = stream._state;
if (state === 'closed' || state === 'errored') {
return promiseResolvedWith(undefined);
}
if (stream._pendingAbortRequest !== undefined) {
return stream._pendingAbortRequest._promise;
}
let wasAlreadyErroring = false;
if (state === 'erroring') {
wasAlreadyErroring = true;
// reason will not be used, so don't keep a reference to it.
reason = undefined;
}
const promise = newPromise((resolve, reject) => {
stream._pendingAbortRequest = {
_promise: undefined,
_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 !== undefined && stream._backpressure && state === 'writable') {
defaultWriterReadyPromiseResolve(writer);
}
WritableStreamDefaultControllerClose(stream._writableStreamController);
return promise;
}
// WritableStream API exposed for controllers.
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 !== undefined) {
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 === undefined) {
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
return;
}
const abortRequest = stream._pendingAbortRequest;
stream._pendingAbortRequest = undefined;
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(undefined);
stream._inFlightWriteRequest = undefined;
}
function WritableStreamFinishInFlightWriteWithError(stream, error) {
stream._inFlightWriteRequest._reject(error);
stream._inFlightWriteRequest = undefined;
WritableStreamDealWithRejection(stream, error);
}
function WritableStreamFinishInFlightClose(stream) {
stream._inFlightCloseRequest._resolve(undefined);
stream._inFlightCloseRequest = undefined;
const state = stream._state;
if (state === 'erroring') {
// The error was too late to do anything, so it is ignored.
stream._storedError = undefined;
if (stream._pendingAbortRequest !== undefined) {
stream._pendingAbortRequest._resolve();
stream._pendingAbortRequest = undefined;
}
}
stream._state = 'closed';
const writer = stream._writer;
if (writer !== undefined) {
defaultWriterClosedPromiseResolve(writer);
}
}
function WritableStreamFinishInFlightCloseWithError(stream, error) {
stream._inFlightCloseRequest._reject(error);
stream._inFlightCloseRequest = undefined;
// Never execute sink abort() after sink close().
if (stream._pendingAbortRequest !== undefined) {
stream._pendingAbortRequest._reject(error);
stream._pendingAbortRequest = undefined;
}
WritableStreamDealWithRejection(stream, error);
}
// TODO(ricea): Fix alphabetical order.
function WritableStreamCloseQueuedOrInFlight(stream) {
if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
return false;
}
return true;
}
function WritableStreamHasOperationMarkedInFlight(stream) {
if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
return false;
}
return true;
}
function WritableStreamMarkCloseRequestInFlight(stream) {
stream._inFlightCloseRequest = stream._closeRequest;
stream._closeRequest = undefined;
}
function WritableStreamMarkFirstWriteRequestInFlight(stream) {
stream._inFlightWriteRequest = stream._writeRequests.shift();
}
function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
if (stream._closeRequest !== undefined) {
stream._closeRequest._reject(stream._storedError);
stream._closeRequest = undefined;
}
const writer = stream._writer;
if (writer !== undefined) {
defaultWriterClosedPromiseReject(writer, stream._storedError);
}
}
function WritableStreamUpdateBackpressure(stream, backpressure) {
const writer = stream._writer;
if (writer !== undefined && backpressure !== stream._backpressure) {
if (backpressure) {
defaultWriterReadyPromiseReset(writer);
}
else {
defaultWriterReadyPromiseResolve(writer);
}
}
stream._backpressure = backpressure;
}
/**
* A default writer vended by a {@link WritableStream}.
*
* @public
*/
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 === undefined) {
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 = undefined) {
if (!IsWritableStreamDefaultWriter(this)) {
return promiseRejectedWith(defaultWriterBrandCheckException('abort'));
}
if (this._ownerWritableStream === undefined) {
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 === undefined) {
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 === undefined) {
return;
}
WritableStreamDefaultWriterRelease(this);
}
write(chunk = undefined) {
if (!IsWritableStreamDefaultWriter(this)) {
return promiseRejectedWith(defaultWriterBrandCheckException('write'));
}
if (this._ownerWritableStream === undefined) {
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
});
}
// Abstract operations for the WritableStreamDefaultWriter.
function IsWritableStreamDefaultWriter(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
return false;
}
return x instanceof WritableStreamDefaultWriter;
}
// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
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(undefined);
}
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);
// The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not
// rejected until afterwards. This means that simply testing state will not work.
WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
stream._writer = undefined;
writer._ownerWritableStream = undefined;
}
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 = {};
/**
* Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
*
* @public
*/
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 === undefined) {
// Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
// We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
// so instead we only implement support for `signal` if we find a global `AbortController` constructor.
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(e = undefined) {
if (!IsWritableStreamDefaultController(this)) {
throw defaultControllerBrandCheckException$2('error');
}
const state = this._controlledWritableStream._state;
if (state !== 'writable') {
// The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so
// just treat it as a no-op.
return;
}
WritableStreamDefaultControllerError(this, e);
}
/** @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
});
}
// Abstract operations implementing interface required by the WritableStream.
function IsWritableStreamDefaultController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
return false;
}
return x instanceof WritableStreamDefaultController;
}
function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
controller._controlledWritableStream = stream;
stream._writableStreamController = controller;
// Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
controller._queue = undefined;
controller._queueTotalSize = undefined;
ResetQueue(controller);
controller._abortReason = undefined;
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;
}, r => {
controller._started = true;
WritableStreamDealWithRejection(stream, r);
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 !== undefined) {
startAlgorithm = () => underlyingSink.start(controller);
}
else {
startAlgorithm = () => undefined;
}
if (underlyingSink.write !== undefined) {
writeAlgorithm = chunk => underlyingSink.write(chunk, controller);
}
else {
writeAlgorithm = () => promiseResolvedWith(undefined);
}
if (underlyingSink.close !== undefined) {
closeAlgorithm = () => underlyingSink.close();
}
else {
closeAlgorithm = () => promiseResolvedWith(undefined);
}
if (underlyingSink.abort !== undefined) {
abortAlgorithm = reason => underlyingSink.abort(reason);
}
else {
abortAlgorithm = () => promiseResolvedWith(undefined);
}
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
}
// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
function WritableStreamDefaultControllerClearAlgorithms(controller) {
controller._writeAlgorithm = undefined;
controller._closeAlgorithm = undefined;
controller._abortAlgorithm = undefined;
controller._strategySizeAlgorithm = undefined;
}
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);
}
// Abstract operations for the WritableStreamDefaultController.
function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
const stream = controller._controlledWritableStream;
if (!controller._started) {
return;
}
if (stream._inFlightWriteRequest !== undefined) {
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;
}
// A client of WritableStreamDefaultController may use these functions directly to bypass state check.
function WritableStreamDefaultControllerError(controller, error) {
const stream = controller._controlledWritableStream;
WritableStreamDefaultControllerClearAlgorithms(controller);
WritableStreamStartErroring(stream, error);
}
// Helper functions for the WritableStream.
function streamBrandCheckException$2(name) {
return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);
}
// Helper functions for the WritableStreamDefaultController.
function defaultControllerBrandCheckException$2(name) {
return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
}
// Helper functions for the WritableStreamDefaultWriter.
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 === undefined) {
return;
}
setPromiseIsHandledToTrue(writer._closedPromise);
writer._closedPromise_reject(reason);
writer._closedPromise_resolve = undefined;
writer._closedPromise_reject = undefined;
writer._closedPromiseState = 'rejected';
}
function defaultWriterClosedPromiseResetToRejected(writer, reason) {
defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
}
function defaultWriterClosedPromiseResolve(writer) {
if (writer._closedPromise_resolve === undefined) {
return;
}
writer._closedPromise_resolve(undefined);
writer._closedPromise_resolve = undefined;
writer._closedPromise_reject = undefined;
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 === undefined) {
return;
}
setPromiseIsHandledToTrue(writer._readyPromise);
writer._readyPromise_reject(reason);
writer._readyPromise_resolve = undefined;
writer._readyPromise_reject = undefined;
writer._readyPromiseState = 'rejected';
}
function defaultWriterReadyPromiseReset(writer) {
defaultWriterReadyPromiseInitialize(writer);
}
function defaultWriterReadyPromiseResetToRejected(writer, reason) {
defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
}
function defaultWriterReadyPromiseResolve(writer) {
if (writer._readyPromise_resolve === undefined) {
return;
}
writer._readyPromise_resolve(undefined);
writer._readyPromise_resolve = undefined;
writer._readyPromise_reject = undefined;
writer._readyPromiseState = 'fulfilled';
}
/// <reference lib="dom" />
function getGlobals() {
if (typeof globalThis !== 'undefined') {
return globalThis;
}
else if (typeof self !== 'undefined') {
return self;
}
else if (typeof global !== 'undefined') {
return global;
}
return undefined;
}
const globals = getGlobals();
/// <reference types="node" />
function isDOMExceptionConstructor(ctor) {
if (!(typeof ctor === 'function' || typeof ctor === 'object')) {
return false;
}
if (ctor.name !== 'DOMException') {
return false;
}
try {
new ctor();
return true;
}
catch (_a) {
return false;
}
}
/**
* Support:
* - Web browsers
* - Node 18 and higher (https://github.com/nodejs/node/commit/e4b1fb5e6422c1ff151234bb9de792d45dd88d87)
*/
function getFromGlobal() {
const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
return isDOMExceptionConstructor(ctor) ? ctor : undefined;
}
/**
* Support:
* - All platforms
*/
function createPolyfill() {
// eslint-disable-next-line @typescript-eslint/no-shadow
const ctor = function DOMException(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;
}
// eslint-disable-next-line @typescript-eslint/no-redeclare
const DOMException = getFromGlobal() || createPolyfill();
function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
const reader = AcquireReadableStreamDefaultReader(source);
const writer = AcquireWritableStreamDefaultWriter(dest);
source._disturbed = true;
let shuttingDown = false;
// This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.
let currentWrite = promiseResolvedWith(undefined);
return newPromise((resolve, reject) => {
let abortAlgorithm;
if (signal !== undefined) {
abortAlgorithm = () => {
const error = signal.reason !== undefined ? signal.reason : new DOMException('Aborted', 'AbortError');
const actions = [];
if (!preventAbort) {
actions.push(() => {
if (dest._state === 'writable') {
return WritableStreamAbort(dest, error);
}
return promiseResolvedWith(undefined);
});
}
if (!preventCancel) {
actions.push(() => {
if (source._state === 'readable') {
return ReadableStreamCancel(source, error);
}
return promiseResolvedWith(undefined);
});
}
shutdownWithAction(() => Promise.all(actions.map(action => action())), true, error);
};
if (signal.aborted) {
abortAlgorithm();
return;
}
signal.addEventListener('abort', abortAlgorithm);
}
// Using reader and writer, read all chunks from this and write them to dest
// - Backpressure must be enforced
// - Shutdown must stop all activity
function pipeLoop() {
return newPromise((resolveLoop, rejectLoop) => {
function next(done) {
if (done) {
resolveLoop();
}
else {
// Use `PerformPromiseThen` instead of `uponPromise` to avoid
// adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers
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), undefined, noop);
resolveRead(false);
},
_closeSteps: () => resolveRead(true),
_errorSteps: rejectRead
});
});
});
}
// Errors must be propagated forward
isOrBecomesErrored(source, reader._closedPromise, storedError => {
if (!preventAbort) {
shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);
}
else {
shutdown(true, storedError);
}
return null;
});
// Errors must be propagated backward
isOrBecomesErrored(dest, writer._closedPromise, storedError => {
if (!preventCancel) {
shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);
}
else {
shutdown(true, storedError);
}
return null;
});
// Closing must be propagated forward
isOrBecomesClosed(source, reader._closedPromise, () => {
if (!preventClose) {
shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
}
else {
shutdown();
}
return null;
});
// Closing must be propagated backward
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() {
// Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait
// for that too.
const oldCurrentWrite = currentWrite;
return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined);
}
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 !== undefined) {
signal.removeEventListener('abort', abortAlgorithm);
}
if (isError) {
reject(error);
}
else {
resolve(undefined);
}
return null;
}
});
}
/**
* Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
*
* @public
*/
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 = undefined) {
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(e = undefined) {
if (!IsReadableStreamDefaultController(this)) {
throw defaultControllerBrandCheckException$1('error');
}
ReadableStreamDefaultControllerError(this, e);
}
/** @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]() {
// Do nothing.
}
}
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
});
}
// Abstract operations for the ReadableStreamDefaultController.
function IsReadableStreamDefaultController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
return false;
}
return x 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;
}, e => {
ReadableStreamDefaultControllerError(controller, e);
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 = undefined;
controller._cancelAlgorithm = undefined;
controller._strategySizeAlgorithm = undefined;
}
// A client of ReadableStreamDefaultController may use these functions directly to bypass state check.
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, e) {
const stream = controller._controlledReadableStream;
if (stream._state !== 'readable') {
return;
}
ResetQueue(controller);
ReadableStreamDefaultControllerClearAlgorithms(controller);
ReadableStreamError(stream, e);
}
function ReadableStreamDefaultControllerGetDesiredSize(controller) {
const state = controller._controlledReadableStream._state;
if (state === 'errored') {
return null;
}
if (state === 'closed') {
return 0;
}
return controller._strategyHWM - controller._queueTotalSize;
}
// This is used in the implementation of TransformStream.
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 = undefined;
controller._queueTotalSize = undefined;
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;
}, r => {
ReadableStreamDefaultControllerError(controller, r);
return null;
});
}
function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
const controller = Object.create(ReadableStreamDefaultController.prototype);
let startAlgorithm;
let pullAlgorithm;
let cancelAlgorithm;
if (underlyingSource.start !== undefined) {
startAlgorithm = () => underlyingSource.start(controller);
}
else {
startAlgorithm = () => undefined;
}
if (underlyingSource.pull !== undefined) {
pullAlgorithm = () => underlyingSource.pull(controller);
}
else {
pullAlgorithm = () => promiseResolvedWith(undefined);
}
if (underlyingSource.cancel !== undefined) {
cancelAlgorithm = reason => underlyingSource.cancel(reason);
}
else {
cancelAlgorithm = () => promiseResolvedWith(undefined);
}
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
}
// Helper functions for the ReadableStreamDefaultController.
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(undefined);
}
reading = true;
const readRequest = {
_chunkSteps: chunk => {
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
// successful synchronously-available reads get ahead of asynchronously-available errors.
_queueMicrotask(() => {
readAgain = false;
const chunk1 = chunk;
const chunk2 = chunk;
// There is no way to access the cloning code right now in the reference implementation.
// If we add one then we'll need an implementation for serializable objects.
// if (!canceled2 && cloneForBranch2) {
// chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
// }
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(undefined);
}
},
_errorSteps: () => {
reading = false;
}
};
ReadableStreamDefaultReaderRead(reader, readRequest);
return promiseResolvedWith(undefined);
}
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() {
// do nothing
}
branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
uponRejection(reader._closedPromise, (r) => {
ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
if (!canceled1 || !canceled2) {
resolveCancelPromise(undefined);
}
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, r => {
if (thisReader !== reader) {
return null;
}
ReadableByteStreamControllerError(branch1._readableStreamController, r);
ReadableByteStreamControllerError(branch2._readableStreamController, r);
if (!canceled1 || !canceled2) {
resolveCancelPromise(undefined);
}
return null;
});
}
function pullWithDefaultReader() {
if (IsReadableStreamBYOBReader(reader)) {
ReadableStreamReaderGenericRelease(reader);
reader = AcquireReadableStreamDefaultReader(stream);
forwardReaderError(reader);
}
const readRequest = {
_chunkSteps: chunk => {
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
// successful synchronously-available reads get ahead of asynchronously-available errors.
_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(undefined);
}
},
_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 => {
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
// successful synchronously-available reads get ahead of asynchronously-available errors.
_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 !== undefined) {
if (!byobCanceled) {
ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
}
if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
}
}
if (!byobCanceled || !otherCanceled) {
resolveCancelPromise(undefined);
}
},
_errorSteps: () => {
reading = false;
}
};
ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
}
function pull1Algorithm() {
if (reading) {
readAgainForBranch1 = true;
return promiseResolvedWith(undefined);
}
reading = true;
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
if (byobRequest === null) {
pullWithDefaultReader();
}
else {
pullWithBYOBReader(byobRequest._view, false);
}
return promiseResolvedWith(undefined);
}
function pull2Algorithm() {
if (reading) {
readAgainForBranch2 = true;
return promiseResolvedWith(undefined);
}
reading = true;
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
if (byobRequest === null) {
pullWithDefaultReader();
}
else {
pullWithBYOBReader(byobRequest._view, true);
}
return promiseResolvedWith(undefined);
}
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 = noop;
function pullAlgorithm() {
let nextResult;
try {
nextResult = IteratorNext(iteratorRecord);
}
catch (e) {
return promiseRejectedWith(e);
}
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 (e) {
return promiseRejectedWith(e);
}
if (returnMethod === undefined) {
return promiseResolvedWith(undefined);
}
let returnResult;
try {
returnResult = reflectCall(returnMethod, iterator, [reason]);
}
catch (e) {
return promiseRejectedWith(e);
}
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 undefined;
});
}
stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
return stream;
}
function ReadableStreamFromDefaultReader(reader) {
let stream;
const startAlgorithm = noop;
function pullAlgorithm() {
let readPromise;
try {
readPromise = reader.read();
}
catch (e) {
return promiseRejectedWith(e);
}
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 (e) {
return promiseRejectedWith(e);
}
}
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 === undefined ?
undefined :
convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),
cancel: cancel === undefined ?
undefined :
convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),
pull: pull === undefined ?
undefined :
convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),
start: start === undefined ?
undefined :
convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`),
type: type === undefined ? undefined : 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 !== undefined) {
assertAbortSignal(signal, `${context} has member 'signal' that`);
}
return {
preventAbort: Boolean(preventAbort),
preventCancel: Boolean(preventCancel),
preventClose: Boolean(preventClose),
signal
};
}
function assertAbortSignal(signal, context) {
if (!isAbortSignal(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 };
}
/**
* A readable stream represents a source of data, from which you can read.
*
* @public
*/
class ReadableStream {
constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
if (rawUnderlyingSource === undefined) {
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 !== undefined) {
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 = undefined) {
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 = undefined) {
if (!IsReadableStream(this)) {
throw streamBrandCheckException$1('getReader');
}
const options = convertReaderOptions(rawOptions, 'First parameter');
if (options.mode === undefined) {
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 === undefined) {
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 (e) {
return promiseRejectedWith(e);
}
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 = undefined) {
if (!IsReadableStream(this)) {
throw streamBrandCheckException$1('values');
}
const options = convertIteratorOptions(rawOptions, 'First parameter');
return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
}
[SymbolAsyncIterator](options) {
// Stub implementation, overridden below
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(ReadableStream, {
from: { enumerable: true }
});
Object.defineProperties(ReadableStream.prototype, {
cancel: { enumerable: true },
getReader: { enumerable: true },
pipeThrough: { enumerable: true },
pipeTo: { enumerable: true },
tee: { enumerable: true },
values: { enumerable: true },
locked: { enumerable: true }
});
setFunctionName(ReadableStream.from, 'from');
setFunctionName(ReadableStream.prototype.cancel, 'cancel');
setFunctionName(ReadableStream.prototype.getReader, 'getReader');
setFunctionName(ReadableStream.prototype.pipeThrough, 'pipeThrough');
setFunctionName(ReadableStream.prototype.pipeTo, 'pipeTo');
setFunctionName(ReadableStream.prototype.tee, 'tee');
setFunctionName(ReadableStream.prototype.values, 'values');
if (typeof Symbol.toStringTag === 'symbol') {
Object.defineProperty(ReadableStream.prototype, Symbol.toStringTag, {
value: 'ReadableStream',
configurable: true
});
}
Object.defineProperty(ReadableStream.prototype, SymbolAsyncIterator, {
value: ReadableStream.prototype.values,
writable: true,
configurable: true
});
// Abstract operations for the ReadableStream.
// Throws if and only if startAlgorithm throws.
function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
const stream = Object.create(ReadableStream.prototype);
InitializeReadableStream(stream);
const controller = Object.create(ReadableStreamDefaultController.prototype);
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
return stream;
}
// Throws if and only if startAlgorithm throws.
function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
const stream = Object.create(ReadableStream.prototype);
InitializeReadableStream(stream);
const controller = Object.create(ReadableByteStreamController.prototype);
SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
return stream;
}
function InitializeReadableStream(stream) {
stream._state = 'readable';
stream._reader = undefined;
stream._storedError = undefined;
stream._disturbed = false;
}
function IsReadableStream(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
return false;
}
return x instanceof ReadableStream;
}
function IsReadableStreamLocked(stream) {
if (stream._reader === undefined) {
return false;
}
return true;
}
// ReadableStream API exposed for controllers.
function ReadableStreamCancel(stream, reason) {
stream._disturbed = true;
if (stream._state === 'closed') {
return promiseResolvedWith(undefined);
}
if (stream._state === 'errored') {
return promiseRejectedWith(stream._storedError);
}
ReadableStreamClose(stream);
const reader = stream._reader;
if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
const readIntoRequests = reader._readIntoRequests;
reader._readIntoRequests = new SimpleQueue();
readIntoRequests.forEach(readIntoRequest => {
readIntoRequest._closeSteps(undefined);
});
}
const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
return transformPromiseWith(sourceCancelPromise, noop);
}
function ReadableStreamClose(stream) {
stream._state = 'closed';
const reader = stream._reader;
if (reader === undefined) {
return;
}
defaultReaderClosedPromiseResolve(reader);
if (IsReadableStreamDefaultReader(reader)) {
const readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue();
readRequests.forEach(readRequest => {
readRequest._closeSteps();
});
}
}
function ReadableStreamError(stream, e) {
stream._state = 'errored';
stream._storedError = e;
const reader = stream._reader;
if (reader === undefined) {
return;
}
defaultReaderClosedPromiseReject(reader, e);
if (IsReadableStreamDefaultReader(reader)) {
ReadableStreamDefaultReaderErrorReadRequests(reader, e);
}
else {
ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
}
}
// Helper functions for the ReadableStream.
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)
};
}
// The size function must not have a prototype property nor be a constructor
const byteLengthSizeFunction = (chunk) => {
return chunk.byteLength;
};
setFunctionName(byteLengthSizeFunction, 'size');
/**
* A queuing strategy that counts the number of bytes in each chunk.
*
* @public
*/
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
});
}
// Helper functions for the ByteLengthQueuingStrategy.
function byteLengthBrandCheckException(name) {
return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);
}
function IsByteLengthQueuingStrategy(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
return false;
}
return x instanceof ByteLengthQueuingStrategy;
}
// The size function must not have a prototype property nor be a constructor
const countSizeFunction = () => {
return 1;
};
setFunctionName(countSizeFunction, 'size');
/**
* A queuing strategy that counts the number of chunks.
*
* @public
*/
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
});
}
// Helper functions for the CountQueuingStrategy.
function countBrandCheckException(name) {
return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);
}
function IsCountQueuingStrategy(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
return false;
}
return x 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 === undefined ?
undefined :
convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
flush: flush === undefined ?
undefined :
convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
readableType,
start: start === undefined ?
undefined :
convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
transform: transform === undefined ?
undefined :
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
/**
* A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
* known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
* In a manner specific to the transform stream in question, writes to the writable side result in new data being
* made available for reading from the readable side.
*
* @public
*/
class TransformStream {
constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
if (rawTransformer === undefined) {
rawTransformer = null;
}
const writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');
const readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');
const transformer = convertTransformer(rawTransformer, 'First parameter');
if (transformer.readableType !== undefined) {
throw new RangeError('Invalid readableType specified');
}
if (transformer.writableType !== undefined) {
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 !== undefined) {
startPromise_resolve(transformer.start(this._transformStreamController));
}
else {
startPromise_resolve(undefined);
}
}
/**
* 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);
// The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
stream._backpressure = undefined;
stream._backpressureChangePromise = undefined;
stream._backpressureChangePromise_resolve = undefined;
TransformStreamSetBackpressure(stream, true);
stream._transformStreamController = undefined;
}
function IsTransformStream(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
return false;
}
return x instanceof TransformStream;
}
// This is a no-op if both sides are already errored.
function TransformStreamError(stream, e) {
ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
TransformStreamErrorWritableAndUnblockWrite(stream, e);
}
function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
TransformStreamUnblockWrite(stream);
}
function TransformStreamUnblockWrite(stream) {
if (stream._backpressure) {
// Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()
// cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time
// _backpressure is set.
TransformStreamSetBackpressure(stream, false);
}
}
function TransformStreamSetBackpressure(stream, backpressure) {
// Passes also when called during construction.
if (stream._backpressureChangePromise !== undefined) {
stream._backpressureChangePromise_resolve();
}
stream._backpressureChangePromise = newPromise(resolve => {
stream._backpressureChangePromise_resolve = resolve;
});
stream._backpressure = backpressure;
}
// Class TransformStreamDefaultController
/**
* Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
*
* @public
*/
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 = undefined) {
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 = undefined) {
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
});
}
// Transform Stream Default Controller Abstract Operations
function IsTransformStreamDefaultController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
return false;
}
return x 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 = undefined;
controller._finishPromise_resolve = undefined;
controller._finishPromise_reject = undefined;
}
function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
const controller = Object.create(TransformStreamDefaultController.prototype);
let transformAlgorithm;
let flushAlgorithm;
let cancelAlgorithm;
if (transformer.transform !== undefined) {
transformAlgorithm = chunk => transformer.transform(chunk, controller);
}
else {
transformAlgorithm = chunk => {
try {
TransformStreamDefaultControllerEnqueue(controller, chunk);
return promiseResolvedWith(undefined);
}
catch (transformResultE) {
return promiseRejectedWith(transformResultE);
}
};
}
if (transformer.flush !== undefined) {
flushAlgorithm = () => transformer.flush(controller);
}
else {
flushAlgorithm = () => promiseResolvedWith(undefined);
}
if (transformer.cancel !== undefined) {
cancelAlgorithm = reason => transformer.cancel(reason);
}
else {
cancelAlgorithm = () => promiseResolvedWith(undefined);
}
SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
}
function TransformStreamDefaultControllerClearAlgorithms(controller) {
controller._transformAlgorithm = undefined;
controller._flushAlgorithm = undefined;
controller._cancelAlgorithm = undefined;
}
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');
}
// We throttle transform invocations based on the backpressure of the ReadableStream, but we still
// accept TransformStreamDefaultControllerEnqueue() calls.
try {
ReadableStreamDefaultControllerEnqueue(readableController, chunk);
}
catch (e) {
// This happens when readableStrategy.size() throws.
TransformStreamErrorWritableAndUnblockWrite(stream, e);
throw stream._readable._storedError;
}
const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
if (backpressure !== stream._backpressure) {
TransformStreamSetBackpressure(stream, true);
}
}
function TransformStreamDefaultControllerError(controller, e) {
TransformStreamError(controller._controlledTransformStream, e);
}
function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
const transformPromise = controller._transformAlgorithm(chunk);
return transformPromiseWith(transformPromise, undefined, r => {
TransformStreamError(controller._controlledTransformStream, r);
throw r;
});
}
function TransformStreamDefaultControllerTerminate(controller) {
const stream = controller._controlledTransformStream;
const readableController = stream._readable._readableStreamController;
ReadableStreamDefaultControllerClose(readableController);
const error = new TypeError('TransformStream terminated');
TransformStreamErrorWritableAndUnblockWrite(stream, error);
}
// TransformStreamDefaultSink Algorithms
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 !== undefined) {
return controller._finishPromise;
}
// stream._readable cannot change after construction, so caching it across a call to user code is safe.
const readable = stream._readable;
// Assign the _finishPromise now so that if _cancelAlgorithm calls readable.cancel() internally,
// we don't run the _cancelAlgorithm again.
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;
}, r => {
ReadableStreamDefaultControllerError(readable._readableStreamController, r);
defaultControllerFinishPromiseReject(controller, r);
return null;
});
return controller._finishPromise;
}
function TransformStreamDefaultSinkCloseAlgorithm(stream) {
const controller = stream._transformStreamController;
if (controller._finishPromise !== undefined) {
return controller._finishPromise;
}
// stream._readable cannot change after construction, so caching it across a call to user code is safe.
const readable = stream._readable;
// Assign the _finishPromise now so that if _flushAlgorithm calls readable.cancel() internally,
// we don't also run the _cancelAlgorithm.
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;
}, r => {
ReadableStreamDefaultControllerError(readable._readableStreamController, r);
defaultControllerFinishPromiseReject(controller, r);
return null;
});
return controller._finishPromise;
}
// TransformStreamDefaultSource Algorithms
function TransformStreamDefaultSourcePullAlgorithm(stream) {
// Invariant. Enforced by the promises returned by start() and pull().
TransformStreamSetBackpressure(stream, false);
// Prevent the next pull() call until there is backpressure.
return stream._backpressureChangePromise;
}
function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
const controller = stream._transformStreamController;
if (controller._finishPromise !== undefined) {
return controller._finishPromise;
}
// stream._writable cannot change after construction, so caching it across a call to user code is safe.
const writable = stream._writable;
// Assign the _finishPromise now so that if _flushAlgorithm calls writable.abort() or
// writable.cancel() internally, we don't run the _cancelAlgorithm again, or also run the
// _flushAlgorithm.
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;
}, r => {
WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r);
TransformStreamUnblockWrite(stream);
defaultControllerFinishPromiseReject(controller, r);
return null;
});
return controller._finishPromise;
}
// Helper functions for the TransformStreamDefaultController.
function defaultControllerBrandCheckException(name) {
return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
}
function defaultControllerFinishPromiseResolve(controller) {
if (controller._finishPromise_resolve === undefined) {
return;
}
controller._finishPromise_resolve();
controller._finishPromise_resolve = undefined;
controller._finishPromise_reject = undefined;
}
function defaultControllerFinishPromiseReject(controller, reason) {
if (controller._finishPromise_reject === undefined) {
return;
}
setPromiseIsHandledToTrue(controller._finishPromise);
controller._finishPromise_reject(reason);
controller._finishPromise_resolve = undefined;
controller._finishPromise_reject = undefined;
}
// Helper functions for the TransformStream.
function streamBrandCheckException(name) {
return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
}
exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
exports.CountQueuingStrategy = CountQueuingStrategy;
exports.ReadableByteStreamController = ReadableByteStreamController;
exports.ReadableStream = ReadableStream;
exports.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
exports.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
exports.ReadableStreamDefaultController = ReadableStreamDefaultController;
exports.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
exports.TransformStream = TransformStream;
exports.TransformStreamDefaultController = TransformStreamDefaultController;
exports.WritableStream = WritableStream;
exports.WritableStreamDefaultController = WritableStreamDefaultController;
exports.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
}));
//# sourceMappingURL=ponyfill.es2018.js.map
/***/ }),
/***/ 181:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(181);
/***/ }),
/***/ 5317:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(5317);
/***/ }),
/***/ 6982:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(6982);
/***/ }),
/***/ 9896:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(9896);
/***/ }),
/***/ 8611:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(8611);
/***/ }),
/***/ 5692:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(5692);
/***/ }),
/***/ 1708:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(1708);
/***/ }),
/***/ 7830:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(7830);
/***/ }),
/***/ 857:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(857);
/***/ }),
/***/ 6928:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(6928);
/***/ }),
/***/ 3785:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(3785);
/***/ }),
/***/ 9023:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(9023);
/***/ }),
/***/ 8167:
/***/ ((module) => {
"use strict";
module.exports = __nccwpck_require__(8167);
/***/ }),
/***/ 1204:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require2_) => {
/* c8 ignore start */
// 64 KiB (same size chrome slice theirs blob into Uint8array's)
const POOL_SIZE = 65536
if (!globalThis.ReadableStream) {
// `node:stream/web` got introduced in v16.5.0 as experimental
// and it's preferred over the polyfilled version. So we also
// suppress the warning that gets emitted by NodeJS for using it.
try {
const process = __nccwpck_require2_(1708)
const { emitWarning } = process
try {
process.emitWarning = () => {}
Object.assign(globalThis, __nccwpck_require2_(7830))
process.emitWarning = emitWarning
} catch (error) {
process.emitWarning = emitWarning
throw error
}
} catch (error) {
// fallback to polyfill implementation
Object.assign(globalThis, __nccwpck_require2_(3585))
}
}
try {
// Don't use node: prefix for this, require+node: is not supported until node v14.14
// Only `import()` can use prefix in 12.20 and later
const { Blob } = __nccwpck_require2_(181)
if (Blob && !Blob.prototype.stream) {
Blob.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_SIZE))
const buffer = await chunk.arrayBuffer()
position += buffer.byteLength
ctrl.enqueue(new Uint8Array(buffer))
if (position === blob.size) {
ctrl.close()
}
}
})
}
}
} catch (error) {}
/* c8 ignore end */
/***/ }),
/***/ 4645:
/***/ ((__unused_webpack___webpack_module__, __nested_webpack_exports__, __nccwpck_require2_) => {
"use strict";
/* harmony export */ __nccwpck_require2_.d(__nested_webpack_exports__, {
/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* unused harmony export File */
/* harmony import */ var _index_js__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require2_(6327);
const _File = class File extends _index_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A {
#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 = {}
// Simulate WebIDL type casting for NaN value in lastModified option.
const lastModified = options.lastModified === undefined ? 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 _index_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A &&
/^(File)$/.test(object[Symbol.toStringTag])
}
}
/** @type {typeof globalThis.File} */// @ts-ignore
const File = _File
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (File);
/***/ }),
/***/ 9802:
/***/ ((__unused_webpack___webpack_module__, __nested_webpack_exports__, __nccwpck_require2_) => {
"use strict";
// EXPORTS
__nccwpck_require2_.d(__nested_webpack_exports__, {
YQ: () => (/* reexport */ fetch_blob/* default */.A),
ZH: () => (/* reexport */ file/* default */.A),
k4: () => (/* binding */ blobFrom),
F8: () => (/* binding */ blobFromSync),
NX: () => (/* binding */ fileFrom),
_M: () => (/* binding */ fileFromSync)
});
// UNUSED EXPORTS: default
;// CONCATENATED MODULE: external "node:fs"
const external_node_fs_namespaceObject = __nccwpck_require__(3024);
;// CONCATENATED MODULE: external "node:path"
const external_node_path_namespaceObject = __nccwpck_require__(6760);
// EXTERNAL MODULE: ./node_modules/node-domexception/index.js
var node_domexception = __nccwpck_require2_(7666);
// EXTERNAL MODULE: ./node_modules/fetch-blob/file.js
var file = __nccwpck_require2_(4645);
// EXTERNAL MODULE: ./node_modules/fetch-blob/index.js
var fetch_blob = __nccwpck_require2_(6327);
;// CONCATENATED MODULE: ./node_modules/fetch-blob/from.js
const { stat } = external_node_fs_namespaceObject.promises
/**
* @param {string} path filepath on the disk
* @param {string} [type] mimetype to use
*/
const blobFromSync = (path, type) => fromBlob((0,external_node_fs_namespaceObject.statSync)(path), path, type)
/**
* @param {string} path filepath on the disk
* @param {string} [type] mimetype to use
* @returns {Promise<Blob>}
*/
const blobFrom = (path, type) => stat(path).then(stat => fromBlob(stat, path, type))
/**
* @param {string} path filepath on the disk
* @param {string} [type] mimetype to use
* @returns {Promise<File>}
*/
const fileFrom = (path, type) => stat(path).then(stat => fromFile(stat, path, type))
/**
* @param {string} path filepath on the disk
* @param {string} [type] mimetype to use
*/
const fileFromSync = (path, type) => fromFile((0,external_node_fs_namespaceObject.statSync)(path), path, type)
// @ts-ignore
const fromBlob = (stat, path, type = '') => new fetch_blob/* default */.A([new BlobDataItem({
path,
size: stat.size,
lastModified: stat.mtimeMs,
start: 0
})], { type })
// @ts-ignore
const fromFile = (stat, path, type = '') => new file/* default */.A([new BlobDataItem({
path,
size: stat.size,
lastModified: stat.mtimeMs,
start: 0
})], (0,external_node_path_namespaceObject.basename)(path), { type, lastModified: stat.mtimeMs })
/**
* This is a blob backed up by a file on the disk
* with minium requirement. Its wrapped around a Blob as a blobPart
* so you have no direct access to this.
*
* @private
*/
class BlobDataItem {
#path
#start
constructor (options) {
this.#path = options.path
this.#start = options.start
this.size = options.size
this.lastModified = options.lastModified
}
/**
* Slicing arguments is first validated and formatted
* to not be out of range by Blob.prototype.slice
*/
slice (start, end) {
return new BlobDataItem({
path: this.#path,
lastModified: this.lastModified,
size: end - start,
start: this.#start + start
})
}
async * stream () {
const { mtimeMs } = await stat(this.#path)
if (mtimeMs > this.lastModified) {
throw new node_domexception('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')
}
yield * (0,external_node_fs_namespaceObject.createReadStream)(this.#path, {
start: this.#start,
end: this.#start + this.size - 1
})
}
get [Symbol.toStringTag] () {
return 'Blob'
}
}
/* harmony default export */ const from = ((/* unused pure expression or super */ null && (0)));
/***/ }),
/***/ 6327:
/***/ ((__unused_webpack___webpack_module__, __nested_webpack_exports__, __nccwpck_require2_) => {
"use strict";
/* harmony export */ __nccwpck_require2_.d(__nested_webpack_exports__, {
/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* unused harmony export Blob */
/* harmony import */ var _streams_cjs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require2_(1204);
/*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
// TODO (jimmywarting): in the feature use conditional loading with top level await (requires 14.x)
// Node has recently added whatwg stream into core
// 64 KiB (same size chrome slice theirs blob into Uint8array's)
const POOL_SIZE = 65536
/** @param {(Blob | Uint8Array)[]} parts */
async function * toIterator (parts, clone = true) {
for (const part of parts) {
if ('stream' in part) {
yield * (/** @type {AsyncIterableIterator<Uint8Array>} */ (part.stream()))
} else if (ArrayBuffer.isView(part)) {
if (clone) {
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
}
/* c8 ignore next 10 */
} else {
// For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
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)
}
}
}
}
const _Blob = class Blob {
/** @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 Blob) {
part = element
} else {
part = encoder.encode(`${element}`)
}
this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size
this.#parts.push(part)
}
this.#endings = `${options.endings === undefined ? 'transparent' : options.endings}`
const type = options.type === undefined ? '' : 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 () {
// More optimized than using this.arrayBuffer()
// that requires twice as much ram
const decoder = new TextDecoder()
let str = ''
for await (const part of toIterator(this.#parts, false)) {
str += decoder.decode(part, { stream: true })
}
// Remaining
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 () {
// Easier way... Just a unnecessary overhead
// const view = new Uint8Array(this.size);
// await this.stream().getReader({mode: 'byob'}).read(view);
// return view.buffer;
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) {
// don't add the overflow to new blobParts
if (added >= span) {
break
}
const size = ArrayBuffer.isView(part) ? part.byteLength : part.size
if (relativeStart && size <= relativeStart) {
// Skip the beginning and change the relative
// start & end position as we skip the unwanted parts
relativeStart -= size
relativeEnd -= size
} else {
let chunk
if (ArrayBuffer.isView(part)) {
chunk = part.subarray(relativeStart, Math.min(size, relativeEnd))
added += chunk.byteLength
} else {
chunk = part.slice(relativeStart, Math.min(size, relativeEnd))
added += chunk.size
}
relativeEnd -= size
blobParts.push(chunk)
relativeStart = 0 // All next sequential parts should start at 0
}
}
const blob = new Blob([], { 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 }
})
/** @type {typeof globalThis.Blob} */
const Blob = _Blob
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Blob);
/***/ }),
/***/ 3018:
/***/ ((__unused_webpack___webpack_module__, __nested_webpack_exports__, __nccwpck_require2_) => {
"use strict";
/* harmony export */ __nccwpck_require2_.d(__nested_webpack_exports__, {
/* harmony export */ $n: () => (/* binding */ formDataToBlob),
/* harmony export */ fS: () => (/* binding */ FormData)
/* harmony export */ });
/* unused harmony export File */
/* harmony import */ var fetch_blob__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require2_(6327);
/* harmony import */ var fetch_blob_file_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require2_(4645);
/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
var {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 fetch_blob_file_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A([b],c,b):b]:[a,b+'']),
e=(c,f)=>(f?c:c.replace(/\r?\n|\r/g,'\r\n')).replace(/\n/g,'%0A').replace(/\r/g,'%0D').replace(/"/g,'%22'),
x=(n, a, e)=>{if(a.length<e){throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`)}}
const File = (/* unused pure expression or super */ null && (0))
/** @type {typeof globalThis.FormData} */
const FormData = class FormData {
#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(m=>typeof o[m]!='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=!0;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}}
/** @param {FormData} F */
function formDataToBlob (F,B=fetch_blob__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A){
var b=`${r()}${r()}`.replace(/\./g, '').slice(-28).padStart(32, '-'),c=[],p=`--${b}\r\nContent-Disposition: form-data; name="`
F.forEach((v,n)=>typeof v=='string'
?c.push(p+e(n)+`"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`)
:c.push(p+e(n)+`"; filename="${e(v.name, 1)}"\r\nContent-Type: ${v.type||"application/octet-stream"}\r\n\r\n`, v, '\r\n'))
c.push(`--${b}--`)
return new B(c,{type:"multipart/form-data; boundary="+b})}
/***/ }),
/***/ 1485:
/***/ ((__unused_webpack___webpack_module__, __nested_webpack_exports__, __nccwpck_require2_) => {
"use strict";
// ESM COMPAT FLAG
__nccwpck_require2_.r(__nested_webpack_exports__);
// EXPORTS
__nccwpck_require2_.d(__nested_webpack_exports__, {
AbortError: () => (/* reexport */ AbortError),
Blob: () => (/* reexport */ from/* Blob */.YQ),
FetchError: () => (/* reexport */ FetchError),
File: () => (/* reexport */ from/* File */.ZH),
FormData: () => (/* reexport */ esm_min/* FormData */.fS),
Headers: () => (/* reexport */ Headers),
Request: () => (/* reexport */ Request),
Response: () => (/* reexport */ Response),
blobFrom: () => (/* reexport */ from/* blobFrom */.k4),
blobFromSync: () => (/* reexport */ from/* blobFromSync */.F8),
"default": () => (/* binding */ fetch),
fileFrom: () => (/* reexport */ from/* fileFrom */.NX),
fileFromSync: () => (/* reexport */ from/* fileFromSync */._M),
isRedirect: () => (/* reexport */ isRedirect)
});
;// CONCATENATED MODULE: external "node:http"
const external_node_http_namespaceObject = __nccwpck_require__(7067);
;// CONCATENATED MODULE: external "node:https"
const external_node_https_namespaceObject = __nccwpck_require__(4708);
;// CONCATENATED MODULE: external "node:zlib"
const external_node_zlib_namespaceObject = __nccwpck_require__(8522);
;// CONCATENATED MODULE: external "node:stream"
const external_node_stream_namespaceObject = __nccwpck_require__(7075);
;// CONCATENATED MODULE: external "node:buffer"
const external_node_buffer_namespaceObject = __nccwpck_require__(4573);
;// CONCATENATED MODULE: ./node_modules/data-uri-to-buffer/dist/index.js
/**
* Returns a `Buffer` instance from the given data URI `uri`.
*
* @param {String} uri Data URI to turn into a Buffer instance
* @returns {Buffer} Buffer instance from Data URI
* @api public
*/
function dataUriToBuffer(uri) {
if (!/^data:/i.test(uri)) {
throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
}
// strip newlines
uri = uri.replace(/\r?\n/g, '');
// split the URI up into the "metadata" and the "data" portions
const firstComma = uri.indexOf(',');
if (firstComma === -1 || firstComma <= 4) {
throw new TypeError('malformed data: URI');
}
// remove the "data:" scheme and parse the metadata
const meta = uri.substring(5, firstComma).split(';');
let charset = '';
let base64 = false;
const type = meta[0] || 'text/plain';
let typeFull = type;
for (let i = 1; i < meta.length; i++) {
if (meta[i] === 'base64') {
base64 = true;
}
else if (meta[i]) {
typeFull += `;${meta[i]}`;
if (meta[i].indexOf('charset=') === 0) {
charset = meta[i].substring(8);
}
}
}
// defaults to US-ASCII only if type is not provided
if (!meta[0] && !charset.length) {
typeFull += ';charset=US-ASCII';
charset = 'US-ASCII';
}
// get the encoded data portion and decode URI-encoded chars
const encoding = base64 ? 'base64' : 'ascii';
const data = unescape(uri.substring(firstComma + 1));
const buffer = Buffer.from(data, encoding);
// set `.type` and `.typeFull` properties to MIME type
buffer.type = type;
buffer.typeFull = typeFull;
// set the `.charset` property
buffer.charset = charset;
return buffer;
}
/* harmony default export */ const dist = (dataUriToBuffer);
//# sourceMappingURL=index.js.map
;// CONCATENATED MODULE: external "node:util"
const external_node_util_namespaceObject = __nccwpck_require__(7975);
// EXTERNAL MODULE: ./node_modules/fetch-blob/index.js
var fetch_blob = __nccwpck_require2_(6327);
// EXTERNAL MODULE: ./node_modules/formdata-polyfill/esm.min.js
var esm_min = __nccwpck_require2_(3018);
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/errors/base.js
class FetchBaseError extends Error {
constructor(message, type) {
super(message);
// Hide custom error implementation details from end-users
Error.captureStackTrace(this, this.constructor);
this.type = type;
}
get name() {
return this.constructor.name;
}
get [Symbol.toStringTag]() {
return this.constructor.name;
}
}
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/errors/fetch-error.js
/**
* @typedef {{ address?: string, code: string, dest?: string, errno: number, info?: object, message: string, path?: string, port?: number, syscall: string}} SystemError
*/
/**
* FetchError interface for operational errors
*/
class FetchError 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);
// When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
if (systemError) {
// eslint-disable-next-line no-multi-assign
this.code = this.errno = systemError.code;
this.erroredSysCall = systemError.syscall;
}
}
}
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/utils/is.js
/**
* Is.js
*
* Object type checks.
*/
const NAME = Symbol.toStringTag;
/**
* Check if `obj` is a URLSearchParams object
* ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
* @param {*} object - Object to check for
* @return {boolean}
*/
const 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'
);
};
/**
* Check if `object` is a W3C `Blob` object (which `File` inherits from)
* @param {*} object - Object to check for
* @return {boolean}
*/
const 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])
);
};
/**
* Check if `obj` is an instance of AbortSignal.
* @param {*} object - Object to check for
* @return {boolean}
*/
const isAbortSignal = object => {
return (
typeof object === 'object' && (
object[NAME] === 'AbortSignal' ||
object[NAME] === 'EventTarget'
)
);
};
/**
* isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
* the parent domain.
*
* Both domains must already be in canonical form.
* @param {string|URL} original
* @param {string|URL} destination
*/
const isDomainOrSubdomain = (destination, original) => {
const orig = new URL(original).hostname;
const dest = new URL(destination).hostname;
return orig === dest || orig.endsWith(`.${dest}`);
};
/**
* isSameProtocol reports whether the two provided URLs use the same protocol.
*
* Both domains must already be in canonical form.
* @param {string|URL} original
* @param {string|URL} destination
*/
const isSameProtocol = (destination, original) => {
const orig = new URL(original).protocol;
const dest = new URL(destination).protocol;
return orig === dest;
};
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/body.js
/**
* Body.js
*
* Body interface provides common methods for Request and Response
*/
const pipeline = (0,external_node_util_namespaceObject.promisify)(external_node_stream_namespaceObject.pipeline);
const INTERNALS = Symbol('Body internals');
/**
* Body mixin
*
* Ref: https://fetch.spec.whatwg.org/#body
*
* @param Stream body Readable stream
* @param Object opts Response options
* @return Void
*/
class Body {
constructor(body, {
size = 0
} = {}) {
let boundary = null;
if (body === null) {
// Body is undefined or null
body = null;
} else if (isURLSearchParameters(body)) {
// Body is a URLSearchParams
body = external_node_buffer_namespaceObject.Buffer.from(body.toString());
} else if (isBlob(body)) {
// Body is blob
} else if (external_node_buffer_namespaceObject.Buffer.isBuffer(body)) {
// Body is Buffer
} else if (external_node_util_namespaceObject.types.isAnyArrayBuffer(body)) {
// Body is ArrayBuffer
body = external_node_buffer_namespaceObject.Buffer.from(body);
} else if (ArrayBuffer.isView(body)) {
// Body is ArrayBufferView
body = external_node_buffer_namespaceObject.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
} else if (body instanceof external_node_stream_namespaceObject) {
// Body is stream
} else if (body instanceof esm_min/* FormData */.fS) {
// Body is FormData
body = (0,esm_min/* formDataToBlob */.$n)(body);
boundary = body.type.split('=')[1];
} else {
// None of the above
// coerce to string then buffer
body = external_node_buffer_namespaceObject.Buffer.from(String(body));
}
let stream = body;
if (external_node_buffer_namespaceObject.Buffer.isBuffer(body)) {
stream = external_node_stream_namespaceObject.Readable.from(body);
} else if (isBlob(body)) {
stream = external_node_stream_namespaceObject.Readable.from(body.stream());
}
this[INTERNALS] = {
body,
stream,
boundary,
disturbed: false,
error: null
};
this.size = size;
if (body instanceof external_node_stream_namespaceObject) {
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 esm_min/* FormData */.fS();
const parameters = new URLSearchParams(await this.text());
for (const [name, value] of parameters) {
formData.append(name, value);
}
return formData;
}
const {toFormData} = await __nccwpck_require2_.e(/* import() */ 101).then(__nccwpck_require2_.bind(__nccwpck_require2_, 9101));
return toFormData(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 */.A([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,external_node_util_namespaceObject.deprecate)(Body.prototype.buffer, 'Please use \'response.arrayBuffer()\' instead of \'response.buffer()\'', 'node-fetch#buffer');
// In browsers, all properties are enumerable.
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,external_node_util_namespaceObject.deprecate)(() => {},
'data doesn\'t exist, use json(), text(), arrayBuffer(), or body instead',
'https://github.com/node-fetch/node-fetch/issues/1000 (response)')}
});
/**
* Consume and convert an entire Body to a Buffer.
*
* Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
*
* @return Promise
*/
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;
// Body is null
if (body === null) {
return external_node_buffer_namespaceObject.Buffer.alloc(0);
}
/* c8 ignore next 3 */
if (!(body instanceof external_node_stream_namespaceObject)) {
return external_node_buffer_namespaceObject.Buffer.alloc(0);
}
// Body is stream
// get ready to actually consume the body
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 external_node_buffer_namespaceObject.Buffer.from(accum.join(''));
}
return external_node_buffer_namespaceObject.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}`);
}
}
/**
* Clone body given Res/Req instance
*
* @param Mixed instance Response or Request instance
* @param String highWaterMark highWaterMark for both PassThrough body streams
* @return Mixed
*/
const clone = (instance, highWaterMark) => {
let p1;
let p2;
let {body} = instance[INTERNALS];
// Don't allow cloning a used body
if (instance.bodyUsed) {
throw new Error('cannot clone body after it is used');
}
// Check that body is a stream and not form-data object
// note: we can't clone the form-data object without having it as a dependency
if ((body instanceof external_node_stream_namespaceObject) && (typeof body.getBoundary !== 'function')) {
// Tee instance body
p1 = new external_node_stream_namespaceObject.PassThrough({highWaterMark});
p2 = new external_node_stream_namespaceObject.PassThrough({highWaterMark});
body.pipe(p1);
body.pipe(p2);
// Set instance body to teed body and return the other teed body
instance[INTERNALS].stream = p1;
body = p2;
}
return body;
};
const getNonSpecFormDataBoundary = (0,external_node_util_namespaceObject.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'
);
/**
* Performs the operation "extract a `Content-Type` value from |object|" as
* specified in the specification:
* https://fetch.spec.whatwg.org/#concept-bodyinit-extract
*
* This function assumes that instance.body is present.
*
* @param {any} body Any options.body input
* @returns {string | null}
*/
const extractContentType = (body, request) => {
// Body is null or undefined
if (body === null) {
return null;
}
// Body is string
if (typeof body === 'string') {
return 'text/plain;charset=UTF-8';
}
// Body is a URLSearchParams
if (isURLSearchParameters(body)) {
return 'application/x-www-form-urlencoded;charset=UTF-8';
}
// Body is blob
if (isBlob(body)) {
return body.type || null;
}
// Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
if (external_node_buffer_namespaceObject.Buffer.isBuffer(body) || external_node_util_namespaceObject.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
return null;
}
if (body instanceof esm_min/* FormData */.fS) {
return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
}
// Detect form data input from form-data module
if (body && typeof body.getBoundary === 'function') {
return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
}
// Body is stream - can't really do much about this
if (body instanceof external_node_stream_namespaceObject) {
return null;
}
// Body constructor defaults other things to string
return 'text/plain;charset=UTF-8';
};
/**
* The Fetch Standard treats this as if "total bytes" is a property on the body.
* For us, we have to explicitly get it with a function.
*
* ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
*
* @param {any} obj.body Body object from the Body instance.
* @returns {number | null}
*/
const getTotalBytes = request => {
const {body} = request[INTERNALS];
// Body is null or undefined
if (body === null) {
return 0;
}
// Body is Blob
if (isBlob(body)) {
return body.size;
}
// Body is Buffer
if (external_node_buffer_namespaceObject.Buffer.isBuffer(body)) {
return body.length;
}
// Detect form data input from form-data module
if (body && typeof body.getLengthSync === 'function') {
return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
}
// Body is stream
return null;
};
/**
* Write a Body to a Node.js WritableStream (e.g. http.Request) object.
*
* @param {Stream.Writable} dest The stream to write to.
* @param obj.body Body object from the Body instance.
* @returns {Promise<void>}
*/
const writeToStream = async (dest, {body}) => {
if (body === null) {
// Body is null
dest.end();
} else {
// Body is stream
await pipeline(body, dest);
}
};
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/headers.js
/**
* Headers.js
*
* Headers class offers convenient helpers
*/
/* c8 ignore next 9 */
const validateHeaderName = typeof external_node_http_namespaceObject.validateHeaderName === 'function' ?
external_node_http_namespaceObject.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;
}
};
/* c8 ignore next 9 */
const validateHeaderValue = typeof external_node_http_namespaceObject.validateHeaderValue === 'function' ?
external_node_http_namespaceObject.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;
}
};
/**
* @typedef {Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>} HeadersInit
*/
/**
* This Fetch API interface allows you to perform various actions on HTTP request and response headers.
* These actions include retrieving, setting, adding to, and removing.
* A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
* You can add to this using methods like append() (see Examples.)
* In all methods of this interface, header names are matched by case-insensitive byte sequence.
*
*/
class Headers extends URLSearchParams {
/**
* Headers class
*
* @constructor
* @param {HeadersInit} [init] - Response headers
*/
constructor(init) {
// Validate and normalize init object in [name, value(s)][]
/** @type {string[][]} */
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) { // eslint-disable-line no-eq-null, eqeqeq
// No op
} else if (typeof init === 'object' && !external_node_util_namespaceObject.types.isBoxedPrimitive(init)) {
const method = init[Symbol.iterator];
// eslint-disable-next-line no-eq-null, eqeqeq
if (method == null) {
// Record<ByteString, ByteString>
result.push(...Object.entries(init));
} else {
if (typeof method !== 'function') {
throw new TypeError('Header pairs must be iterable');
}
// Sequence<sequence<ByteString>>
// Note: per spec we have to first exhaust the lists then process them
result = [...init]
.map(pair => {
if (
typeof pair !== 'object' || external_node_util_namespaceObject.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>)');
}
// Validate and lowercase
result =
result.length > 0 ?
result.map(([name, value]) => {
validateHeaderName(name);
validateHeaderValue(name, String(value));
return [String(name).toLowerCase(), String(value)];
}) :
undefined;
super(result);
// Returning a Proxy that will lowercase key names, validate parameters and sort keys
// eslint-disable-next-line no-constructor-return
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);
}
}
});
/* c8 ignore next */
}
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 = undefined) {
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);
// Http.request() only supports string as Host header.
// This hack makes specifying custom Host header possible.
if (key === 'host') {
result[key] = values[0];
} else {
result[key] = values.length > 1 ? values : values[0];
}
return result;
}, {});
}
}
/**
* Re-shaping object for Web IDL tests
* Only need to do it for overridden methods
*/
Object.defineProperties(
Headers.prototype,
['get', 'entries', 'forEach', 'values'].reduce((result, property) => {
result[property] = {enumerable: true};
return result;
}, {})
);
/**
* Create a Headers object from an http.IncomingMessage.rawHeaders, ignoring those that do
* not conform to HTTP grammar productions.
* @param {import('http').IncomingMessage['rawHeaders']} headers
*/
function fromRawHeaders(headers = []) {
return new Headers(
headers
// Split into pairs
.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;
}
})
);
}
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/utils/is-redirect.js
const redirectStatus = new Set([301, 302, 303, 307, 308]);
/**
* Redirect code matching
*
* @param {number} code - Status code
* @return {boolean}
*/
const isRedirect = code => {
return redirectStatus.has(code);
};
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/response.js
/**
* Response.js
*
* Response class provides content decoding
*/
const response_INTERNALS = Symbol('Response internals');
/**
* Response class
*
* Ref: https://fetch.spec.whatwg.org/#response-class
*
* @param Stream body Readable stream
* @param Object opts Response options
* @return Void
*/
class Response extends Body {
constructor(body = null, options = {}) {
super(body, options);
// eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
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[response_INTERNALS] = {
type: 'default',
url: options.url,
status,
statusText: options.statusText || '',
headers,
counter: options.counter,
highWaterMark: options.highWaterMark
};
}
get type() {
return this[response_INTERNALS].type;
}
get url() {
return this[response_INTERNALS].url || '';
}
get status() {
return this[response_INTERNALS].status;
}
/**
* Convenience property representing if the request ended normally
*/
get ok() {
return this[response_INTERNALS].status >= 200 && this[response_INTERNALS].status < 300;
}
get redirected() {
return this[response_INTERNALS].counter > 0;
}
get statusText() {
return this[response_INTERNALS].statusText;
}
get headers() {
return this[response_INTERNALS].headers;
}
get highWaterMark() {
return this[response_INTERNALS].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[response_INTERNALS].type = 'error';
return response;
}
static json(data = undefined, init = {}) {
const body = JSON.stringify(data);
if (body === undefined) {
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}
});
;// CONCATENATED MODULE: external "node:url"
const external_node_url_namespaceObject = __nccwpck_require__(3136);
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/utils/get-search.js
const 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] === '?' ? '?' : '';
};
;// CONCATENATED MODULE: external "node:net"
const external_node_net_namespaceObject = __nccwpck_require__(7030);
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/utils/referrer.js
/**
* @external URL
* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URL|URL}
*/
/**
* @module utils/referrer
* @private
*/
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#strip-url|Referrer Policy §8.4. Strip url for use as a referrer}
* @param {string} URL
* @param {boolean} [originOnly=false]
*/
function stripURLForUseAsAReferrer(url, originOnly = false) {
// 1. If url is null, return no referrer.
if (url == null) { // eslint-disable-line no-eq-null, eqeqeq
return 'no-referrer';
}
url = new URL(url);
// 2. If url's scheme is a local scheme, then return no referrer.
if (/^(about|blob|data):$/.test(url.protocol)) {
return 'no-referrer';
}
// 3. Set url's username to the empty string.
url.username = '';
// 4. Set url's password to null.
// Note: `null` appears to be a mistake as this actually results in the password being `"null"`.
url.password = '';
// 5. Set url's fragment to null.
// Note: `null` appears to be a mistake as this actually results in the fragment being `"#null"`.
url.hash = '';
// 6. If the origin-only flag is true, then:
if (originOnly) {
// 6.1. Set url's path to null.
// Note: `null` appears to be a mistake as this actually results in the path being `"/null"`.
url.pathname = '';
// 6.2. Set url's query to null.
// Note: `null` appears to be a mistake as this actually results in the query being `"?null"`.
url.search = '';
}
// 7. Return url.
return url;
}
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#enumdef-referrerpolicy|enum ReferrerPolicy}
*/
const ReferrerPolicy = new Set([
'',
'no-referrer',
'no-referrer-when-downgrade',
'same-origin',
'origin',
'strict-origin',
'origin-when-cross-origin',
'strict-origin-when-cross-origin',
'unsafe-url'
]);
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#default-referrer-policy|default referrer policy}
*/
const DEFAULT_REFERRER_POLICY = 'strict-origin-when-cross-origin';
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#referrer-policies|Referrer Policy §3. Referrer Policies}
* @param {string} referrerPolicy
* @returns {string} referrerPolicy
*/
function validateReferrerPolicy(referrerPolicy) {
if (!ReferrerPolicy.has(referrerPolicy)) {
throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
}
return referrerPolicy;
}
/**
* @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy|Referrer Policy §3.2. Is origin potentially trustworthy?}
* @param {external:URL} url
* @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
*/
function isOriginPotentiallyTrustworthy(url) {
// 1. If origin is an opaque origin, return "Not Trustworthy".
// Not applicable
// 2. Assert: origin is a tuple origin.
// Not for implementations
// 3. If origin's scheme is either "https" or "wss", return "Potentially Trustworthy".
if (/^(http|ws)s:$/.test(url.protocol)) {
return true;
}
// 4. If origin's host component matches one of the CIDR notations 127.0.0.0/8 or ::1/128 [RFC4632], return "Potentially Trustworthy".
const hostIp = url.host.replace(/(^\[)|(]$)/g, '');
const hostIPVersion = (0,external_node_net_namespaceObject.isIP)(hostIp);
if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
return true;
}
if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
return true;
}
// 5. If origin's host component is "localhost" or falls within ".localhost", and the user agent conforms to the name resolution rules in [let-localhost-be-localhost], return "Potentially Trustworthy".
// We are returning FALSE here because we cannot ensure conformance to
// let-localhost-be-loalhost (https://tools.ietf.org/html/draft-west-let-localhost-be-localhost)
if (url.host === 'localhost' || url.host.endsWith('.localhost')) {
return false;
}
// 6. If origin's scheme component is file, return "Potentially Trustworthy".
if (url.protocol === 'file:') {
return true;
}
// 7. If origin's scheme component is one which the user agent considers to be authenticated, return "Potentially Trustworthy".
// Not supported
// 8. If origin has been configured as a trustworthy origin, return "Potentially Trustworthy".
// Not supported
// 9. Return "Not Trustworthy".
return false;
}
/**
* @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy|Referrer Policy §3.3. Is url potentially trustworthy?}
* @param {external:URL} url
* @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
*/
function isUrlPotentiallyTrustworthy(url) {
// 1. If url is "about:blank" or "about:srcdoc", return "Potentially Trustworthy".
if (/^about:(blank|srcdoc)$/.test(url)) {
return true;
}
// 2. If url's scheme is "data", return "Potentially Trustworthy".
if (url.protocol === 'data:') {
return true;
}
// Note: The origin of blob: and filesystem: URLs is the origin of the context in which they were
// created. Therefore, blobs created in a trustworthy origin will themselves be potentially
// trustworthy.
if (/^(blob|filesystem):$/.test(url.protocol)) {
return true;
}
// 3. Return the result of executing §3.2 Is origin potentially trustworthy? on url's origin.
return isOriginPotentiallyTrustworthy(url);
}
/**
* Modifies the referrerURL to enforce any extra security policy considerations.
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
* @callback module:utils/referrer~referrerURLCallback
* @param {external:URL} referrerURL
* @returns {external:URL} modified referrerURL
*/
/**
* Modifies the referrerOrigin to enforce any extra security policy considerations.
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
* @callback module:utils/referrer~referrerOriginCallback
* @param {external:URL} referrerOrigin
* @returns {external:URL} modified referrerOrigin
*/
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}
* @param {Request} request
* @param {object} o
* @param {module:utils/referrer~referrerURLCallback} o.referrerURLCallback
* @param {module:utils/referrer~referrerOriginCallback} o.referrerOriginCallback
* @returns {external:URL} Request's referrer
*/
function determineRequestsReferrer(request, {referrerURLCallback, referrerOriginCallback} = {}) {
// There are 2 notes in the specification about invalid pre-conditions. We return null, here, for
// these cases:
// > Note: If request's referrer is "no-referrer", Fetch will not call into this algorithm.
// > Note: If request's referrer policy is the empty string, Fetch will not call into this
// > algorithm.
if (request.referrer === 'no-referrer' || request.referrerPolicy === '') {
return null;
}
// 1. Let policy be request's associated referrer policy.
const policy = request.referrerPolicy;
// 2. Let environment be request's client.
// not applicable to node.js
// 3. Switch on request's referrer:
if (request.referrer === 'about:client') {
return 'no-referrer';
}
// "a URL": Let referrerSource be request's referrer.
const referrerSource = request.referrer;
// 4. Let request's referrerURL be the result of stripping referrerSource for use as a referrer.
let referrerURL = stripURLForUseAsAReferrer(referrerSource);
// 5. Let referrerOrigin be the result of stripping referrerSource for use as a referrer, with the
// origin-only flag set to true.
let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
// 6. If the result of serializing referrerURL is a string whose length is greater than 4096, set
// referrerURL to referrerOrigin.
if (referrerURL.toString().length > 4096) {
referrerURL = referrerOrigin;
}
// 7. The user agent MAY alter referrerURL or referrerOrigin at this point to enforce arbitrary
// policy considerations in the interests of minimizing data leakage. For example, the user
// agent could strip the URL down to an origin, modify its host, replace it with an empty
// string, etc.
if (referrerURLCallback) {
referrerURL = referrerURLCallback(referrerURL);
}
if (referrerOriginCallback) {
referrerOrigin = referrerOriginCallback(referrerOrigin);
}
// 8.Execute the statements corresponding to the value of policy:
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':
// 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
// potentially trustworthy URL, then return no referrer.
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
return 'no-referrer';
}
// 2. Return referrerOrigin.
return referrerOrigin.toString();
case 'strict-origin-when-cross-origin':
// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
// return referrerURL.
if (referrerURL.origin === currentURL.origin) {
return referrerURL;
}
// 2. If referrerURL is a potentially trustworthy URL and request's current URL is not a
// potentially trustworthy URL, then return no referrer.
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
return 'no-referrer';
}
// 3. Return referrerOrigin.
return referrerOrigin;
case 'same-origin':
// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
// return referrerURL.
if (referrerURL.origin === currentURL.origin) {
return referrerURL;
}
// 2. Return no referrer.
return 'no-referrer';
case 'origin-when-cross-origin':
// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
// return referrerURL.
if (referrerURL.origin === currentURL.origin) {
return referrerURL;
}
// Return referrerOrigin.
return referrerOrigin;
case 'no-referrer-when-downgrade':
// 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
// potentially trustworthy URL, then return no referrer.
if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
return 'no-referrer';
}
// 2. Return referrerURL.
return referrerURL;
default:
throw new TypeError(`Invalid referrerPolicy: ${policy}`);
}
}
/**
* @see {@link https://w3c.github.io/webappsec-referrer-policy/#parse-referrer-policy-from-header|Referrer Policy §8.1. Parse a referrer policy from a Referrer-Policy header}
* @param {Headers} headers Response headers
* @returns {string} policy
*/
function parseReferrerPolicyFromHeader(headers) {
// 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy`
// and response’s header list.
const policyTokens = (headers.get('referrer-policy') || '').split(/[,\s]+/);
// 2. Let policy be the empty string.
let policy = '';
// 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty
// string, then set policy to token.
// Note: This algorithm loops over multiple policy values to allow deployment of new policy
// values with fallbacks for older user agents, as described in § 11.1 Unknown Policy Values.
for (const token of policyTokens) {
if (token && ReferrerPolicy.has(token)) {
policy = token;
}
}
// 4. Return policy.
return policy;
}
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/request.js
/**
* Request.js
*
* Request class contains server only options
*
* All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
*/
const request_INTERNALS = Symbol('Request internals');
/**
* Check if `obj` is an instance of Request.
*
* @param {*} object
* @return {boolean}
*/
const isRequest = object => {
return (
typeof object === 'object' &&
typeof object[request_INTERNALS] === 'object'
);
};
const doBadDataWarn = (0,external_node_util_namespaceObject.deprecate)(() => {},
'.data is not a valid RequestInit property, use .body instead',
'https://github.com/node-fetch/node-fetch/issues/1000 (request)');
/**
* Request class
*
* Ref: https://fetch.spec.whatwg.org/#request-class
*
* @param Mixed input Url or Request instance
* @param Object init Custom options
* @return Void
*/
class Request extends Body {
constructor(input, init = {}) {
let parsedURL;
// Normalize input and force URL to be encoded as UTF-8 (https://github.com/node-fetch/node-fetch/issues/245)
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();
}
// eslint-disable-next-line no-eq-null, eqeqeq
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;
}
// eslint-disable-next-line no-eq-null, eqeqeq
if (signal != null && !isAbortSignal(signal)) {
throw new TypeError('Expected signal to be an instanceof AbortSignal or EventTarget');
}
// §5.4, Request constructor steps, step 15.1
// eslint-disable-next-line no-eq-null, eqeqeq
let referrer = init.referrer == null ? input.referrer : init.referrer;
if (referrer === '') {
// §5.4, Request constructor steps, step 15.2
referrer = 'no-referrer';
} else if (referrer) {
// §5.4, Request constructor steps, step 15.3.1, 15.3.2
const parsedReferrer = new URL(referrer);
// §5.4, Request constructor steps, step 15.3.3, 15.3.4
referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? 'client' : parsedReferrer;
} else {
referrer = undefined;
}
this[request_INTERNALS] = {
method,
redirect: init.redirect || input.redirect || 'follow',
headers,
parsedURL,
signal,
referrer
};
// Node-fetch-only options
this.follow = init.follow === undefined ? (input.follow === undefined ? 20 : input.follow) : init.follow;
this.compress = init.compress === undefined ? (input.compress === undefined ? 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;
// §5.4, Request constructor steps, step 16.
// Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || '';
}
/** @returns {string} */
get method() {
return this[request_INTERNALS].method;
}
/** @returns {string} */
get url() {
return (0,external_node_url_namespaceObject.format)(this[request_INTERNALS].parsedURL);
}
/** @returns {Headers} */
get headers() {
return this[request_INTERNALS].headers;
}
get redirect() {
return this[request_INTERNALS].redirect;
}
/** @returns {AbortSignal} */
get signal() {
return this[request_INTERNALS].signal;
}
// https://fetch.spec.whatwg.org/#dom-request-referrer
get referrer() {
if (this[request_INTERNALS].referrer === 'no-referrer') {
return '';
}
if (this[request_INTERNALS].referrer === 'client') {
return 'about:client';
}
if (this[request_INTERNALS].referrer) {
return this[request_INTERNALS].referrer.toString();
}
return undefined;
}
get referrerPolicy() {
return this[request_INTERNALS].referrerPolicy;
}
set referrerPolicy(referrerPolicy) {
this[request_INTERNALS].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}
});
/**
* Convert a Request to Node.js http request options.
*
* @param {Request} request - A Request instance
* @return The options object to be passed to http.request
*/
const getNodeRequestOptions = request => {
const {parsedURL} = request[request_INTERNALS];
const headers = new Headers(request[request_INTERNALS].headers);
// Fetch step 1.3
if (!headers.has('Accept')) {
headers.set('Accept', '*/*');
}
// HTTP-network-or-cache fetch steps 2.4-2.7
let contentLengthValue = null;
if (request.body === null && /^(post|put)$/i.test(request.method)) {
contentLengthValue = '0';
}
if (request.body !== null) {
const totalBytes = getTotalBytes(request);
// Set Content-Length if totalBytes is a number (that is not NaN)
if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
contentLengthValue = String(totalBytes);
}
}
if (contentLengthValue) {
headers.set('Content-Length', contentLengthValue);
}
// 4.1. Main fetch, step 2.6
// > If request's referrer policy is the empty string, then set request's referrer policy to the
// > default referrer policy.
if (request.referrerPolicy === '') {
request.referrerPolicy = DEFAULT_REFERRER_POLICY;
}
// 4.1. Main fetch, step 2.7
// > If request's referrer is not "no-referrer", set request's referrer to the result of invoking
// > determine request's referrer.
if (request.referrer && request.referrer !== 'no-referrer') {
request[request_INTERNALS].referrer = determineRequestsReferrer(request);
} else {
request[request_INTERNALS].referrer = 'no-referrer';
}
// 4.5. HTTP-network-or-cache fetch, step 6.9
// > If httpRequest's referrer is a URL, then append `Referer`/httpRequest's referrer, serialized
// > and isomorphic encoded, to httpRequest's header list.
if (request[request_INTERNALS].referrer instanceof URL) {
headers.set('Referer', request.referrer);
}
// HTTP-network-or-cache fetch step 2.11
if (!headers.has('User-Agent')) {
headers.set('User-Agent', 'node-fetch');
}
// HTTP-network-or-cache fetch step 2.15
if (request.compress && !headers.has('Accept-Encoding')) {
headers.set('Accept-Encoding', 'gzip, deflate, br');
}
let {agent} = request;
if (typeof agent === 'function') {
agent = agent(parsedURL);
}
// HTTP-network fetch step 4.2
// chunked encoding is handled by Node.js
const search = getSearch(parsedURL);
// Pass the full URL directly to request(), but overwrite the following
// options:
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
};
};
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/errors/abort-error.js
/**
* AbortError interface for cancelled requests
*/
class AbortError extends FetchBaseError {
constructor(message, type = 'aborted') {
super(message, type);
}
}
// EXTERNAL MODULE: ./node_modules/fetch-blob/from.js + 2 modules
var from = __nccwpck_require2_(9802);
;// CONCATENATED MODULE: ./node_modules/node-fetch/src/index.js
/**
* Index.js
*
* a request API compatible with window.fetch
*
* All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
*/
const supportedSchemas = new Set(['data:', 'http:', 'https:']);
/**
* Fetch function
*
* @param {string | URL | import('./request').default} url - Absolute url or Request instance
* @param {*} [options_] - Fetch options
* @return {Promise<import('./response').default>}
*/
async function fetch(url, options_) {
return new Promise((resolve, reject) => {
// Build request object
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(request.url);
const response = new Response(data, {headers: {'Content-Type': data.typeFull}});
resolve(response);
return;
}
// Wrap http.request into fetch
const send = (parsedURL.protocol === 'https:' ? external_node_https_namespaceObject : external_node_http_namespaceObject).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 external_node_stream_namespaceObject.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();
};
// Send request
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);
}
});
/* c8 ignore next 18 */
if (process.version < 'v14') {
// Before Node.js 14, pipeline() does not fully support async iterators and does not always
// properly handle when the socket close/end events are out of order.
request_.on('socket', s => {
let endedWithEventsCount;
s.prependListener('end', () => {
endedWithEventsCount = s._eventsCount;
});
s.prependListener('close', hadError => {
// if end happened before close but the socket didn't emit an error, do it now
if (response && endedWithEventsCount < s._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);
// HTTP fetch step 5
if (isRedirect(response_.statusCode)) {
// HTTP fetch step 5.2
const location = headers.get('Location');
// HTTP fetch step 5.3
let locationURL = null;
try {
locationURL = location === null ? null : new URL(location, request.url);
} catch {
// error here can only be invalid URL in Location: header
// do not throw when options.redirect == manual
// let the user extract the errorneous redirect URL
if (request.redirect !== 'manual') {
reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
finalize();
return;
}
}
// HTTP fetch step 5.5
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':
// Nothing to do
break;
case 'follow': {
// HTTP-redirect fetch step 2
if (locationURL === null) {
break;
}
// HTTP-redirect fetch step 5
if (request.counter >= request.follow) {
reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
finalize();
return;
}
// HTTP-redirect fetch step 6 (counter increment)
// Create a new Request object.
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
};
// when forwarding sensitive headers like "Authorization",
// "WWW-Authenticate", and "Cookie" to untrusted targets,
// headers will be ignored when following a redirect to a domain
// that is not a subdomain match or exact match of the initial domain.
// For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
// will forward the sensitive headers, but a redirect to "bar.com" will not.
// headers will also be ignored when following a redirect to a domain using
// a different protocol. For example, a redirect from "https://foo.com" to "http://foo.com"
// will not forward the sensitive headers
if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
requestOptions.headers.delete(name);
}
}
// HTTP-redirect fetch step 9
if (response_.statusCode !== 303 && request.body && options_.body instanceof external_node_stream_namespaceObject.Readable) {
reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
finalize();
return;
}
// HTTP-redirect fetch step 11
if (response_.statusCode === 303 || ((response_.statusCode === 301 || response_.statusCode === 302) && request.method === 'POST')) {
requestOptions.method = 'GET';
requestOptions.body = undefined;
requestOptions.headers.delete('content-length');
}
// HTTP-redirect fetch step 14
const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
if (responseReferrerPolicy) {
requestOptions.referrerPolicy = responseReferrerPolicy;
}
// HTTP-redirect fetch step 15
resolve(fetch(new Request(locationURL, requestOptions)));
finalize();
return;
}
default:
return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
}
}
// Prepare response
if (signal) {
response_.once('end', () => {
signal.removeEventListener('abort', abortAndFinalize);
});
}
let body = (0,external_node_stream_namespaceObject.pipeline)(response_, new external_node_stream_namespaceObject.PassThrough(), error => {
if (error) {
reject(error);
}
});
// see https://github.com/nodejs/node/pull/29376
/* c8 ignore next 3 */
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
};
// HTTP-network fetch step 12.1.1.3
const codings = headers.get('Content-Encoding');
// HTTP-network fetch step 12.1.1.4: handle content codings
// in following scenarios we ignore compression support
// 1. compression support is disabled
// 2. HEAD request
// 3. no Content-Encoding header
// 4. no content response (204)
// 5. content not modified response (304)
if (!request.compress || request.method === 'HEAD' || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
response = new Response(body, responseOptions);
resolve(response);
return;
}
// For Node v6+
// 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.
const zlibOptions = {
flush: external_node_zlib_namespaceObject.Z_SYNC_FLUSH,
finishFlush: external_node_zlib_namespaceObject.Z_SYNC_FLUSH
};
// For gzip
if (codings === 'gzip' || codings === 'x-gzip') {
body = (0,external_node_stream_namespaceObject.pipeline)(body, external_node_zlib_namespaceObject.createGunzip(zlibOptions), error => {
if (error) {
reject(error);
}
});
response = new Response(body, responseOptions);
resolve(response);
return;
}
// For deflate
if (codings === 'deflate' || codings === 'x-deflate') {
// Handle the infamous raw deflate response from old servers
// a hack for old IIS and Apache servers
const raw = (0,external_node_stream_namespaceObject.pipeline)(response_, new external_node_stream_namespaceObject.PassThrough(), error => {
if (error) {
reject(error);
}
});
raw.once('data', chunk => {
// See http://stackoverflow.com/questions/37519828
if ((chunk[0] & 0x0F) === 0x08) {
body = (0,external_node_stream_namespaceObject.pipeline)(body, external_node_zlib_namespaceObject.createInflate(), error => {
if (error) {
reject(error);
}
});
} else {
body = (0,external_node_stream_namespaceObject.pipeline)(body, external_node_zlib_namespaceObject.createInflateRaw(), error => {
if (error) {
reject(error);
}
});
}
response = new Response(body, responseOptions);
resolve(response);
});
raw.once('end', () => {
// Some old IIS servers return zero-length OK deflate responses, so
// 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
if (!response) {
response = new Response(body, responseOptions);
resolve(response);
}
});
return;
}
// For br
if (codings === 'br') {
body = (0,external_node_stream_namespaceObject.pipeline)(body, external_node_zlib_namespaceObject.createBrotliDecompress(), error => {
if (error) {
reject(error);
}
});
response = new Response(body, responseOptions);
resolve(response);
return;
}
// Otherwise, use response as-is
response = new Response(body, responseOptions);
resolve(response);
});
// eslint-disable-next-line promise/prefer-await-to-then
writeToStream(request_, request).catch(reject);
});
}
function fixResponseChunkedTransferBadEnding(request, errorCallback) {
const LAST_CHUNK = external_node_buffer_namespaceObject.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 = external_node_buffer_namespaceObject.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
// Sometimes final 0-length chunk and end of message code are in separate packets
if (!properLastChunkReceived && previousChunk) {
properLastChunkReceived = (
external_node_buffer_namespaceObject.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 &&
external_node_buffer_namespaceObject.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);
});
});
}
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __nccwpck_require2_(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ var threw = true;
/******/ try {
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require2_);
/******/ threw = false;
/******/ } finally {
/******/ if(threw) delete __webpack_module_cache__[moduleId];
/******/ }
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __nccwpck_require2_.m = __webpack_modules__;
/******/
/************************************************************************/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __nccwpck_require2_.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__nccwpck_require2_.o(definition, key) && !__nccwpck_require2_.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/ensure chunk */
/******/ (() => {
/******/ __nccwpck_require2_.f = {};
/******/ // This file contains only the entry chunk.
/******/ // The chunk loading function for additional chunks
/******/ __nccwpck_require2_.e = (chunkId) => {
/******/ return Promise.all(Object.keys(__nccwpck_require2_.f).reduce((promises, key) => {
/******/ __nccwpck_require2_.f[key](chunkId, promises);
/******/ return promises;
/******/ }, []));
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/get javascript chunk filename */
/******/ (() => {
/******/ // This function allow to reference async chunks
/******/ __nccwpck_require2_.u = (chunkId) => {
/******/ // return url for filenames based on template
/******/ return "" + chunkId + ".index.js";
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __nccwpck_require2_.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __nccwpck_require2_.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/compat */
/******/
/******/ if (typeof __nccwpck_require2_ !== 'undefined') __nccwpck_require2_.ab = __dirname + "/";
/******/
/******/ /* webpack/runtime/require chunk loading */
/******/ (() => {
/******/ // no baseURI
/******/
/******/ // object to store loaded chunks
/******/ // "1" means "loaded", otherwise not loaded yet
/******/ var installedChunks = {
/******/ 792: 1
/******/ };
/******/
/******/ // no on chunks loaded
/******/
/******/ var installChunk = (chunk) => {
/******/ var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
/******/ for(var moduleId in moreModules) {
/******/ if(__nccwpck_require2_.o(moreModules, moduleId)) {
/******/ __nccwpck_require2_.m[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(runtime) runtime(__nccwpck_require2_);
/******/ for(var i = 0; i < chunkIds.length; i++)
/******/ installedChunks[chunkIds[i]] = 1;
/******/
/******/ };
/******/
/******/ // require() chunk loading for javascript
/******/ __nccwpck_require2_.f.require = (chunkId, promises) => {
/******/ // "1" is the signal for "already loaded"
/******/ if(!installedChunks[chunkId]) {
/******/ if(true) { // all chunks have JS
/******/ installChunk(require("./" + __nccwpck_require2_.u(chunkId)));
/******/ } else {}
/******/ }
/******/ };
/******/
/******/ // no external install chunk
/******/
/******/ // no HMR
/******/
/******/ // no HMR manifest
/******/ })();
/******/
/************************************************************************/
var __nested_webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
(() => {
"use strict";
var exports = __nested_webpack_exports__;
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.makeThisModuleAnExecutableReplacer = exports.ParsedImportExportStatement = exports.assert = exports.Version = exports.urlJoin = exports.is404 = void 0;
var is404_1 = __nccwpck_require2_(6689);
Object.defineProperty(exports, "is404", ({ enumerable: true, get: function () { return is404_1.is404; } }));
var urlJoin_1 = __nccwpck_require2_(6748);
Object.defineProperty(exports, "urlJoin", ({ enumerable: true, get: function () { return urlJoin_1.urlJoin; } }));
var Version_1 = __nccwpck_require2_(8165);
Object.defineProperty(exports, "Version", ({ enumerable: true, get: function () { return Version_1.Version; } }));
var tsafe_1 = __nccwpck_require2_(4653);
Object.defineProperty(exports, "assert", ({ enumerable: true, get: function () { return tsafe_1.assert; } }));
var replacer_1 = __nccwpck_require2_(1107);
Object.defineProperty(exports, "ParsedImportExportStatement", ({ enumerable: true, get: function () { return replacer_1.ParsedImportExportStatement; } }));
Object.defineProperty(exports, "makeThisModuleAnExecutableReplacer", ({ enumerable: true, get: function () { return replacer_1.makeThisModuleAnExecutableReplacer; } }));
})();
module.exports = __nested_webpack_exports__;
/******/ })()
;
/***/ }),
/***/ 1107:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.consumeExecutableReplacerFactory = exports.makeThisModuleAnExecutableReplacer = exports.ParsedImportExportStatement = void 0;
const tsafe_1 = __nccwpck_require__(4653);
const st = __nccwpck_require__(7516);
const addCache_1 = __nccwpck_require__(8590);
const ParsedImportExportStatement_1 = __nccwpck_require__(9832);
var ParsedImportExportStatement;
(function (ParsedImportExportStatement) {
ParsedImportExportStatement.stringify = ParsedImportExportStatement_1.ParsedImportExportStatement.stringify;
})(ParsedImportExportStatement = exports.ParsedImportExportStatement || (exports.ParsedImportExportStatement = {}));
const exitCodeForUndefined = 153;
const separatorBetweenDebugAndResult = "\n===========>> | REPLACER RESULT | <<===========\n";
/**
* Assert the replacer never throws, if you do not want to override
* the normal module resolution just return undefined.
*/
async function makeThisModuleAnExecutableReplacer(replacer) {
process.once("unhandledRejection", error => {
throw error;
});
let [, , importExportStatement, version, destDirPath] = process.argv;
(0, tsafe_1.assert)(typeof version !== undefined, `expect: node ${process.argv[1]} '<importExportStatement>' <version>`);
const parsedImportExportStatement = ParsedImportExportStatement_1.ParsedImportExportStatement.parse(JSON.parse(`"${importExportStatement.replace(/"/g, '\\"')}"`));
(0, tsafe_1.assert)(parsedImportExportStatement.parsedArgument.type === "DEPENDENCY");
//NOTE: Should be inferable...
(0, tsafe_1.assert)((0, tsafe_1.is)(parsedImportExportStatement));
const result = await replacer({
parsedImportExportStatement,
importExportStatement,
version,
destDirPath
});
if (result === undefined) {
process.exit(exitCodeForUndefined);
}
process.stdout.write(separatorBetweenDebugAndResult + result);
process.exit(0);
}
exports.makeThisModuleAnExecutableReplacer = makeThisModuleAnExecutableReplacer;
function consumeExecutableReplacerFactory(params) {
const { executableFilePath } = params;
const consumeExecutableReplacer = (0, addCache_1.addCache)(async (params) => {
const { parsedImportExportStatement, version, destDirPath } = params;
let out;
try {
out = await st.exec(`"${process.argv[0]}" "${executableFilePath}" ${JSON.stringify(ParsedImportExportStatement_1.ParsedImportExportStatement.stringify(parsedImportExportStatement))} ${version} ${JSON.stringify(destDirPath)}`);
}
catch (error) {
(0, tsafe_1.assert)((0, tsafe_1.is)(error));
if (error.code === exitCodeForUndefined) {
return undefined;
}
throw error;
}
const [debugLog, result] = out.split(separatorBetweenDebugAndResult);
if (debugLog) {
process.stdout.write(debugLog);
}
return result;
});
return { consumeExecutableReplacer };
}
exports.consumeExecutableReplacerFactory = consumeExecutableReplacerFactory;
/***/ }),
/***/ 9832:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ParsedImportExportStatement = void 0;
const tsafe_1 = __nccwpck_require__(4653);
var ParsedImportExportStatement;
(function (ParsedImportExportStatement) {
let ParsedArgument;
(function (ParsedArgument) {
function parse(argument) {
if (argument.startsWith(".")) {
return (0, tsafe_1.id)({
"type": "PROJECT LOCAL FILE",
"relativePath": argument
});
}
if (/^(https?:)?\/\//i.test(argument)) {
return (0, tsafe_1.id)({
"type": "URL",
"url": argument
});
}
{
let [nodeModuleName, ...rest] = argument.split("/");
if (nodeModuleName.startsWith("@") && rest.length !== 0) {
const [scopedNodeModuleName, ...restNew] = rest;
nodeModuleName = `${nodeModuleName}/${scopedNodeModuleName}`;
rest = restNew;
}
return (0, tsafe_1.id)({
"type": "DEPENDENCY",
nodeModuleName,
"specificImportPath": rest.join("/") || undefined
});
}
}
ParsedArgument.parse = parse;
function stringify(parsedArgument) {
switch (parsedArgument.type) {
case "PROJECT LOCAL FILE":
return parsedArgument.relativePath;
case "DEPENDENCY": {
const { nodeModuleName, specificImportPath } = parsedArgument;
return `${nodeModuleName}${specificImportPath ? `/${specificImportPath}` : ``}`;
}
case "URL":
return parsedArgument.url;
}
}
ParsedArgument.stringify = stringify;
})(ParsedArgument = ParsedImportExportStatement.ParsedArgument || (ParsedImportExportStatement.ParsedArgument = {}));
function parse(importExportStatement) {
importExportStatement = importExportStatement.replace(/\s+^/, "").replace(/$\s+/, "");
const isAsyncImport = importExportStatement.endsWith(")");
const quoteSymbol = importExportStatement.endsWith(`'${isAsyncImport ? ")" : ""}`) ? "'" : '"';
const parsedArgument = ParsedImportExportStatement.ParsedArgument.parse(importExportStatement.match(new RegExp(`^[^${quoteSymbol}]*${quoteSymbol}([^${quoteSymbol}]+)${quoteSymbol}[^${quoteSymbol}]*$`))[1]);
if (isAsyncImport) {
return (0, tsafe_1.id)({
"isAsyncImport": true,
quoteSymbol,
parsedArgument
});
}
if (new RegExp(`^declare\\s+module\\s+${quoteSymbol}`).test(importExportStatement)) {
return (0, tsafe_1.id)({
parsedArgument,
"isAsyncImport": false,
quoteSymbol,
"statementType": "declare module"
});
}
if (new RegExp(`^import\\s+${quoteSymbol}`).test(importExportStatement)) {
return (0, tsafe_1.id)({
parsedArgument,
"isAsyncImport": false,
quoteSymbol,
"statementType": "import",
"target": undefined
});
}
const statementType = importExportStatement.startsWith("import") ? "import" : "export";
const isTypeOnly = /^(?:import|export)\s+type/.test(importExportStatement);
const target = importExportStatement
.match(new RegExp(`^(?:import|export)(?:\\s+type)?\\s*([^${quoteSymbol}]+)${quoteSymbol}`))[1]
.replace(/\s*from\s*$/, "");
return (0, tsafe_1.id)({
"isAsyncImport": false,
parsedArgument,
isTypeOnly,
quoteSymbol,
statementType,
target
});
}
ParsedImportExportStatement.parse = parse;
function stringify(parsedImportExportStatement) {
const { quoteSymbol, parsedArgument } = parsedImportExportStatement;
const quotedArgument = `${quoteSymbol}${ParsedImportExportStatement.ParsedArgument.stringify(parsedArgument)}${quoteSymbol}`;
if (parsedImportExportStatement.isAsyncImport) {
return `import(${quotedArgument})`;
}
if (parsedImportExportStatement.statementType === "declare module") {
return `declare module ${quotedArgument}`;
}
if (parsedImportExportStatement.target === undefined) {
return `import ${quotedArgument}`;
}
const { statementType, isTypeOnly, target } = parsedImportExportStatement;
return [statementType, ...(isTypeOnly ? ["type"] : []), target, "from", quotedArgument].join(" ");
}
ParsedImportExportStatement.stringify = stringify;
})(ParsedImportExportStatement = exports.ParsedImportExportStatement || (exports.ParsedImportExportStatement = {}));
/***/ }),
/***/ 8165:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Version = void 0;
var Version;
(function (Version) {
function parse(versionStr) {
const match = versionStr.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
if (!match) {
throw new Error(`${versionStr} is not a valid NPM version`);
}
return {
"major": parseInt(match[1]),
"minor": parseInt(match[2]),
"patch": parseInt(match[3])
};
}
Version.parse = parse;
function stringify(v) {
return `${v.major}.${v.minor}.${v.patch}`;
}
Version.stringify = stringify;
/**
*
* v1 < v2 => -1
* v1 === v2 => 0
* v1 > v2 => 1
*
*/
function compare(v1, v2) {
const sign = (n) => (n === 0 ? 0 : n < 0 ? -1 : 1);
if (v1.major === v2.major) {
if (v1.minor === v2.minor) {
return sign(v1.patch - v2.patch);
}
else {
return sign(v1.minor - v2.minor);
}
}
else {
return sign(v1.major - v2.major);
}
}
Version.compare = compare;
function bumpType(params) {
const versionAhead = parse(params.versionAheadStr);
const versionBehind = parse(params.versionBehindStr);
if (compare(versionBehind, versionAhead) === 1) {
throw new Error(`Version regression ${versionBehind} -> ${versionAhead}`);
}
if (versionBehind.major !== versionAhead.major) {
return "MAJOR";
}
else if (versionBehind.minor !== versionAhead.minor) {
return "MINOR";
}
else if (versionBehind.patch !== versionAhead.patch) {
return "PATCH";
}
else {
return "SAME";
}
}
Version.bumpType = bumpType;
})(Version = exports.Version || (exports.Version = {}));
/***/ }),
/***/ 8590:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.addCache = void 0;
const fs = __nccwpck_require__(9896);
/** Save results of anterior calls */
function addCache(f, params) {
const previousResults = params === undefined || !fs.existsSync(params.filePathForPersistanceAcrossRun)
? {}
: JSON.parse(fs.readFileSync(params.filePathForPersistanceAcrossRun).toString("utf8"));
if (params !== undefined) {
process.once("exit", () => fs.writeFileSync(params.filePathForPersistanceAcrossRun, Buffer.from(JSON.stringify(previousResults), "utf8") //TODO: reorder props
));
}
return async function callee(...args) {
const key = shallowEqualStringifyInvariant(args);
if (key in previousResults) {
return previousResults[key][0];
}
previousResults[key] = [await f(...args)];
//NOTE: So that JSON.parse restore it well.
if (previousResults[key][0] === undefined) {
previousResults[key].pop();
}
return callee(...args);
};
}
exports.addCache = addCache;
/**
Two shallow equal object will return the same string.
assert(
shallowEqualStringifyInvariant({ "p1": "foo", "p2": "bar" })
===
shallowEqualStringifyInvariant({ "p2": "bar", "p1": "foo" })
);
*/
function shallowEqualStringifyInvariant(o) {
const s1 = JSON.stringify(o);
const p1 = JSON.parse(s1);
const p2 = {};
Object.keys(p1)
.sort()
.forEach(key => (p2[key] = p1[key]));
return JSON.stringify(p2);
}
/***/ }),
/***/ 1199:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
/**
*
* Let's say we have this function declared somewhere.
*
* function get__filename(){
* return get_caller_file_path();
* }
*
* Then we can assert that:
*
* get__filename() === __filename
*
*
*/
function get_caller_file_path() {
//NOTE: Cannot be move to the index file.
//The function can't be declared and used
//in the same file.
var prepareStackTraceBackup = Error.prepareStackTrace;
var callerFile = "";
try {
var error = new Error();
Error.prepareStackTrace = function (_, stack) { return stack; };
error.stack.shift().getFileName();
var fileImportedFrom = error.stack.shift().getFileName();
while (error.stack.length) {
var fileName = error.stack.shift().getFileName();
if (fileName === callerFile) {
break;
}
callerFile = fileName;
if (fileImportedFrom !== callerFile) {
break;
}
}
}
catch (_a) { }
Error.prepareStackTrace = prepareStackTraceBackup;
return callerFile;
}
exports.get_caller_file_path = get_caller_file_path;
/***/ }),
/***/ 7516:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
var child_process = __nccwpck_require__(5317);
var readline = __nccwpck_require__(3785);
var fs = __nccwpck_require__(9896);
var path = __nccwpck_require__(6928);
var https = __nccwpck_require__(5692);
var http = __nccwpck_require__(8611);
var util = __nccwpck_require__(9023);
var os = __nccwpck_require__(857);
var crypto = __nccwpck_require__(6982);
/**
* After this function is called every call to execSync
* or exec will print the unix commands being executed.
* */
function enableCmdTrace() {
traceCmdIfEnabled.enabled = true;
}
exports.enableCmdTrace = enableCmdTrace;
function traceCmdIfEnabled(cmd, options) {
if (!traceCmdIfEnabled.enabled) {
return;
}
console.log(colorize("$ " + cmd + " ", "YELLOW") + (!!options ? JSON.stringify(options) + "\n" : ""));
}
(function (traceCmdIfEnabled) {
traceCmdIfEnabled.enabled = false;
})(traceCmdIfEnabled || (traceCmdIfEnabled = {}));
function get_uid(unix_user) {
return parseInt(sh_eval("id -u " + unix_user));
}
exports.get_uid = get_uid;
function get_gid(unix_user) {
return parseInt(sh_eval("id -g " + unix_user));
}
exports.get_gid = get_gid;
function colorize(str, color) {
var color_code = (function () {
switch (color) {
case "GREEN": return "\x1b[32m";
case "RED": return "\x1b[31m";
case "YELLOW": return "\x1b[33m";
}
})();
return "" + color_code + str + "\u001B[0m";
}
exports.colorize = colorize;
/**
*
* The stderr is forwarded to the console realtime.
*
* The returned value is the concatenated data received on stdout.
*
* If the return code of the cmd is not 0 an exception is thrown
* and the message cmd + the concatenated data received on stderr.
*
* If enableTrace() have been called the command called will be printed.
*
*/
function execSync(cmd, options) {
traceCmdIfEnabled(cmd, options);
return child_process.execSync(cmd, __assign({}, (options || {}), { "encoding": "utf8" }));
}
exports.execSync = execSync;
/**
*
* The cmd is printed before execution
* stdout and stderr are forwarded to the console realtime.
* Return nothing.
*
* stdio is set to "inherit" and thus should not be redefined.
*
*/
function execSyncTrace(cmd, options) {
traceCmdIfEnabled(cmd, options);
child_process.execSync(cmd, __assign({}, (options || {}), { "stdio": "inherit" }));
}
exports.execSyncTrace = execSyncTrace;
/** Same as execSync except that it dose not print cmd even if cmdTrace have been enabled */
var execSyncNoCmdTrace = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var enabled_back = traceCmdIfEnabled.enabled;
traceCmdIfEnabled.enabled = false;
try {
var out = execSync.apply(null, args);
traceCmdIfEnabled.enabled = enabled_back;
return out;
}
catch (error) {
traceCmdIfEnabled.enabled = enabled_back;
throw error;
}
};
/**
*
* Like execSync but stderr is not forwarded.
* WARNING: If mean that when the cmd return 0
* all data that may have been wrote on stderr
* are lost into oblivion.
*
* stdio is set to "pipe" and thus should not be redefined.
*
*/
function execSyncQuiet(cmd, options) {
return execSync(cmd, __assign({}, (options || {}), { "stdio": "pipe" }));
}
exports.execSyncQuiet = execSyncQuiet;
/** Same as execSync but async */
function exec(cmd, options) {
var _this = this;
traceCmdIfEnabled(cmd, options);
return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
child_process.exec(cmd, __assign({}, (options || {}), { "encoding": "utf8" }), function (error, stdout, stderr) {
if (!!error) {
error["stderr"] = stderr;
reject(error);
}
else {
resolve(stdout);
}
});
return [2 /*return*/];
});
}); });
}
exports.exec = exec;
/**
* Spawn a process that continue running after current process exit.
* This process will be ignored by stopSubProcessesAsapSync.
* If a logfile_path if provided stdout and stderr will be redirected to this file.
*
* detached, and stdio options should not be set as they are set internally.
* */
function spawnAndDetach(command, args, options, logfile_path) {
var out = !!logfile_path ? fs.openSync(logfile_path, "a") : "ignore";
var subprocess = child_process.spawn(command, args, __assign({}, (options || {}), { "detached": true, "stdio": ["ignore", out, out] }));
stopProcessSync.stopSubProcessesAsapSync.ignorePids.add(subprocess.pid);
subprocess.unref();
return subprocess;
}
exports.spawnAndDetach = spawnAndDetach;
/**
*
* Print a message and enable a moving loading bar.
* WARNING: Nothing should be printed to stdout until we stop showing the moving loading.
*
* returns:
* -exec: A proxy to the exec fnc that will call onError before it throw the error.
* -onSuccess: Stop showing the moving loading and pretty print a success message ("ok" by default)
* -onError: Stop showing the moving loading and pretty print error message.
*
*/
function start_long_running_process(message) {
process.stdout.write(message + "... ");
var moveBack = (function () {
var cp = message.length + 3;
return function () { return readline.cursorTo(process.stdout, cp); };
})();
var p = ["\\", "|", "/", "-"].map(function (i) { return colorize(i, "GREEN"); });
var x = 0;
var timer = setInterval(function () {
moveBack();
process.stdout.write(p[x++]);
x = x % p.length;
}, 250);
var onComplete = function (message) {
clearInterval(timer);
moveBack();
process.stdout.write(message + "\n");
};
var onError = function (errorMessage) { return onComplete(colorize(errorMessage, "RED")); };
var onSuccess = function (message) { return onComplete(colorize(message || "ok", "GREEN")); };
if (traceCmdIfEnabled.enabled) {
onComplete("");
onComplete = function (message) { return console.log(message); };
}
return {
onError: onError,
onSuccess: onSuccess,
"exec": function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4 /*yield*/, exec.apply(null, args)];
case 1: return [2 /*return*/, _a.sent()];
case 2:
error_1 = _a.sent();
onError(error_1.message);
throw error_1;
case 3: return [2 /*return*/];
}
});
});
}
};
}
exports.start_long_running_process = start_long_running_process;
;
/**
* Apt package if not already installed,
* if prog is provided and prog is in the PATH the package will not be installed
* */
function apt_get_install_if_missing(package_name, prog) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
process.stdout.write("Looking for " + package_name + " ... ");
if (!!prog && apt_get_install_if_missing.doesHaveProg(prog)) {
console.log(prog + " executable found. " + colorize("OK", "GREEN"));
return [2 /*return*/];
}
if (apt_get_install_if_missing.isPkgInstalled(package_name)) {
console.log(package_name + " is installed. " + colorize("OK", "GREEN"));
return [2 /*return*/];
}
readline.clearLine(process.stdout, 0);
process.stdout.write("\r");
return [4 /*yield*/, apt_get_install(package_name)];
case 1: return [2 /*return*/, _a.sent()];
}
});
});
}
exports.apt_get_install_if_missing = apt_get_install_if_missing;
(function (apt_get_install_if_missing) {
function isPkgInstalled(package_name) {
try {
console.assert(!!execSyncNoCmdTrace("dpkg-query -W -f='${Status}' " + package_name, { "stdio": "pipe" })
.match(/^install ok installed$/));
}
catch (_a) {
return false;
}
return true;
}
apt_get_install_if_missing.isPkgInstalled = isPkgInstalled;
function doesHaveProg(prog) {
try {
execSyncNoCmdTrace("which " + prog);
}
catch (_a) {
return false;
}
return true;
}
apt_get_install_if_missing.doesHaveProg = doesHaveProg;
})(apt_get_install_if_missing = exports.apt_get_install_if_missing || (exports.apt_get_install_if_missing = {}));
/** Install or upgrade package via APT */
function apt_get_install(package_name) {
return __awaiter(this, void 0, void 0, function () {
var _a, onSuccess, exec, was_installed_before, error_2;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_a = start_long_running_process("Installing or upgrading " + package_name + " package"), onSuccess = _a.onSuccess, exec = _a.exec;
_b.label = 1;
case 1:
_b.trys.push([1, 5, , 6]);
if (!apt_get_install.isFirst) return [3 /*break*/, 3];
return [4 /*yield*/, exec("apt-get update || true")];
case 2:
_b.sent();
apt_get_install.isFirst = false;
_b.label = 3;
case 3:
was_installed_before = apt_get_install_if_missing.isPkgInstalled(package_name);
return [4 /*yield*/, exec("apt-get -y install " + package_name)];
case 4:
_b.sent();
if (!was_installed_before) {
apt_get_install.onInstallSuccess(package_name);
}
return [3 /*break*/, 6];
case 5:
error_2 = _b.sent();
apt_get_install.onError(error_2);
return [3 /*break*/, 6];
case 6:
onSuccess("DONE");
return [2 /*return*/];
}
});
});
}
exports.apt_get_install = apt_get_install;
(function (apt_get_install) {
apt_get_install.isFirst = true;
function record_installed_package(file_json_path, package_name) {
execSyncNoCmdTrace("touch " + file_json_path);
var raw = fs.readFileSync(file_json_path).toString("utf8");
var list = raw === "" ? [] : JSON.parse(raw);
if (!list.find(function (p) { return p === package_name; })) {
list.push(package_name);
fs.writeFileSync(file_json_path, Buffer.from(JSON.stringify(list, null, 2), "utf8"));
}
}
apt_get_install.record_installed_package = record_installed_package;
apt_get_install.onError = function (error) { throw error; };
apt_get_install.onInstallSuccess = function (package_name) { };
})(apt_get_install = exports.apt_get_install || (exports.apt_get_install = {}));
function exit_if_not_root() {
if (process.getuid() !== 0) {
console.log(colorize("Error: root privilege required ", "RED"));
process.exit(1);
}
}
exports.exit_if_not_root = exit_if_not_root;
/**
*
* Locate a given module in a node_modules directory.
* If the module is required in different version and thus
* present multiple times will be returned the shorter path.
* This ensure that if a given module is in package.json 's dependencies
* section the returned path will be the one we looking for.
*
* @param module_name The name of the module.
* @param module_dir_path Path to the root of the module ( will search in ./node_modules ).
*
* Throw if the module is not found.
*
*/
function find_module_path(module_name, module_dir_path) {
if (module_dir_path.endsWith(module_name)) {
return module_dir_path;
}
var node_module_path = path.join(module_dir_path, "node_modules");
if (!fs.existsSync(node_module_path)) {
throw new Error("No node_modules in " + module_dir_path);
}
var _a = __read(fs.readdirSync(node_module_path)
.filter(function (file_or_dir_name) { return fs.statSync(path.join(node_module_path, file_or_dir_name)).isDirectory; })
.map(function (dir_name) {
return !dir_name.startsWith("@") ?
[path.join(node_module_path, dir_name)] :
fs.readdirSync(path.join(node_module_path, dir_name))
.map(function (file_or_dir_name) { return path.join(node_module_path, dir_name, file_or_dir_name); })
.filter(function (file_or_dir_path) { return fs.statSync(file_or_dir_path).isDirectory; });
})
.reduce(function (prev, curr) { return __spread(prev, curr); }, [])
.filter(function (file_or_dir_path) { return fs.existsSync(path.join(file_or_dir_path, "package.json")); })
.map(function (module_dir_path) {
try {
return find_module_path(module_name, module_dir_path);
}
catch (_a) {
return "";
}
})
.filter(function (module_dir_path) { return !!module_dir_path; })
.sort(function (a, b) { return a.length - b.length; }), 1), out = _a[0];
if (out === undefined) {
throw new Error("module " + module_name + " not installed in " + module_dir_path);
}
return out;
}
exports.find_module_path = find_module_path;
/**
*
* Test if two file of folder are same.
* Does not consider stat ( ownership and permission ).
* transparent handling of symlinks.
*
* Example
*
* /foo1/bar/file.txt
* /foo2/bar/file.txt
*
* to compare the two version of file.txt
* call with "/foo1", "/foo2", "./bar/file.txt";
* or with "/foo1/bar/file.txt", "/foo2/bar/file.txt"
*
* @param relative_from_path1 absolute path ex: '/foo1'
* @param relative_from_path2 absolute path ex: '/foo2'
* @param relative_to_path relative path ex: './bar/file.txt" or 'bar/file.txt'
* for convenience relative_to_path can be absolute as long as it has relative_from_path1
* or relative_from_path2 as parent.
*
*/
function fs_areSame(relative_from_path1, relative_from_path2, relative_to_path) {
if (relative_to_path === void 0) { relative_to_path = "."; }
relative_to_path = fs_areSame.get_relative_to_path(relative_from_path1, relative_from_path2, relative_to_path);
try {
execSyncNoCmdTrace([
"diff -r",
path.join(relative_from_path1, relative_to_path),
path.join(relative_from_path2, relative_to_path)
].join(" "), { "stdio": "pipe" });
}
catch (_a) {
return false;
}
return true;
}
exports.fs_areSame = fs_areSame;
(function (fs_areSame) {
function get_relative_to_path(dir_path1, dir_path2, to_path) {
if (path.isAbsolute(to_path)) {
var dir_path = [dir_path1, dir_path2]
.filter(function (v) { return to_path.startsWith(v); })
.sort(function (a, b) { return b.length - a.length; })[0];
if (!dir_path) {
throw new Error("Not relative!");
}
return path.relative(dir_path, to_path);
}
else {
return to_path;
}
}
fs_areSame.get_relative_to_path = get_relative_to_path;
})(fs_areSame = exports.fs_areSame || (exports.fs_areSame = {}));
/**
*
* Move or copy file of folder.
* -If dest is identical to source nothing is copied nor moved.
* -If dest exist and is different of source it will be deleted prior to proceeding with action.
* -In move mode if dest identical to source source will be removed.
* -When copy is effectively performed the stat are conserved.
* -If dirname of dest does not exist in fs, it will be created.
* -Unlike cp or mv "/src/file.txt" "/dest" will NOT place file.txt in dest but dest will become file.txt
*
* calling [action] "/src/foo" "/dst/foo" is equivalent
* to calling [action] "/src" "/dst" "./foo" ( or "foo" )
* or [action] "/src" "/dst" "src/foo"
* or [action] "/src" "/dst" "dst/foo"
*
*/
function fs_move(action, relative_from_path_src, relative_from_path_dest, relative_to_path) {
if (relative_to_path === void 0) { relative_to_path = "."; }
relative_to_path = fs_areSame.get_relative_to_path(relative_from_path_src, relative_from_path_dest, relative_to_path);
var src_path = path.join(relative_from_path_src, relative_to_path);
var dst_path = path.join(relative_from_path_dest, relative_to_path);
if (!fs_areSame(src_path, dst_path)) {
if (!fs.existsSync(dst_path)) {
execSyncNoCmdTrace("mkdir -p " + dst_path);
}
execSyncNoCmdTrace("rm -rf " + dst_path);
execSyncNoCmdTrace([
action === "COPY" ? "cp -rp" : "mv",
src_path,
dst_path
].join(" "));
}
else {
if (action === "MOVE") {
execSyncNoCmdTrace("rm -r " + src_path);
}
}
}
exports.fs_move = fs_move;
/**
* Download and extract a tarball. throws web_get.DownloadError and Error
*
* Example
*
* website.com/rel.tar.gz
* ./file1.txt
* ./dir/file2.txt
*
* /foo/
* ./file3.txt
* ./dir/file4.txt
*
* calling with "website.com/rel.tar.gz", "MERGE" will result in:
*
* /foo/
* ./file1.txt
* ./file3.txt
* ./dir/file4.txt
*
* calling with "website.com/rel.tar.gz", "OVERWRITE IF EXIST" will result in:
*
* /foo/
* ./file1.txt
* ./dir/file2.txt
*
*/
function download_and_extract_tarball(url, dest_dir_path, mode) {
return __awaiter(this, void 0, void 0, function () {
var _a, exec, onSuccess, onError, tarball_dir_path, tarball_path, error_3, _b, _c, name;
var e_1, _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
_a = start_long_running_process("Downloading " + url + " and extracting to " + dest_dir_path), exec = _a.exec, onSuccess = _a.onSuccess, onError = _a.onError;
tarball_dir_path = (function () {
var hash = crypto.createHash("sha1");
hash.write(url);
hash.end();
return "/tmp/_" + hash.read().toString("hex");
})();
tarball_path = tarball_dir_path + ".tar.gz";
if (!(fs.existsSync(tarball_dir_path) || fs.existsSync(tarball_path))) return [3 /*break*/, 2];
return [4 /*yield*/, exec("rm -rf " + tarball_dir_path + " " + tarball_path)];
case 1:
_e.sent();
_e.label = 2;
case 2:
_e.trys.push([2, 4, , 5]);
return [4 /*yield*/, web_get(url, tarball_path)];
case 3:
_e.sent();
return [3 /*break*/, 5];
case 4:
error_3 = _e.sent();
onError(error_3.message);
throw error_3;
case 5: return [4 /*yield*/, exec("mkdir " + tarball_dir_path)];
case 6:
_e.sent();
return [4 /*yield*/, exec("tar -xzf " + tarball_path + " -C " + tarball_dir_path)];
case 7:
_e.sent();
return [4 /*yield*/, exec("rm " + tarball_path)];
case 8:
_e.sent();
if (!(mode === "MERGE")) return [3 /*break*/, 10];
try {
for (_b = __values(fs_ls(tarball_dir_path)), _c = _b.next(); !_c.done; _c = _b.next()) {
name = _c.value;
fs_move("MOVE", tarball_dir_path, dest_dir_path, name);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return [4 /*yield*/, exec("rm -r " + tarball_dir_path)];
case 9:
_e.sent();
return [3 /*break*/, 11];
case 10:
fs_move("MOVE", tarball_dir_path, dest_dir_path);
_e.label = 11;
case 11:
onSuccess();
return [2 /*return*/];
}
});
});
}
exports.download_and_extract_tarball = download_and_extract_tarball;
function web_get(url, file_path) {
if (!url.startsWith("http")) {
url = "http://" + url;
}
return new Promise(function (resolve, reject) {
var get = url.startsWith("https") ?
https.get.bind(https) : http.get.bind(http);
var timer = setTimeout(function () {
clientRequest.abort();
reject(new web_get.DownloadError(url, "CONNECTION ERROR", "web_get connection error: timeout"));
}, 20000);
var clientRequest = get(url, function (res) {
clearTimeout(timer);
if (("" + res.statusCode).startsWith("30")) {
var url_redirect = res.headers.location;
if (!!url_redirect) {
web_get(url_redirect, file_path)
.then(function (out) { return resolve(out); })
.catch(function (error) { return reject(error); });
return;
}
}
if (!("" + res.statusCode).startsWith("2")) {
reject(new web_get.DownloadErrorHttpErrorCode(url, res.statusCode));
return;
}
var contentLength = undefined;
var receivedBytes = 0;
if (res.headers["content-length"] !== undefined) {
contentLength = parseInt(res.headers["content-length"]);
res.on("data", function (chunk) { return receivedBytes += chunk.length; });
(function () {
var resolve_src = resolve;
resolve = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (receivedBytes !== contentLength) {
reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes));
return;
}
resolve_src.apply(null, args);
};
})();
}
res.socket.setTimeout(60000, function () { return res.socket.destroy(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, "socket timeout")); });
if (!!file_path) {
(function () {
var reject_src = reject;
reject = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return fs.unlink(file_path, function () { return reject_src.apply(null, args); });
};
})();
fs.writeFileSync(file_path, new Buffer(0));
var fsWriteStream = fs.createWriteStream(file_path);
res.pipe(fsWriteStream);
fsWriteStream.once("finish", function () { return resolve(); });
res.once("error", function (error) { return reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, error.message)); });
fsWriteStream.once("error", function (error) { return reject(new web_get.DownloadErrorIncomplete(url, contentLength, receivedBytes, error.message)); });
}
else {
var data_1 = new Buffer(0);
res.on("data", function (chunk) { return data_1 = Buffer.concat([data_1, chunk]); });
res.once("end", function () { return resolve(data_1.toString("utf8")); });
}
});
clientRequest.once("error", function (error) {
clearTimeout(timer);
reject(new web_get.DownloadError(url, "CONNECTION ERROR", error.message));
});
});
}
exports.web_get = web_get;
(function (web_get) {
var DownloadError = /** @class */ (function (_super) {
__extends(DownloadError, _super);
function DownloadError(url, cause, message) {
var _newTarget = this.constructor;
var _this = _super.call(this, message) || this;
_this.url = url;
_this.cause = cause;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadError;
}(Error));
web_get.DownloadError = DownloadError;
var DownloadErrorIncomplete = /** @class */ (function (_super) {
__extends(DownloadErrorIncomplete, _super);
function DownloadErrorIncomplete(url, contentLength, receivedBytes, info) {
var _newTarget = this.constructor;
var _this = _super.call(this, url, "INCOMPLETE", "web_get failed, download incomplete " + receivedBytes + "/" + contentLength + ", " + (!!info ? info : "")) || this;
_this.contentLength = contentLength;
_this.receivedBytes = receivedBytes;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadErrorIncomplete;
}(DownloadError));
web_get.DownloadErrorIncomplete = DownloadErrorIncomplete;
var DownloadErrorHttpErrorCode = /** @class */ (function (_super) {
__extends(DownloadErrorHttpErrorCode, _super);
function DownloadErrorHttpErrorCode(url, code) {
var _newTarget = this.constructor;
var _this = _super.call(this, url, "HTTP ERROR CODE", "web_get failed, HTTP error code: " + code) || this;
_this.code = code;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return DownloadErrorHttpErrorCode;
}(DownloadError));
web_get.DownloadErrorHttpErrorCode = DownloadErrorHttpErrorCode;
})(web_get = exports.web_get || (exports.web_get = {}));
function fs_ls(dir_path, mode, showHidden) {
if (mode === void 0) { mode = "FILENAME"; }
if (showHidden === void 0) { showHidden = false; }
return execSyncNoCmdTrace("ls" + (showHidden ? " -a" : ""), { "cwd": dir_path })
.slice(0, -1)
.split("\n")
.map(function (name) { return mode === "ABSOLUTE PATH" ? path.join(dir_path, name) : name; });
}
exports.fs_ls = fs_ls;
/**
*
* Create a symbolic link.
* If dst exist it is removed.
* directories leading to dest are created if necessary.
*
*/
function createSymlink(src_path, dst_path) {
if (!fs.existsSync(dst_path)) {
execSyncNoCmdTrace("mkdir -p " + dst_path);
}
execSyncNoCmdTrace("rm -rf " + dst_path);
execSync("ln -s " + src_path + " " + dst_path);
}
exports.createSymlink = createSymlink;
/** Create a executable file */
function createScript(file_path, content) {
if (traceCmdIfEnabled.enabled) {
console.log("Creating script " + file_path);
}
fs.writeFileSync(file_path, Buffer.from(content, "utf8"));
execSyncNoCmdTrace("chmod +x " + file_path);
}
exports.createScript = createScript;
var unixUser;
(function (unixUser) {
function create(unix_user, home_dir_path) {
if (home_dir_path === void 0) { home_dir_path = "/tmp"; }
execSyncNoCmdTrace("useradd -M " + unix_user + " -s /bin/false -d " + home_dir_path);
}
unixUser.create = create;
function remove(unix_user) {
execSyncNoCmdTrace("userdel " + unix_user, { "stdio": "pipe" });
}
unixUser.remove = remove;
})(unixUser = exports.unixUser || (exports.unixUser = {}));
var get_caller_file_path_1 = __nccwpck_require__(1199);
exports.get_caller_file_path = get_caller_file_path_1.get_caller_file_path;
var get_caller_file_path_2 = __nccwpck_require__(1199);
/**
*
* DO NOT USE TEST PURPOSE ONLY
*
* return __filename
*
*/
function get__filename() {
return get_caller_file_path_2.get_caller_file_path();
}
exports.get__filename = get__filename;
/**
*
* Equivalent to the pattern $() in bash.
* Strip final LF if present.
* If cmd fail no error is thrown, an empty string is returned.
* Does not print to stdout.
*
* Typical usage: uname -r or which pkill
*
*/
function sh_eval(cmd) {
var res;
try {
res = execSyncNoCmdTrace(cmd, { "stdio": "pipe" });
}
catch (_a) {
return "";
}
return res.replace(/\n$/, "");
}
exports.sh_eval = sh_eval;
/**
* Run a command and return true if the return code was 0.
* Does not print to stdout.
*/
function sh_if(cmd) {
try {
execSyncNoCmdTrace(cmd, { "stdio": "pipe" });
}
catch (_a) {
return false;
}
return true;
}
exports.sh_if = sh_if;
/**
* Return a promise that resolve as the source promise when fulfilled
* or resolve with the error when reject.
* If a timeout is specified the returned promise resolve with an error after [timeout]ms
* if the source promise did not completed before.
* The message of the timeout error is safePr.timeoutErrorMessage
*/
function safePr(pr, timeout) {
var prSafe = pr.then(function (val) { return val; }, function (error) { return error; });
if (timeout !== undefined) {
var timer_1;
return Promise.race([
new Promise(function (resolve) { return timer_1 = setTimeout(function () { return resolve(new Error(safePr.timeoutErrorMessage)); }, timeout); }),
prSafe.then(function (val) {
clearTimeout(timer_1);
return val;
})
]);
}
else {
return prSafe;
}
}
exports.safePr = safePr;
;
(function (safePr) {
safePr.timeoutErrorMessage = "safePr timeout";
})(safePr = exports.safePr || (exports.safePr = {}));
/**
*
* Allow to schedule action function to perform before exiting.
*
* The task function will always be called before the process stop
* unless process.exit is explicitly called somewhere or
* if the process receive any signal other than the ones specified
* in the ExitCause.Signal["signal"] type.
*
* The process may stop for tree reasons:
* 1) If there is no more work scheduled ( natural termination ).
* 2) If an uncaught exception it thrown ( or a unhandled promise rejection )
* 3) If a signal ( one of the handled ) is sent to the process.
*
* To manually exit the process there is two option:
* - Call process.exit(X) but the task function will not be called.
* - Emit "beforeExit" on process object ( process.emit("beforeExit, process.exitCode= X) );
* Doing so you simulate 1st stop condition ( natural termination ).
*
* To define the return code set process.exitCode. The exit code can be set
* before emitting "beforeExit" or in the task function.
* If exitCode has not be defined the process will exit with 0 if
* there was nothing else to do and 1 otherwise.
*
* The task function can be synchronous or asynchronous.
* The task function has [timeout] ms to complete.
* If it has not completed within this delay the process will
* be terminated anyway. (Default 4000 ms )
* Setting [timeout] to a negative value will disable the timer.
* WARNING: It is important not to perform sync operation that can
* hang for a long time in the task function ( e.g. execSync("sleep 1000"); )
* because while the sync operation are performed the timeout can't be triggered.
*
* As soon as the task function is called all the other exitCause that
* may auccur will be ignored so that the task function have time to complete.
* Anyway the task function is called only once.
*
* Whether the task function complete by successfully or throw
* an exception the process will terminate with exit code set
* in process.exitCode at the time of the completion.
*
* Provide shouldExitIf function to filter what should be
* considered a case to terminate the process.
* Only exception and supported signals can be bypassed,
* Nothing else to do will always terminate the process.
* By default exiting on any signal or uncaught errors.
*
* Before exiting all subprocess will be killed.
*
*
*/
function setProcessExitHandler(task, timeout, shouldExitIf) {
var e_2, _a, e_3, _b;
var _this = this;
if (timeout === void 0) { timeout = 4000; }
if (shouldExitIf === void 0) { shouldExitIf = function () { return true; }; }
var log = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return setProcessExitHandler.log("[ exit handler ] " + util.format.apply(util, args));
};
var handler = function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var process_exit, actionOut, error_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (exitCause.type !== "NOTHING ELSE TO DO" && !shouldExitIf(exitCause)) {
log("Choosing ( c.f shouldExitIf ) not to terminate the process despite: ", exitCause);
return [2 /*return*/];
}
handler = function (exitCause) { return log("Ignored extra exit cause", exitCause); };
process_exit = function () {
if (typeof process.exitCode !== "number" || isNaN(process.exitCode)) {
if (exitCause.type === "NOTHING ELSE TO DO") {
process.exitCode = 0;
}
else {
log("Exit cause " + exitCause.type + " and not exitCode have been set, using exit code 1");
process.exitCode = 1;
}
}
else {
log("Exit code have been set to " + process.exitCode);
}
log("Stopping subprocess asap if any...");
stopProcessSync.stopSubProcessesAsapSync();
log("exiting now with code " + process.exitCode);
process.exit();
};
log("Cause of process termination: ", exitCause);
if (timeout >= 0) {
setTimeout(function () {
log("Exit task timeout");
process.exitCode = 1;
process_exit();
}, timeout);
}
try {
actionOut = task(exitCause);
}
catch (error) {
log("Exit task thrown error", error);
process_exit();
return [2 /*return*/];
}
if (!(actionOut instanceof Promise)) return [3 /*break*/, 4];
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, actionOut];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
error_4 = _a.sent();
log("Exit task returned a promise that rejected", error_4);
process_exit();
return [2 /*return*/];
case 4:
log("Exit task complete successfully.");
process_exit();
return [2 /*return*/];
}
});
}); };
var _loop_1 = function (signal) {
process.on(signal, function () { return handler({ "type": "SIGNAL", signal: signal }); });
};
try {
for (var _c = __values(setProcessExitHandler.ExitCause.Signal.list), _d = _c.next(); !_d.done; _d = _c.next()) {
var signal = _d.value;
_loop_1(signal);
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_2) throw e_2.error; }
}
try {
for (var _e = __values(["uncaughtException", "unhandledRejection"]), _f = _e.next(); !_f.done; _f = _e.next()) {
var eventName = _f.value;
process.on(eventName, function (error) { return handler({ "type": "EXCEPTION", error: error }); });
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
}
finally { if (e_3) throw e_3.error; }
}
process.on("beforeExit", function () { return handler({ "type": "NOTHING ELSE TO DO" }); });
}
exports.setProcessExitHandler = setProcessExitHandler;
(function (setProcessExitHandler) {
var ExitCause;
(function (ExitCause) {
var Signal;
(function (Signal) {
Signal._obj = { "SIGINT": null, "SIGUSR2": null, "SIGHUP": null };
Signal.list = Object.keys(Signal._obj);
})(Signal = ExitCause.Signal || (ExitCause.Signal = {}));
})(ExitCause = setProcessExitHandler.ExitCause || (setProcessExitHandler.ExitCause = {}));
setProcessExitHandler.log = function () { };
})(setProcessExitHandler = exports.setProcessExitHandler || (exports.setProcessExitHandler = {}));
/**
*
* Stop a process by sending a specific signal to a target process.
* When the function return the main process and all it's descendent processes are terminated.
*
* The default signal is SIGUSR2 which is the signal used to gracefully terminate
* Process created by the createService function.
*
* Optionally runfiles_path can be provided to define a set of files
* that should be suppressed before returning.
*
* If pid is provided under the form of a pidfile path it will
* be added to the runfiles set.
*
* If all the processes does not terminate within [delay_before_sigkill]ms
* (default 50000) then KILL signal will be sent to all processes still alive.
*
* If the PID provided is the same that the PID of the process running the function
* PidMatchCurrentProcessError will be thrown.
*
*/
function stopProcessSync(pidfile_path_or_pid, signal, delay_before_sigkill, runfiles_path) {
if (signal === void 0) { signal = "SIGUSR2"; }
if (delay_before_sigkill === void 0) { delay_before_sigkill = 5000; }
if (runfiles_path === void 0) { runfiles_path = []; }
var log = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return stopProcessSync.log("[ stop process sync ] " + util.format.apply(util, args));
};
var cleanupRunfiles = function () {
var e_4, _a;
try {
for (var runfiles_path_1 = __values(runfiles_path), runfiles_path_1_1 = runfiles_path_1.next(); !runfiles_path_1_1.done; runfiles_path_1_1 = runfiles_path_1.next()) {
var runfile_path = runfiles_path_1_1.value;
if (fs.existsSync(runfile_path)) {
try {
fs.unlinkSync(runfile_path);
log(path.basename(runfile_path) + " runfile manually cleaned up.");
}
catch (_b) {
log(colorize("Could not remove runfile " + runfile_path, "RED"));
}
}
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (runfiles_path_1_1 && !runfiles_path_1_1.done && (_a = runfiles_path_1.return)) _a.call(runfiles_path_1);
}
finally { if (e_4) throw e_4.error; }
}
};
var pid;
if (typeof pidfile_path_or_pid === "number") {
pid = pidfile_path_or_pid;
}
else {
var pidfile_path = pidfile_path_or_pid;
runfiles_path = __spread([pidfile_path], runfiles_path);
if (!fs.existsSync(pidfile_path)) {
log("Pidfile does not exist, assuming process not running");
cleanupRunfiles();
return;
}
try {
pid = parseInt(fs.readFileSync(pidfile_path).toString("utf8").replace(/\n$/, ""));
if (isNaN(pid)) {
throw new Error("pid is NaN");
}
}
catch (_a) {
log("Pidfile does does not contain pid");
cleanupRunfiles();
return;
}
}
if (pid === process.pid) {
throw new stopProcessSync.PidMatchCurrentProcessError(cleanupRunfiles);
}
var pids = __spread(stopProcessSync.getSubProcesses(pid, "FULL PROCESS TREE"), [
pid
]);
var startTime = Date.now();
if (stopProcessSync.isProcessRunning(pid)) {
log("Sending " + signal + " to target process (" + pid + ")");
stopProcessSync.kill(pid, signal);
}
else {
log("Target process (" + pid + ") is not running");
}
var _loop_2 = function () {
var e_5, _a;
var runningPids = pids.filter(function (pid) { return stopProcessSync.isProcessRunning(pid); });
if (runningPids.length === 0) {
log("Target process (" + pid + ") and all it's sub processes are now terminated");
return "break";
}
else if (Date.now() >= startTime + delay_before_sigkill) {
log((function () {
if (delay_before_sigkill === 0) {
return "Immediately sending SIGKILL to " + runningPids.length + " remaining sub processes of target process (" + pid + ")";
}
else {
return [
!!runningPids.find(function (_pid) { return _pid === pid; }) ?
"Target process (" + pid + ") and " + (runningPids.length - 1) + " of it's sub processes" :
runningPids.length + " sub processes of the target process (" + pid + ")",
"did not terminate in time, sending KILL signals."
].join(" ");
}
})());
try {
for (var runningPids_1 = (e_5 = void 0, __values(runningPids)), runningPids_1_1 = runningPids_1.next(); !runningPids_1_1.done; runningPids_1_1 = runningPids_1.next()) {
var pid_1 = runningPids_1_1.value;
stopProcessSync.kill(pid_1, "SIGKILL");
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (runningPids_1_1 && !runningPids_1_1.done && (_a = runningPids_1.return)) _a.call(runningPids_1);
}
finally { if (e_5) throw e_5.error; }
}
return "continue";
}
execSyncNoCmdTrace("sleep 0.1");
};
while (true) {
var state_1 = _loop_2();
if (state_1 === "break")
break;
}
cleanupRunfiles();
}
exports.stopProcessSync = stopProcessSync;
(function (stopProcessSync) {
var PidMatchCurrentProcessError = /** @class */ (function (_super) {
__extends(PidMatchCurrentProcessError, _super);
function PidMatchCurrentProcessError(cleanupRunfiles) {
var _newTarget = this.constructor;
var _this = _super.call(this, "StopProcessSync error, provided PID is the PID of the current process") || this;
_this.cleanupRunfiles = cleanupRunfiles;
Object.setPrototypeOf(_this, _newTarget.prototype);
return _this;
}
return PidMatchCurrentProcessError;
}(Error));
stopProcessSync.PidMatchCurrentProcessError = PidMatchCurrentProcessError;
/**
* Stopping process As Soon As Possible,
* stopProcessSync with signal SIGKILL and timeout 0
* */
function stopProcessAsapSync(pidfile_path_or_pid, runfiles_path) {
if (runfiles_path === void 0) { runfiles_path = []; }
stopProcessSync(pidfile_path_or_pid, "SIGKILL", 0, runfiles_path);
}
stopProcessSync.stopProcessAsapSync = stopProcessAsapSync;
/**
* Terminate all child process of current process ASAP.
*
* NOTE: Directly after this function ( in the current tick )
* direct parents process that had sub processes will be Zombies.
* However they will be reaped by the current process on next tick.
*
*/
function stopSubProcessesAsapSync() {
var e_6, _a;
try {
for (var _b = __values(getSubProcesses(process.pid, "DIRECT SUB PROCESSES ONLY")), _c = _b.next(); !_c.done; _c = _b.next()) {
var pid = _c.value;
if (stopSubProcessesAsapSync.ignorePids.has(pid)) {
continue;
}
stopProcessSync(pid, "SIGKILL", 0);
}
}
catch (e_6_1) { e_6 = { error: e_6_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_6) throw e_6.error; }
}
}
stopProcessSync.stopSubProcessesAsapSync = stopSubProcessesAsapSync;
(function (stopSubProcessesAsapSync) {
stopSubProcessesAsapSync.ignorePids = new Set();
})(stopSubProcessesAsapSync = stopProcessSync.stopSubProcessesAsapSync || (stopProcessSync.stopSubProcessesAsapSync = {}));
/** Invoke kill, can't throw */
function kill(pid, signal) {
try {
execSyncNoCmdTrace("kill -" + signal + " " + pid, { "stdio": "pipe", "shell": "/bin/bash" });
}
catch (_a) {
}
}
stopProcessSync.kill = kill;
/**
* Get the list of subprocess of a process ( return a list of pid )
*/
function getSubProcesses(pid, depth) {
var _a = child_process.spawnSync("/bin/ps", ["--ppid", "" + pid, "-o", "pid,state"], { "shell": false }), stdout = _a.stdout, ps_pid = _a.pid, ps_exitCode = _a.status;
if (ps_exitCode !== 0) {
return [];
}
var pids = stdout
.toString("utf8")
.split("\n")
.filter(function (v) { return !v.match(/Z/); })
.map(function (v) { return v.replace(/[^0-9]/g, ""); })
.filter(function (v) { return !!v; })
.map(function (v) { return parseInt(v); })
.filter(function (pid) { return pid !== ps_pid; });
switch (depth) {
case "DIRECT SUB PROCESSES ONLY": return pids;
case "FULL PROCESS TREE": return (function () {
var e_7, _a;
var out = [];
try {
for (var pids_1 = __values(pids), pids_1_1 = pids_1.next(); !pids_1_1.done; pids_1_1 = pids_1.next()) {
var pid_2 = pids_1_1.value;
out = __spread(out, getSubProcesses(pid_2, "FULL PROCESS TREE"), [pid_2]);
}
}
catch (e_7_1) { e_7 = { error: e_7_1 }; }
finally {
try {
if (pids_1_1 && !pids_1_1.done && (_a = pids_1.return)) _a.call(pids_1);
}
finally { if (e_7) throw e_7.error; }
}
return out;
})();
}
}
stopProcessSync.getSubProcesses = getSubProcesses;
/** Return true only if exist and is not a daemon */
function isProcessRunning(pid) {
var psCmdOut;
try {
psCmdOut = execSyncNoCmdTrace("ps --pid " + pid + " -o state");
}
catch (_a) {
return false;
}
return !psCmdOut.match(/Z/);
}
stopProcessSync.isProcessRunning = isProcessRunning;
/** Debug function to print the process tree of the current process. */
function _printProcessTree(log) {
if (log === void 0) { log = console.log.bind(console); }
var rec = function (node) {
var e_8, _a;
var pids = getSubProcesses(node.pid, "DIRECT SUB PROCESSES ONLY");
if (pids.length === 0) {
return;
}
node.sub = [];
try {
for (var pids_2 = __values(pids), pids_2_1 = pids_2.next(); !pids_2_1.done; pids_2_1 = pids_2.next()) {
var pid = pids_2_1.value;
var sub_node = { pid: pid };
node.sub.push(sub_node);
rec(sub_node);
}
}
catch (e_8_1) { e_8 = { error: e_8_1 }; }
finally {
try {
if (pids_2_1 && !pids_2_1.done && (_a = pids_2.return)) _a.call(pids_2);
}
finally { if (e_8) throw e_8.error; }
}
};
var tree = { "pid": process.pid };
rec(tree);
log(JSON.stringify(tree, null, 3));
}
stopProcessSync._printProcessTree = _printProcessTree;
stopProcessSync.log = function () { };
})(stopProcessSync = exports.stopProcessSync || (exports.stopProcessSync = {}));
/**
*
* Function to create the entry point (main.js) of a node service that can:
* -Restart on crash (without relying on systemd to do so).
* -Execute as specific unix user but can perform tasks as root before start.
* -Be stopped gracefully by sending USR2 signal on the root process ( identified by pidfile ).
* -Be started via a shell and gracefully stopped with CTRL-C (INT signal).
* -Ensure only one instance of the service run at the same time.
* ( if at the time the main is called there is an other instance of the service
* running it is gracefully terminated )
* -Ensure that the process will terminate in at most [ stop_timeout ] ms after
* receiving INT or USR2 signal. (default 5second)
* -Forward daemon processes stdout to root process stdout.
* -Can fork multiple daemon process.
*
* The root process forward command line arguments and environnement variable to
* the daemon processes.
*
* => rootProcess function should return ( when not default ):
* -pidfile_path: where to store the pid of the root process.
* take to terminate after requested to exit gracefully.
* -srv_name: Name of the service to overwrite the process names. (Default: not overwriting)
* -stop_timeout: The maximum amount of time ( in ms ) the
* that beforeExitTask can take to complete before being killed by force by root process.
* After receiving USR2 signal or CTRL, the root process will be closed within [trop_timeout]+1000ms
* -assert_unix_user: enforce that the main be called by a specific user.
* -isQuiet?: set to true to disable process debug info logging on stdout. Prefixed by [ service ]. ( default false )
* -doForwardDaemonStdout?: set to true to forward everything the daemon
* process write to stdout to the root process stdout. ( default true )
* -daemon_unix_user?: User who should own the daemon process.
* -daemon_node_path?: Node.js executable that should be used to by the daemon process.
* -daemon_cwd?: working directory of the daemon process.
* -daemon_restart_after_crash_delay?: ( Default to 500ms. )Delay in ms before restarting the daemon
* after it terminate without being requested to. If set to a negative number the daemons
* will not be restarted after it terminate for the first time and :
* If all daemons process exited with 0 and there is no other daemon process the root process
* will end with a clean exit code.
* If any of the daemon exit with an unclean code the root process will be terminated with an error code
* even if there is some other daemon running.
* -daemon_count: Number of instance of daemon process that should be forked, default 1.
* -max_consecutive_restart: Number of time a daemon should be restarted after crashing right after start.
* (Default ~Infinity).
* -preForkTask: Task to perform before forking a daemon process.
* It is called just before forking the daemon process. ( called again on every restart. )
* If the function is async the daemon will not be forked until the returned promise resolve.
* If the function throw exception root process will exit with code 1.
* (pidfile will be deleted)
* If the function is async and if it need to spawn child processes then
* an implementation for terminateSubProcess ( passed as reference ) should be provided so that
* if when called it kill all the child processes then resolve once they are terminated.
* The to which the promise resolve will be used as exit code for the root process.
* Note that terminateSubProcess should never be called, it is a OUT parameter.
* However if the implementation provided is just to send a SIGKILL to the forked processes
* then there is no need to provide an implementation as all the root process's sub processes tree
* will be killed before exiting anyway.
*
* => daemonProcess
* It should return:
* -launch: the function that the daemon process need to call to start the actual job that the service is meant to perform.
* -beforeExitTask: function that should be called before the daemon process exit. ( e.g. creating crash report ).
* If the daemon process is terminating due to an error the error will be passed as argument.
* There is two scenario that will led to this function NOT being called:
* 1)The daemon process receive KILL or other deadly signal that can't be overridden.
* 2)The root process terminate.
* daemon_number represent the instance index of the daemon among the total of [damon_count] process forked.
* It can be user to use a different logfile for each daemon process instance.
*
* NOTE: If the root process receive a deadly signal other than INT, USR2 or HUP
* ( e.g. KILL or STOP ) the root and daemon processes will immediately terminate without
* executing beforeExit tasks or removing pidfile.
*
* NOTE: because setting listener on "message" and "disconnect" process event prevent the
* thread from terminating naturally where is nothing more to do if you wish to manually
* terminate the daemon process without termination being requested from the parent you can:
* 1) emit "beforeExit" on process setting the desired exit code ( process.emit("beforeExit", process.exitCode= X);
* 2) throw an exception.
*
*/
function createService(params) {
var _this = this;
var log = (function () { });
var getLog = function (prefix) {
return (function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return process.stdout.write(Buffer.from("[service] ( " + prefix + " ) " + util.format.apply(util, args) + "\n", "utf8"));
});
};
var rootProcess = params.rootProcess, daemonProcess = params.daemonProcess;
var main_root = function (main_js_path) { return __awaiter(_this, void 0, void 0, function () {
var _a, pidfile_path, srv_name, _stop_timeout, assert_unix_user, isQuiet, _doForwardDaemonStdout, daemon_unix_user, daemon_node_path, daemon_cwd, _daemon_restart_after_crash_delay, max_consecutive_restart, preForkTask, _daemon_count, stop_timeout, doForwardDaemonStdout, daemon_restart_after_crash_delay, daemon_count, daemonContexts, isTerminating, args, _b, daemon_uid, daemon_gid, makeForkOptions, forkDaemon, daemon_number;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0: return [4 /*yield*/, rootProcess()];
case 1:
_a = _c.sent(), pidfile_path = _a.pidfile_path, srv_name = _a.srv_name, _stop_timeout = _a.stop_timeout, assert_unix_user = _a.assert_unix_user, isQuiet = _a.isQuiet, _doForwardDaemonStdout = _a.doForwardDaemonStdout, daemon_unix_user = _a.daemon_unix_user, daemon_node_path = _a.daemon_node_path, daemon_cwd = _a.daemon_cwd, _daemon_restart_after_crash_delay = _a.daemon_restart_after_crash_delay, max_consecutive_restart = _a.max_consecutive_restart, preForkTask = _a.preForkTask, _daemon_count = _a.daemon_count;
if (srv_name !== undefined) {
process.title = srv_name + " root process";
}
stop_timeout = _stop_timeout !== undefined ?
_stop_timeout : 5000;
doForwardDaemonStdout = _doForwardDaemonStdout !== undefined ?
_doForwardDaemonStdout : true;
daemon_restart_after_crash_delay = _daemon_restart_after_crash_delay !== undefined ?
_daemon_restart_after_crash_delay : 500;
daemon_count = _daemon_count !== undefined ?
_daemon_count : 1;
if (assert_unix_user !== undefined && os.userInfo().username !== assert_unix_user) {
console.log(colorize("Must be run as " + assert_unix_user, "RED"));
process.exit(1);
return [2 /*return*/];
}
if (!isQuiet) {
log = getLog("root process");
}
stopProcessSync.log = log;
try {
stopProcessSync(pidfile_path);
}
catch (error) {
if (!(error instanceof stopProcessSync.PidMatchCurrentProcessError)) {
throw error;
}
error.cleanupRunfiles();
}
if (fs.existsSync(pidfile_path)) {
throw Error("Other instance launched simultaneously");
}
(function createPidfile() {
var pidfile_dir_path = path.dirname(pidfile_path);
if (!fs.existsSync(pidfile_dir_path)) {
execSyncNoCmdTrace("mkdir -p " + pidfile_dir_path);
}
fs.writeFileSync(pidfile_path, process.pid.toString());
})();
log("PID: " + process.pid);
daemonContexts = new Map((new Array(daemon_count))
.fill(null)
.map(function (_, index) {
var context = [
index + 1,
{
"daemonProcess": undefined,
"terminatePreForkChildProcesses": { "impl": function () { return Promise.resolve(); } },
"restart_attempt_remaining": max_consecutive_restart || NaN,
"reset_restart_attempt_timer": setTimeout(function () { }, 0)
}
];
return context;
}));
isTerminating = false;
setProcessExitHandler(function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var childProcessExitCode;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
isTerminating = true;
return [4 /*yield*/, (function terminateAllChildProcesses() {
return __awaiter(this, void 0, void 0, function () {
var terminateDaemonProcess, terminatePreForkChildProcessesSafeCall, tasks, _loop_3, _a, _b, _c, daemonProcess_1, terminatePreForkChildProcesses;
var e_9, _d;
var _this = this;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
terminateDaemonProcess = function (daemonProcess) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, new Promise(function (resolve) {
log("Attempt to gracefully terminate daemon process PID: " + daemonProcess.pid + "...");
daemonProcess.send(null);
var timer = setTimeout(function () { return doStopAsap(); }, stop_timeout + 500);
daemonProcess.once("error", function () { return doStopAsap(); });
daemonProcess.once("close", function (childProcessExitCode) {
clearTimeout(timer);
log("Daemon process PID: " + daemonProcess.pid + " exited with code " + childProcessExitCode);
if (typeof childProcessExitCode !== "number" || isNaN(childProcessExitCode)) {
childProcessExitCode = 1;
}
resolve(childProcessExitCode);
});
var doStopAsap = function () {
log("Daemon process PID:" + daemonProcess.pid + " not responding, force kill...");
clearTimeout(timer);
daemonProcess.removeAllListeners("error");
daemonProcess.removeAllListeners("close");
stopProcessSync.stopProcessAsapSync(daemonProcess.pid);
resolve(1);
};
})];
});
}); };
terminatePreForkChildProcessesSafeCall = function (impl) {
var timer;
return Promise.race([
new Promise(function (resolve) { return timer = setTimeout(function () { return resolve("TIMEOUT"); }, stop_timeout + 500); }),
(function () { return __awaiter(_this, void 0, void 0, function () {
var result, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_b.trys.push([0, 2, , 3]);
return [4 /*yield*/, impl()];
case 1:
_b.sent();
result = "SUCCESS";
return [3 /*break*/, 3];
case 2:
_a = _b.sent();
result = "ERROR";
return [3 /*break*/, 3];
case 3:
clearTimeout(timer);
return [2 /*return*/, result];
}
});
}); })()
]);
};
tasks = [];
_loop_3 = function (daemonProcess_1, terminatePreForkChildProcesses) {
tasks[tasks.length] = !daemonProcess_1 ? (new Promise(function (resolve) { return terminatePreForkChildProcessesSafeCall(terminatePreForkChildProcesses.impl)
.then(function (result) { return result === "SUCCESS" ? resolve(0) : resolve(1); }); })) : terminateDaemonProcess(daemonProcess_1);
};
try {
for (_a = __values(daemonContexts.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
_c = _b.value, daemonProcess_1 = _c.daemonProcess, terminatePreForkChildProcesses = _c.terminatePreForkChildProcesses;
_loop_3(daemonProcess_1, terminatePreForkChildProcesses);
}
}
catch (e_9_1) { e_9 = { error: e_9_1 }; }
finally {
try {
if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
}
finally { if (e_9) throw e_9.error; }
}
return [4 /*yield*/, Promise.all(tasks)];
case 1: return [2 /*return*/, (_e.sent()).reduce(function (accumulator, currentValue) { return accumulator === 0 ? currentValue : accumulator; }, 0)];
}
});
});
})()];
case 1:
childProcessExitCode = _a.sent();
if (exitCause.type === "EXCEPTION") {
/*
preForkTask throw or daemonProcess emit error or
one of the daemon exited with a non 0 code and
restart_delay was set <0
*/
log("Root process exception message: " + exitCause.error.message);
process.exitCode = 1;
}
else {
process.exitCode = childProcessExitCode;
}
fs.unlinkSync(pidfile_path);
log("pidfile deleted");
return [2 /*return*/];
}
});
}); }, stop_timeout + 1000);
setProcessExitHandler.log = log;
args = (function () {
var out = __spread(process.argv);
out.shift();
out.shift();
return out;
})();
_b = __read((function () {
if (!!daemon_unix_user) {
return [get_uid(daemon_unix_user), get_gid(daemon_unix_user)];
}
else {
return [undefined, undefined];
}
})(), 2), daemon_uid = _b[0], daemon_gid = _b[1];
makeForkOptions = function (daemon_number) { return ({
"uid": daemon_uid,
"gid": daemon_gid,
"silent": true,
"cwd": daemon_cwd,
"execPath": daemon_node_path,
"env": __assign({}, process.env, { daemon_number: daemon_number,
daemon_count: daemon_count,
srv_name: srv_name,
stop_timeout: stop_timeout, "isQuiet": isQuiet ? "1" : "0" })
}); };
forkDaemon = function (daemon_number) { return __awaiter(_this, void 0, void 0, function () {
var context, error_5, daemonProcess;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
context = daemonContexts.get(daemon_number);
clearTimeout(context.reset_restart_attempt_timer);
if (!!!preForkTask) return [3 /*break*/, 5];
log("performing pre fork tasks for daemon number " + daemon_number + "...");
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, preForkTask(context.terminatePreForkChildProcesses, daemon_number)];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
error_5 = _a.sent();
log("PreFork tasks for daemon number " + daemon_number + " raised an exception");
throw error_5;
case 4:
context.terminatePreForkChildProcesses.impl = function () { return Promise.resolve(); };
_a.label = 5;
case 5:
if (isTerminating) {
log("Not forking daemon because root process is terminating");
return [2 /*return*/];
}
if (max_consecutive_restart !== undefined) {
context.reset_restart_attempt_timer = setTimeout(function () { return context.restart_attempt_remaining = max_consecutive_restart; }, 10000);
}
log("Forking daemon process number " + daemon_number + " now.");
daemonProcess = child_process.fork(main_js_path, args, makeForkOptions(daemon_number));
context.daemonProcess = daemonProcess;
if (doForwardDaemonStdout) {
daemonProcess.stdout.on("data", function (data) {
return process.stdout.write(data);
});
}
daemonProcess.once("error", function (error) {
if (isTerminating) {
return;
}
context.daemonProcess = undefined;
log([
"Error evt emitted by daemon process number " + daemon_number,
"Meaning that: ",
"The process could not be spawned, or",
"The process could not be killed, or",
"Sending a message to the child process failed."
].join("\n"));
throw error;
});
daemonProcess.once("close", function (childProcessExitCode) {
if (isTerminating) {
return;
}
context.daemonProcess = undefined;
log("Daemon process " + daemon_number + " exited without being requested to.");
if (daemon_restart_after_crash_delay < 0) {
if (childProcessExitCode === null) {
childProcessExitCode = 1;
}
log("Daemon number " + daemon_number + " will not be restarted.");
clearTimeout(context.reset_restart_attempt_timer);
if (childProcessExitCode !== 0) {
throw new Error("Daemon number " + daemon_number + ", crashed");
}
else if (!Array.from(daemonContexts.values()).find(function (_a) {
var daemonProcess = _a.daemonProcess;
return !!daemonProcess;
})) {
log("As last remaining daemon process terminated cleanly we stop end root process");
process.emit("beforeExit", NaN);
}
return;
}
if (max_consecutive_restart !== undefined) {
if (context.restart_attempt_remaining-- === 0) {
throw new Error("Daemon process " + daemon_number + " is crashing over and over");
}
else {
log("Restart remaining: " + context.restart_attempt_remaining);
}
}
log("Daemon process " + daemon_number + " will be restarted");
setTimeout(function () { return forkDaemon(daemon_number); }, daemon_restart_after_crash_delay);
});
return [2 /*return*/];
}
});
}); };
for (daemon_number = 1; daemon_number <= daemon_count; daemon_number++) {
forkDaemon(daemon_number);
}
return [2 /*return*/];
}
});
}); };
var main_daemon = function () { return __awaiter(_this, void 0, void 0, function () {
var _a, daemon_number, daemon_count, stop_timeout, isQuiet, srv_name, _b, launch, beforeExitTask;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = __read(["daemon_number", "daemon_count", "stop_timeout", "isQuiet"].map(function (key) {
var value = parseInt(process.env[key]);
delete process.env[key];
return value;
}), 4), daemon_number = _a[0], daemon_count = _a[1], stop_timeout = _a[2], isQuiet = _a[3];
srv_name = (function () {
var key = "srv_name";
var value = process.env[key];
delete process.env[key];
if (value === "" + undefined) {
return undefined;
}
else {
return value;
}
})();
if (!isQuiet) {
log = getLog("daemon process " + daemon_number + "/" + daemon_count + ", PID: " + process.pid);
}
if (srv_name !== undefined) {
process.title = srv_name + " daemon " + (daemon_count === 1 ? "" : daemon_number);
}
return [4 /*yield*/, daemonProcess(daemon_number, daemon_count)];
case 1:
_b = _c.sent(), launch = _b.launch, beforeExitTask = _b.beforeExitTask;
process.once("message", function () { return process.emit("beforeExit", process.exitCode = 0); });
process.once("disconnect", function () { return process.exit(1); });
setProcessExitHandler(function (exitCause) { return __awaiter(_this, void 0, void 0, function () {
var error, prBeforeExitTask;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
error = exitCause.type === "EXCEPTION" ? exitCause.error : undefined;
if (!!!beforeExitTask) return [3 /*break*/, 2];
prBeforeExitTask = beforeExitTask(error);
if (!(prBeforeExitTask instanceof Promise)) return [3 /*break*/, 2];
return [4 /*yield*/, safePr(prBeforeExitTask, stop_timeout + 2000).then(function (error) {
if (error instanceof Error) {
//NOTE: Throwing does not overwrite the exit code.
if (error.message === safePr.timeoutErrorMessage) {
//NOTE: Throwing string to not have the log of setProcessExitHandler
//display the stack trace.
throw "beforeExitTask took too much time to complete.";
}
else {
throw error;
}
}
})];
case 1:
_a.sent();
_a.label = 2;
case 2: return [2 /*return*/];
}
});
}); }, -1, function (exitCause) { return exitCause.type !== "SIGNAL"; });
setProcessExitHandler.log = log;
launch();
return [2 /*return*/];
}
});
}); };
if (!process.send) {
main_root(get_caller_file_path_2.get_caller_file_path());
}
else {
main_daemon();
}
}
exports.createService = createService;
var systemd;
(function (systemd) {
var mkPath = function (srv_name) { return "/etc/systemd/system/" + srv_name + ".service"; };
/**
* Generate a systemd config file for a service created via "createService" function
* enable by default, start by default.
*/
function createConfigFile(srv_name, main_js_path, node_path, enable, start) {
if (node_path === void 0) { node_path = process.argv[0]; }
if (enable === void 0) { enable = "ENABLE"; }
if (start === void 0) { start = "START"; }
fs.writeFileSync(mkPath(srv_name), Buffer.from([
"[Unit]",
"After=network.target",
"",
"[Service]",
"ExecStart=" + node_path + " " + main_js_path,
"StandardOutput=inherit",
"KillMode=process",
"KillSignal=SIGUSR2",
"SendSIGKILL=no",
"Environment=NODE_ENV=production",
"",
"[Install]",
"WantedBy=multi-user.target",
""
].join("\n"), "utf8"));
execSyncNoCmdTrace("systemctl daemon-reload");
if (!!enable) {
execSyncNoCmdTrace("systemctl enable " + srv_name, { "stdio": "pipe" });
}
if (!!start) {
execSyncNoCmdTrace("systemctl start " + srv_name);
}
}
systemd.createConfigFile = createConfigFile;
/** Remove config file disable and reload daemon, never throw, stop is false by default */
function deleteConfigFile(srv_name, stop) {
if (stop === void 0) { stop = false; }
if (!!stop) {
execSyncNoCmdTrace("systemctl stop " + srv_name + " || true", { "stdio": "pipe" });
}
execSyncNoCmdTrace("systemctl disable " + srv_name + " || true", { "stdio": "pipe" });
try {
fs.unlinkSync(mkPath(srv_name));
}
catch (_a) { }
execSyncNoCmdTrace("systemctl daemon-reload || true", { "stdio": "pipe" });
}
systemd.deleteConfigFile = deleteConfigFile;
})(systemd = exports.systemd || (exports.systemd = {}));
/***/ }),
/***/ 6160:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Reflect = void 0;
/** Always return null but pretends it returns an object of type T */
function Reflect() {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return null;
}
exports.Reflect = Reflect;
//# sourceMappingURL=Reflect.js.map
/***/ }),
/***/ 2419:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.assert = exports.AssertionError = void 0;
/* eslint-disable @typescript-eslint/no-unused-vars */
var overwriteReadonlyProp_1 = __nccwpck_require__(43);
var assertIsRefWrapper_1 = __nccwpck_require__(2918);
/** @see <https://docs.tsafe.dev/assert#error-thrown> */
var AssertionError = /** @class */ (function (_super) {
__extends(AssertionError, _super);
function AssertionError(msg) {
var _newTarget = this.constructor;
var _this = _super.call(this, "Wrong assertion encountered" + (!msg ? "" : ": \"".concat(msg, "\""))) || this;
Object.setPrototypeOf(_this, _newTarget.prototype);
if (!_this.stack) {
return _this;
}
try {
(0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this, "stack", _this.stack
.split("\n")
.filter(function () {
var _a = [];
for (var _i = 0; _i < arguments.length; _i++) {
_a[_i] = arguments[_i];
}
var _b = __read(_a, 2), i = _b[1];
return i !== 1 && i !== 2;
})
.join("\n"));
// eslint-disable-next-line no-empty
}
catch (_a) { }
return _this;
}
return AssertionError;
}(Error));
exports.AssertionError = AssertionError;
/** https://docs.tsafe.dev/assert */
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function assert(condition, msg) {
if (arguments.length === 0) {
condition = true;
}
if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== undefined) {
assertIsRefWrapper_1.assertIsRefWrapper.ref = undefined;
return;
}
if (!condition) {
throw new AssertionError(msg);
}
}
exports.assert = assert;
//# sourceMappingURL=assert.js.map
/***/ }),
/***/ 2655:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.capitalize = void 0;
/** @see <https://docs.tsafe.dev/capitalize> */
function capitalize(str) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (str.charAt(0).toUpperCase() + str.slice(1));
}
exports.capitalize = capitalize;
//# sourceMappingURL=capitalize.js.map
/***/ }),
/***/ 5567:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.exclude = void 0;
/** Return a function to use as Array.prototype.filter argument
* to exclude one or many primitive value element from the array.
* Ex: ([ "a", "b", "c" ] as const).filter(exclude("a")) return ("b" | "c")[]
* Ex: ([ "a", "b", "c", "d"] as const).filter(exclude(["a", "b"]) gives ("c" | "d")[]
*/
function exclude(target) {
var test = target instanceof Object
? function (element) { return target.indexOf(element) < 0; }
: function (element) { return element !== target; };
return function (elemnt) {
return test(elemnt);
};
}
exports.exclude = exclude;
//# sourceMappingURL=exclude.js.map
/***/ }),
/***/ 8534:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.flip = void 0;
/**
* Flip the value of a boolean without having to reference it twice
* after running flip(x.y, "z") x.y.z !== x.y.z,
* https://docs.tsafe.dev/flip
*/
function flip(object, prop) {
if (object[prop] === undefined) {
return;
}
return (object[prop] = !object[prop]);
}
exports.flip = flip;
//# sourceMappingURL=flip.js.map
/***/ }),
/***/ 2632:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.id = void 0;
/** https://docs.tsafe.dev/id */
var id = function (x) { return x; };
exports.id = id;
//# sourceMappingURL=id.js.map
/***/ }),
/***/ 4653:
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
__exportStar(__nccwpck_require__(2419), exports);
__exportStar(__nccwpck_require__(5567), exports);
__exportStar(__nccwpck_require__(8534), exports);
__exportStar(__nccwpck_require__(2632), exports);
__exportStar(__nccwpck_require__(5639), exports);
__exportStar(__nccwpck_require__(6958), exports);
__exportStar(__nccwpck_require__(9980), exports);
__exportStar(__nccwpck_require__(3069), exports);
__exportStar(__nccwpck_require__(7937), exports);
__exportStar(__nccwpck_require__(5656), exports);
__exportStar(__nccwpck_require__(6640), exports);
__exportStar(__nccwpck_require__(1184), exports);
__exportStar(__nccwpck_require__(6160), exports);
__exportStar(__nccwpck_require__(2655), exports);
__exportStar(__nccwpck_require__(1392), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 3069:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.is = void 0;
var assertIsRefWrapper_1 = __nccwpck_require__(2918);
var errorMessage = [
"Wrong usage of the ".concat(is.name, " function refer to"),
"https://docs.tsafe.dev/".concat(is.name.toLowerCase()),
].join(" ");
function is(_value) {
var ref = {};
if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== undefined) {
assertIsRefWrapper_1.assertIsRefWrapper.ref = undefined;
throw new Error(errorMessage);
}
assertIsRefWrapper_1.assertIsRefWrapper.ref = ref;
Promise.resolve().then(function () {
if (assertIsRefWrapper_1.assertIsRefWrapper.ref === ref) {
throw new Error(errorMessage);
}
});
return null;
}
exports.is = is;
//# sourceMappingURL=is.js.map
/***/ }),
/***/ 7937:
/***/ (function(__unused_webpack_module, exports) {
"use strict";
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isAmong = void 0;
/** https://docs.tsafe.dev/isamong */
function isAmong(names, value) {
var e_1, _a;
try {
for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
var name_1 = names_1_1.value;
if (name_1 === value) {
return true;
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
}
finally { if (e_1) throw e_1.error; }
}
return false;
}
exports.isAmong = isAmong;
//# sourceMappingURL=isAmong.js.map
/***/ }),
/***/ 5639:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isPromiseLike = void 0;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function isPromiseLike(o) {
return typeof o === "object" && o !== null && "then" in o && typeof o.then === "function";
}
exports.isPromiseLike = isPromiseLike;
//# sourceMappingURL=isPromiseLike.js.map
/***/ }),
/***/ 43:
/***/ (function(__unused_webpack_module, exports) {
"use strict";
/* eslint-disable no-empty */
/* eslint-disable @typescript-eslint/no-explicit-any */
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.overwriteReadonlyProp = void 0;
/**
* Assign a value to a property even if the object is freezed or if the property is not writable
* Throw if the assignation fail ( for example if the property is non configurable write: false )
* */
var overwriteReadonlyProp = function (obj, propertyName, value) {
try {
obj[propertyName] = value;
}
catch (_a) { }
if (obj[propertyName] === value) {
return value;
}
var errorDefineProperty = undefined;
var propertyDescriptor = Object.getOwnPropertyDescriptor(obj, propertyName) || {
"enumerable": true,
"configurable": true,
};
if (!!propertyDescriptor.get) {
throw new Error("Probably a wrong ides to overwrite ".concat(String(propertyName), " getter"));
}
try {
Object.defineProperty(obj, propertyName, __assign(__assign({}, propertyDescriptor), { value: value }));
}
catch (error) {
errorDefineProperty = error;
}
if (obj[propertyName] !== value) {
throw errorDefineProperty || new Error("Can't assign");
}
return value;
};
exports.overwriteReadonlyProp = overwriteReadonlyProp;
//# sourceMappingURL=overwriteReadonlyProp.js.map
/***/ }),
/***/ 1184:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/ban-types */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.noUndefined = void 0;
/**
* Removes the enumerable properties whose values are
* undefined.
*
* Example:
* noUndefined({ "foo": undefined, "bar": 3 }) returns
* a new object { "bar": 3 }
*/
function noUndefined(obj) {
var out = {};
for (var key in obj) {
if (obj[key] === undefined) {
continue;
}
out[key] = obj[key];
}
return out;
}
exports.noUndefined = noUndefined;
//# sourceMappingURL=noUndefined.js.map
/***/ }),
/***/ 5656:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectEntries = void 0;
/** https://docs.tsafe.dev/objectentries */
function objectEntries(o) {
return Object.entries(o);
}
exports.objectEntries = objectEntries;
//# sourceMappingURL=objectEntries.js.map
/***/ }),
/***/ 6640:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectFromEntries = void 0;
/** https://docs.tsafe.dev/objectFromEntries */
function objectFromEntries(entries) {
return Object.fromEntries(entries);
}
exports.objectFromEntries = objectFromEntries;
//# sourceMappingURL=objectFromEntries.js.map
/***/ }),
/***/ 6958:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.objectKeys = void 0;
/** https://docs.tsafe.dev/objectKeys */
function objectKeys(o) {
return Object.keys(o);
}
exports.objectKeys = objectKeys;
//# sourceMappingURL=objectKeys.js.map
/***/ }),
/***/ 9980:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.typeGuard = void 0;
/** https://docs.tsafe.dev/typeguard */
function typeGuard(_value, isMatched) {
return isMatched;
}
exports.typeGuard = typeGuard;
//# sourceMappingURL=typeGuard.js.map
/***/ }),
/***/ 1392:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.uncapitalize = void 0;
/** @see <https://docs.tsafe.dev/capitalize#uncapitalize> */
function uncapitalize(str) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (str.charAt(0).toLowerCase() + str.slice(1));
}
exports.uncapitalize = uncapitalize;
//# sourceMappingURL=uncapitalize.js.map
/***/ }),
/***/ 2918:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.assertIsRefWrapper = void 0;
var id_1 = __nccwpck_require__(2632);
exports.assertIsRefWrapper = {
"ref": (0, id_1.id)(undefined),
};
//# sourceMappingURL=assertIsRefWrapper.js.map
/***/ }),
/***/ 181:
/***/ ((module) => {
"use strict";
module.exports = require("buffer");
/***/ }),
/***/ 5317:
/***/ ((module) => {
"use strict";
module.exports = require("child_process");
/***/ }),
/***/ 6982:
/***/ ((module) => {
"use strict";
module.exports = require("crypto");
/***/ }),
/***/ 9896:
/***/ ((module) => {
"use strict";
module.exports = require("fs");
/***/ }),
/***/ 8611:
/***/ ((module) => {
"use strict";
module.exports = require("http");
/***/ }),
/***/ 5692:
/***/ ((module) => {
"use strict";
module.exports = require("https");
/***/ }),
/***/ 4573:
/***/ ((module) => {
"use strict";
module.exports = require("node:buffer");
/***/ }),
/***/ 3024:
/***/ ((module) => {
"use strict";
module.exports = require("node:fs");
/***/ }),
/***/ 7067:
/***/ ((module) => {
"use strict";
module.exports = require("node:http");
/***/ }),
/***/ 4708:
/***/ ((module) => {
"use strict";
module.exports = require("node:https");
/***/ }),
/***/ 7030:
/***/ ((module) => {
"use strict";
module.exports = require("node:net");
/***/ }),
/***/ 6760:
/***/ ((module) => {
"use strict";
module.exports = require("node:path");
/***/ }),
/***/ 1708:
/***/ ((module) => {
"use strict";
module.exports = require("node:process");
/***/ }),
/***/ 7075:
/***/ ((module) => {
"use strict";
module.exports = require("node:stream");
/***/ }),
/***/ 7830:
/***/ ((module) => {
"use strict";
module.exports = require("node:stream/web");
/***/ }),
/***/ 3136:
/***/ ((module) => {
"use strict";
module.exports = require("node:url");
/***/ }),
/***/ 7975:
/***/ ((module) => {
"use strict";
module.exports = require("node:util");
/***/ }),
/***/ 8522:
/***/ ((module) => {
"use strict";
module.exports = require("node:zlib");
/***/ }),
/***/ 857:
/***/ ((module) => {
"use strict";
module.exports = require("os");
/***/ }),
/***/ 6928:
/***/ ((module) => {
"use strict";
module.exports = require("path");
/***/ }),
/***/ 3785:
/***/ ((module) => {
"use strict";
module.exports = require("readline");
/***/ }),
/***/ 9023:
/***/ ((module) => {
"use strict";
module.exports = require("util");
/***/ }),
/***/ 8167:
/***/ ((module) => {
"use strict";
module.exports = require("worker_threads");
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __nccwpck_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ var threw = true;
/******/ try {
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
/******/ threw = false;
/******/ } finally {
/******/ if(threw) delete __webpack_module_cache__[moduleId];
/******/ }
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat */
/******/
/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
(() => {
"use strict";
var exports = __webpack_exports__;
Object.defineProperty(exports, "__esModule", ({ value: true }));
const replacer_1 = __nccwpck_require__(1107);
(0, replacer_1.makeThisModuleAnExecutableReplacer)(async (params) => {
for (const { replacer } of await Promise.all([
Promise.resolve().then(() => __nccwpck_require__(464)),
Promise.resolve().then(() => __nccwpck_require__(8307)),
Promise.resolve().then(() => __nccwpck_require__(2381)),
Promise.resolve().then(() => __nccwpck_require__(1057)),
Promise.resolve().then(() => __nccwpck_require__(2132)),
Promise.resolve().then(() => __nccwpck_require__(2513))
])) {
const output = await replacer(params);
if (output !== undefined) {
return output;
}
}
return undefined;
});
})();
module.exports = __webpack_exports__;
/******/ })()
;