9799 lines
1.1 MiB
9799 lines
1.1 MiB
'use strict';
|
||
|
||
var obsidian = require('obsidian');
|
||
var require$$0$1 = require('path');
|
||
var require$$0 = require('fs');
|
||
var process$2 = require('node:process');
|
||
var require$$0$2 = require('child_process');
|
||
var require$$0$3 = require('os');
|
||
var require$$0$4 = require('assert');
|
||
var require$$2 = require('events');
|
||
var require$$0$6 = require('buffer');
|
||
var require$$0$5 = require('stream');
|
||
var require$$2$1 = require('util');
|
||
var node_os = require('node:os');
|
||
var node_buffer = require('node:buffer');
|
||
require('electron');
|
||
|
||
/******************************************************************************
|
||
Copyright (c) Microsoft Corporation.
|
||
|
||
Permission to use, copy, modify, and/or distribute this software for any
|
||
purpose with or without fee is hereby granted.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||
PERFORMANCE OF THIS SOFTWARE.
|
||
***************************************************************************** */
|
||
/* global Reflect, Promise */
|
||
|
||
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);
|
||
};
|
||
|
||
function __extends(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 __());
|
||
}
|
||
|
||
function __awaiter(thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
}
|
||
|
||
function __generator(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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
|
||
}
|
||
}
|
||
|
||
function __values(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.");
|
||
}
|
||
|
||
function __read(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;
|
||
}
|
||
|
||
function __spreadArray(to, from, pack) {
|
||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||
if (ar || !(i in from)) {
|
||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||
ar[i] = from[i];
|
||
}
|
||
}
|
||
return to.concat(ar || Array.prototype.slice.call(from));
|
||
}
|
||
|
||
function __asyncValues(o) {
|
||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
var m = o[Symbol.asyncIterator], i;
|
||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||
}
|
||
|
||
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
||
|
||
function getDefaultExportFromCjs (x) {
|
||
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
||
}
|
||
|
||
var execa$2 = {exports: {}};
|
||
|
||
var crossSpawn$1 = {exports: {}};
|
||
|
||
var windows;
|
||
var hasRequiredWindows;
|
||
|
||
function requireWindows () {
|
||
if (hasRequiredWindows) return windows;
|
||
hasRequiredWindows = 1;
|
||
windows = isexe;
|
||
isexe.sync = sync;
|
||
|
||
var fs = require$$0;
|
||
|
||
function checkPathExt (path, options) {
|
||
var pathext = options.pathExt !== undefined ?
|
||
options.pathExt : process.env.PATHEXT;
|
||
|
||
if (!pathext) {
|
||
return true
|
||
}
|
||
|
||
pathext = pathext.split(';');
|
||
if (pathext.indexOf('') !== -1) {
|
||
return true
|
||
}
|
||
for (var i = 0; i < pathext.length; i++) {
|
||
var p = pathext[i].toLowerCase();
|
||
if (p && path.substr(-p.length).toLowerCase() === p) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
function checkStat (stat, path, options) {
|
||
if (!stat.isSymbolicLink() && !stat.isFile()) {
|
||
return false
|
||
}
|
||
return checkPathExt(path, options)
|
||
}
|
||
|
||
function isexe (path, options, cb) {
|
||
fs.stat(path, function (er, stat) {
|
||
cb(er, er ? false : checkStat(stat, path, options));
|
||
});
|
||
}
|
||
|
||
function sync (path, options) {
|
||
return checkStat(fs.statSync(path), path, options)
|
||
}
|
||
return windows;
|
||
}
|
||
|
||
var mode;
|
||
var hasRequiredMode;
|
||
|
||
function requireMode () {
|
||
if (hasRequiredMode) return mode;
|
||
hasRequiredMode = 1;
|
||
mode = isexe;
|
||
isexe.sync = sync;
|
||
|
||
var fs = require$$0;
|
||
|
||
function isexe (path, options, cb) {
|
||
fs.stat(path, function (er, stat) {
|
||
cb(er, er ? false : checkStat(stat, options));
|
||
});
|
||
}
|
||
|
||
function sync (path, options) {
|
||
return checkStat(fs.statSync(path), options)
|
||
}
|
||
|
||
function checkStat (stat, options) {
|
||
return stat.isFile() && checkMode(stat, options)
|
||
}
|
||
|
||
function checkMode (stat, options) {
|
||
var mod = stat.mode;
|
||
var uid = stat.uid;
|
||
var gid = stat.gid;
|
||
|
||
var myUid = options.uid !== undefined ?
|
||
options.uid : process.getuid && process.getuid();
|
||
var myGid = options.gid !== undefined ?
|
||
options.gid : process.getgid && process.getgid();
|
||
|
||
var u = parseInt('100', 8);
|
||
var g = parseInt('010', 8);
|
||
var o = parseInt('001', 8);
|
||
var ug = u | g;
|
||
|
||
var ret = (mod & o) ||
|
||
(mod & g) && gid === myGid ||
|
||
(mod & u) && uid === myUid ||
|
||
(mod & ug) && myUid === 0;
|
||
|
||
return ret
|
||
}
|
||
return mode;
|
||
}
|
||
|
||
var core$1;
|
||
if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
|
||
core$1 = requireWindows();
|
||
} else {
|
||
core$1 = requireMode();
|
||
}
|
||
|
||
var isexe_1 = isexe$1;
|
||
isexe$1.sync = sync;
|
||
|
||
function isexe$1 (path, options, cb) {
|
||
if (typeof options === 'function') {
|
||
cb = options;
|
||
options = {};
|
||
}
|
||
|
||
if (!cb) {
|
||
if (typeof Promise !== 'function') {
|
||
throw new TypeError('callback not provided')
|
||
}
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
isexe$1(path, options || {}, function (er, is) {
|
||
if (er) {
|
||
reject(er);
|
||
} else {
|
||
resolve(is);
|
||
}
|
||
});
|
||
})
|
||
}
|
||
|
||
core$1(path, options || {}, function (er, is) {
|
||
// ignore EACCES because that just means we aren't allowed to run it
|
||
if (er) {
|
||
if (er.code === 'EACCES' || options && options.ignoreErrors) {
|
||
er = null;
|
||
is = false;
|
||
}
|
||
}
|
||
cb(er, is);
|
||
});
|
||
}
|
||
|
||
function sync (path, options) {
|
||
// my kingdom for a filtered catch
|
||
try {
|
||
return core$1.sync(path, options || {})
|
||
} catch (er) {
|
||
if (options && options.ignoreErrors || er.code === 'EACCES') {
|
||
return false
|
||
} else {
|
||
throw er
|
||
}
|
||
}
|
||
}
|
||
|
||
const isWindows = process.platform === 'win32' ||
|
||
process.env.OSTYPE === 'cygwin' ||
|
||
process.env.OSTYPE === 'msys';
|
||
|
||
const path$3 = require$$0$1;
|
||
const COLON = isWindows ? ';' : ':';
|
||
const isexe = isexe_1;
|
||
|
||
const getNotFoundError = (cmd) =>
|
||
Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
|
||
|
||
const getPathInfo = (cmd, opt) => {
|
||
const colon = opt.colon || COLON;
|
||
|
||
// If it has a slash, then we don't bother searching the pathenv.
|
||
// just check the file itself, and that's it.
|
||
const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
|
||
: (
|
||
[
|
||
// windows always checks the cwd first
|
||
...(isWindows ? [process.cwd()] : []),
|
||
...(opt.path || process.env.PATH ||
|
||
/* istanbul ignore next: very unusual */ '').split(colon),
|
||
]
|
||
);
|
||
const pathExtExe = isWindows
|
||
? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
|
||
: '';
|
||
const pathExt = isWindows ? pathExtExe.split(colon) : [''];
|
||
|
||
if (isWindows) {
|
||
if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
|
||
pathExt.unshift('');
|
||
}
|
||
|
||
return {
|
||
pathEnv,
|
||
pathExt,
|
||
pathExtExe,
|
||
}
|
||
};
|
||
|
||
const which$1 = (cmd, opt, cb) => {
|
||
if (typeof opt === 'function') {
|
||
cb = opt;
|
||
opt = {};
|
||
}
|
||
if (!opt)
|
||
opt = {};
|
||
|
||
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
|
||
const found = [];
|
||
|
||
const step = i => new Promise((resolve, reject) => {
|
||
if (i === pathEnv.length)
|
||
return opt.all && found.length ? resolve(found)
|
||
: reject(getNotFoundError(cmd))
|
||
|
||
const ppRaw = pathEnv[i];
|
||
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
|
||
|
||
const pCmd = path$3.join(pathPart, cmd);
|
||
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
|
||
: pCmd;
|
||
|
||
resolve(subStep(p, i, 0));
|
||
});
|
||
|
||
const subStep = (p, i, ii) => new Promise((resolve, reject) => {
|
||
if (ii === pathExt.length)
|
||
return resolve(step(i + 1))
|
||
const ext = pathExt[ii];
|
||
isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
|
||
if (!er && is) {
|
||
if (opt.all)
|
||
found.push(p + ext);
|
||
else
|
||
return resolve(p + ext)
|
||
}
|
||
return resolve(subStep(p, i, ii + 1))
|
||
});
|
||
});
|
||
|
||
return cb ? step(0).then(res => cb(null, res), cb) : step(0)
|
||
};
|
||
|
||
const whichSync = (cmd, opt) => {
|
||
opt = opt || {};
|
||
|
||
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
|
||
const found = [];
|
||
|
||
for (let i = 0; i < pathEnv.length; i ++) {
|
||
const ppRaw = pathEnv[i];
|
||
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
|
||
|
||
const pCmd = path$3.join(pathPart, cmd);
|
||
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
|
||
: pCmd;
|
||
|
||
for (let j = 0; j < pathExt.length; j ++) {
|
||
const cur = p + pathExt[j];
|
||
try {
|
||
const is = isexe.sync(cur, { pathExt: pathExtExe });
|
||
if (is) {
|
||
if (opt.all)
|
||
found.push(cur);
|
||
else
|
||
return cur
|
||
}
|
||
} catch (ex) {}
|
||
}
|
||
}
|
||
|
||
if (opt.all && found.length)
|
||
return found
|
||
|
||
if (opt.nothrow)
|
||
return null
|
||
|
||
throw getNotFoundError(cmd)
|
||
};
|
||
|
||
var which_1 = which$1;
|
||
which$1.sync = whichSync;
|
||
|
||
var pathKey$1 = {exports: {}};
|
||
|
||
const pathKey = (options = {}) => {
|
||
const environment = options.env || process.env;
|
||
const platform = options.platform || process.platform;
|
||
|
||
if (platform !== 'win32') {
|
||
return 'PATH';
|
||
}
|
||
|
||
return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
|
||
};
|
||
|
||
pathKey$1.exports = pathKey;
|
||
// TODO: Remove this for the next major release
|
||
pathKey$1.exports.default = pathKey;
|
||
|
||
var pathKeyExports = pathKey$1.exports;
|
||
|
||
const path$2 = require$$0$1;
|
||
const which = which_1;
|
||
const getPathKey = pathKeyExports;
|
||
|
||
function resolveCommandAttempt(parsed, withoutPathExt) {
|
||
const env = parsed.options.env || process.env;
|
||
const cwd = process.cwd();
|
||
const hasCustomCwd = parsed.options.cwd != null;
|
||
// Worker threads do not have process.chdir()
|
||
const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
|
||
|
||
// If a custom `cwd` was specified, we need to change the process cwd
|
||
// because `which` will do stat calls but does not support a custom cwd
|
||
if (shouldSwitchCwd) {
|
||
try {
|
||
process.chdir(parsed.options.cwd);
|
||
} catch (err) {
|
||
/* Empty */
|
||
}
|
||
}
|
||
|
||
let resolved;
|
||
|
||
try {
|
||
resolved = which.sync(parsed.command, {
|
||
path: env[getPathKey({ env })],
|
||
pathExt: withoutPathExt ? path$2.delimiter : undefined,
|
||
});
|
||
} catch (e) {
|
||
/* Empty */
|
||
} finally {
|
||
if (shouldSwitchCwd) {
|
||
process.chdir(cwd);
|
||
}
|
||
}
|
||
|
||
// If we successfully resolved, ensure that an absolute path is returned
|
||
// Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
|
||
if (resolved) {
|
||
resolved = path$2.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
|
||
}
|
||
|
||
return resolved;
|
||
}
|
||
|
||
function resolveCommand$1(parsed) {
|
||
return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
|
||
}
|
||
|
||
var resolveCommand_1 = resolveCommand$1;
|
||
|
||
var _escape = {};
|
||
|
||
// See http://www.robvanderwoude.com/escapechars.php
|
||
const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
|
||
|
||
function escapeCommand(arg) {
|
||
// Escape meta chars
|
||
arg = arg.replace(metaCharsRegExp, '^$1');
|
||
|
||
return arg;
|
||
}
|
||
|
||
function escapeArgument(arg, doubleEscapeMetaChars) {
|
||
// Convert to string
|
||
arg = `${arg}`;
|
||
|
||
// Algorithm below is based on https://qntm.org/cmd
|
||
|
||
// Sequence of backslashes followed by a double quote:
|
||
// double up all the backslashes and escape the double quote
|
||
arg = arg.replace(/(\\*)"/g, '$1$1\\"');
|
||
|
||
// Sequence of backslashes followed by the end of the string
|
||
// (which will become a double quote later):
|
||
// double up all the backslashes
|
||
arg = arg.replace(/(\\*)$/, '$1$1');
|
||
|
||
// All other backslashes occur literally
|
||
|
||
// Quote the whole thing:
|
||
arg = `"${arg}"`;
|
||
|
||
// Escape meta chars
|
||
arg = arg.replace(metaCharsRegExp, '^$1');
|
||
|
||
// Double escape meta chars if necessary
|
||
if (doubleEscapeMetaChars) {
|
||
arg = arg.replace(metaCharsRegExp, '^$1');
|
||
}
|
||
|
||
return arg;
|
||
}
|
||
|
||
_escape.command = escapeCommand;
|
||
_escape.argument = escapeArgument;
|
||
|
||
var shebangRegex$1 = /^#!(.*)/;
|
||
|
||
const shebangRegex = shebangRegex$1;
|
||
|
||
var shebangCommand$1 = (string = '') => {
|
||
const match = string.match(shebangRegex);
|
||
|
||
if (!match) {
|
||
return null;
|
||
}
|
||
|
||
const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
|
||
const binary = path.split('/').pop();
|
||
|
||
if (binary === 'env') {
|
||
return argument;
|
||
}
|
||
|
||
return argument ? `${binary} ${argument}` : binary;
|
||
};
|
||
|
||
const fs = require$$0;
|
||
const shebangCommand = shebangCommand$1;
|
||
|
||
function readShebang$1(command) {
|
||
// Read the first 150 bytes from the file
|
||
const size = 150;
|
||
const buffer = Buffer.alloc(size);
|
||
|
||
let fd;
|
||
|
||
try {
|
||
fd = fs.openSync(command, 'r');
|
||
fs.readSync(fd, buffer, 0, size, 0);
|
||
fs.closeSync(fd);
|
||
} catch (e) { /* Empty */ }
|
||
|
||
// Attempt to extract shebang (null is returned if not a shebang)
|
||
return shebangCommand(buffer.toString());
|
||
}
|
||
|
||
var readShebang_1 = readShebang$1;
|
||
|
||
const path$1 = require$$0$1;
|
||
const resolveCommand = resolveCommand_1;
|
||
const escape = _escape;
|
||
const readShebang = readShebang_1;
|
||
|
||
const isWin$2 = process.platform === 'win32';
|
||
const isExecutableRegExp = /\.(?:com|exe)$/i;
|
||
const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
|
||
|
||
function detectShebang(parsed) {
|
||
parsed.file = resolveCommand(parsed);
|
||
|
||
const shebang = parsed.file && readShebang(parsed.file);
|
||
|
||
if (shebang) {
|
||
parsed.args.unshift(parsed.file);
|
||
parsed.command = shebang;
|
||
|
||
return resolveCommand(parsed);
|
||
}
|
||
|
||
return parsed.file;
|
||
}
|
||
|
||
function parseNonShell(parsed) {
|
||
if (!isWin$2) {
|
||
return parsed;
|
||
}
|
||
|
||
// Detect & add support for shebangs
|
||
const commandFile = detectShebang(parsed);
|
||
|
||
// We don't need a shell if the command filename is an executable
|
||
const needsShell = !isExecutableRegExp.test(commandFile);
|
||
|
||
// If a shell is required, use cmd.exe and take care of escaping everything correctly
|
||
// Note that `forceShell` is an hidden option used only in tests
|
||
if (parsed.options.forceShell || needsShell) {
|
||
// Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
|
||
// The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
|
||
// Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
|
||
// we need to double escape them
|
||
const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
|
||
|
||
// Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
|
||
// This is necessary otherwise it will always fail with ENOENT in those cases
|
||
parsed.command = path$1.normalize(parsed.command);
|
||
|
||
// Escape command & arguments
|
||
parsed.command = escape.command(parsed.command);
|
||
parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
|
||
|
||
const shellCommand = [parsed.command].concat(parsed.args).join(' ');
|
||
|
||
parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
|
||
parsed.command = process.env.comspec || 'cmd.exe';
|
||
parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
|
||
}
|
||
|
||
return parsed;
|
||
}
|
||
|
||
function parse$1(command, args, options) {
|
||
// Normalize arguments, similar to nodejs
|
||
if (args && !Array.isArray(args)) {
|
||
options = args;
|
||
args = null;
|
||
}
|
||
|
||
args = args ? args.slice(0) : []; // Clone array to avoid changing the original
|
||
options = Object.assign({}, options); // Clone object to avoid changing the original
|
||
|
||
// Build our parsed object
|
||
const parsed = {
|
||
command,
|
||
args,
|
||
options,
|
||
file: undefined,
|
||
original: {
|
||
command,
|
||
args,
|
||
},
|
||
};
|
||
|
||
// Delegate further parsing to shell or non-shell
|
||
return options.shell ? parsed : parseNonShell(parsed);
|
||
}
|
||
|
||
var parse_1 = parse$1;
|
||
|
||
const isWin$1 = process.platform === 'win32';
|
||
|
||
function notFoundError(original, syscall) {
|
||
return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
|
||
code: 'ENOENT',
|
||
errno: 'ENOENT',
|
||
syscall: `${syscall} ${original.command}`,
|
||
path: original.command,
|
||
spawnargs: original.args,
|
||
});
|
||
}
|
||
|
||
function hookChildProcess(cp, parsed) {
|
||
if (!isWin$1) {
|
||
return;
|
||
}
|
||
|
||
const originalEmit = cp.emit;
|
||
|
||
cp.emit = function (name, arg1) {
|
||
// If emitting "exit" event and exit code is 1, we need to check if
|
||
// the command exists and emit an "error" instead
|
||
// See https://github.com/IndigoUnited/node-cross-spawn/issues/16
|
||
if (name === 'exit') {
|
||
const err = verifyENOENT(arg1, parsed);
|
||
|
||
if (err) {
|
||
return originalEmit.call(cp, 'error', err);
|
||
}
|
||
}
|
||
|
||
return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
|
||
};
|
||
}
|
||
|
||
function verifyENOENT(status, parsed) {
|
||
if (isWin$1 && status === 1 && !parsed.file) {
|
||
return notFoundError(parsed.original, 'spawn');
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function verifyENOENTSync(status, parsed) {
|
||
if (isWin$1 && status === 1 && !parsed.file) {
|
||
return notFoundError(parsed.original, 'spawnSync');
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
var enoent$1 = {
|
||
hookChildProcess,
|
||
verifyENOENT,
|
||
verifyENOENTSync,
|
||
notFoundError,
|
||
};
|
||
|
||
const cp = require$$0$2;
|
||
const parse = parse_1;
|
||
const enoent = enoent$1;
|
||
|
||
function spawn(command, args, options) {
|
||
// Parse the arguments
|
||
const parsed = parse(command, args, options);
|
||
|
||
// Spawn the child process
|
||
const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
|
||
|
||
// Hook into child process "exit" event to emit an error if the command
|
||
// does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
|
||
enoent.hookChildProcess(spawned, parsed);
|
||
|
||
return spawned;
|
||
}
|
||
|
||
function spawnSync(command, args, options) {
|
||
// Parse the arguments
|
||
const parsed = parse(command, args, options);
|
||
|
||
// Spawn the child process
|
||
const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
|
||
|
||
// Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
|
||
result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
|
||
|
||
return result;
|
||
}
|
||
|
||
crossSpawn$1.exports = spawn;
|
||
crossSpawn$1.exports.spawn = spawn;
|
||
crossSpawn$1.exports.sync = spawnSync;
|
||
|
||
crossSpawn$1.exports._parse = parse;
|
||
crossSpawn$1.exports._enoent = enoent;
|
||
|
||
var crossSpawnExports = crossSpawn$1.exports;
|
||
|
||
var stripFinalNewline$1 = input => {
|
||
const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
|
||
const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
|
||
|
||
if (input[input.length - 1] === LF) {
|
||
input = input.slice(0, input.length - 1);
|
||
}
|
||
|
||
if (input[input.length - 1] === CR) {
|
||
input = input.slice(0, input.length - 1);
|
||
}
|
||
|
||
return input;
|
||
};
|
||
|
||
var npmRunPath$1 = {exports: {}};
|
||
|
||
npmRunPath$1.exports;
|
||
|
||
(function (module) {
|
||
const path = require$$0$1;
|
||
const pathKey = pathKeyExports;
|
||
|
||
const npmRunPath = options => {
|
||
options = {
|
||
cwd: process.cwd(),
|
||
path: process.env[pathKey()],
|
||
execPath: process.execPath,
|
||
...options
|
||
};
|
||
|
||
let previous;
|
||
let cwdPath = path.resolve(options.cwd);
|
||
const result = [];
|
||
|
||
while (previous !== cwdPath) {
|
||
result.push(path.join(cwdPath, 'node_modules/.bin'));
|
||
previous = cwdPath;
|
||
cwdPath = path.resolve(cwdPath, '..');
|
||
}
|
||
|
||
// Ensure the running `node` binary is used
|
||
const execPathDir = path.resolve(options.cwd, options.execPath, '..');
|
||
result.push(execPathDir);
|
||
|
||
return result.concat(options.path).join(path.delimiter);
|
||
};
|
||
|
||
module.exports = npmRunPath;
|
||
// TODO: Remove this for the next major release
|
||
module.exports.default = npmRunPath;
|
||
|
||
module.exports.env = options => {
|
||
options = {
|
||
env: process.env,
|
||
...options
|
||
};
|
||
|
||
const env = {...options.env};
|
||
const path = pathKey({env});
|
||
|
||
options.path = env[path];
|
||
env[path] = module.exports(options);
|
||
|
||
return env;
|
||
};
|
||
} (npmRunPath$1));
|
||
|
||
var npmRunPathExports = npmRunPath$1.exports;
|
||
|
||
var onetime$2 = {exports: {}};
|
||
|
||
var mimicFn$2 = {exports: {}};
|
||
|
||
const mimicFn$1 = (to, from) => {
|
||
for (const prop of Reflect.ownKeys(from)) {
|
||
Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
|
||
}
|
||
|
||
return to;
|
||
};
|
||
|
||
mimicFn$2.exports = mimicFn$1;
|
||
// TODO: Remove this for the next major release
|
||
mimicFn$2.exports.default = mimicFn$1;
|
||
|
||
var mimicFnExports = mimicFn$2.exports;
|
||
|
||
const mimicFn = mimicFnExports;
|
||
|
||
const calledFunctions = new WeakMap();
|
||
|
||
const onetime$1 = (function_, options = {}) => {
|
||
if (typeof function_ !== 'function') {
|
||
throw new TypeError('Expected a function');
|
||
}
|
||
|
||
let returnValue;
|
||
let callCount = 0;
|
||
const functionName = function_.displayName || function_.name || '<anonymous>';
|
||
|
||
const onetime = function (...arguments_) {
|
||
calledFunctions.set(onetime, ++callCount);
|
||
|
||
if (callCount === 1) {
|
||
returnValue = function_.apply(this, arguments_);
|
||
function_ = null;
|
||
} else if (options.throw === true) {
|
||
throw new Error(`Function \`${functionName}\` can only be called once`);
|
||
}
|
||
|
||
return returnValue;
|
||
};
|
||
|
||
mimicFn(onetime, function_);
|
||
calledFunctions.set(onetime, callCount);
|
||
|
||
return onetime;
|
||
};
|
||
|
||
onetime$2.exports = onetime$1;
|
||
// TODO: Remove this for the next major release
|
||
onetime$2.exports.default = onetime$1;
|
||
|
||
onetime$2.exports.callCount = function_ => {
|
||
if (!calledFunctions.has(function_)) {
|
||
throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
|
||
}
|
||
|
||
return calledFunctions.get(function_);
|
||
};
|
||
|
||
var onetimeExports = onetime$2.exports;
|
||
|
||
var main = {};
|
||
|
||
var signals$2 = {};
|
||
|
||
var core = {};
|
||
|
||
Object.defineProperty(core,"__esModule",{value:true});core.SIGNALS=void 0;
|
||
|
||
const SIGNALS=[
|
||
{
|
||
name:"SIGHUP",
|
||
number:1,
|
||
action:"terminate",
|
||
description:"Terminal closed",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGINT",
|
||
number:2,
|
||
action:"terminate",
|
||
description:"User interruption with CTRL-C",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGQUIT",
|
||
number:3,
|
||
action:"core",
|
||
description:"User interruption with CTRL-\\",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGILL",
|
||
number:4,
|
||
action:"core",
|
||
description:"Invalid machine instruction",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGTRAP",
|
||
number:5,
|
||
action:"core",
|
||
description:"Debugger breakpoint",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGABRT",
|
||
number:6,
|
||
action:"core",
|
||
description:"Aborted",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGIOT",
|
||
number:6,
|
||
action:"core",
|
||
description:"Aborted",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGBUS",
|
||
number:7,
|
||
action:"core",
|
||
description:
|
||
"Bus error due to misaligned, non-existing address or paging error",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGEMT",
|
||
number:7,
|
||
action:"terminate",
|
||
description:"Command should be emulated but is not implemented",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGFPE",
|
||
number:8,
|
||
action:"core",
|
||
description:"Floating point arithmetic error",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGKILL",
|
||
number:9,
|
||
action:"terminate",
|
||
description:"Forced termination",
|
||
standard:"posix",
|
||
forced:true},
|
||
|
||
{
|
||
name:"SIGUSR1",
|
||
number:10,
|
||
action:"terminate",
|
||
description:"Application-specific signal",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGSEGV",
|
||
number:11,
|
||
action:"core",
|
||
description:"Segmentation fault",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGUSR2",
|
||
number:12,
|
||
action:"terminate",
|
||
description:"Application-specific signal",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGPIPE",
|
||
number:13,
|
||
action:"terminate",
|
||
description:"Broken pipe or socket",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGALRM",
|
||
number:14,
|
||
action:"terminate",
|
||
description:"Timeout or timer",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGTERM",
|
||
number:15,
|
||
action:"terminate",
|
||
description:"Termination",
|
||
standard:"ansi"},
|
||
|
||
{
|
||
name:"SIGSTKFLT",
|
||
number:16,
|
||
action:"terminate",
|
||
description:"Stack is empty or overflowed",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGCHLD",
|
||
number:17,
|
||
action:"ignore",
|
||
description:"Child process terminated, paused or unpaused",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGCLD",
|
||
number:17,
|
||
action:"ignore",
|
||
description:"Child process terminated, paused or unpaused",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGCONT",
|
||
number:18,
|
||
action:"unpause",
|
||
description:"Unpaused",
|
||
standard:"posix",
|
||
forced:true},
|
||
|
||
{
|
||
name:"SIGSTOP",
|
||
number:19,
|
||
action:"pause",
|
||
description:"Paused",
|
||
standard:"posix",
|
||
forced:true},
|
||
|
||
{
|
||
name:"SIGTSTP",
|
||
number:20,
|
||
action:"pause",
|
||
description:"Paused using CTRL-Z or \"suspend\"",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGTTIN",
|
||
number:21,
|
||
action:"pause",
|
||
description:"Background process cannot read terminal input",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGBREAK",
|
||
number:21,
|
||
action:"terminate",
|
||
description:"User interruption with CTRL-BREAK",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGTTOU",
|
||
number:22,
|
||
action:"pause",
|
||
description:"Background process cannot write to terminal output",
|
||
standard:"posix"},
|
||
|
||
{
|
||
name:"SIGURG",
|
||
number:23,
|
||
action:"ignore",
|
||
description:"Socket received out-of-band data",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGXCPU",
|
||
number:24,
|
||
action:"core",
|
||
description:"Process timed out",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGXFSZ",
|
||
number:25,
|
||
action:"core",
|
||
description:"File too big",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGVTALRM",
|
||
number:26,
|
||
action:"terminate",
|
||
description:"Timeout or timer",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGPROF",
|
||
number:27,
|
||
action:"terminate",
|
||
description:"Timeout or timer",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGWINCH",
|
||
number:28,
|
||
action:"ignore",
|
||
description:"Terminal window size changed",
|
||
standard:"bsd"},
|
||
|
||
{
|
||
name:"SIGIO",
|
||
number:29,
|
||
action:"terminate",
|
||
description:"I/O is available",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGPOLL",
|
||
number:29,
|
||
action:"terminate",
|
||
description:"Watched event",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGINFO",
|
||
number:29,
|
||
action:"ignore",
|
||
description:"Request for process information",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGPWR",
|
||
number:30,
|
||
action:"terminate",
|
||
description:"Device running out of power",
|
||
standard:"systemv"},
|
||
|
||
{
|
||
name:"SIGSYS",
|
||
number:31,
|
||
action:"core",
|
||
description:"Invalid system call",
|
||
standard:"other"},
|
||
|
||
{
|
||
name:"SIGUNUSED",
|
||
number:31,
|
||
action:"terminate",
|
||
description:"Invalid system call",
|
||
standard:"other"}];core.SIGNALS=SIGNALS;
|
||
|
||
var realtime = {};
|
||
|
||
Object.defineProperty(realtime,"__esModule",{value:true});realtime.SIGRTMAX=realtime.getRealtimeSignals=void 0;
|
||
const getRealtimeSignals=function(){
|
||
const length=SIGRTMAX-SIGRTMIN+1;
|
||
return Array.from({length},getRealtimeSignal);
|
||
};realtime.getRealtimeSignals=getRealtimeSignals;
|
||
|
||
const getRealtimeSignal=function(value,index){
|
||
return {
|
||
name:`SIGRT${index+1}`,
|
||
number:SIGRTMIN+index,
|
||
action:"terminate",
|
||
description:"Application-specific signal (realtime)",
|
||
standard:"posix"};
|
||
|
||
};
|
||
|
||
const SIGRTMIN=34;
|
||
const SIGRTMAX=64;realtime.SIGRTMAX=SIGRTMAX;
|
||
|
||
Object.defineProperty(signals$2,"__esModule",{value:true});signals$2.getSignals=void 0;var _os$1=require$$0$3;
|
||
|
||
var _core=core;
|
||
var _realtime$1=realtime;
|
||
|
||
|
||
|
||
const getSignals=function(){
|
||
const realtimeSignals=(0, _realtime$1.getRealtimeSignals)();
|
||
const signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);
|
||
return signals;
|
||
};signals$2.getSignals=getSignals;
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
const normalizeSignal=function({
|
||
name,
|
||
number:defaultNumber,
|
||
description,
|
||
action,
|
||
forced=false,
|
||
standard})
|
||
{
|
||
const{
|
||
signals:{[name]:constantSignal}}=
|
||
_os$1.constants;
|
||
const supported=constantSignal!==undefined;
|
||
const number=supported?constantSignal:defaultNumber;
|
||
return {name,number,description,supported,action,forced,standard};
|
||
};
|
||
|
||
Object.defineProperty(main,"__esModule",{value:true});main.signalsByNumber=main.signalsByName=void 0;var _os=require$$0$3;
|
||
|
||
var _signals=signals$2;
|
||
var _realtime=realtime;
|
||
|
||
|
||
|
||
const getSignalsByName=function(){
|
||
const signals=(0, _signals.getSignals)();
|
||
return signals.reduce(getSignalByName,{});
|
||
};
|
||
|
||
const getSignalByName=function(
|
||
signalByNameMemo,
|
||
{name,number,description,supported,action,forced,standard})
|
||
{
|
||
return {
|
||
...signalByNameMemo,
|
||
[name]:{name,number,description,supported,action,forced,standard}};
|
||
|
||
};
|
||
|
||
const signalsByName$1=getSignalsByName();main.signalsByName=signalsByName$1;
|
||
|
||
|
||
|
||
|
||
const getSignalsByNumber=function(){
|
||
const signals=(0, _signals.getSignals)();
|
||
const length=_realtime.SIGRTMAX+1;
|
||
const signalsA=Array.from({length},(value,number)=>
|
||
getSignalByNumber(number,signals));
|
||
|
||
return Object.assign({},...signalsA);
|
||
};
|
||
|
||
const getSignalByNumber=function(number,signals){
|
||
const signal=findSignalByNumber(number,signals);
|
||
|
||
if(signal===undefined){
|
||
return {};
|
||
}
|
||
|
||
const{name,description,supported,action,forced,standard}=signal;
|
||
return {
|
||
[number]:{
|
||
name,
|
||
number,
|
||
description,
|
||
supported,
|
||
action,
|
||
forced,
|
||
standard}};
|
||
|
||
|
||
};
|
||
|
||
|
||
|
||
const findSignalByNumber=function(number,signals){
|
||
const signal=signals.find(({name})=>_os.constants.signals[name]===number);
|
||
|
||
if(signal!==undefined){
|
||
return signal;
|
||
}
|
||
|
||
return signals.find(signalA=>signalA.number===number);
|
||
};
|
||
|
||
const signalsByNumber=getSignalsByNumber();main.signalsByNumber=signalsByNumber;
|
||
|
||
const {signalsByName} = main;
|
||
|
||
const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
|
||
if (timedOut) {
|
||
return `timed out after ${timeout} milliseconds`;
|
||
}
|
||
|
||
if (isCanceled) {
|
||
return 'was canceled';
|
||
}
|
||
|
||
if (errorCode !== undefined) {
|
||
return `failed with ${errorCode}`;
|
||
}
|
||
|
||
if (signal !== undefined) {
|
||
return `was killed with ${signal} (${signalDescription})`;
|
||
}
|
||
|
||
if (exitCode !== undefined) {
|
||
return `failed with exit code ${exitCode}`;
|
||
}
|
||
|
||
return 'failed';
|
||
};
|
||
|
||
const makeError$1 = ({
|
||
stdout,
|
||
stderr,
|
||
all,
|
||
error,
|
||
signal,
|
||
exitCode,
|
||
command,
|
||
escapedCommand,
|
||
timedOut,
|
||
isCanceled,
|
||
killed,
|
||
parsed: {options: {timeout}}
|
||
}) => {
|
||
// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
|
||
// We normalize them to `undefined`
|
||
exitCode = exitCode === null ? undefined : exitCode;
|
||
signal = signal === null ? undefined : signal;
|
||
const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
|
||
|
||
const errorCode = error && error.code;
|
||
|
||
const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
|
||
const execaMessage = `Command ${prefix}: ${command}`;
|
||
const isError = Object.prototype.toString.call(error) === '[object Error]';
|
||
const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
|
||
const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
|
||
|
||
if (isError) {
|
||
error.originalMessage = error.message;
|
||
error.message = message;
|
||
} else {
|
||
error = new Error(message);
|
||
}
|
||
|
||
error.shortMessage = shortMessage;
|
||
error.command = command;
|
||
error.escapedCommand = escapedCommand;
|
||
error.exitCode = exitCode;
|
||
error.signal = signal;
|
||
error.signalDescription = signalDescription;
|
||
error.stdout = stdout;
|
||
error.stderr = stderr;
|
||
|
||
if (all !== undefined) {
|
||
error.all = all;
|
||
}
|
||
|
||
if ('bufferedData' in error) {
|
||
delete error.bufferedData;
|
||
}
|
||
|
||
error.failed = true;
|
||
error.timedOut = Boolean(timedOut);
|
||
error.isCanceled = isCanceled;
|
||
error.killed = killed && !timedOut;
|
||
|
||
return error;
|
||
};
|
||
|
||
var error = makeError$1;
|
||
|
||
var stdio = {exports: {}};
|
||
|
||
const aliases = ['stdin', 'stdout', 'stderr'];
|
||
|
||
const hasAlias = options => aliases.some(alias => options[alias] !== undefined);
|
||
|
||
const normalizeStdio$1 = options => {
|
||
if (!options) {
|
||
return;
|
||
}
|
||
|
||
const {stdio} = options;
|
||
|
||
if (stdio === undefined) {
|
||
return aliases.map(alias => options[alias]);
|
||
}
|
||
|
||
if (hasAlias(options)) {
|
||
throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
|
||
}
|
||
|
||
if (typeof stdio === 'string') {
|
||
return stdio;
|
||
}
|
||
|
||
if (!Array.isArray(stdio)) {
|
||
throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
|
||
}
|
||
|
||
const length = Math.max(stdio.length, aliases.length);
|
||
return Array.from({length}, (value, index) => stdio[index]);
|
||
};
|
||
|
||
stdio.exports = normalizeStdio$1;
|
||
|
||
// `ipc` is pushed unless it is already present
|
||
stdio.exports.node = options => {
|
||
const stdio = normalizeStdio$1(options);
|
||
|
||
if (stdio === 'ipc') {
|
||
return 'ipc';
|
||
}
|
||
|
||
if (stdio === undefined || typeof stdio === 'string') {
|
||
return [stdio, stdio, stdio, 'ipc'];
|
||
}
|
||
|
||
if (stdio.includes('ipc')) {
|
||
return stdio;
|
||
}
|
||
|
||
return [...stdio, 'ipc'];
|
||
};
|
||
|
||
var stdioExports = stdio.exports;
|
||
|
||
var signalExit = {exports: {}};
|
||
|
||
var signals$1 = {exports: {}};
|
||
|
||
var hasRequiredSignals;
|
||
|
||
function requireSignals () {
|
||
if (hasRequiredSignals) return signals$1.exports;
|
||
hasRequiredSignals = 1;
|
||
(function (module) {
|
||
// This is not the set of all possible signals.
|
||
//
|
||
// It IS, however, the set of all signals that trigger
|
||
// an exit on either Linux or BSD systems. Linux is a
|
||
// superset of the signal names supported on BSD, and
|
||
// the unknown signals just fail to register, so we can
|
||
// catch that easily enough.
|
||
//
|
||
// Don't bother with SIGKILL. It's uncatchable, which
|
||
// means that we can't fire any callbacks anyway.
|
||
//
|
||
// If a user does happen to register a handler on a non-
|
||
// fatal signal like SIGWINCH or something, and then
|
||
// exit, it'll end up firing `process.emit('exit')`, so
|
||
// the handler will be fired anyway.
|
||
//
|
||
// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
|
||
// artificially, inherently leave the process in a
|
||
// state from which it is not safe to try and enter JS
|
||
// listeners.
|
||
module.exports = [
|
||
'SIGABRT',
|
||
'SIGALRM',
|
||
'SIGHUP',
|
||
'SIGINT',
|
||
'SIGTERM'
|
||
];
|
||
|
||
if (process.platform !== 'win32') {
|
||
module.exports.push(
|
||
'SIGVTALRM',
|
||
'SIGXCPU',
|
||
'SIGXFSZ',
|
||
'SIGUSR2',
|
||
'SIGTRAP',
|
||
'SIGSYS',
|
||
'SIGQUIT',
|
||
'SIGIOT'
|
||
// should detect profiler and enable/disable accordingly.
|
||
// see #21
|
||
// 'SIGPROF'
|
||
);
|
||
}
|
||
|
||
if (process.platform === 'linux') {
|
||
module.exports.push(
|
||
'SIGIO',
|
||
'SIGPOLL',
|
||
'SIGPWR',
|
||
'SIGSTKFLT',
|
||
'SIGUNUSED'
|
||
);
|
||
}
|
||
} (signals$1));
|
||
return signals$1.exports;
|
||
}
|
||
|
||
// Note: since nyc uses this module to output coverage, any lines
|
||
// that are in the direct sync flow of nyc's outputCoverage are
|
||
// ignored, since we can never get coverage for them.
|
||
// grab a reference to node's real process object right away
|
||
var process$1 = commonjsGlobal.process;
|
||
|
||
const processOk = function (process) {
|
||
return process &&
|
||
typeof process === 'object' &&
|
||
typeof process.removeListener === 'function' &&
|
||
typeof process.emit === 'function' &&
|
||
typeof process.reallyExit === 'function' &&
|
||
typeof process.listeners === 'function' &&
|
||
typeof process.kill === 'function' &&
|
||
typeof process.pid === 'number' &&
|
||
typeof process.on === 'function'
|
||
};
|
||
|
||
// some kind of non-node environment, just no-op
|
||
/* istanbul ignore if */
|
||
if (!processOk(process$1)) {
|
||
signalExit.exports = function () {
|
||
return function () {}
|
||
};
|
||
} else {
|
||
var assert = require$$0$4;
|
||
var signals = requireSignals();
|
||
var isWin = /^win/i.test(process$1.platform);
|
||
|
||
var EE = require$$2;
|
||
/* istanbul ignore if */
|
||
if (typeof EE !== 'function') {
|
||
EE = EE.EventEmitter;
|
||
}
|
||
|
||
var emitter;
|
||
if (process$1.__signal_exit_emitter__) {
|
||
emitter = process$1.__signal_exit_emitter__;
|
||
} else {
|
||
emitter = process$1.__signal_exit_emitter__ = new EE();
|
||
emitter.count = 0;
|
||
emitter.emitted = {};
|
||
}
|
||
|
||
// Because this emitter is a global, we have to check to see if a
|
||
// previous version of this library failed to enable infinite listeners.
|
||
// I know what you're about to say. But literally everything about
|
||
// signal-exit is a compromise with evil. Get used to it.
|
||
if (!emitter.infinite) {
|
||
emitter.setMaxListeners(Infinity);
|
||
emitter.infinite = true;
|
||
}
|
||
|
||
signalExit.exports = function (cb, opts) {
|
||
/* istanbul ignore if */
|
||
if (!processOk(commonjsGlobal.process)) {
|
||
return function () {}
|
||
}
|
||
assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
|
||
|
||
if (loaded === false) {
|
||
load();
|
||
}
|
||
|
||
var ev = 'exit';
|
||
if (opts && opts.alwaysLast) {
|
||
ev = 'afterexit';
|
||
}
|
||
|
||
var remove = function () {
|
||
emitter.removeListener(ev, cb);
|
||
if (emitter.listeners('exit').length === 0 &&
|
||
emitter.listeners('afterexit').length === 0) {
|
||
unload();
|
||
}
|
||
};
|
||
emitter.on(ev, cb);
|
||
|
||
return remove
|
||
};
|
||
|
||
var unload = function unload () {
|
||
if (!loaded || !processOk(commonjsGlobal.process)) {
|
||
return
|
||
}
|
||
loaded = false;
|
||
|
||
signals.forEach(function (sig) {
|
||
try {
|
||
process$1.removeListener(sig, sigListeners[sig]);
|
||
} catch (er) {}
|
||
});
|
||
process$1.emit = originalProcessEmit;
|
||
process$1.reallyExit = originalProcessReallyExit;
|
||
emitter.count -= 1;
|
||
};
|
||
signalExit.exports.unload = unload;
|
||
|
||
var emit = function emit (event, code, signal) {
|
||
/* istanbul ignore if */
|
||
if (emitter.emitted[event]) {
|
||
return
|
||
}
|
||
emitter.emitted[event] = true;
|
||
emitter.emit(event, code, signal);
|
||
};
|
||
|
||
// { <signal>: <listener fn>, ... }
|
||
var sigListeners = {};
|
||
signals.forEach(function (sig) {
|
||
sigListeners[sig] = function listener () {
|
||
/* istanbul ignore if */
|
||
if (!processOk(commonjsGlobal.process)) {
|
||
return
|
||
}
|
||
// If there are no other listeners, an exit is coming!
|
||
// Simplest way: remove us and then re-send the signal.
|
||
// We know that this will kill the process, so we can
|
||
// safely emit now.
|
||
var listeners = process$1.listeners(sig);
|
||
if (listeners.length === emitter.count) {
|
||
unload();
|
||
emit('exit', null, sig);
|
||
/* istanbul ignore next */
|
||
emit('afterexit', null, sig);
|
||
/* istanbul ignore next */
|
||
if (isWin && sig === 'SIGHUP') {
|
||
// "SIGHUP" throws an `ENOSYS` error on Windows,
|
||
// so use a supported signal instead
|
||
sig = 'SIGINT';
|
||
}
|
||
/* istanbul ignore next */
|
||
process$1.kill(process$1.pid, sig);
|
||
}
|
||
};
|
||
});
|
||
|
||
signalExit.exports.signals = function () {
|
||
return signals
|
||
};
|
||
|
||
var loaded = false;
|
||
|
||
var load = function load () {
|
||
if (loaded || !processOk(commonjsGlobal.process)) {
|
||
return
|
||
}
|
||
loaded = true;
|
||
|
||
// This is the number of onSignalExit's that are in play.
|
||
// It's important so that we can count the correct number of
|
||
// listeners on signals, and don't wait for the other one to
|
||
// handle it instead of us.
|
||
emitter.count += 1;
|
||
|
||
signals = signals.filter(function (sig) {
|
||
try {
|
||
process$1.on(sig, sigListeners[sig]);
|
||
return true
|
||
} catch (er) {
|
||
return false
|
||
}
|
||
});
|
||
|
||
process$1.emit = processEmit;
|
||
process$1.reallyExit = processReallyExit;
|
||
};
|
||
signalExit.exports.load = load;
|
||
|
||
var originalProcessReallyExit = process$1.reallyExit;
|
||
var processReallyExit = function processReallyExit (code) {
|
||
/* istanbul ignore if */
|
||
if (!processOk(commonjsGlobal.process)) {
|
||
return
|
||
}
|
||
process$1.exitCode = code || /* istanbul ignore next */ 0;
|
||
emit('exit', process$1.exitCode, null);
|
||
/* istanbul ignore next */
|
||
emit('afterexit', process$1.exitCode, null);
|
||
/* istanbul ignore next */
|
||
originalProcessReallyExit.call(process$1, process$1.exitCode);
|
||
};
|
||
|
||
var originalProcessEmit = process$1.emit;
|
||
var processEmit = function processEmit (ev, arg) {
|
||
if (ev === 'exit' && processOk(commonjsGlobal.process)) {
|
||
/* istanbul ignore else */
|
||
if (arg !== undefined) {
|
||
process$1.exitCode = arg;
|
||
}
|
||
var ret = originalProcessEmit.apply(this, arguments);
|
||
/* istanbul ignore next */
|
||
emit('exit', process$1.exitCode, null);
|
||
/* istanbul ignore next */
|
||
emit('afterexit', process$1.exitCode, null);
|
||
/* istanbul ignore next */
|
||
return ret
|
||
} else {
|
||
return originalProcessEmit.apply(this, arguments)
|
||
}
|
||
};
|
||
}
|
||
|
||
var signalExitExports = signalExit.exports;
|
||
|
||
const os = require$$0$3;
|
||
const onExit = signalExitExports;
|
||
|
||
const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
|
||
|
||
// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
|
||
const spawnedKill$1 = (kill, signal = 'SIGTERM', options = {}) => {
|
||
const killResult = kill(signal);
|
||
setKillTimeout(kill, signal, options, killResult);
|
||
return killResult;
|
||
};
|
||
|
||
const setKillTimeout = (kill, signal, options, killResult) => {
|
||
if (!shouldForceKill(signal, options, killResult)) {
|
||
return;
|
||
}
|
||
|
||
const timeout = getForceKillAfterTimeout(options);
|
||
const t = setTimeout(() => {
|
||
kill('SIGKILL');
|
||
}, timeout);
|
||
|
||
// Guarded because there's no `.unref()` when `execa` is used in the renderer
|
||
// process in Electron. This cannot be tested since we don't run tests in
|
||
// Electron.
|
||
// istanbul ignore else
|
||
if (t.unref) {
|
||
t.unref();
|
||
}
|
||
};
|
||
|
||
const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
|
||
return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
|
||
};
|
||
|
||
const isSigterm = signal => {
|
||
return signal === os.constants.signals.SIGTERM ||
|
||
(typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
|
||
};
|
||
|
||
const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
|
||
if (forceKillAfterTimeout === true) {
|
||
return DEFAULT_FORCE_KILL_TIMEOUT;
|
||
}
|
||
|
||
if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
|
||
throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
|
||
}
|
||
|
||
return forceKillAfterTimeout;
|
||
};
|
||
|
||
// `childProcess.cancel()`
|
||
const spawnedCancel$1 = (spawned, context) => {
|
||
const killResult = spawned.kill();
|
||
|
||
if (killResult) {
|
||
context.isCanceled = true;
|
||
}
|
||
};
|
||
|
||
const timeoutKill = (spawned, signal, reject) => {
|
||
spawned.kill(signal);
|
||
reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
|
||
};
|
||
|
||
// `timeout` option handling
|
||
const setupTimeout$1 = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
|
||
if (timeout === 0 || timeout === undefined) {
|
||
return spawnedPromise;
|
||
}
|
||
|
||
let timeoutId;
|
||
const timeoutPromise = new Promise((resolve, reject) => {
|
||
timeoutId = setTimeout(() => {
|
||
timeoutKill(spawned, killSignal, reject);
|
||
}, timeout);
|
||
});
|
||
|
||
const safeSpawnedPromise = spawnedPromise.finally(() => {
|
||
clearTimeout(timeoutId);
|
||
});
|
||
|
||
return Promise.race([timeoutPromise, safeSpawnedPromise]);
|
||
};
|
||
|
||
const validateTimeout$1 = ({timeout}) => {
|
||
if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
|
||
throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
|
||
}
|
||
};
|
||
|
||
// `cleanup` option handling
|
||
const setExitHandler$1 = async (spawned, {cleanup, detached}, timedPromise) => {
|
||
if (!cleanup || detached) {
|
||
return timedPromise;
|
||
}
|
||
|
||
const removeExitHandler = onExit(() => {
|
||
spawned.kill();
|
||
});
|
||
|
||
return timedPromise.finally(() => {
|
||
removeExitHandler();
|
||
});
|
||
};
|
||
|
||
var kill = {
|
||
spawnedKill: spawnedKill$1,
|
||
spawnedCancel: spawnedCancel$1,
|
||
setupTimeout: setupTimeout$1,
|
||
validateTimeout: validateTimeout$1,
|
||
setExitHandler: setExitHandler$1
|
||
};
|
||
|
||
const isStream$1 = stream =>
|
||
stream !== null &&
|
||
typeof stream === 'object' &&
|
||
typeof stream.pipe === 'function';
|
||
|
||
isStream$1.writable = stream =>
|
||
isStream$1(stream) &&
|
||
stream.writable !== false &&
|
||
typeof stream._write === 'function' &&
|
||
typeof stream._writableState === 'object';
|
||
|
||
isStream$1.readable = stream =>
|
||
isStream$1(stream) &&
|
||
stream.readable !== false &&
|
||
typeof stream._read === 'function' &&
|
||
typeof stream._readableState === 'object';
|
||
|
||
isStream$1.duplex = stream =>
|
||
isStream$1.writable(stream) &&
|
||
isStream$1.readable(stream);
|
||
|
||
isStream$1.transform = stream =>
|
||
isStream$1.duplex(stream) &&
|
||
typeof stream._transform === 'function';
|
||
|
||
var isStream_1 = isStream$1;
|
||
|
||
var getStream$2 = {exports: {}};
|
||
|
||
const {PassThrough: PassThroughStream} = require$$0$5;
|
||
|
||
var bufferStream$1 = options => {
|
||
options = {...options};
|
||
|
||
const {array} = options;
|
||
let {encoding} = options;
|
||
const isBuffer = encoding === 'buffer';
|
||
let objectMode = false;
|
||
|
||
if (array) {
|
||
objectMode = !(encoding || isBuffer);
|
||
} else {
|
||
encoding = encoding || 'utf8';
|
||
}
|
||
|
||
if (isBuffer) {
|
||
encoding = null;
|
||
}
|
||
|
||
const stream = new PassThroughStream({objectMode});
|
||
|
||
if (encoding) {
|
||
stream.setEncoding(encoding);
|
||
}
|
||
|
||
let length = 0;
|
||
const chunks = [];
|
||
|
||
stream.on('data', chunk => {
|
||
chunks.push(chunk);
|
||
|
||
if (objectMode) {
|
||
length = chunks.length;
|
||
} else {
|
||
length += chunk.length;
|
||
}
|
||
});
|
||
|
||
stream.getBufferedValue = () => {
|
||
if (array) {
|
||
return chunks;
|
||
}
|
||
|
||
return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
|
||
};
|
||
|
||
stream.getBufferedLength = () => length;
|
||
|
||
return stream;
|
||
};
|
||
|
||
const {constants: BufferConstants} = require$$0$6;
|
||
const stream$2 = require$$0$5;
|
||
const {promisify} = require$$2$1;
|
||
const bufferStream = bufferStream$1;
|
||
|
||
const streamPipelinePromisified = promisify(stream$2.pipeline);
|
||
|
||
class MaxBufferError extends Error {
|
||
constructor() {
|
||
super('maxBuffer exceeded');
|
||
this.name = 'MaxBufferError';
|
||
}
|
||
}
|
||
|
||
async function getStream$1(inputStream, options) {
|
||
if (!inputStream) {
|
||
throw new Error('Expected a stream');
|
||
}
|
||
|
||
options = {
|
||
maxBuffer: Infinity,
|
||
...options
|
||
};
|
||
|
||
const {maxBuffer} = options;
|
||
const stream = bufferStream(options);
|
||
|
||
await new Promise((resolve, reject) => {
|
||
const rejectPromise = error => {
|
||
// Don't retrieve an oversized buffer.
|
||
if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
|
||
error.bufferedData = stream.getBufferedValue();
|
||
}
|
||
|
||
reject(error);
|
||
};
|
||
|
||
(async () => {
|
||
try {
|
||
await streamPipelinePromisified(inputStream, stream);
|
||
resolve();
|
||
} catch (error) {
|
||
rejectPromise(error);
|
||
}
|
||
})();
|
||
|
||
stream.on('data', () => {
|
||
if (stream.getBufferedLength() > maxBuffer) {
|
||
rejectPromise(new MaxBufferError());
|
||
}
|
||
});
|
||
});
|
||
|
||
return stream.getBufferedValue();
|
||
}
|
||
|
||
getStream$2.exports = getStream$1;
|
||
getStream$2.exports.buffer = (stream, options) => getStream$1(stream, {...options, encoding: 'buffer'});
|
||
getStream$2.exports.array = (stream, options) => getStream$1(stream, {...options, array: true});
|
||
getStream$2.exports.MaxBufferError = MaxBufferError;
|
||
|
||
var getStreamExports = getStream$2.exports;
|
||
|
||
const { PassThrough } = require$$0$5;
|
||
|
||
var mergeStream$1 = function (/*streams...*/) {
|
||
var sources = [];
|
||
var output = new PassThrough({objectMode: true});
|
||
|
||
output.setMaxListeners(0);
|
||
|
||
output.add = add;
|
||
output.isEmpty = isEmpty;
|
||
|
||
output.on('unpipe', remove);
|
||
|
||
Array.prototype.slice.call(arguments).forEach(add);
|
||
|
||
return output
|
||
|
||
function add (source) {
|
||
if (Array.isArray(source)) {
|
||
source.forEach(add);
|
||
return this
|
||
}
|
||
|
||
sources.push(source);
|
||
source.once('end', remove.bind(null, source));
|
||
source.once('error', output.emit.bind(output, 'error'));
|
||
source.pipe(output, {end: false});
|
||
return this
|
||
}
|
||
|
||
function isEmpty () {
|
||
return sources.length == 0;
|
||
}
|
||
|
||
function remove (source) {
|
||
sources = sources.filter(function (it) { return it !== source });
|
||
if (!sources.length && output.readable) { output.end(); }
|
||
}
|
||
};
|
||
|
||
const isStream = isStream_1;
|
||
const getStream = getStreamExports;
|
||
const mergeStream = mergeStream$1;
|
||
|
||
// `input` option
|
||
const handleInput$1 = (spawned, input) => {
|
||
// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
|
||
// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
|
||
if (input === undefined || spawned.stdin === undefined) {
|
||
return;
|
||
}
|
||
|
||
if (isStream(input)) {
|
||
input.pipe(spawned.stdin);
|
||
} else {
|
||
spawned.stdin.end(input);
|
||
}
|
||
};
|
||
|
||
// `all` interleaves `stdout` and `stderr`
|
||
const makeAllStream$1 = (spawned, {all}) => {
|
||
if (!all || (!spawned.stdout && !spawned.stderr)) {
|
||
return;
|
||
}
|
||
|
||
const mixed = mergeStream();
|
||
|
||
if (spawned.stdout) {
|
||
mixed.add(spawned.stdout);
|
||
}
|
||
|
||
if (spawned.stderr) {
|
||
mixed.add(spawned.stderr);
|
||
}
|
||
|
||
return mixed;
|
||
};
|
||
|
||
// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
|
||
const getBufferedData = async (stream, streamPromise) => {
|
||
if (!stream) {
|
||
return;
|
||
}
|
||
|
||
stream.destroy();
|
||
|
||
try {
|
||
return await streamPromise;
|
||
} catch (error) {
|
||
return error.bufferedData;
|
||
}
|
||
};
|
||
|
||
const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
|
||
if (!stream || !buffer) {
|
||
return;
|
||
}
|
||
|
||
if (encoding) {
|
||
return getStream(stream, {encoding, maxBuffer});
|
||
}
|
||
|
||
return getStream.buffer(stream, {maxBuffer});
|
||
};
|
||
|
||
// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
|
||
const getSpawnedResult$1 = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
|
||
const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
|
||
const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
|
||
const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
|
||
|
||
try {
|
||
return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
|
||
} catch (error) {
|
||
return Promise.all([
|
||
{error, signal: error.signal, timedOut: error.timedOut},
|
||
getBufferedData(stdout, stdoutPromise),
|
||
getBufferedData(stderr, stderrPromise),
|
||
getBufferedData(all, allPromise)
|
||
]);
|
||
}
|
||
};
|
||
|
||
const validateInputSync$1 = ({input}) => {
|
||
if (isStream(input)) {
|
||
throw new TypeError('The `input` option cannot be a stream in sync mode');
|
||
}
|
||
};
|
||
|
||
var stream$1 = {
|
||
handleInput: handleInput$1,
|
||
makeAllStream: makeAllStream$1,
|
||
getSpawnedResult: getSpawnedResult$1,
|
||
validateInputSync: validateInputSync$1
|
||
};
|
||
|
||
const nativePromisePrototype = (async () => {})().constructor.prototype;
|
||
const descriptors = ['then', 'catch', 'finally'].map(property => [
|
||
property,
|
||
Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
|
||
]);
|
||
|
||
// The return value is a mixin of `childProcess` and `Promise`
|
||
const mergePromise$1 = (spawned, promise) => {
|
||
for (const [property, descriptor] of descriptors) {
|
||
// Starting the main `promise` is deferred to avoid consuming streams
|
||
const value = typeof promise === 'function' ?
|
||
(...args) => Reflect.apply(descriptor.value, promise(), args) :
|
||
descriptor.value.bind(promise);
|
||
|
||
Reflect.defineProperty(spawned, property, {...descriptor, value});
|
||
}
|
||
|
||
return spawned;
|
||
};
|
||
|
||
// Use promises instead of `child_process` events
|
||
const getSpawnedPromise$1 = spawned => {
|
||
return new Promise((resolve, reject) => {
|
||
spawned.on('exit', (exitCode, signal) => {
|
||
resolve({exitCode, signal});
|
||
});
|
||
|
||
spawned.on('error', error => {
|
||
reject(error);
|
||
});
|
||
|
||
if (spawned.stdin) {
|
||
spawned.stdin.on('error', error => {
|
||
reject(error);
|
||
});
|
||
}
|
||
});
|
||
};
|
||
|
||
var promise = {
|
||
mergePromise: mergePromise$1,
|
||
getSpawnedPromise: getSpawnedPromise$1
|
||
};
|
||
|
||
const normalizeArgs = (file, args = []) => {
|
||
if (!Array.isArray(args)) {
|
||
return [file];
|
||
}
|
||
|
||
return [file, ...args];
|
||
};
|
||
|
||
const NO_ESCAPE_REGEXP = /^[\w.-]+$/;
|
||
const DOUBLE_QUOTES_REGEXP = /"/g;
|
||
|
||
const escapeArg = arg => {
|
||
if (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {
|
||
return arg;
|
||
}
|
||
|
||
return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
|
||
};
|
||
|
||
const joinCommand$1 = (file, args) => {
|
||
return normalizeArgs(file, args).join(' ');
|
||
};
|
||
|
||
const getEscapedCommand$1 = (file, args) => {
|
||
return normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');
|
||
};
|
||
|
||
const SPACES_REGEXP = / +/g;
|
||
|
||
// Handle `execa.command()`
|
||
const parseCommand$1 = command => {
|
||
const tokens = [];
|
||
for (const token of command.trim().split(SPACES_REGEXP)) {
|
||
// Allow spaces to be escaped by a backslash if not meant as a delimiter
|
||
const previousToken = tokens[tokens.length - 1];
|
||
if (previousToken && previousToken.endsWith('\\')) {
|
||
// Merge previous token with current one
|
||
tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
|
||
} else {
|
||
tokens.push(token);
|
||
}
|
||
}
|
||
|
||
return tokens;
|
||
};
|
||
|
||
var command = {
|
||
joinCommand: joinCommand$1,
|
||
getEscapedCommand: getEscapedCommand$1,
|
||
parseCommand: parseCommand$1
|
||
};
|
||
|
||
const path = require$$0$1;
|
||
const childProcess = require$$0$2;
|
||
const crossSpawn = crossSpawnExports;
|
||
const stripFinalNewline = stripFinalNewline$1;
|
||
const npmRunPath = npmRunPathExports;
|
||
const onetime = onetimeExports;
|
||
const makeError = error;
|
||
const normalizeStdio = stdioExports;
|
||
const {spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler} = kill;
|
||
const {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = stream$1;
|
||
const {mergePromise, getSpawnedPromise} = promise;
|
||
const {joinCommand, parseCommand, getEscapedCommand} = command;
|
||
|
||
const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
|
||
|
||
const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {
|
||
const env = extendEnv ? {...process.env, ...envOption} : envOption;
|
||
|
||
if (preferLocal) {
|
||
return npmRunPath.env({env, cwd: localDir, execPath});
|
||
}
|
||
|
||
return env;
|
||
};
|
||
|
||
const handleArguments = (file, args, options = {}) => {
|
||
const parsed = crossSpawn._parse(file, args, options);
|
||
file = parsed.command;
|
||
args = parsed.args;
|
||
options = parsed.options;
|
||
|
||
options = {
|
||
maxBuffer: DEFAULT_MAX_BUFFER,
|
||
buffer: true,
|
||
stripFinalNewline: true,
|
||
extendEnv: true,
|
||
preferLocal: false,
|
||
localDir: options.cwd || process.cwd(),
|
||
execPath: process.execPath,
|
||
encoding: 'utf8',
|
||
reject: true,
|
||
cleanup: true,
|
||
all: false,
|
||
windowsHide: true,
|
||
...options
|
||
};
|
||
|
||
options.env = getEnv(options);
|
||
|
||
options.stdio = normalizeStdio(options);
|
||
|
||
if (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {
|
||
// #116
|
||
args.unshift('/q');
|
||
}
|
||
|
||
return {file, args, options, parsed};
|
||
};
|
||
|
||
const handleOutput = (options, value, error) => {
|
||
if (typeof value !== 'string' && !Buffer.isBuffer(value)) {
|
||
// When `execa.sync()` errors, we normalize it to '' to mimic `execa()`
|
||
return error === undefined ? undefined : '';
|
||
}
|
||
|
||
if (options.stripFinalNewline) {
|
||
return stripFinalNewline(value);
|
||
}
|
||
|
||
return value;
|
||
};
|
||
|
||
const execa = (file, args, options) => {
|
||
const parsed = handleArguments(file, args, options);
|
||
const command = joinCommand(file, args);
|
||
const escapedCommand = getEscapedCommand(file, args);
|
||
|
||
validateTimeout(parsed.options);
|
||
|
||
let spawned;
|
||
try {
|
||
spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
|
||
} catch (error) {
|
||
// Ensure the returned error is always both a promise and a child process
|
||
const dummySpawned = new childProcess.ChildProcess();
|
||
const errorPromise = Promise.reject(makeError({
|
||
error,
|
||
stdout: '',
|
||
stderr: '',
|
||
all: '',
|
||
command,
|
||
escapedCommand,
|
||
parsed,
|
||
timedOut: false,
|
||
isCanceled: false,
|
||
killed: false
|
||
}));
|
||
return mergePromise(dummySpawned, errorPromise);
|
||
}
|
||
|
||
const spawnedPromise = getSpawnedPromise(spawned);
|
||
const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
|
||
const processDone = setExitHandler(spawned, parsed.options, timedPromise);
|
||
|
||
const context = {isCanceled: false};
|
||
|
||
spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
|
||
spawned.cancel = spawnedCancel.bind(null, spawned, context);
|
||
|
||
const handlePromise = async () => {
|
||
const [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
|
||
const stdout = handleOutput(parsed.options, stdoutResult);
|
||
const stderr = handleOutput(parsed.options, stderrResult);
|
||
const all = handleOutput(parsed.options, allResult);
|
||
|
||
if (error || exitCode !== 0 || signal !== null) {
|
||
const returnedError = makeError({
|
||
error,
|
||
exitCode,
|
||
signal,
|
||
stdout,
|
||
stderr,
|
||
all,
|
||
command,
|
||
escapedCommand,
|
||
parsed,
|
||
timedOut,
|
||
isCanceled: context.isCanceled,
|
||
killed: spawned.killed
|
||
});
|
||
|
||
if (!parsed.options.reject) {
|
||
return returnedError;
|
||
}
|
||
|
||
throw returnedError;
|
||
}
|
||
|
||
return {
|
||
command,
|
||
escapedCommand,
|
||
exitCode: 0,
|
||
stdout,
|
||
stderr,
|
||
all,
|
||
failed: false,
|
||
timedOut: false,
|
||
isCanceled: false,
|
||
killed: false
|
||
};
|
||
};
|
||
|
||
const handlePromiseOnce = onetime(handlePromise);
|
||
|
||
handleInput(spawned, parsed.options.input);
|
||
|
||
spawned.all = makeAllStream(spawned, parsed.options);
|
||
|
||
return mergePromise(spawned, handlePromiseOnce);
|
||
};
|
||
|
||
execa$2.exports = execa;
|
||
|
||
execa$2.exports.sync = (file, args, options) => {
|
||
const parsed = handleArguments(file, args, options);
|
||
const command = joinCommand(file, args);
|
||
const escapedCommand = getEscapedCommand(file, args);
|
||
|
||
validateInputSync(parsed.options);
|
||
|
||
let result;
|
||
try {
|
||
result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
|
||
} catch (error) {
|
||
throw makeError({
|
||
error,
|
||
stdout: '',
|
||
stderr: '',
|
||
all: '',
|
||
command,
|
||
escapedCommand,
|
||
parsed,
|
||
timedOut: false,
|
||
isCanceled: false,
|
||
killed: false
|
||
});
|
||
}
|
||
|
||
const stdout = handleOutput(parsed.options, result.stdout, result.error);
|
||
const stderr = handleOutput(parsed.options, result.stderr, result.error);
|
||
|
||
if (result.error || result.status !== 0 || result.signal !== null) {
|
||
const error = makeError({
|
||
stdout,
|
||
stderr,
|
||
error: result.error,
|
||
signal: result.signal,
|
||
exitCode: result.status,
|
||
command,
|
||
escapedCommand,
|
||
parsed,
|
||
timedOut: result.error && result.error.code === 'ETIMEDOUT',
|
||
isCanceled: false,
|
||
killed: result.signal !== null
|
||
});
|
||
|
||
if (!parsed.options.reject) {
|
||
return error;
|
||
}
|
||
|
||
throw error;
|
||
}
|
||
|
||
return {
|
||
command,
|
||
escapedCommand,
|
||
exitCode: 0,
|
||
stdout,
|
||
stderr,
|
||
failed: false,
|
||
timedOut: false,
|
||
isCanceled: false,
|
||
killed: false
|
||
};
|
||
};
|
||
|
||
execa$2.exports.command = (command, options) => {
|
||
const [file, ...args] = parseCommand(command);
|
||
return execa(file, args, options);
|
||
};
|
||
|
||
execa$2.exports.commandSync = (command, options) => {
|
||
const [file, ...args] = parseCommand(command);
|
||
return execa.sync(file, args, options);
|
||
};
|
||
|
||
execa$2.exports.node = (scriptPath, args, options = {}) => {
|
||
if (args && !Array.isArray(args) && typeof args === 'object') {
|
||
options = args;
|
||
args = [];
|
||
}
|
||
|
||
const stdio = normalizeStdio.node(options);
|
||
const defaultExecArgv = process.execArgv.filter(arg => !arg.startsWith('--inspect'));
|
||
|
||
const {
|
||
nodePath = process.execPath,
|
||
nodeOptions = defaultExecArgv
|
||
} = options;
|
||
|
||
return execa(
|
||
nodePath,
|
||
[
|
||
...nodeOptions,
|
||
scriptPath,
|
||
...(Array.isArray(args) ? args : [])
|
||
],
|
||
{
|
||
...options,
|
||
stdin: undefined,
|
||
stdout: undefined,
|
||
stderr: undefined,
|
||
stdio,
|
||
shell: false
|
||
}
|
||
);
|
||
};
|
||
|
||
var execaExports = execa$2.exports;
|
||
var execa$1 = /*@__PURE__*/getDefaultExportFromCjs(execaExports);
|
||
|
||
function ansiRegex({onlyFirst = false} = {}) {
|
||
const pattern = [
|
||
'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
|
||
'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
|
||
].join('|');
|
||
|
||
return new RegExp(pattern, onlyFirst ? undefined : 'g');
|
||
}
|
||
|
||
function stripAnsi(string) {
|
||
if (typeof string !== 'string') {
|
||
throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
|
||
}
|
||
|
||
return string.replace(ansiRegex(), '');
|
||
}
|
||
|
||
const detectDefaultShell = () => {
|
||
const {env} = process$2;
|
||
|
||
if (process$2.platform === 'win32') {
|
||
return env.COMSPEC || 'cmd.exe';
|
||
}
|
||
|
||
try {
|
||
const {shell} = node_os.userInfo();
|
||
if (shell) {
|
||
return shell;
|
||
}
|
||
} catch {}
|
||
|
||
if (process$2.platform === 'darwin') {
|
||
return env.SHELL || '/bin/zsh';
|
||
}
|
||
|
||
return env.SHELL || '/bin/sh';
|
||
};
|
||
|
||
// Stores default shell when imported.
|
||
const defaultShell = detectDefaultShell();
|
||
|
||
const args = [
|
||
'-ilc',
|
||
'echo -n "_SHELL_ENV_DELIMITER_"; env; echo -n "_SHELL_ENV_DELIMITER_"; exit',
|
||
];
|
||
|
||
const env = {
|
||
// Disables Oh My Zsh auto-update thing that can block the process.
|
||
DISABLE_AUTO_UPDATE: 'true',
|
||
};
|
||
|
||
const parseEnv = env => {
|
||
env = env.split('_SHELL_ENV_DELIMITER_')[1];
|
||
const returnValue = {};
|
||
|
||
for (const line of stripAnsi(env).split('\n').filter(line => Boolean(line))) {
|
||
const [key, ...values] = line.split('=');
|
||
returnValue[key] = values.join('=');
|
||
}
|
||
|
||
return returnValue;
|
||
};
|
||
|
||
function shellEnvSync(shell) {
|
||
if (process$2.platform === 'win32') {
|
||
return process$2.env;
|
||
}
|
||
|
||
try {
|
||
const {stdout} = execa$1.sync(shell || defaultShell, args, {env});
|
||
return parseEnv(stdout);
|
||
} catch (error) {
|
||
if (shell) {
|
||
throw error;
|
||
} else {
|
||
return process$2.env;
|
||
}
|
||
}
|
||
}
|
||
|
||
function shellPathSync() {
|
||
const {PATH} = shellEnvSync();
|
||
return PATH;
|
||
}
|
||
|
||
function fixPath() {
|
||
if (process$2.platform === 'win32') {
|
||
return;
|
||
}
|
||
|
||
process$2.env.PATH = shellPathSync() || [
|
||
'./node_modules/.bin',
|
||
'/.nodebrew/current/bin',
|
||
'/usr/local/bin',
|
||
process$2.env.PATH,
|
||
].join(':');
|
||
}
|
||
|
||
var lib = {};
|
||
|
||
var readable = {exports: {}};
|
||
|
||
var stream;
|
||
var hasRequiredStream;
|
||
|
||
function requireStream () {
|
||
if (hasRequiredStream) return stream;
|
||
hasRequiredStream = 1;
|
||
stream = require$$0$5;
|
||
return stream;
|
||
}
|
||
|
||
var buffer_list;
|
||
var hasRequiredBuffer_list;
|
||
|
||
function requireBuffer_list () {
|
||
if (hasRequiredBuffer_list) return buffer_list;
|
||
hasRequiredBuffer_list = 1;
|
||
|
||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
|
||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
||
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
|
||
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
|
||
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
|
||
var _require = require$$0$6,
|
||
Buffer = _require.Buffer;
|
||
var _require2 = require$$2$1,
|
||
inspect = _require2.inspect;
|
||
var custom = inspect && inspect.custom || 'inspect';
|
||
function copyBuffer(src, target, offset) {
|
||
Buffer.prototype.copy.call(src, target, offset);
|
||
}
|
||
buffer_list = /*#__PURE__*/function () {
|
||
function BufferList() {
|
||
_classCallCheck(this, BufferList);
|
||
this.head = null;
|
||
this.tail = null;
|
||
this.length = 0;
|
||
}
|
||
_createClass(BufferList, [{
|
||
key: "push",
|
||
value: function push(v) {
|
||
var entry = {
|
||
data: v,
|
||
next: null
|
||
};
|
||
if (this.length > 0) this.tail.next = entry;else this.head = entry;
|
||
this.tail = entry;
|
||
++this.length;
|
||
}
|
||
}, {
|
||
key: "unshift",
|
||
value: function unshift(v) {
|
||
var entry = {
|
||
data: v,
|
||
next: this.head
|
||
};
|
||
if (this.length === 0) this.tail = entry;
|
||
this.head = entry;
|
||
++this.length;
|
||
}
|
||
}, {
|
||
key: "shift",
|
||
value: function shift() {
|
||
if (this.length === 0) return;
|
||
var ret = this.head.data;
|
||
if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
|
||
--this.length;
|
||
return ret;
|
||
}
|
||
}, {
|
||
key: "clear",
|
||
value: function clear() {
|
||
this.head = this.tail = null;
|
||
this.length = 0;
|
||
}
|
||
}, {
|
||
key: "join",
|
||
value: function join(s) {
|
||
if (this.length === 0) return '';
|
||
var p = this.head;
|
||
var ret = '' + p.data;
|
||
while (p = p.next) ret += s + p.data;
|
||
return ret;
|
||
}
|
||
}, {
|
||
key: "concat",
|
||
value: function concat(n) {
|
||
if (this.length === 0) return Buffer.alloc(0);
|
||
var ret = Buffer.allocUnsafe(n >>> 0);
|
||
var p = this.head;
|
||
var i = 0;
|
||
while (p) {
|
||
copyBuffer(p.data, ret, i);
|
||
i += p.data.length;
|
||
p = p.next;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Consumes a specified amount of bytes or characters from the buffered data.
|
||
}, {
|
||
key: "consume",
|
||
value: function consume(n, hasStrings) {
|
||
var ret;
|
||
if (n < this.head.data.length) {
|
||
// `slice` is the same for buffers and strings.
|
||
ret = this.head.data.slice(0, n);
|
||
this.head.data = this.head.data.slice(n);
|
||
} else if (n === this.head.data.length) {
|
||
// First chunk is a perfect match.
|
||
ret = this.shift();
|
||
} else {
|
||
// Result spans more than one buffer.
|
||
ret = hasStrings ? this._getString(n) : this._getBuffer(n);
|
||
}
|
||
return ret;
|
||
}
|
||
}, {
|
||
key: "first",
|
||
value: function first() {
|
||
return this.head.data;
|
||
}
|
||
|
||
// Consumes a specified amount of characters from the buffered data.
|
||
}, {
|
||
key: "_getString",
|
||
value: function _getString(n) {
|
||
var p = this.head;
|
||
var c = 1;
|
||
var ret = p.data;
|
||
n -= ret.length;
|
||
while (p = p.next) {
|
||
var str = p.data;
|
||
var nb = n > str.length ? str.length : n;
|
||
if (nb === str.length) ret += str;else ret += str.slice(0, n);
|
||
n -= nb;
|
||
if (n === 0) {
|
||
if (nb === str.length) {
|
||
++c;
|
||
if (p.next) this.head = p.next;else this.head = this.tail = null;
|
||
} else {
|
||
this.head = p;
|
||
p.data = str.slice(nb);
|
||
}
|
||
break;
|
||
}
|
||
++c;
|
||
}
|
||
this.length -= c;
|
||
return ret;
|
||
}
|
||
|
||
// Consumes a specified amount of bytes from the buffered data.
|
||
}, {
|
||
key: "_getBuffer",
|
||
value: function _getBuffer(n) {
|
||
var ret = Buffer.allocUnsafe(n);
|
||
var p = this.head;
|
||
var c = 1;
|
||
p.data.copy(ret);
|
||
n -= p.data.length;
|
||
while (p = p.next) {
|
||
var buf = p.data;
|
||
var nb = n > buf.length ? buf.length : n;
|
||
buf.copy(ret, ret.length - n, 0, nb);
|
||
n -= nb;
|
||
if (n === 0) {
|
||
if (nb === buf.length) {
|
||
++c;
|
||
if (p.next) this.head = p.next;else this.head = this.tail = null;
|
||
} else {
|
||
this.head = p;
|
||
p.data = buf.slice(nb);
|
||
}
|
||
break;
|
||
}
|
||
++c;
|
||
}
|
||
this.length -= c;
|
||
return ret;
|
||
}
|
||
|
||
// Make sure the linked list only shows the minimal necessary information.
|
||
}, {
|
||
key: custom,
|
||
value: function value(_, options) {
|
||
return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
|
||
// Only inspect one level.
|
||
depth: 0,
|
||
// It should not recurse.
|
||
customInspect: false
|
||
}));
|
||
}
|
||
}]);
|
||
return BufferList;
|
||
}();
|
||
return buffer_list;
|
||
}
|
||
|
||
var destroy_1;
|
||
var hasRequiredDestroy;
|
||
|
||
function requireDestroy () {
|
||
if (hasRequiredDestroy) return destroy_1;
|
||
hasRequiredDestroy = 1;
|
||
|
||
// undocumented cb() API, needed for core, not for public API
|
||
function destroy(err, cb) {
|
||
var _this = this;
|
||
var readableDestroyed = this._readableState && this._readableState.destroyed;
|
||
var writableDestroyed = this._writableState && this._writableState.destroyed;
|
||
if (readableDestroyed || writableDestroyed) {
|
||
if (cb) {
|
||
cb(err);
|
||
} else if (err) {
|
||
if (!this._writableState) {
|
||
process.nextTick(emitErrorNT, this, err);
|
||
} else if (!this._writableState.errorEmitted) {
|
||
this._writableState.errorEmitted = true;
|
||
process.nextTick(emitErrorNT, this, err);
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
|
||
// we set destroyed to true before firing error callbacks in order
|
||
// to make it re-entrance safe in case destroy() is called within callbacks
|
||
|
||
if (this._readableState) {
|
||
this._readableState.destroyed = true;
|
||
}
|
||
|
||
// if this is a duplex stream mark the writable part as destroyed as well
|
||
if (this._writableState) {
|
||
this._writableState.destroyed = true;
|
||
}
|
||
this._destroy(err || null, function (err) {
|
||
if (!cb && err) {
|
||
if (!_this._writableState) {
|
||
process.nextTick(emitErrorAndCloseNT, _this, err);
|
||
} else if (!_this._writableState.errorEmitted) {
|
||
_this._writableState.errorEmitted = true;
|
||
process.nextTick(emitErrorAndCloseNT, _this, err);
|
||
} else {
|
||
process.nextTick(emitCloseNT, _this);
|
||
}
|
||
} else if (cb) {
|
||
process.nextTick(emitCloseNT, _this);
|
||
cb(err);
|
||
} else {
|
||
process.nextTick(emitCloseNT, _this);
|
||
}
|
||
});
|
||
return this;
|
||
}
|
||
function emitErrorAndCloseNT(self, err) {
|
||
emitErrorNT(self, err);
|
||
emitCloseNT(self);
|
||
}
|
||
function emitCloseNT(self) {
|
||
if (self._writableState && !self._writableState.emitClose) return;
|
||
if (self._readableState && !self._readableState.emitClose) return;
|
||
self.emit('close');
|
||
}
|
||
function undestroy() {
|
||
if (this._readableState) {
|
||
this._readableState.destroyed = false;
|
||
this._readableState.reading = false;
|
||
this._readableState.ended = false;
|
||
this._readableState.endEmitted = false;
|
||
}
|
||
if (this._writableState) {
|
||
this._writableState.destroyed = false;
|
||
this._writableState.ended = false;
|
||
this._writableState.ending = false;
|
||
this._writableState.finalCalled = false;
|
||
this._writableState.prefinished = false;
|
||
this._writableState.finished = false;
|
||
this._writableState.errorEmitted = false;
|
||
}
|
||
}
|
||
function emitErrorNT(self, err) {
|
||
self.emit('error', err);
|
||
}
|
||
function errorOrDestroy(stream, err) {
|
||
// We have tests that rely on errors being emitted
|
||
// in the same tick, so changing this is semver major.
|
||
// For now when you opt-in to autoDestroy we allow
|
||
// the error to be emitted nextTick. In a future
|
||
// semver major update we should change the default to this.
|
||
|
||
var rState = stream._readableState;
|
||
var wState = stream._writableState;
|
||
if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
|
||
}
|
||
destroy_1 = {
|
||
destroy: destroy,
|
||
undestroy: undestroy,
|
||
errorOrDestroy: errorOrDestroy
|
||
};
|
||
return destroy_1;
|
||
}
|
||
|
||
var errors = {};
|
||
|
||
var hasRequiredErrors;
|
||
|
||
function requireErrors () {
|
||
if (hasRequiredErrors) return errors;
|
||
hasRequiredErrors = 1;
|
||
|
||
const codes = {};
|
||
|
||
function createErrorType(code, message, Base) {
|
||
if (!Base) {
|
||
Base = Error;
|
||
}
|
||
|
||
function getMessage (arg1, arg2, arg3) {
|
||
if (typeof message === 'string') {
|
||
return message
|
||
} else {
|
||
return message(arg1, arg2, arg3)
|
||
}
|
||
}
|
||
|
||
class NodeError extends Base {
|
||
constructor (arg1, arg2, arg3) {
|
||
super(getMessage(arg1, arg2, arg3));
|
||
}
|
||
}
|
||
|
||
NodeError.prototype.name = Base.name;
|
||
NodeError.prototype.code = code;
|
||
|
||
codes[code] = NodeError;
|
||
}
|
||
|
||
// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
|
||
function oneOf(expected, thing) {
|
||
if (Array.isArray(expected)) {
|
||
const len = expected.length;
|
||
expected = expected.map((i) => String(i));
|
||
if (len > 2) {
|
||
return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
|
||
expected[len - 1];
|
||
} else if (len === 2) {
|
||
return `one of ${thing} ${expected[0]} or ${expected[1]}`;
|
||
} else {
|
||
return `of ${thing} ${expected[0]}`;
|
||
}
|
||
} else {
|
||
return `of ${thing} ${String(expected)}`;
|
||
}
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
|
||
function startsWith(str, search, pos) {
|
||
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
|
||
function endsWith(str, search, this_len) {
|
||
if (this_len === undefined || this_len > str.length) {
|
||
this_len = str.length;
|
||
}
|
||
return str.substring(this_len - search.length, this_len) === search;
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
|
||
function includes(str, search, start) {
|
||
if (typeof start !== 'number') {
|
||
start = 0;
|
||
}
|
||
|
||
if (start + search.length > str.length) {
|
||
return false;
|
||
} else {
|
||
return str.indexOf(search, start) !== -1;
|
||
}
|
||
}
|
||
|
||
createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
|
||
return 'The value "' + value + '" is invalid for option "' + name + '"'
|
||
}, TypeError);
|
||
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
|
||
// determiner: 'must be' or 'must not be'
|
||
let determiner;
|
||
if (typeof expected === 'string' && startsWith(expected, 'not ')) {
|
||
determiner = 'must not be';
|
||
expected = expected.replace(/^not /, '');
|
||
} else {
|
||
determiner = 'must be';
|
||
}
|
||
|
||
let msg;
|
||
if (endsWith(name, ' argument')) {
|
||
// For cases like 'first argument'
|
||
msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
|
||
} else {
|
||
const type = includes(name, '.') ? 'property' : 'argument';
|
||
msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
|
||
}
|
||
|
||
msg += `. Received type ${typeof actual}`;
|
||
return msg;
|
||
}, TypeError);
|
||
createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
|
||
createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
|
||
return 'The ' + name + ' method is not implemented'
|
||
});
|
||
createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
|
||
createErrorType('ERR_STREAM_DESTROYED', function (name) {
|
||
return 'Cannot call ' + name + ' after a stream was destroyed';
|
||
});
|
||
createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
|
||
createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
|
||
createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
|
||
createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
|
||
createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
|
||
return 'Unknown encoding: ' + arg
|
||
}, TypeError);
|
||
createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
|
||
|
||
errors.codes = codes;
|
||
return errors;
|
||
}
|
||
|
||
var state;
|
||
var hasRequiredState;
|
||
|
||
function requireState () {
|
||
if (hasRequiredState) return state;
|
||
hasRequiredState = 1;
|
||
|
||
var ERR_INVALID_OPT_VALUE = requireErrors().codes.ERR_INVALID_OPT_VALUE;
|
||
function highWaterMarkFrom(options, isDuplex, duplexKey) {
|
||
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
|
||
}
|
||
function getHighWaterMark(state, options, duplexKey, isDuplex) {
|
||
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
|
||
if (hwm != null) {
|
||
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
|
||
var name = isDuplex ? duplexKey : 'highWaterMark';
|
||
throw new ERR_INVALID_OPT_VALUE(name, hwm);
|
||
}
|
||
return Math.floor(hwm);
|
||
}
|
||
|
||
// Default value
|
||
return state.objectMode ? 16 : 16 * 1024;
|
||
}
|
||
state = {
|
||
getHighWaterMark: getHighWaterMark
|
||
};
|
||
return state;
|
||
}
|
||
|
||
var inherits = {exports: {}};
|
||
|
||
var inherits_browser = {exports: {}};
|
||
|
||
var hasRequiredInherits_browser;
|
||
|
||
function requireInherits_browser () {
|
||
if (hasRequiredInherits_browser) return inherits_browser.exports;
|
||
hasRequiredInherits_browser = 1;
|
||
if (typeof Object.create === 'function') {
|
||
// implementation from standard node.js 'util' module
|
||
inherits_browser.exports = function inherits(ctor, superCtor) {
|
||
if (superCtor) {
|
||
ctor.super_ = superCtor;
|
||
ctor.prototype = Object.create(superCtor.prototype, {
|
||
constructor: {
|
||
value: ctor,
|
||
enumerable: false,
|
||
writable: true,
|
||
configurable: true
|
||
}
|
||
});
|
||
}
|
||
};
|
||
} else {
|
||
// old school shim for old browsers
|
||
inherits_browser.exports = function inherits(ctor, superCtor) {
|
||
if (superCtor) {
|
||
ctor.super_ = superCtor;
|
||
var TempCtor = function () {};
|
||
TempCtor.prototype = superCtor.prototype;
|
||
ctor.prototype = new TempCtor();
|
||
ctor.prototype.constructor = ctor;
|
||
}
|
||
};
|
||
}
|
||
return inherits_browser.exports;
|
||
}
|
||
|
||
var hasRequiredInherits;
|
||
|
||
function requireInherits () {
|
||
if (hasRequiredInherits) return inherits.exports;
|
||
hasRequiredInherits = 1;
|
||
try {
|
||
var util = require('util');
|
||
/* istanbul ignore next */
|
||
if (typeof util.inherits !== 'function') throw '';
|
||
inherits.exports = util.inherits;
|
||
} catch (e) {
|
||
/* istanbul ignore next */
|
||
inherits.exports = requireInherits_browser();
|
||
}
|
||
return inherits.exports;
|
||
}
|
||
|
||
var node;
|
||
var hasRequiredNode;
|
||
|
||
function requireNode () {
|
||
if (hasRequiredNode) return node;
|
||
hasRequiredNode = 1;
|
||
/**
|
||
* For Node.js, simply re-export the core `util.deprecate` function.
|
||
*/
|
||
|
||
node = require$$2$1.deprecate;
|
||
return node;
|
||
}
|
||
|
||
var _stream_writable;
|
||
var hasRequired_stream_writable;
|
||
|
||
function require_stream_writable () {
|
||
if (hasRequired_stream_writable) return _stream_writable;
|
||
hasRequired_stream_writable = 1;
|
||
|
||
_stream_writable = Writable;
|
||
|
||
// It seems a linked list but it is not
|
||
// there will be only 2 of these for each stream
|
||
function CorkedRequest(state) {
|
||
var _this = this;
|
||
this.next = null;
|
||
this.entry = null;
|
||
this.finish = function () {
|
||
onCorkedFinish(_this, state);
|
||
};
|
||
}
|
||
/* </replacement> */
|
||
|
||
/*<replacement>*/
|
||
var Duplex;
|
||
/*</replacement>*/
|
||
|
||
Writable.WritableState = WritableState;
|
||
|
||
/*<replacement>*/
|
||
var internalUtil = {
|
||
deprecate: requireNode()
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var Stream = requireStream();
|
||
/*</replacement>*/
|
||
|
||
var Buffer = require$$0$6.Buffer;
|
||
var OurUint8Array = (typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};
|
||
function _uint8ArrayToBuffer(chunk) {
|
||
return Buffer.from(chunk);
|
||
}
|
||
function _isUint8Array(obj) {
|
||
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
||
}
|
||
var destroyImpl = requireDestroy();
|
||
var _require = requireState(),
|
||
getHighWaterMark = _require.getHighWaterMark;
|
||
var _require$codes = requireErrors().codes,
|
||
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
||
ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
|
||
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
|
||
ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
|
||
ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
|
||
ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
|
||
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
||
requireInherits()(Writable, Stream);
|
||
function nop() {}
|
||
function WritableState(options, stream, isDuplex) {
|
||
Duplex = Duplex || require_stream_duplex();
|
||
options = options || {};
|
||
|
||
// Duplex streams are both readable and writable, but share
|
||
// the same options object.
|
||
// However, some cases require setting options to different
|
||
// values for the readable and the writable sides of the duplex stream,
|
||
// e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
|
||
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;
|
||
|
||
// object stream flag to indicate whether or not this stream
|
||
// contains buffers or objects.
|
||
this.objectMode = !!options.objectMode;
|
||
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
|
||
|
||
// the point at which write() starts returning false
|
||
// Note: 0 is a valid value, means that we always return false if
|
||
// the entire buffer is not flushed immediately on write()
|
||
this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);
|
||
|
||
// if _final has been called
|
||
this.finalCalled = false;
|
||
|
||
// drain event flag.
|
||
this.needDrain = false;
|
||
// at the start of calling end()
|
||
this.ending = false;
|
||
// when end() has been called, and returned
|
||
this.ended = false;
|
||
// when 'finish' is emitted
|
||
this.finished = false;
|
||
|
||
// has it been destroyed
|
||
this.destroyed = false;
|
||
|
||
// should we decode strings into buffers before passing to _write?
|
||
// this is here so that some node-core streams can optimize string
|
||
// handling at a lower level.
|
||
var noDecode = options.decodeStrings === false;
|
||
this.decodeStrings = !noDecode;
|
||
|
||
// Crypto is kind of old and crusty. Historically, its default string
|
||
// encoding is 'binary' so we have to make this configurable.
|
||
// Everything else in the universe uses 'utf8', though.
|
||
this.defaultEncoding = options.defaultEncoding || 'utf8';
|
||
|
||
// not an actual buffer we keep track of, but a measurement
|
||
// of how much we're waiting to get pushed to some underlying
|
||
// socket or file.
|
||
this.length = 0;
|
||
|
||
// a flag to see when we're in the middle of a write.
|
||
this.writing = false;
|
||
|
||
// when true all writes will be buffered until .uncork() call
|
||
this.corked = 0;
|
||
|
||
// a flag to be able to tell if the onwrite cb is called immediately,
|
||
// or on a later tick. We set this to true at first, because any
|
||
// actions that shouldn't happen until "later" should generally also
|
||
// not happen before the first write call.
|
||
this.sync = true;
|
||
|
||
// a flag to know if we're processing previously buffered items, which
|
||
// may call the _write() callback in the same tick, so that we don't
|
||
// end up in an overlapped onwrite situation.
|
||
this.bufferProcessing = false;
|
||
|
||
// the callback that's passed to _write(chunk,cb)
|
||
this.onwrite = function (er) {
|
||
onwrite(stream, er);
|
||
};
|
||
|
||
// the callback that the user supplies to write(chunk,encoding,cb)
|
||
this.writecb = null;
|
||
|
||
// the amount that is being written when _write is called.
|
||
this.writelen = 0;
|
||
this.bufferedRequest = null;
|
||
this.lastBufferedRequest = null;
|
||
|
||
// number of pending user-supplied write callbacks
|
||
// this must be 0 before 'finish' can be emitted
|
||
this.pendingcb = 0;
|
||
|
||
// emit prefinish if the only thing we're waiting for is _write cbs
|
||
// This is relevant for synchronous Transform streams
|
||
this.prefinished = false;
|
||
|
||
// True if the error was already emitted and should not be thrown again
|
||
this.errorEmitted = false;
|
||
|
||
// Should close be emitted on destroy. Defaults to true.
|
||
this.emitClose = options.emitClose !== false;
|
||
|
||
// Should .destroy() be called after 'finish' (and potentially 'end')
|
||
this.autoDestroy = !!options.autoDestroy;
|
||
|
||
// count buffered requests
|
||
this.bufferedRequestCount = 0;
|
||
|
||
// allocate the first CorkedRequest, there is always
|
||
// one allocated and free to use, and we maintain at most two
|
||
this.corkedRequestsFree = new CorkedRequest(this);
|
||
}
|
||
WritableState.prototype.getBuffer = function getBuffer() {
|
||
var current = this.bufferedRequest;
|
||
var out = [];
|
||
while (current) {
|
||
out.push(current);
|
||
current = current.next;
|
||
}
|
||
return out;
|
||
};
|
||
(function () {
|
||
try {
|
||
Object.defineProperty(WritableState.prototype, 'buffer', {
|
||
get: internalUtil.deprecate(function writableStateBufferGetter() {
|
||
return this.getBuffer();
|
||
}, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
|
||
});
|
||
} catch (_) {}
|
||
})();
|
||
|
||
// Test _writableState for inheritance to account for Duplex streams,
|
||
// whose prototype chain only points to Readable.
|
||
var realHasInstance;
|
||
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
|
||
realHasInstance = Function.prototype[Symbol.hasInstance];
|
||
Object.defineProperty(Writable, Symbol.hasInstance, {
|
||
value: function value(object) {
|
||
if (realHasInstance.call(this, object)) return true;
|
||
if (this !== Writable) return false;
|
||
return object && object._writableState instanceof WritableState;
|
||
}
|
||
});
|
||
} else {
|
||
realHasInstance = function realHasInstance(object) {
|
||
return object instanceof this;
|
||
};
|
||
}
|
||
function Writable(options) {
|
||
Duplex = Duplex || require_stream_duplex();
|
||
|
||
// Writable ctor is applied to Duplexes, too.
|
||
// `realHasInstance` is necessary because using plain `instanceof`
|
||
// would return false, as no `_writableState` property is attached.
|
||
|
||
// Trying to use the custom `instanceof` for Writable here will also break the
|
||
// Node.js LazyTransform implementation, which has a non-trivial getter for
|
||
// `_writableState` that would lead to infinite recursion.
|
||
|
||
// Checking for a Stream.Duplex instance is faster here instead of inside
|
||
// the WritableState constructor, at least with V8 6.5
|
||
var isDuplex = this instanceof Duplex;
|
||
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
|
||
this._writableState = new WritableState(options, this, isDuplex);
|
||
|
||
// legacy.
|
||
this.writable = true;
|
||
if (options) {
|
||
if (typeof options.write === 'function') this._write = options.write;
|
||
if (typeof options.writev === 'function') this._writev = options.writev;
|
||
if (typeof options.destroy === 'function') this._destroy = options.destroy;
|
||
if (typeof options.final === 'function') this._final = options.final;
|
||
}
|
||
Stream.call(this);
|
||
}
|
||
|
||
// Otherwise people can pipe Writable streams, which is just wrong.
|
||
Writable.prototype.pipe = function () {
|
||
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
|
||
};
|
||
function writeAfterEnd(stream, cb) {
|
||
var er = new ERR_STREAM_WRITE_AFTER_END();
|
||
// TODO: defer error events consistently everywhere, not just the cb
|
||
errorOrDestroy(stream, er);
|
||
process.nextTick(cb, er);
|
||
}
|
||
|
||
// Checks that a user-supplied chunk is valid, especially for the particular
|
||
// mode the stream is in. Currently this means that `null` is never accepted
|
||
// and undefined/non-string values are only allowed in object mode.
|
||
function validChunk(stream, state, chunk, cb) {
|
||
var er;
|
||
if (chunk === null) {
|
||
er = new ERR_STREAM_NULL_VALUES();
|
||
} else if (typeof chunk !== 'string' && !state.objectMode) {
|
||
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
|
||
}
|
||
if (er) {
|
||
errorOrDestroy(stream, er);
|
||
process.nextTick(cb, er);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
Writable.prototype.write = function (chunk, encoding, cb) {
|
||
var state = this._writableState;
|
||
var ret = false;
|
||
var isBuf = !state.objectMode && _isUint8Array(chunk);
|
||
if (isBuf && !Buffer.isBuffer(chunk)) {
|
||
chunk = _uint8ArrayToBuffer(chunk);
|
||
}
|
||
if (typeof encoding === 'function') {
|
||
cb = encoding;
|
||
encoding = null;
|
||
}
|
||
if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
|
||
if (typeof cb !== 'function') cb = nop;
|
||
if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
|
||
state.pendingcb++;
|
||
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
|
||
}
|
||
return ret;
|
||
};
|
||
Writable.prototype.cork = function () {
|
||
this._writableState.corked++;
|
||
};
|
||
Writable.prototype.uncork = function () {
|
||
var state = this._writableState;
|
||
if (state.corked) {
|
||
state.corked--;
|
||
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
|
||
}
|
||
};
|
||
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
|
||
// node::ParseEncoding() requires lower case.
|
||
if (typeof encoding === 'string') encoding = encoding.toLowerCase();
|
||
if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
|
||
this._writableState.defaultEncoding = encoding;
|
||
return this;
|
||
};
|
||
Object.defineProperty(Writable.prototype, 'writableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState && this._writableState.getBuffer();
|
||
}
|
||
});
|
||
function decodeChunk(state, chunk, encoding) {
|
||
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
|
||
chunk = Buffer.from(chunk, encoding);
|
||
}
|
||
return chunk;
|
||
}
|
||
Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.highWaterMark;
|
||
}
|
||
});
|
||
|
||
// if we're already writing something, then just put this
|
||
// in the queue, and wait our turn. Otherwise, call _write
|
||
// If we return false, then we need a drain event, so set that flag.
|
||
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
|
||
if (!isBuf) {
|
||
var newChunk = decodeChunk(state, chunk, encoding);
|
||
if (chunk !== newChunk) {
|
||
isBuf = true;
|
||
encoding = 'buffer';
|
||
chunk = newChunk;
|
||
}
|
||
}
|
||
var len = state.objectMode ? 1 : chunk.length;
|
||
state.length += len;
|
||
var ret = state.length < state.highWaterMark;
|
||
// we must ensure that previous needDrain will not be reset to false.
|
||
if (!ret) state.needDrain = true;
|
||
if (state.writing || state.corked) {
|
||
var last = state.lastBufferedRequest;
|
||
state.lastBufferedRequest = {
|
||
chunk: chunk,
|
||
encoding: encoding,
|
||
isBuf: isBuf,
|
||
callback: cb,
|
||
next: null
|
||
};
|
||
if (last) {
|
||
last.next = state.lastBufferedRequest;
|
||
} else {
|
||
state.bufferedRequest = state.lastBufferedRequest;
|
||
}
|
||
state.bufferedRequestCount += 1;
|
||
} else {
|
||
doWrite(stream, state, false, len, chunk, encoding, cb);
|
||
}
|
||
return ret;
|
||
}
|
||
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
|
||
state.writelen = len;
|
||
state.writecb = cb;
|
||
state.writing = true;
|
||
state.sync = true;
|
||
if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
|
||
state.sync = false;
|
||
}
|
||
function onwriteError(stream, state, sync, er, cb) {
|
||
--state.pendingcb;
|
||
if (sync) {
|
||
// defer the callback if we are being called synchronously
|
||
// to avoid piling up things on the stack
|
||
process.nextTick(cb, er);
|
||
// this can emit finish, and it will always happen
|
||
// after error
|
||
process.nextTick(finishMaybe, stream, state);
|
||
stream._writableState.errorEmitted = true;
|
||
errorOrDestroy(stream, er);
|
||
} else {
|
||
// the caller expect this to happen before if
|
||
// it is async
|
||
cb(er);
|
||
stream._writableState.errorEmitted = true;
|
||
errorOrDestroy(stream, er);
|
||
// this can emit finish, but finish must
|
||
// always follow error
|
||
finishMaybe(stream, state);
|
||
}
|
||
}
|
||
function onwriteStateUpdate(state) {
|
||
state.writing = false;
|
||
state.writecb = null;
|
||
state.length -= state.writelen;
|
||
state.writelen = 0;
|
||
}
|
||
function onwrite(stream, er) {
|
||
var state = stream._writableState;
|
||
var sync = state.sync;
|
||
var cb = state.writecb;
|
||
if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
|
||
onwriteStateUpdate(state);
|
||
if (er) onwriteError(stream, state, sync, er, cb);else {
|
||
// Check if we're actually ready to finish, but don't emit yet
|
||
var finished = needFinish(state) || stream.destroyed;
|
||
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
|
||
clearBuffer(stream, state);
|
||
}
|
||
if (sync) {
|
||
process.nextTick(afterWrite, stream, state, finished, cb);
|
||
} else {
|
||
afterWrite(stream, state, finished, cb);
|
||
}
|
||
}
|
||
}
|
||
function afterWrite(stream, state, finished, cb) {
|
||
if (!finished) onwriteDrain(stream, state);
|
||
state.pendingcb--;
|
||
cb();
|
||
finishMaybe(stream, state);
|
||
}
|
||
|
||
// Must force callback to be called on nextTick, so that we don't
|
||
// emit 'drain' before the write() consumer gets the 'false' return
|
||
// value, and has a chance to attach a 'drain' listener.
|
||
function onwriteDrain(stream, state) {
|
||
if (state.length === 0 && state.needDrain) {
|
||
state.needDrain = false;
|
||
stream.emit('drain');
|
||
}
|
||
}
|
||
|
||
// if there's something in the buffer waiting, then process it
|
||
function clearBuffer(stream, state) {
|
||
state.bufferProcessing = true;
|
||
var entry = state.bufferedRequest;
|
||
if (stream._writev && entry && entry.next) {
|
||
// Fast case, write everything using _writev()
|
||
var l = state.bufferedRequestCount;
|
||
var buffer = new Array(l);
|
||
var holder = state.corkedRequestsFree;
|
||
holder.entry = entry;
|
||
var count = 0;
|
||
var allBuffers = true;
|
||
while (entry) {
|
||
buffer[count] = entry;
|
||
if (!entry.isBuf) allBuffers = false;
|
||
entry = entry.next;
|
||
count += 1;
|
||
}
|
||
buffer.allBuffers = allBuffers;
|
||
doWrite(stream, state, true, state.length, buffer, '', holder.finish);
|
||
|
||
// doWrite is almost always async, defer these to save a bit of time
|
||
// as the hot path ends with doWrite
|
||
state.pendingcb++;
|
||
state.lastBufferedRequest = null;
|
||
if (holder.next) {
|
||
state.corkedRequestsFree = holder.next;
|
||
holder.next = null;
|
||
} else {
|
||
state.corkedRequestsFree = new CorkedRequest(state);
|
||
}
|
||
state.bufferedRequestCount = 0;
|
||
} else {
|
||
// Slow case, write chunks one-by-one
|
||
while (entry) {
|
||
var chunk = entry.chunk;
|
||
var encoding = entry.encoding;
|
||
var cb = entry.callback;
|
||
var len = state.objectMode ? 1 : chunk.length;
|
||
doWrite(stream, state, false, len, chunk, encoding, cb);
|
||
entry = entry.next;
|
||
state.bufferedRequestCount--;
|
||
// if we didn't call the onwrite immediately, then
|
||
// it means that we need to wait until it does.
|
||
// also, that means that the chunk and cb are currently
|
||
// being processed, so move the buffer counter past them.
|
||
if (state.writing) {
|
||
break;
|
||
}
|
||
}
|
||
if (entry === null) state.lastBufferedRequest = null;
|
||
}
|
||
state.bufferedRequest = entry;
|
||
state.bufferProcessing = false;
|
||
}
|
||
Writable.prototype._write = function (chunk, encoding, cb) {
|
||
cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
|
||
};
|
||
Writable.prototype._writev = null;
|
||
Writable.prototype.end = function (chunk, encoding, cb) {
|
||
var state = this._writableState;
|
||
if (typeof chunk === 'function') {
|
||
cb = chunk;
|
||
chunk = null;
|
||
encoding = null;
|
||
} else if (typeof encoding === 'function') {
|
||
cb = encoding;
|
||
encoding = null;
|
||
}
|
||
if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
|
||
|
||
// .end() fully uncorks
|
||
if (state.corked) {
|
||
state.corked = 1;
|
||
this.uncork();
|
||
}
|
||
|
||
// ignore unnecessary end() calls.
|
||
if (!state.ending) endWritable(this, state, cb);
|
||
return this;
|
||
};
|
||
Object.defineProperty(Writable.prototype, 'writableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.length;
|
||
}
|
||
});
|
||
function needFinish(state) {
|
||
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
|
||
}
|
||
function callFinal(stream, state) {
|
||
stream._final(function (err) {
|
||
state.pendingcb--;
|
||
if (err) {
|
||
errorOrDestroy(stream, err);
|
||
}
|
||
state.prefinished = true;
|
||
stream.emit('prefinish');
|
||
finishMaybe(stream, state);
|
||
});
|
||
}
|
||
function prefinish(stream, state) {
|
||
if (!state.prefinished && !state.finalCalled) {
|
||
if (typeof stream._final === 'function' && !state.destroyed) {
|
||
state.pendingcb++;
|
||
state.finalCalled = true;
|
||
process.nextTick(callFinal, stream, state);
|
||
} else {
|
||
state.prefinished = true;
|
||
stream.emit('prefinish');
|
||
}
|
||
}
|
||
}
|
||
function finishMaybe(stream, state) {
|
||
var need = needFinish(state);
|
||
if (need) {
|
||
prefinish(stream, state);
|
||
if (state.pendingcb === 0) {
|
||
state.finished = true;
|
||
stream.emit('finish');
|
||
if (state.autoDestroy) {
|
||
// In case of duplex streams we need a way to detect
|
||
// if the readable side is ready for autoDestroy as well
|
||
var rState = stream._readableState;
|
||
if (!rState || rState.autoDestroy && rState.endEmitted) {
|
||
stream.destroy();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return need;
|
||
}
|
||
function endWritable(stream, state, cb) {
|
||
state.ending = true;
|
||
finishMaybe(stream, state);
|
||
if (cb) {
|
||
if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
|
||
}
|
||
state.ended = true;
|
||
stream.writable = false;
|
||
}
|
||
function onCorkedFinish(corkReq, state, err) {
|
||
var entry = corkReq.entry;
|
||
corkReq.entry = null;
|
||
while (entry) {
|
||
var cb = entry.callback;
|
||
state.pendingcb--;
|
||
cb(err);
|
||
entry = entry.next;
|
||
}
|
||
|
||
// reuse the free corkReq.
|
||
state.corkedRequestsFree.next = corkReq;
|
||
}
|
||
Object.defineProperty(Writable.prototype, 'destroyed', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._writableState === undefined) {
|
||
return false;
|
||
}
|
||
return this._writableState.destroyed;
|
||
},
|
||
set: function set(value) {
|
||
// we ignore the value if the stream
|
||
// has not been initialized yet
|
||
if (!this._writableState) {
|
||
return;
|
||
}
|
||
|
||
// backward compatibility, the user is explicitly
|
||
// managing destroyed
|
||
this._writableState.destroyed = value;
|
||
}
|
||
});
|
||
Writable.prototype.destroy = destroyImpl.destroy;
|
||
Writable.prototype._undestroy = destroyImpl.undestroy;
|
||
Writable.prototype._destroy = function (err, cb) {
|
||
cb(err);
|
||
};
|
||
return _stream_writable;
|
||
}
|
||
|
||
var _stream_duplex;
|
||
var hasRequired_stream_duplex;
|
||
|
||
function require_stream_duplex () {
|
||
if (hasRequired_stream_duplex) return _stream_duplex;
|
||
hasRequired_stream_duplex = 1;
|
||
|
||
/*<replacement>*/
|
||
var objectKeys = Object.keys || function (obj) {
|
||
var keys = [];
|
||
for (var key in obj) keys.push(key);
|
||
return keys;
|
||
};
|
||
/*</replacement>*/
|
||
|
||
_stream_duplex = Duplex;
|
||
var Readable = require_stream_readable();
|
||
var Writable = require_stream_writable();
|
||
requireInherits()(Duplex, Readable);
|
||
{
|
||
// Allow the keys array to be GC'ed.
|
||
var keys = objectKeys(Writable.prototype);
|
||
for (var v = 0; v < keys.length; v++) {
|
||
var method = keys[v];
|
||
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
|
||
}
|
||
}
|
||
function Duplex(options) {
|
||
if (!(this instanceof Duplex)) return new Duplex(options);
|
||
Readable.call(this, options);
|
||
Writable.call(this, options);
|
||
this.allowHalfOpen = true;
|
||
if (options) {
|
||
if (options.readable === false) this.readable = false;
|
||
if (options.writable === false) this.writable = false;
|
||
if (options.allowHalfOpen === false) {
|
||
this.allowHalfOpen = false;
|
||
this.once('end', onend);
|
||
}
|
||
}
|
||
}
|
||
Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.highWaterMark;
|
||
}
|
||
});
|
||
Object.defineProperty(Duplex.prototype, 'writableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState && this._writableState.getBuffer();
|
||
}
|
||
});
|
||
Object.defineProperty(Duplex.prototype, 'writableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.length;
|
||
}
|
||
});
|
||
|
||
// the no-half-open enforcer
|
||
function onend() {
|
||
// If the writable side ended, then we're ok.
|
||
if (this._writableState.ended) return;
|
||
|
||
// no more data can be written.
|
||
// But allow more writes to happen in this tick.
|
||
process.nextTick(onEndNT, this);
|
||
}
|
||
function onEndNT(self) {
|
||
self.end();
|
||
}
|
||
Object.defineProperty(Duplex.prototype, 'destroyed', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._readableState === undefined || this._writableState === undefined) {
|
||
return false;
|
||
}
|
||
return this._readableState.destroyed && this._writableState.destroyed;
|
||
},
|
||
set: function set(value) {
|
||
// we ignore the value if the stream
|
||
// has not been initialized yet
|
||
if (this._readableState === undefined || this._writableState === undefined) {
|
||
return;
|
||
}
|
||
|
||
// backward compatibility, the user is explicitly
|
||
// managing destroyed
|
||
this._readableState.destroyed = value;
|
||
this._writableState.destroyed = value;
|
||
}
|
||
});
|
||
return _stream_duplex;
|
||
}
|
||
|
||
var string_decoder = {};
|
||
|
||
var safeBuffer = {exports: {}};
|
||
|
||
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
||
|
||
var hasRequiredSafeBuffer;
|
||
|
||
function requireSafeBuffer () {
|
||
if (hasRequiredSafeBuffer) return safeBuffer.exports;
|
||
hasRequiredSafeBuffer = 1;
|
||
(function (module, exports) {
|
||
/* eslint-disable node/no-deprecated-api */
|
||
var buffer = require$$0$6;
|
||
var Buffer = buffer.Buffer;
|
||
|
||
// alternative to using Object.keys for old browsers
|
||
function copyProps (src, dst) {
|
||
for (var key in src) {
|
||
dst[key] = src[key];
|
||
}
|
||
}
|
||
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
|
||
module.exports = buffer;
|
||
} else {
|
||
// Copy properties from require('buffer')
|
||
copyProps(buffer, exports);
|
||
exports.Buffer = SafeBuffer;
|
||
}
|
||
|
||
function SafeBuffer (arg, encodingOrOffset, length) {
|
||
return Buffer(arg, encodingOrOffset, length)
|
||
}
|
||
|
||
SafeBuffer.prototype = Object.create(Buffer.prototype);
|
||
|
||
// Copy static methods from Buffer
|
||
copyProps(Buffer, SafeBuffer);
|
||
|
||
SafeBuffer.from = function (arg, encodingOrOffset, length) {
|
||
if (typeof arg === 'number') {
|
||
throw new TypeError('Argument must not be a number')
|
||
}
|
||
return Buffer(arg, encodingOrOffset, length)
|
||
};
|
||
|
||
SafeBuffer.alloc = function (size, fill, encoding) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('Argument must be a number')
|
||
}
|
||
var buf = Buffer(size);
|
||
if (fill !== undefined) {
|
||
if (typeof encoding === 'string') {
|
||
buf.fill(fill, encoding);
|
||
} else {
|
||
buf.fill(fill);
|
||
}
|
||
} else {
|
||
buf.fill(0);
|
||
}
|
||
return buf
|
||
};
|
||
|
||
SafeBuffer.allocUnsafe = function (size) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('Argument must be a number')
|
||
}
|
||
return Buffer(size)
|
||
};
|
||
|
||
SafeBuffer.allocUnsafeSlow = function (size) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('Argument must be a number')
|
||
}
|
||
return buffer.SlowBuffer(size)
|
||
};
|
||
} (safeBuffer, safeBuffer.exports));
|
||
return safeBuffer.exports;
|
||
}
|
||
|
||
var hasRequiredString_decoder;
|
||
|
||
function requireString_decoder () {
|
||
if (hasRequiredString_decoder) return string_decoder;
|
||
hasRequiredString_decoder = 1;
|
||
|
||
/*<replacement>*/
|
||
|
||
var Buffer = requireSafeBuffer().Buffer;
|
||
/*</replacement>*/
|
||
|
||
var isEncoding = Buffer.isEncoding || function (encoding) {
|
||
encoding = '' + encoding;
|
||
switch (encoding && encoding.toLowerCase()) {
|
||
case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
|
||
function _normalizeEncoding(enc) {
|
||
if (!enc) return 'utf8';
|
||
var retried;
|
||
while (true) {
|
||
switch (enc) {
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return 'utf8';
|
||
case 'ucs2':
|
||
case 'ucs-2':
|
||
case 'utf16le':
|
||
case 'utf-16le':
|
||
return 'utf16le';
|
||
case 'latin1':
|
||
case 'binary':
|
||
return 'latin1';
|
||
case 'base64':
|
||
case 'ascii':
|
||
case 'hex':
|
||
return enc;
|
||
default:
|
||
if (retried) return; // undefined
|
||
enc = ('' + enc).toLowerCase();
|
||
retried = true;
|
||
}
|
||
}
|
||
}
|
||
// Do not cache `Buffer.isEncoding` when checking encoding names as some
|
||
// modules monkey-patch it to support additional encodings
|
||
function normalizeEncoding(enc) {
|
||
var nenc = _normalizeEncoding(enc);
|
||
if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
|
||
return nenc || enc;
|
||
}
|
||
|
||
// StringDecoder provides an interface for efficiently splitting a series of
|
||
// buffers into a series of JS strings without breaking apart multi-byte
|
||
// characters.
|
||
string_decoder.StringDecoder = StringDecoder;
|
||
function StringDecoder(encoding) {
|
||
this.encoding = normalizeEncoding(encoding);
|
||
var nb;
|
||
switch (this.encoding) {
|
||
case 'utf16le':
|
||
this.text = utf16Text;
|
||
this.end = utf16End;
|
||
nb = 4;
|
||
break;
|
||
case 'utf8':
|
||
this.fillLast = utf8FillLast;
|
||
nb = 4;
|
||
break;
|
||
case 'base64':
|
||
this.text = base64Text;
|
||
this.end = base64End;
|
||
nb = 3;
|
||
break;
|
||
default:
|
||
this.write = simpleWrite;
|
||
this.end = simpleEnd;
|
||
return;
|
||
}
|
||
this.lastNeed = 0;
|
||
this.lastTotal = 0;
|
||
this.lastChar = Buffer.allocUnsafe(nb);
|
||
}
|
||
|
||
StringDecoder.prototype.write = function (buf) {
|
||
if (buf.length === 0) return '';
|
||
var r;
|
||
var i;
|
||
if (this.lastNeed) {
|
||
r = this.fillLast(buf);
|
||
if (r === undefined) return '';
|
||
i = this.lastNeed;
|
||
this.lastNeed = 0;
|
||
} else {
|
||
i = 0;
|
||
}
|
||
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
|
||
return r || '';
|
||
};
|
||
|
||
StringDecoder.prototype.end = utf8End;
|
||
|
||
// Returns only complete characters in a Buffer
|
||
StringDecoder.prototype.text = utf8Text;
|
||
|
||
// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
|
||
StringDecoder.prototype.fillLast = function (buf) {
|
||
if (this.lastNeed <= buf.length) {
|
||
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
|
||
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
||
}
|
||
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
|
||
this.lastNeed -= buf.length;
|
||
};
|
||
|
||
// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
|
||
// continuation byte. If an invalid byte is detected, -2 is returned.
|
||
function utf8CheckByte(byte) {
|
||
if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
|
||
return byte >> 6 === 0x02 ? -1 : -2;
|
||
}
|
||
|
||
// Checks at most 3 bytes at the end of a Buffer in order to detect an
|
||
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
|
||
// needed to complete the UTF-8 character (if applicable) are returned.
|
||
function utf8CheckIncomplete(self, buf, i) {
|
||
var j = buf.length - 1;
|
||
if (j < i) return 0;
|
||
var nb = utf8CheckByte(buf[j]);
|
||
if (nb >= 0) {
|
||
if (nb > 0) self.lastNeed = nb - 1;
|
||
return nb;
|
||
}
|
||
if (--j < i || nb === -2) return 0;
|
||
nb = utf8CheckByte(buf[j]);
|
||
if (nb >= 0) {
|
||
if (nb > 0) self.lastNeed = nb - 2;
|
||
return nb;
|
||
}
|
||
if (--j < i || nb === -2) return 0;
|
||
nb = utf8CheckByte(buf[j]);
|
||
if (nb >= 0) {
|
||
if (nb > 0) {
|
||
if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
|
||
}
|
||
return nb;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// Validates as many continuation bytes for a multi-byte UTF-8 character as
|
||
// needed or are available. If we see a non-continuation byte where we expect
|
||
// one, we "replace" the validated continuation bytes we've seen so far with
|
||
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
|
||
// behavior. The continuation byte check is included three times in the case
|
||
// where all of the continuation bytes for a character exist in the same buffer.
|
||
// It is also done this way as a slight performance increase instead of using a
|
||
// loop.
|
||
function utf8CheckExtraBytes(self, buf, p) {
|
||
if ((buf[0] & 0xC0) !== 0x80) {
|
||
self.lastNeed = 0;
|
||
return '\ufffd';
|
||
}
|
||
if (self.lastNeed > 1 && buf.length > 1) {
|
||
if ((buf[1] & 0xC0) !== 0x80) {
|
||
self.lastNeed = 1;
|
||
return '\ufffd';
|
||
}
|
||
if (self.lastNeed > 2 && buf.length > 2) {
|
||
if ((buf[2] & 0xC0) !== 0x80) {
|
||
self.lastNeed = 2;
|
||
return '\ufffd';
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
|
||
function utf8FillLast(buf) {
|
||
var p = this.lastTotal - this.lastNeed;
|
||
var r = utf8CheckExtraBytes(this, buf);
|
||
if (r !== undefined) return r;
|
||
if (this.lastNeed <= buf.length) {
|
||
buf.copy(this.lastChar, p, 0, this.lastNeed);
|
||
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
||
}
|
||
buf.copy(this.lastChar, p, 0, buf.length);
|
||
this.lastNeed -= buf.length;
|
||
}
|
||
|
||
// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
|
||
// partial character, the character's bytes are buffered until the required
|
||
// number of bytes are available.
|
||
function utf8Text(buf, i) {
|
||
var total = utf8CheckIncomplete(this, buf, i);
|
||
if (!this.lastNeed) return buf.toString('utf8', i);
|
||
this.lastTotal = total;
|
||
var end = buf.length - (total - this.lastNeed);
|
||
buf.copy(this.lastChar, 0, end);
|
||
return buf.toString('utf8', i, end);
|
||
}
|
||
|
||
// For UTF-8, a replacement character is added when ending on a partial
|
||
// character.
|
||
function utf8End(buf) {
|
||
var r = buf && buf.length ? this.write(buf) : '';
|
||
if (this.lastNeed) return r + '\ufffd';
|
||
return r;
|
||
}
|
||
|
||
// UTF-16LE typically needs two bytes per character, but even if we have an even
|
||
// number of bytes available, we need to check if we end on a leading/high
|
||
// surrogate. In that case, we need to wait for the next two bytes in order to
|
||
// decode the last character properly.
|
||
function utf16Text(buf, i) {
|
||
if ((buf.length - i) % 2 === 0) {
|
||
var r = buf.toString('utf16le', i);
|
||
if (r) {
|
||
var c = r.charCodeAt(r.length - 1);
|
||
if (c >= 0xD800 && c <= 0xDBFF) {
|
||
this.lastNeed = 2;
|
||
this.lastTotal = 4;
|
||
this.lastChar[0] = buf[buf.length - 2];
|
||
this.lastChar[1] = buf[buf.length - 1];
|
||
return r.slice(0, -1);
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
this.lastNeed = 1;
|
||
this.lastTotal = 2;
|
||
this.lastChar[0] = buf[buf.length - 1];
|
||
return buf.toString('utf16le', i, buf.length - 1);
|
||
}
|
||
|
||
// For UTF-16LE we do not explicitly append special replacement characters if we
|
||
// end on a partial character, we simply let v8 handle that.
|
||
function utf16End(buf) {
|
||
var r = buf && buf.length ? this.write(buf) : '';
|
||
if (this.lastNeed) {
|
||
var end = this.lastTotal - this.lastNeed;
|
||
return r + this.lastChar.toString('utf16le', 0, end);
|
||
}
|
||
return r;
|
||
}
|
||
|
||
function base64Text(buf, i) {
|
||
var n = (buf.length - i) % 3;
|
||
if (n === 0) return buf.toString('base64', i);
|
||
this.lastNeed = 3 - n;
|
||
this.lastTotal = 3;
|
||
if (n === 1) {
|
||
this.lastChar[0] = buf[buf.length - 1];
|
||
} else {
|
||
this.lastChar[0] = buf[buf.length - 2];
|
||
this.lastChar[1] = buf[buf.length - 1];
|
||
}
|
||
return buf.toString('base64', i, buf.length - n);
|
||
}
|
||
|
||
function base64End(buf) {
|
||
var r = buf && buf.length ? this.write(buf) : '';
|
||
if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
|
||
return r;
|
||
}
|
||
|
||
// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
|
||
function simpleWrite(buf) {
|
||
return buf.toString(this.encoding);
|
||
}
|
||
|
||
function simpleEnd(buf) {
|
||
return buf && buf.length ? this.write(buf) : '';
|
||
}
|
||
return string_decoder;
|
||
}
|
||
|
||
var endOfStream;
|
||
var hasRequiredEndOfStream;
|
||
|
||
function requireEndOfStream () {
|
||
if (hasRequiredEndOfStream) return endOfStream;
|
||
hasRequiredEndOfStream = 1;
|
||
|
||
var ERR_STREAM_PREMATURE_CLOSE = requireErrors().codes.ERR_STREAM_PREMATURE_CLOSE;
|
||
function once(callback) {
|
||
var called = false;
|
||
return function () {
|
||
if (called) return;
|
||
called = true;
|
||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
callback.apply(this, args);
|
||
};
|
||
}
|
||
function noop() {}
|
||
function isRequest(stream) {
|
||
return stream.setHeader && typeof stream.abort === 'function';
|
||
}
|
||
function eos(stream, opts, callback) {
|
||
if (typeof opts === 'function') return eos(stream, null, opts);
|
||
if (!opts) opts = {};
|
||
callback = once(callback || noop);
|
||
var readable = opts.readable || opts.readable !== false && stream.readable;
|
||
var writable = opts.writable || opts.writable !== false && stream.writable;
|
||
var onlegacyfinish = function onlegacyfinish() {
|
||
if (!stream.writable) onfinish();
|
||
};
|
||
var writableEnded = stream._writableState && stream._writableState.finished;
|
||
var onfinish = function onfinish() {
|
||
writable = false;
|
||
writableEnded = true;
|
||
if (!readable) callback.call(stream);
|
||
};
|
||
var readableEnded = stream._readableState && stream._readableState.endEmitted;
|
||
var onend = function onend() {
|
||
readable = false;
|
||
readableEnded = true;
|
||
if (!writable) callback.call(stream);
|
||
};
|
||
var onerror = function onerror(err) {
|
||
callback.call(stream, err);
|
||
};
|
||
var onclose = function onclose() {
|
||
var err;
|
||
if (readable && !readableEnded) {
|
||
if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
||
return callback.call(stream, err);
|
||
}
|
||
if (writable && !writableEnded) {
|
||
if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
||
return callback.call(stream, err);
|
||
}
|
||
};
|
||
var onrequest = function onrequest() {
|
||
stream.req.on('finish', onfinish);
|
||
};
|
||
if (isRequest(stream)) {
|
||
stream.on('complete', onfinish);
|
||
stream.on('abort', onclose);
|
||
if (stream.req) onrequest();else stream.on('request', onrequest);
|
||
} else if (writable && !stream._writableState) {
|
||
// legacy streams
|
||
stream.on('end', onlegacyfinish);
|
||
stream.on('close', onlegacyfinish);
|
||
}
|
||
stream.on('end', onend);
|
||
stream.on('finish', onfinish);
|
||
if (opts.error !== false) stream.on('error', onerror);
|
||
stream.on('close', onclose);
|
||
return function () {
|
||
stream.removeListener('complete', onfinish);
|
||
stream.removeListener('abort', onclose);
|
||
stream.removeListener('request', onrequest);
|
||
if (stream.req) stream.req.removeListener('finish', onfinish);
|
||
stream.removeListener('end', onlegacyfinish);
|
||
stream.removeListener('close', onlegacyfinish);
|
||
stream.removeListener('finish', onfinish);
|
||
stream.removeListener('end', onend);
|
||
stream.removeListener('error', onerror);
|
||
stream.removeListener('close', onclose);
|
||
};
|
||
}
|
||
endOfStream = eos;
|
||
return endOfStream;
|
||
}
|
||
|
||
var async_iterator;
|
||
var hasRequiredAsync_iterator;
|
||
|
||
function requireAsync_iterator () {
|
||
if (hasRequiredAsync_iterator) return async_iterator;
|
||
hasRequiredAsync_iterator = 1;
|
||
|
||
var _Object$setPrototypeO;
|
||
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
|
||
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
|
||
var finished = requireEndOfStream();
|
||
var kLastResolve = Symbol('lastResolve');
|
||
var kLastReject = Symbol('lastReject');
|
||
var kError = Symbol('error');
|
||
var kEnded = Symbol('ended');
|
||
var kLastPromise = Symbol('lastPromise');
|
||
var kHandlePromise = Symbol('handlePromise');
|
||
var kStream = Symbol('stream');
|
||
function createIterResult(value, done) {
|
||
return {
|
||
value: value,
|
||
done: done
|
||
};
|
||
}
|
||
function readAndResolve(iter) {
|
||
var resolve = iter[kLastResolve];
|
||
if (resolve !== null) {
|
||
var data = iter[kStream].read();
|
||
// we defer if data is null
|
||
// we can be expecting either 'end' or
|
||
// 'error'
|
||
if (data !== null) {
|
||
iter[kLastPromise] = null;
|
||
iter[kLastResolve] = null;
|
||
iter[kLastReject] = null;
|
||
resolve(createIterResult(data, false));
|
||
}
|
||
}
|
||
}
|
||
function onReadable(iter) {
|
||
// we wait for the next tick, because it might
|
||
// emit an error with process.nextTick
|
||
process.nextTick(readAndResolve, iter);
|
||
}
|
||
function wrapForNext(lastPromise, iter) {
|
||
return function (resolve, reject) {
|
||
lastPromise.then(function () {
|
||
if (iter[kEnded]) {
|
||
resolve(createIterResult(undefined, true));
|
||
return;
|
||
}
|
||
iter[kHandlePromise](resolve, reject);
|
||
}, reject);
|
||
};
|
||
}
|
||
var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
|
||
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
|
||
get stream() {
|
||
return this[kStream];
|
||
},
|
||
next: function next() {
|
||
var _this = this;
|
||
// if we have detected an error in the meanwhile
|
||
// reject straight away
|
||
var error = this[kError];
|
||
if (error !== null) {
|
||
return Promise.reject(error);
|
||
}
|
||
if (this[kEnded]) {
|
||
return Promise.resolve(createIterResult(undefined, true));
|
||
}
|
||
if (this[kStream].destroyed) {
|
||
// We need to defer via nextTick because if .destroy(err) is
|
||
// called, the error will be emitted via nextTick, and
|
||
// we cannot guarantee that there is no error lingering around
|
||
// waiting to be emitted.
|
||
return new Promise(function (resolve, reject) {
|
||
process.nextTick(function () {
|
||
if (_this[kError]) {
|
||
reject(_this[kError]);
|
||
} else {
|
||
resolve(createIterResult(undefined, true));
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
// if we have multiple next() calls
|
||
// we will wait for the previous Promise to finish
|
||
// this logic is optimized to support for await loops,
|
||
// where next() is only called once at a time
|
||
var lastPromise = this[kLastPromise];
|
||
var promise;
|
||
if (lastPromise) {
|
||
promise = new Promise(wrapForNext(lastPromise, this));
|
||
} else {
|
||
// fast path needed to support multiple this.push()
|
||
// without triggering the next() queue
|
||
var data = this[kStream].read();
|
||
if (data !== null) {
|
||
return Promise.resolve(createIterResult(data, false));
|
||
}
|
||
promise = new Promise(this[kHandlePromise]);
|
||
}
|
||
this[kLastPromise] = promise;
|
||
return promise;
|
||
}
|
||
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
|
||
return this;
|
||
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
|
||
var _this2 = this;
|
||
// destroy(err, cb) is a private API
|
||
// we can guarantee we have that here, because we control the
|
||
// Readable class this is attached to
|
||
return new Promise(function (resolve, reject) {
|
||
_this2[kStream].destroy(null, function (err) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
resolve(createIterResult(undefined, true));
|
||
});
|
||
});
|
||
}), _Object$setPrototypeO), AsyncIteratorPrototype);
|
||
var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
|
||
var _Object$create;
|
||
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
|
||
value: stream,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kLastResolve, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kLastReject, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kError, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kEnded, {
|
||
value: stream._readableState.endEmitted,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kHandlePromise, {
|
||
value: function value(resolve, reject) {
|
||
var data = iterator[kStream].read();
|
||
if (data) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
resolve(createIterResult(data, false));
|
||
} else {
|
||
iterator[kLastResolve] = resolve;
|
||
iterator[kLastReject] = reject;
|
||
}
|
||
},
|
||
writable: true
|
||
}), _Object$create));
|
||
iterator[kLastPromise] = null;
|
||
finished(stream, function (err) {
|
||
if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
|
||
var reject = iterator[kLastReject];
|
||
// reject if we are waiting for data in the Promise
|
||
// returned by next() and store the error
|
||
if (reject !== null) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
reject(err);
|
||
}
|
||
iterator[kError] = err;
|
||
return;
|
||
}
|
||
var resolve = iterator[kLastResolve];
|
||
if (resolve !== null) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
resolve(createIterResult(undefined, true));
|
||
}
|
||
iterator[kEnded] = true;
|
||
});
|
||
stream.on('readable', onReadable.bind(null, iterator));
|
||
return iterator;
|
||
};
|
||
async_iterator = createReadableStreamAsyncIterator;
|
||
return async_iterator;
|
||
}
|
||
|
||
var from_1;
|
||
var hasRequiredFrom;
|
||
|
||
function requireFrom () {
|
||
if (hasRequiredFrom) return from_1;
|
||
hasRequiredFrom = 1;
|
||
|
||
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
|
||
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
|
||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
|
||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
||
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
|
||
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
|
||
var ERR_INVALID_ARG_TYPE = requireErrors().codes.ERR_INVALID_ARG_TYPE;
|
||
function from(Readable, iterable, opts) {
|
||
var iterator;
|
||
if (iterable && typeof iterable.next === 'function') {
|
||
iterator = iterable;
|
||
} else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
|
||
var readable = new Readable(_objectSpread({
|
||
objectMode: true
|
||
}, opts));
|
||
// Reading boolean to protect against _read
|
||
// being called before last iteration completion.
|
||
var reading = false;
|
||
readable._read = function () {
|
||
if (!reading) {
|
||
reading = true;
|
||
next();
|
||
}
|
||
};
|
||
function next() {
|
||
return _next2.apply(this, arguments);
|
||
}
|
||
function _next2() {
|
||
_next2 = _asyncToGenerator(function* () {
|
||
try {
|
||
var _yield$iterator$next = yield iterator.next(),
|
||
value = _yield$iterator$next.value,
|
||
done = _yield$iterator$next.done;
|
||
if (done) {
|
||
readable.push(null);
|
||
} else if (readable.push(yield value)) {
|
||
next();
|
||
} else {
|
||
reading = false;
|
||
}
|
||
} catch (err) {
|
||
readable.destroy(err);
|
||
}
|
||
});
|
||
return _next2.apply(this, arguments);
|
||
}
|
||
return readable;
|
||
}
|
||
from_1 = from;
|
||
return from_1;
|
||
}
|
||
|
||
var _stream_readable;
|
||
var hasRequired_stream_readable;
|
||
|
||
function require_stream_readable () {
|
||
if (hasRequired_stream_readable) return _stream_readable;
|
||
hasRequired_stream_readable = 1;
|
||
|
||
_stream_readable = Readable;
|
||
|
||
/*<replacement>*/
|
||
var Duplex;
|
||
/*</replacement>*/
|
||
|
||
Readable.ReadableState = ReadableState;
|
||
|
||
/*<replacement>*/
|
||
require$$2.EventEmitter;
|
||
var EElistenerCount = function EElistenerCount(emitter, type) {
|
||
return emitter.listeners(type).length;
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var Stream = requireStream();
|
||
/*</replacement>*/
|
||
|
||
var Buffer = require$$0$6.Buffer;
|
||
var OurUint8Array = (typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};
|
||
function _uint8ArrayToBuffer(chunk) {
|
||
return Buffer.from(chunk);
|
||
}
|
||
function _isUint8Array(obj) {
|
||
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
||
}
|
||
|
||
/*<replacement>*/
|
||
var debugUtil = require$$2$1;
|
||
var debug;
|
||
if (debugUtil && debugUtil.debuglog) {
|
||
debug = debugUtil.debuglog('stream');
|
||
} else {
|
||
debug = function debug() {};
|
||
}
|
||
/*</replacement>*/
|
||
|
||
var BufferList = requireBuffer_list();
|
||
var destroyImpl = requireDestroy();
|
||
var _require = requireState(),
|
||
getHighWaterMark = _require.getHighWaterMark;
|
||
var _require$codes = requireErrors().codes,
|
||
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
||
ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
|
||
|
||
// Lazy loaded to improve the startup performance.
|
||
var StringDecoder;
|
||
var createReadableStreamAsyncIterator;
|
||
var from;
|
||
requireInherits()(Readable, Stream);
|
||
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
||
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
|
||
function prependListener(emitter, event, fn) {
|
||
// Sadly this is not cacheable as some libraries bundle their own
|
||
// event emitter implementation with them.
|
||
if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
|
||
|
||
// This is a hack to make sure that our error handler is attached before any
|
||
// userland ones. NEVER DO THIS. This is here only because this code needs
|
||
// to continue to work with older versions of Node.js that do not include
|
||
// the prependListener() method. The goal is to eventually remove this hack.
|
||
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
|
||
}
|
||
function ReadableState(options, stream, isDuplex) {
|
||
Duplex = Duplex || require_stream_duplex();
|
||
options = options || {};
|
||
|
||
// Duplex streams are both readable and writable, but share
|
||
// the same options object.
|
||
// However, some cases require setting options to different
|
||
// values for the readable and the writable sides of the duplex stream.
|
||
// These options can be provided separately as readableXXX and writableXXX.
|
||
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;
|
||
|
||
// object stream flag. Used to make read(n) ignore n and to
|
||
// make all the buffer merging and length checks go away
|
||
this.objectMode = !!options.objectMode;
|
||
if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
|
||
|
||
// the point at which it stops calling _read() to fill the buffer
|
||
// Note: 0 is a valid value, means "don't call _read preemptively ever"
|
||
this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);
|
||
|
||
// A linked list is used to store data chunks instead of an array because the
|
||
// linked list can remove elements from the beginning faster than
|
||
// array.shift()
|
||
this.buffer = new BufferList();
|
||
this.length = 0;
|
||
this.pipes = null;
|
||
this.pipesCount = 0;
|
||
this.flowing = null;
|
||
this.ended = false;
|
||
this.endEmitted = false;
|
||
this.reading = false;
|
||
|
||
// a flag to be able to tell if the event 'readable'/'data' is emitted
|
||
// immediately, or on a later tick. We set this to true at first, because
|
||
// any actions that shouldn't happen until "later" should generally also
|
||
// not happen before the first read call.
|
||
this.sync = true;
|
||
|
||
// whenever we return null, then we set a flag to say
|
||
// that we're awaiting a 'readable' event emission.
|
||
this.needReadable = false;
|
||
this.emittedReadable = false;
|
||
this.readableListening = false;
|
||
this.resumeScheduled = false;
|
||
this.paused = true;
|
||
|
||
// Should close be emitted on destroy. Defaults to true.
|
||
this.emitClose = options.emitClose !== false;
|
||
|
||
// Should .destroy() be called after 'end' (and potentially 'finish')
|
||
this.autoDestroy = !!options.autoDestroy;
|
||
|
||
// has it been destroyed
|
||
this.destroyed = false;
|
||
|
||
// Crypto is kind of old and crusty. Historically, its default string
|
||
// encoding is 'binary' so we have to make this configurable.
|
||
// Everything else in the universe uses 'utf8', though.
|
||
this.defaultEncoding = options.defaultEncoding || 'utf8';
|
||
|
||
// the number of writers that are awaiting a drain event in .pipe()s
|
||
this.awaitDrain = 0;
|
||
|
||
// if true, a maybeReadMore has been scheduled
|
||
this.readingMore = false;
|
||
this.decoder = null;
|
||
this.encoding = null;
|
||
if (options.encoding) {
|
||
if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
|
||
this.decoder = new StringDecoder(options.encoding);
|
||
this.encoding = options.encoding;
|
||
}
|
||
}
|
||
function Readable(options) {
|
||
Duplex = Duplex || require_stream_duplex();
|
||
if (!(this instanceof Readable)) return new Readable(options);
|
||
|
||
// Checking for a Stream.Duplex instance is faster here instead of inside
|
||
// the ReadableState constructor, at least with V8 6.5
|
||
var isDuplex = this instanceof Duplex;
|
||
this._readableState = new ReadableState(options, this, isDuplex);
|
||
|
||
// legacy
|
||
this.readable = true;
|
||
if (options) {
|
||
if (typeof options.read === 'function') this._read = options.read;
|
||
if (typeof options.destroy === 'function') this._destroy = options.destroy;
|
||
}
|
||
Stream.call(this);
|
||
}
|
||
Object.defineProperty(Readable.prototype, 'destroyed', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._readableState === undefined) {
|
||
return false;
|
||
}
|
||
return this._readableState.destroyed;
|
||
},
|
||
set: function set(value) {
|
||
// we ignore the value if the stream
|
||
// has not been initialized yet
|
||
if (!this._readableState) {
|
||
return;
|
||
}
|
||
|
||
// backward compatibility, the user is explicitly
|
||
// managing destroyed
|
||
this._readableState.destroyed = value;
|
||
}
|
||
});
|
||
Readable.prototype.destroy = destroyImpl.destroy;
|
||
Readable.prototype._undestroy = destroyImpl.undestroy;
|
||
Readable.prototype._destroy = function (err, cb) {
|
||
cb(err);
|
||
};
|
||
|
||
// Manually shove something into the read() buffer.
|
||
// This returns true if the highWaterMark has not been hit yet,
|
||
// similar to how Writable.write() returns true if you should
|
||
// write() some more.
|
||
Readable.prototype.push = function (chunk, encoding) {
|
||
var state = this._readableState;
|
||
var skipChunkCheck;
|
||
if (!state.objectMode) {
|
||
if (typeof chunk === 'string') {
|
||
encoding = encoding || state.defaultEncoding;
|
||
if (encoding !== state.encoding) {
|
||
chunk = Buffer.from(chunk, encoding);
|
||
encoding = '';
|
||
}
|
||
skipChunkCheck = true;
|
||
}
|
||
} else {
|
||
skipChunkCheck = true;
|
||
}
|
||
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
|
||
};
|
||
|
||
// Unshift should *always* be something directly out of read()
|
||
Readable.prototype.unshift = function (chunk) {
|
||
return readableAddChunk(this, chunk, null, true, false);
|
||
};
|
||
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
|
||
debug('readableAddChunk', chunk);
|
||
var state = stream._readableState;
|
||
if (chunk === null) {
|
||
state.reading = false;
|
||
onEofChunk(stream, state);
|
||
} else {
|
||
var er;
|
||
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
|
||
if (er) {
|
||
errorOrDestroy(stream, er);
|
||
} else if (state.objectMode || chunk && chunk.length > 0) {
|
||
if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
|
||
chunk = _uint8ArrayToBuffer(chunk);
|
||
}
|
||
if (addToFront) {
|
||
if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
|
||
} else if (state.ended) {
|
||
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
|
||
} else if (state.destroyed) {
|
||
return false;
|
||
} else {
|
||
state.reading = false;
|
||
if (state.decoder && !encoding) {
|
||
chunk = state.decoder.write(chunk);
|
||
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
|
||
} else {
|
||
addChunk(stream, state, chunk, false);
|
||
}
|
||
}
|
||
} else if (!addToFront) {
|
||
state.reading = false;
|
||
maybeReadMore(stream, state);
|
||
}
|
||
}
|
||
|
||
// We can push more data if we are below the highWaterMark.
|
||
// Also, if we have no data yet, we can stand some more bytes.
|
||
// This is to work around cases where hwm=0, such as the repl.
|
||
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
|
||
}
|
||
function addChunk(stream, state, chunk, addToFront) {
|
||
if (state.flowing && state.length === 0 && !state.sync) {
|
||
state.awaitDrain = 0;
|
||
stream.emit('data', chunk);
|
||
} else {
|
||
// update the buffer info.
|
||
state.length += state.objectMode ? 1 : chunk.length;
|
||
if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
|
||
if (state.needReadable) emitReadable(stream);
|
||
}
|
||
maybeReadMore(stream, state);
|
||
}
|
||
function chunkInvalid(state, chunk) {
|
||
var er;
|
||
if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
|
||
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
|
||
}
|
||
return er;
|
||
}
|
||
Readable.prototype.isPaused = function () {
|
||
return this._readableState.flowing === false;
|
||
};
|
||
|
||
// backwards compatibility.
|
||
Readable.prototype.setEncoding = function (enc) {
|
||
if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
|
||
var decoder = new StringDecoder(enc);
|
||
this._readableState.decoder = decoder;
|
||
// If setEncoding(null), decoder.encoding equals utf8
|
||
this._readableState.encoding = this._readableState.decoder.encoding;
|
||
|
||
// Iterate over current buffer to convert already stored Buffers:
|
||
var p = this._readableState.buffer.head;
|
||
var content = '';
|
||
while (p !== null) {
|
||
content += decoder.write(p.data);
|
||
p = p.next;
|
||
}
|
||
this._readableState.buffer.clear();
|
||
if (content !== '') this._readableState.buffer.push(content);
|
||
this._readableState.length = content.length;
|
||
return this;
|
||
};
|
||
|
||
// Don't raise the hwm > 1GB
|
||
var MAX_HWM = 0x40000000;
|
||
function computeNewHighWaterMark(n) {
|
||
if (n >= MAX_HWM) {
|
||
// TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
|
||
n = MAX_HWM;
|
||
} else {
|
||
// Get the next highest power of 2 to prevent increasing hwm excessively in
|
||
// tiny amounts
|
||
n--;
|
||
n |= n >>> 1;
|
||
n |= n >>> 2;
|
||
n |= n >>> 4;
|
||
n |= n >>> 8;
|
||
n |= n >>> 16;
|
||
n++;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
// This function is designed to be inlinable, so please take care when making
|
||
// changes to the function body.
|
||
function howMuchToRead(n, state) {
|
||
if (n <= 0 || state.length === 0 && state.ended) return 0;
|
||
if (state.objectMode) return 1;
|
||
if (n !== n) {
|
||
// Only flow one buffer at a time
|
||
if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
|
||
}
|
||
// If we're asking for more than the current hwm, then raise the hwm.
|
||
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
|
||
if (n <= state.length) return n;
|
||
// Don't have enough
|
||
if (!state.ended) {
|
||
state.needReadable = true;
|
||
return 0;
|
||
}
|
||
return state.length;
|
||
}
|
||
|
||
// you can override either this method, or the async _read(n) below.
|
||
Readable.prototype.read = function (n) {
|
||
debug('read', n);
|
||
n = parseInt(n, 10);
|
||
var state = this._readableState;
|
||
var nOrig = n;
|
||
if (n !== 0) state.emittedReadable = false;
|
||
|
||
// if we're doing read(0) to trigger a readable event, but we
|
||
// already have a bunch of data in the buffer, then just trigger
|
||
// the 'readable' event and move on.
|
||
if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
|
||
debug('read: emitReadable', state.length, state.ended);
|
||
if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
|
||
return null;
|
||
}
|
||
n = howMuchToRead(n, state);
|
||
|
||
// if we've ended, and we're now clear, then finish it up.
|
||
if (n === 0 && state.ended) {
|
||
if (state.length === 0) endReadable(this);
|
||
return null;
|
||
}
|
||
|
||
// All the actual chunk generation logic needs to be
|
||
// *below* the call to _read. The reason is that in certain
|
||
// synthetic stream cases, such as passthrough streams, _read
|
||
// may be a completely synchronous operation which may change
|
||
// the state of the read buffer, providing enough data when
|
||
// before there was *not* enough.
|
||
//
|
||
// So, the steps are:
|
||
// 1. Figure out what the state of things will be after we do
|
||
// a read from the buffer.
|
||
//
|
||
// 2. If that resulting state will trigger a _read, then call _read.
|
||
// Note that this may be asynchronous, or synchronous. Yes, it is
|
||
// deeply ugly to write APIs this way, but that still doesn't mean
|
||
// that the Readable class should behave improperly, as streams are
|
||
// designed to be sync/async agnostic.
|
||
// Take note if the _read call is sync or async (ie, if the read call
|
||
// has returned yet), so that we know whether or not it's safe to emit
|
||
// 'readable' etc.
|
||
//
|
||
// 3. Actually pull the requested chunks out of the buffer and return.
|
||
|
||
// if we need a readable event, then we need to do some reading.
|
||
var doRead = state.needReadable;
|
||
debug('need readable', doRead);
|
||
|
||
// if we currently have less than the highWaterMark, then also read some
|
||
if (state.length === 0 || state.length - n < state.highWaterMark) {
|
||
doRead = true;
|
||
debug('length less than watermark', doRead);
|
||
}
|
||
|
||
// however, if we've ended, then there's no point, and if we're already
|
||
// reading, then it's unnecessary.
|
||
if (state.ended || state.reading) {
|
||
doRead = false;
|
||
debug('reading or ended', doRead);
|
||
} else if (doRead) {
|
||
debug('do read');
|
||
state.reading = true;
|
||
state.sync = true;
|
||
// if the length is currently zero, then we *need* a readable event.
|
||
if (state.length === 0) state.needReadable = true;
|
||
// call internal read method
|
||
this._read(state.highWaterMark);
|
||
state.sync = false;
|
||
// If _read pushed data synchronously, then `reading` will be false,
|
||
// and we need to re-evaluate how much data we can return to the user.
|
||
if (!state.reading) n = howMuchToRead(nOrig, state);
|
||
}
|
||
var ret;
|
||
if (n > 0) ret = fromList(n, state);else ret = null;
|
||
if (ret === null) {
|
||
state.needReadable = state.length <= state.highWaterMark;
|
||
n = 0;
|
||
} else {
|
||
state.length -= n;
|
||
state.awaitDrain = 0;
|
||
}
|
||
if (state.length === 0) {
|
||
// If we have nothing in the buffer, then we want to know
|
||
// as soon as we *do* get something into the buffer.
|
||
if (!state.ended) state.needReadable = true;
|
||
|
||
// If we tried to read() past the EOF, then emit end on the next tick.
|
||
if (nOrig !== n && state.ended) endReadable(this);
|
||
}
|
||
if (ret !== null) this.emit('data', ret);
|
||
return ret;
|
||
};
|
||
function onEofChunk(stream, state) {
|
||
debug('onEofChunk');
|
||
if (state.ended) return;
|
||
if (state.decoder) {
|
||
var chunk = state.decoder.end();
|
||
if (chunk && chunk.length) {
|
||
state.buffer.push(chunk);
|
||
state.length += state.objectMode ? 1 : chunk.length;
|
||
}
|
||
}
|
||
state.ended = true;
|
||
if (state.sync) {
|
||
// if we are sync, wait until next tick to emit the data.
|
||
// Otherwise we risk emitting data in the flow()
|
||
// the readable code triggers during a read() call
|
||
emitReadable(stream);
|
||
} else {
|
||
// emit 'readable' now to make sure it gets picked up.
|
||
state.needReadable = false;
|
||
if (!state.emittedReadable) {
|
||
state.emittedReadable = true;
|
||
emitReadable_(stream);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Don't emit readable right away in sync mode, because this can trigger
|
||
// another read() call => stack overflow. This way, it might trigger
|
||
// a nextTick recursion warning, but that's not so bad.
|
||
function emitReadable(stream) {
|
||
var state = stream._readableState;
|
||
debug('emitReadable', state.needReadable, state.emittedReadable);
|
||
state.needReadable = false;
|
||
if (!state.emittedReadable) {
|
||
debug('emitReadable', state.flowing);
|
||
state.emittedReadable = true;
|
||
process.nextTick(emitReadable_, stream);
|
||
}
|
||
}
|
||
function emitReadable_(stream) {
|
||
var state = stream._readableState;
|
||
debug('emitReadable_', state.destroyed, state.length, state.ended);
|
||
if (!state.destroyed && (state.length || state.ended)) {
|
||
stream.emit('readable');
|
||
state.emittedReadable = false;
|
||
}
|
||
|
||
// The stream needs another readable event if
|
||
// 1. It is not flowing, as the flow mechanism will take
|
||
// care of it.
|
||
// 2. It is not ended.
|
||
// 3. It is below the highWaterMark, so we can schedule
|
||
// another readable later.
|
||
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
|
||
flow(stream);
|
||
}
|
||
|
||
// at this point, the user has presumably seen the 'readable' event,
|
||
// and called read() to consume some data. that may have triggered
|
||
// in turn another _read(n) call, in which case reading = true if
|
||
// it's in progress.
|
||
// However, if we're not ended, or reading, and the length < hwm,
|
||
// then go ahead and try to read some more preemptively.
|
||
function maybeReadMore(stream, state) {
|
||
if (!state.readingMore) {
|
||
state.readingMore = true;
|
||
process.nextTick(maybeReadMore_, stream, state);
|
||
}
|
||
}
|
||
function maybeReadMore_(stream, state) {
|
||
// Attempt to read more data if we should.
|
||
//
|
||
// The conditions for reading more data are (one of):
|
||
// - Not enough data buffered (state.length < state.highWaterMark). The loop
|
||
// is responsible for filling the buffer with enough data if such data
|
||
// is available. If highWaterMark is 0 and we are not in the flowing mode
|
||
// we should _not_ attempt to buffer any extra data. We'll get more data
|
||
// when the stream consumer calls read() instead.
|
||
// - No data in the buffer, and the stream is in flowing mode. In this mode
|
||
// the loop below is responsible for ensuring read() is called. Failing to
|
||
// call read here would abort the flow and there's no other mechanism for
|
||
// continuing the flow if the stream consumer has just subscribed to the
|
||
// 'data' event.
|
||
//
|
||
// In addition to the above conditions to keep reading data, the following
|
||
// conditions prevent the data from being read:
|
||
// - The stream has ended (state.ended).
|
||
// - There is already a pending 'read' operation (state.reading). This is a
|
||
// case where the the stream has called the implementation defined _read()
|
||
// method, but they are processing the call asynchronously and have _not_
|
||
// called push() with new data. In this case we skip performing more
|
||
// read()s. The execution ends in this method again after the _read() ends
|
||
// up calling push() with more data.
|
||
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
|
||
var len = state.length;
|
||
debug('maybeReadMore read 0');
|
||
stream.read(0);
|
||
if (len === state.length)
|
||
// didn't get any data, stop spinning.
|
||
break;
|
||
}
|
||
state.readingMore = false;
|
||
}
|
||
|
||
// abstract method. to be overridden in specific implementation classes.
|
||
// call cb(er, data) where data is <= n in length.
|
||
// for virtual (non-string, non-buffer) streams, "length" is somewhat
|
||
// arbitrary, and perhaps not very meaningful.
|
||
Readable.prototype._read = function (n) {
|
||
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
|
||
};
|
||
Readable.prototype.pipe = function (dest, pipeOpts) {
|
||
var src = this;
|
||
var state = this._readableState;
|
||
switch (state.pipesCount) {
|
||
case 0:
|
||
state.pipes = dest;
|
||
break;
|
||
case 1:
|
||
state.pipes = [state.pipes, dest];
|
||
break;
|
||
default:
|
||
state.pipes.push(dest);
|
||
break;
|
||
}
|
||
state.pipesCount += 1;
|
||
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
|
||
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
|
||
var endFn = doEnd ? onend : unpipe;
|
||
if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
|
||
dest.on('unpipe', onunpipe);
|
||
function onunpipe(readable, unpipeInfo) {
|
||
debug('onunpipe');
|
||
if (readable === src) {
|
||
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
|
||
unpipeInfo.hasUnpiped = true;
|
||
cleanup();
|
||
}
|
||
}
|
||
}
|
||
function onend() {
|
||
debug('onend');
|
||
dest.end();
|
||
}
|
||
|
||
// when the dest drains, it reduces the awaitDrain counter
|
||
// on the source. This would be more elegant with a .once()
|
||
// handler in flow(), but adding and removing repeatedly is
|
||
// too slow.
|
||
var ondrain = pipeOnDrain(src);
|
||
dest.on('drain', ondrain);
|
||
var cleanedUp = false;
|
||
function cleanup() {
|
||
debug('cleanup');
|
||
// cleanup event handlers once the pipe is broken
|
||
dest.removeListener('close', onclose);
|
||
dest.removeListener('finish', onfinish);
|
||
dest.removeListener('drain', ondrain);
|
||
dest.removeListener('error', onerror);
|
||
dest.removeListener('unpipe', onunpipe);
|
||
src.removeListener('end', onend);
|
||
src.removeListener('end', unpipe);
|
||
src.removeListener('data', ondata);
|
||
cleanedUp = true;
|
||
|
||
// if the reader is waiting for a drain event from this
|
||
// specific writer, then it would cause it to never start
|
||
// flowing again.
|
||
// So, if this is awaiting a drain, then we just call it now.
|
||
// If we don't know, then assume that we are waiting for one.
|
||
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
|
||
}
|
||
src.on('data', ondata);
|
||
function ondata(chunk) {
|
||
debug('ondata');
|
||
var ret = dest.write(chunk);
|
||
debug('dest.write', ret);
|
||
if (ret === false) {
|
||
// If the user unpiped during `dest.write()`, it is possible
|
||
// to get stuck in a permanently paused state if that write
|
||
// also returned false.
|
||
// => Check whether `dest` is still a piping destination.
|
||
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
|
||
debug('false write response, pause', state.awaitDrain);
|
||
state.awaitDrain++;
|
||
}
|
||
src.pause();
|
||
}
|
||
}
|
||
|
||
// if the dest has an error, then stop piping into it.
|
||
// however, don't suppress the throwing behavior for this.
|
||
function onerror(er) {
|
||
debug('onerror', er);
|
||
unpipe();
|
||
dest.removeListener('error', onerror);
|
||
if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
|
||
}
|
||
|
||
// Make sure our error handler is attached before userland ones.
|
||
prependListener(dest, 'error', onerror);
|
||
|
||
// Both close and finish should trigger unpipe, but only once.
|
||
function onclose() {
|
||
dest.removeListener('finish', onfinish);
|
||
unpipe();
|
||
}
|
||
dest.once('close', onclose);
|
||
function onfinish() {
|
||
debug('onfinish');
|
||
dest.removeListener('close', onclose);
|
||
unpipe();
|
||
}
|
||
dest.once('finish', onfinish);
|
||
function unpipe() {
|
||
debug('unpipe');
|
||
src.unpipe(dest);
|
||
}
|
||
|
||
// tell the dest that it's being piped to
|
||
dest.emit('pipe', src);
|
||
|
||
// start the flow if it hasn't been started already.
|
||
if (!state.flowing) {
|
||
debug('pipe resume');
|
||
src.resume();
|
||
}
|
||
return dest;
|
||
};
|
||
function pipeOnDrain(src) {
|
||
return function pipeOnDrainFunctionResult() {
|
||
var state = src._readableState;
|
||
debug('pipeOnDrain', state.awaitDrain);
|
||
if (state.awaitDrain) state.awaitDrain--;
|
||
if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
|
||
state.flowing = true;
|
||
flow(src);
|
||
}
|
||
};
|
||
}
|
||
Readable.prototype.unpipe = function (dest) {
|
||
var state = this._readableState;
|
||
var unpipeInfo = {
|
||
hasUnpiped: false
|
||
};
|
||
|
||
// if we're not piping anywhere, then do nothing.
|
||
if (state.pipesCount === 0) return this;
|
||
|
||
// just one destination. most common case.
|
||
if (state.pipesCount === 1) {
|
||
// passed in one, but it's not the right one.
|
||
if (dest && dest !== state.pipes) return this;
|
||
if (!dest) dest = state.pipes;
|
||
|
||
// got a match.
|
||
state.pipes = null;
|
||
state.pipesCount = 0;
|
||
state.flowing = false;
|
||
if (dest) dest.emit('unpipe', this, unpipeInfo);
|
||
return this;
|
||
}
|
||
|
||
// slow case. multiple pipe destinations.
|
||
|
||
if (!dest) {
|
||
// remove all.
|
||
var dests = state.pipes;
|
||
var len = state.pipesCount;
|
||
state.pipes = null;
|
||
state.pipesCount = 0;
|
||
state.flowing = false;
|
||
for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {
|
||
hasUnpiped: false
|
||
});
|
||
return this;
|
||
}
|
||
|
||
// try to find the right one.
|
||
var index = indexOf(state.pipes, dest);
|
||
if (index === -1) return this;
|
||
state.pipes.splice(index, 1);
|
||
state.pipesCount -= 1;
|
||
if (state.pipesCount === 1) state.pipes = state.pipes[0];
|
||
dest.emit('unpipe', this, unpipeInfo);
|
||
return this;
|
||
};
|
||
|
||
// set up data events if they are asked for
|
||
// Ensure readable listeners eventually get something
|
||
Readable.prototype.on = function (ev, fn) {
|
||
var res = Stream.prototype.on.call(this, ev, fn);
|
||
var state = this._readableState;
|
||
if (ev === 'data') {
|
||
// update readableListening so that resume() may be a no-op
|
||
// a few lines down. This is needed to support once('readable').
|
||
state.readableListening = this.listenerCount('readable') > 0;
|
||
|
||
// Try start flowing on next tick if stream isn't explicitly paused
|
||
if (state.flowing !== false) this.resume();
|
||
} else if (ev === 'readable') {
|
||
if (!state.endEmitted && !state.readableListening) {
|
||
state.readableListening = state.needReadable = true;
|
||
state.flowing = false;
|
||
state.emittedReadable = false;
|
||
debug('on readable', state.length, state.reading);
|
||
if (state.length) {
|
||
emitReadable(this);
|
||
} else if (!state.reading) {
|
||
process.nextTick(nReadingNextTick, this);
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
Readable.prototype.addListener = Readable.prototype.on;
|
||
Readable.prototype.removeListener = function (ev, fn) {
|
||
var res = Stream.prototype.removeListener.call(this, ev, fn);
|
||
if (ev === 'readable') {
|
||
// We need to check if there is someone still listening to
|
||
// readable and reset the state. However this needs to happen
|
||
// after readable has been emitted but before I/O (nextTick) to
|
||
// support once('readable', fn) cycles. This means that calling
|
||
// resume within the same tick will have no
|
||
// effect.
|
||
process.nextTick(updateReadableListening, this);
|
||
}
|
||
return res;
|
||
};
|
||
Readable.prototype.removeAllListeners = function (ev) {
|
||
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
|
||
if (ev === 'readable' || ev === undefined) {
|
||
// We need to check if there is someone still listening to
|
||
// readable and reset the state. However this needs to happen
|
||
// after readable has been emitted but before I/O (nextTick) to
|
||
// support once('readable', fn) cycles. This means that calling
|
||
// resume within the same tick will have no
|
||
// effect.
|
||
process.nextTick(updateReadableListening, this);
|
||
}
|
||
return res;
|
||
};
|
||
function updateReadableListening(self) {
|
||
var state = self._readableState;
|
||
state.readableListening = self.listenerCount('readable') > 0;
|
||
if (state.resumeScheduled && !state.paused) {
|
||
// flowing needs to be set to true now, otherwise
|
||
// the upcoming resume will not flow.
|
||
state.flowing = true;
|
||
|
||
// crude way to check if we should resume
|
||
} else if (self.listenerCount('data') > 0) {
|
||
self.resume();
|
||
}
|
||
}
|
||
function nReadingNextTick(self) {
|
||
debug('readable nexttick read 0');
|
||
self.read(0);
|
||
}
|
||
|
||
// pause() and resume() are remnants of the legacy readable stream API
|
||
// If the user uses them, then switch into old mode.
|
||
Readable.prototype.resume = function () {
|
||
var state = this._readableState;
|
||
if (!state.flowing) {
|
||
debug('resume');
|
||
// we flow only if there is no one listening
|
||
// for readable, but we still have to call
|
||
// resume()
|
||
state.flowing = !state.readableListening;
|
||
resume(this, state);
|
||
}
|
||
state.paused = false;
|
||
return this;
|
||
};
|
||
function resume(stream, state) {
|
||
if (!state.resumeScheduled) {
|
||
state.resumeScheduled = true;
|
||
process.nextTick(resume_, stream, state);
|
||
}
|
||
}
|
||
function resume_(stream, state) {
|
||
debug('resume', state.reading);
|
||
if (!state.reading) {
|
||
stream.read(0);
|
||
}
|
||
state.resumeScheduled = false;
|
||
stream.emit('resume');
|
||
flow(stream);
|
||
if (state.flowing && !state.reading) stream.read(0);
|
||
}
|
||
Readable.prototype.pause = function () {
|
||
debug('call pause flowing=%j', this._readableState.flowing);
|
||
if (this._readableState.flowing !== false) {
|
||
debug('pause');
|
||
this._readableState.flowing = false;
|
||
this.emit('pause');
|
||
}
|
||
this._readableState.paused = true;
|
||
return this;
|
||
};
|
||
function flow(stream) {
|
||
var state = stream._readableState;
|
||
debug('flow', state.flowing);
|
||
while (state.flowing && stream.read() !== null);
|
||
}
|
||
|
||
// wrap an old-style stream as the async data source.
|
||
// This is *not* part of the readable stream interface.
|
||
// It is an ugly unfortunate mess of history.
|
||
Readable.prototype.wrap = function (stream) {
|
||
var _this = this;
|
||
var state = this._readableState;
|
||
var paused = false;
|
||
stream.on('end', function () {
|
||
debug('wrapped end');
|
||
if (state.decoder && !state.ended) {
|
||
var chunk = state.decoder.end();
|
||
if (chunk && chunk.length) _this.push(chunk);
|
||
}
|
||
_this.push(null);
|
||
});
|
||
stream.on('data', function (chunk) {
|
||
debug('wrapped data');
|
||
if (state.decoder) chunk = state.decoder.write(chunk);
|
||
|
||
// don't skip over falsy values in objectMode
|
||
if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
|
||
var ret = _this.push(chunk);
|
||
if (!ret) {
|
||
paused = true;
|
||
stream.pause();
|
||
}
|
||
});
|
||
|
||
// proxy all the other methods.
|
||
// important when wrapping filters and duplexes.
|
||
for (var i in stream) {
|
||
if (this[i] === undefined && typeof stream[i] === 'function') {
|
||
this[i] = function methodWrap(method) {
|
||
return function methodWrapReturnFunction() {
|
||
return stream[method].apply(stream, arguments);
|
||
};
|
||
}(i);
|
||
}
|
||
}
|
||
|
||
// proxy certain important events.
|
||
for (var n = 0; n < kProxyEvents.length; n++) {
|
||
stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
|
||
}
|
||
|
||
// when we try to consume some more bytes, simply unpause the
|
||
// underlying stream.
|
||
this._read = function (n) {
|
||
debug('wrapped _read', n);
|
||
if (paused) {
|
||
paused = false;
|
||
stream.resume();
|
||
}
|
||
};
|
||
return this;
|
||
};
|
||
if (typeof Symbol === 'function') {
|
||
Readable.prototype[Symbol.asyncIterator] = function () {
|
||
if (createReadableStreamAsyncIterator === undefined) {
|
||
createReadableStreamAsyncIterator = requireAsync_iterator();
|
||
}
|
||
return createReadableStreamAsyncIterator(this);
|
||
};
|
||
}
|
||
Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState.highWaterMark;
|
||
}
|
||
});
|
||
Object.defineProperty(Readable.prototype, 'readableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState && this._readableState.buffer;
|
||
}
|
||
});
|
||
Object.defineProperty(Readable.prototype, 'readableFlowing', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState.flowing;
|
||
},
|
||
set: function set(state) {
|
||
if (this._readableState) {
|
||
this._readableState.flowing = state;
|
||
}
|
||
}
|
||
});
|
||
|
||
// exposed for testing purposes only.
|
||
Readable._fromList = fromList;
|
||
Object.defineProperty(Readable.prototype, 'readableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState.length;
|
||
}
|
||
});
|
||
|
||
// Pluck off n bytes from an array of buffers.
|
||
// Length is the combined lengths of all the buffers in the list.
|
||
// This function is designed to be inlinable, so please take care when making
|
||
// changes to the function body.
|
||
function fromList(n, state) {
|
||
// nothing buffered
|
||
if (state.length === 0) return null;
|
||
var ret;
|
||
if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
|
||
// read it all, truncate the list
|
||
if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
|
||
state.buffer.clear();
|
||
} else {
|
||
// read part of list
|
||
ret = state.buffer.consume(n, state.decoder);
|
||
}
|
||
return ret;
|
||
}
|
||
function endReadable(stream) {
|
||
var state = stream._readableState;
|
||
debug('endReadable', state.endEmitted);
|
||
if (!state.endEmitted) {
|
||
state.ended = true;
|
||
process.nextTick(endReadableNT, state, stream);
|
||
}
|
||
}
|
||
function endReadableNT(state, stream) {
|
||
debug('endReadableNT', state.endEmitted, state.length);
|
||
|
||
// Check that we didn't get one last unshift.
|
||
if (!state.endEmitted && state.length === 0) {
|
||
state.endEmitted = true;
|
||
stream.readable = false;
|
||
stream.emit('end');
|
||
if (state.autoDestroy) {
|
||
// In case of duplex streams we need a way to detect
|
||
// if the writable side is ready for autoDestroy as well
|
||
var wState = stream._writableState;
|
||
if (!wState || wState.autoDestroy && wState.finished) {
|
||
stream.destroy();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (typeof Symbol === 'function') {
|
||
Readable.from = function (iterable, opts) {
|
||
if (from === undefined) {
|
||
from = requireFrom();
|
||
}
|
||
return from(Readable, iterable, opts);
|
||
};
|
||
}
|
||
function indexOf(xs, x) {
|
||
for (var i = 0, l = xs.length; i < l; i++) {
|
||
if (xs[i] === x) return i;
|
||
}
|
||
return -1;
|
||
}
|
||
return _stream_readable;
|
||
}
|
||
|
||
var _stream_transform;
|
||
var hasRequired_stream_transform;
|
||
|
||
function require_stream_transform () {
|
||
if (hasRequired_stream_transform) return _stream_transform;
|
||
hasRequired_stream_transform = 1;
|
||
|
||
_stream_transform = Transform;
|
||
var _require$codes = requireErrors().codes,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
||
ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
|
||
ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
|
||
var Duplex = require_stream_duplex();
|
||
requireInherits()(Transform, Duplex);
|
||
function afterTransform(er, data) {
|
||
var ts = this._transformState;
|
||
ts.transforming = false;
|
||
var cb = ts.writecb;
|
||
if (cb === null) {
|
||
return this.emit('error', new ERR_MULTIPLE_CALLBACK());
|
||
}
|
||
ts.writechunk = null;
|
||
ts.writecb = null;
|
||
if (data != null)
|
||
// single equals check for both `null` and `undefined`
|
||
this.push(data);
|
||
cb(er);
|
||
var rs = this._readableState;
|
||
rs.reading = false;
|
||
if (rs.needReadable || rs.length < rs.highWaterMark) {
|
||
this._read(rs.highWaterMark);
|
||
}
|
||
}
|
||
function Transform(options) {
|
||
if (!(this instanceof Transform)) return new Transform(options);
|
||
Duplex.call(this, options);
|
||
this._transformState = {
|
||
afterTransform: afterTransform.bind(this),
|
||
needTransform: false,
|
||
transforming: false,
|
||
writecb: null,
|
||
writechunk: null,
|
||
writeencoding: null
|
||
};
|
||
|
||
// start out asking for a readable event once data is transformed.
|
||
this._readableState.needReadable = true;
|
||
|
||
// we have implemented the _read method, and done the other things
|
||
// that Readable wants before the first _read call, so unset the
|
||
// sync guard flag.
|
||
this._readableState.sync = false;
|
||
if (options) {
|
||
if (typeof options.transform === 'function') this._transform = options.transform;
|
||
if (typeof options.flush === 'function') this._flush = options.flush;
|
||
}
|
||
|
||
// When the writable side finishes, then flush out anything remaining.
|
||
this.on('prefinish', prefinish);
|
||
}
|
||
function prefinish() {
|
||
var _this = this;
|
||
if (typeof this._flush === 'function' && !this._readableState.destroyed) {
|
||
this._flush(function (er, data) {
|
||
done(_this, er, data);
|
||
});
|
||
} else {
|
||
done(this, null, null);
|
||
}
|
||
}
|
||
Transform.prototype.push = function (chunk, encoding) {
|
||
this._transformState.needTransform = false;
|
||
return Duplex.prototype.push.call(this, chunk, encoding);
|
||
};
|
||
|
||
// This is the part where you do stuff!
|
||
// override this function in implementation classes.
|
||
// 'chunk' is an input chunk.
|
||
//
|
||
// Call `push(newChunk)` to pass along transformed output
|
||
// to the readable side. You may call 'push' zero or more times.
|
||
//
|
||
// Call `cb(err)` when you are done with this chunk. If you pass
|
||
// an error, then that'll put the hurt on the whole operation. If you
|
||
// never call cb(), then you'll never get another chunk.
|
||
Transform.prototype._transform = function (chunk, encoding, cb) {
|
||
cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
|
||
};
|
||
Transform.prototype._write = function (chunk, encoding, cb) {
|
||
var ts = this._transformState;
|
||
ts.writecb = cb;
|
||
ts.writechunk = chunk;
|
||
ts.writeencoding = encoding;
|
||
if (!ts.transforming) {
|
||
var rs = this._readableState;
|
||
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
|
||
}
|
||
};
|
||
|
||
// Doesn't matter what the args are here.
|
||
// _transform does all the work.
|
||
// That we got here means that the readable side wants more data.
|
||
Transform.prototype._read = function (n) {
|
||
var ts = this._transformState;
|
||
if (ts.writechunk !== null && !ts.transforming) {
|
||
ts.transforming = true;
|
||
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
|
||
} else {
|
||
// mark that we need a transform, so that any data that comes in
|
||
// will get processed, now that we've asked for it.
|
||
ts.needTransform = true;
|
||
}
|
||
};
|
||
Transform.prototype._destroy = function (err, cb) {
|
||
Duplex.prototype._destroy.call(this, err, function (err2) {
|
||
cb(err2);
|
||
});
|
||
};
|
||
function done(stream, er, data) {
|
||
if (er) return stream.emit('error', er);
|
||
if (data != null)
|
||
// single equals check for both `null` and `undefined`
|
||
stream.push(data);
|
||
|
||
// TODO(BridgeAR): Write a test for these two error cases
|
||
// if there's nothing in the write buffer, then that means
|
||
// that nothing more will ever be provided
|
||
if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
|
||
if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
|
||
return stream.push(null);
|
||
}
|
||
return _stream_transform;
|
||
}
|
||
|
||
var _stream_passthrough;
|
||
var hasRequired_stream_passthrough;
|
||
|
||
function require_stream_passthrough () {
|
||
if (hasRequired_stream_passthrough) return _stream_passthrough;
|
||
hasRequired_stream_passthrough = 1;
|
||
|
||
_stream_passthrough = PassThrough;
|
||
var Transform = require_stream_transform();
|
||
requireInherits()(PassThrough, Transform);
|
||
function PassThrough(options) {
|
||
if (!(this instanceof PassThrough)) return new PassThrough(options);
|
||
Transform.call(this, options);
|
||
}
|
||
PassThrough.prototype._transform = function (chunk, encoding, cb) {
|
||
cb(null, chunk);
|
||
};
|
||
return _stream_passthrough;
|
||
}
|
||
|
||
var pipeline_1;
|
||
var hasRequiredPipeline;
|
||
|
||
function requirePipeline () {
|
||
if (hasRequiredPipeline) return pipeline_1;
|
||
hasRequiredPipeline = 1;
|
||
|
||
var eos;
|
||
function once(callback) {
|
||
var called = false;
|
||
return function () {
|
||
if (called) return;
|
||
called = true;
|
||
callback.apply(void 0, arguments);
|
||
};
|
||
}
|
||
var _require$codes = requireErrors().codes,
|
||
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
|
||
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
|
||
function noop(err) {
|
||
// Rethrow the error if it exists to avoid swallowing it
|
||
if (err) throw err;
|
||
}
|
||
function isRequest(stream) {
|
||
return stream.setHeader && typeof stream.abort === 'function';
|
||
}
|
||
function destroyer(stream, reading, writing, callback) {
|
||
callback = once(callback);
|
||
var closed = false;
|
||
stream.on('close', function () {
|
||
closed = true;
|
||
});
|
||
if (eos === undefined) eos = requireEndOfStream();
|
||
eos(stream, {
|
||
readable: reading,
|
||
writable: writing
|
||
}, function (err) {
|
||
if (err) return callback(err);
|
||
closed = true;
|
||
callback();
|
||
});
|
||
var destroyed = false;
|
||
return function (err) {
|
||
if (closed) return;
|
||
if (destroyed) return;
|
||
destroyed = true;
|
||
|
||
// request.destroy just do .end - .abort is what we want
|
||
if (isRequest(stream)) return stream.abort();
|
||
if (typeof stream.destroy === 'function') return stream.destroy();
|
||
callback(err || new ERR_STREAM_DESTROYED('pipe'));
|
||
};
|
||
}
|
||
function call(fn) {
|
||
fn();
|
||
}
|
||
function pipe(from, to) {
|
||
return from.pipe(to);
|
||
}
|
||
function popCallback(streams) {
|
||
if (!streams.length) return noop;
|
||
if (typeof streams[streams.length - 1] !== 'function') return noop;
|
||
return streams.pop();
|
||
}
|
||
function pipeline() {
|
||
for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
streams[_key] = arguments[_key];
|
||
}
|
||
var callback = popCallback(streams);
|
||
if (Array.isArray(streams[0])) streams = streams[0];
|
||
if (streams.length < 2) {
|
||
throw new ERR_MISSING_ARGS('streams');
|
||
}
|
||
var error;
|
||
var destroys = streams.map(function (stream, i) {
|
||
var reading = i < streams.length - 1;
|
||
var writing = i > 0;
|
||
return destroyer(stream, reading, writing, function (err) {
|
||
if (!error) error = err;
|
||
if (err) destroys.forEach(call);
|
||
if (reading) return;
|
||
destroys.forEach(call);
|
||
callback(error);
|
||
});
|
||
});
|
||
return streams.reduce(pipe);
|
||
}
|
||
pipeline_1 = pipeline;
|
||
return pipeline_1;
|
||
}
|
||
|
||
(function (module, exports) {
|
||
var Stream = require$$0$5;
|
||
if (process.env.READABLE_STREAM === 'disable' && Stream) {
|
||
module.exports = Stream.Readable;
|
||
Object.assign(module.exports, Stream);
|
||
module.exports.Stream = Stream;
|
||
} else {
|
||
exports = module.exports = require_stream_readable();
|
||
exports.Stream = Stream || exports;
|
||
exports.Readable = exports;
|
||
exports.Writable = require_stream_writable();
|
||
exports.Duplex = require_stream_duplex();
|
||
exports.Transform = require_stream_transform();
|
||
exports.PassThrough = require_stream_passthrough();
|
||
exports.finished = requireEndOfStream();
|
||
exports.pipeline = requirePipeline();
|
||
}
|
||
} (readable, readable.exports));
|
||
|
||
var readableExports = readable.exports;
|
||
|
||
Object.defineProperty(lib, "__esModule", { value: true });
|
||
lib.ReadableWebToNodeStream = void 0;
|
||
const readable_stream_1 = readableExports;
|
||
/**
|
||
* Converts a Web-API stream into Node stream.Readable class
|
||
* Node stream readable: https://nodejs.org/api/stream.html#stream_readable_streams
|
||
* Web API readable-stream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
|
||
* Node readable stream: https://nodejs.org/api/stream.html#stream_readable_streams
|
||
*/
|
||
class ReadableWebToNodeStream extends readable_stream_1.Readable {
|
||
/**
|
||
*
|
||
* @param stream ReadableStream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
|
||
*/
|
||
constructor(stream) {
|
||
super();
|
||
this.bytesRead = 0;
|
||
this.released = false;
|
||
this.reader = stream.getReader();
|
||
}
|
||
/**
|
||
* Implementation of readable._read(size).
|
||
* When readable._read() is called, if data is available from the resource,
|
||
* the implementation should begin pushing that data into the read queue
|
||
* https://nodejs.org/api/stream.html#stream_readable_read_size_1
|
||
*/
|
||
async _read() {
|
||
// Should start pushing data into the queue
|
||
// Read data from the underlying Web-API-readable-stream
|
||
if (this.released) {
|
||
this.push(null); // Signal EOF
|
||
return;
|
||
}
|
||
this.pendingRead = this.reader.read();
|
||
const data = await this.pendingRead;
|
||
// clear the promise before pushing pushing new data to the queue and allow sequential calls to _read()
|
||
delete this.pendingRead;
|
||
if (data.done || this.released) {
|
||
this.push(null); // Signal EOF
|
||
}
|
||
else {
|
||
this.bytesRead += data.value.length;
|
||
this.push(data.value); // Push new data to the queue
|
||
}
|
||
}
|
||
/**
|
||
* If there is no unresolved read call to Web-API ReadableStream immediately returns;
|
||
* otherwise will wait until the read is resolved.
|
||
*/
|
||
async waitForReadToComplete() {
|
||
if (this.pendingRead) {
|
||
await this.pendingRead;
|
||
}
|
||
}
|
||
/**
|
||
* Close wrapper
|
||
*/
|
||
async close() {
|
||
await this.syncAndRelease();
|
||
}
|
||
async syncAndRelease() {
|
||
this.released = true;
|
||
await this.waitForReadToComplete();
|
||
await this.reader.releaseLock();
|
||
}
|
||
}
|
||
lib.ReadableWebToNodeStream = ReadableWebToNodeStream;
|
||
|
||
// Primitive types
|
||
function dv(array) {
|
||
return new DataView(array.buffer, array.byteOffset);
|
||
}
|
||
/**
|
||
* 8-bit unsigned integer
|
||
*/
|
||
const UINT8 = {
|
||
len: 1,
|
||
get(array, offset) {
|
||
return dv(array).getUint8(offset);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setUint8(offset, value);
|
||
return offset + 1;
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
const UINT16_LE = {
|
||
len: 2,
|
||
get(array, offset) {
|
||
return dv(array).getUint16(offset, true);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setUint16(offset, value, true);
|
||
return offset + 2;
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
const UINT16_BE = {
|
||
len: 2,
|
||
get(array, offset) {
|
||
return dv(array).getUint16(offset);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setUint16(offset, value);
|
||
return offset + 2;
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
const UINT32_LE = {
|
||
len: 4,
|
||
get(array, offset) {
|
||
return dv(array).getUint32(offset, true);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setUint32(offset, value, true);
|
||
return offset + 4;
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
const UINT32_BE = {
|
||
len: 4,
|
||
get(array, offset) {
|
||
return dv(array).getUint32(offset);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setUint32(offset, value);
|
||
return offset + 4;
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit signed integer, Big Endian byte order
|
||
*/
|
||
const INT32_BE = {
|
||
len: 4,
|
||
get(array, offset) {
|
||
return dv(array).getInt32(offset);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setInt32(offset, value);
|
||
return offset + 4;
|
||
}
|
||
};
|
||
/**
|
||
* 64-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
const UINT64_LE = {
|
||
len: 8,
|
||
get(array, offset) {
|
||
return dv(array).getBigUint64(offset, true);
|
||
},
|
||
put(array, offset, value) {
|
||
dv(array).setBigUint64(offset, value, true);
|
||
return offset + 8;
|
||
}
|
||
};
|
||
/**
|
||
* Consume a fixed number of bytes from the stream and return a string with a specified encoding.
|
||
*/
|
||
class StringType {
|
||
constructor(len, encoding) {
|
||
this.len = len;
|
||
this.encoding = encoding;
|
||
}
|
||
get(uint8Array, offset) {
|
||
return node_buffer.Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);
|
||
}
|
||
}
|
||
|
||
const defaultMessages = 'End-Of-Stream';
|
||
/**
|
||
* Thrown on read operation of the end of file or stream has been reached
|
||
*/
|
||
class EndOfStreamError extends Error {
|
||
constructor() {
|
||
super(defaultMessages);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Core tokenizer
|
||
*/
|
||
class AbstractTokenizer {
|
||
constructor(fileInfo) {
|
||
/**
|
||
* Tokenizer-stream position
|
||
*/
|
||
this.position = 0;
|
||
this.numBuffer = new Uint8Array(8);
|
||
this.fileInfo = fileInfo ? fileInfo : {};
|
||
}
|
||
/**
|
||
* Read a token from the tokenizer-stream
|
||
* @param token - The token to read
|
||
* @param position - If provided, the desired position in the tokenizer-stream
|
||
* @returns Promise with token data
|
||
*/
|
||
async readToken(token, position = this.position) {
|
||
const uint8Array = node_buffer.Buffer.alloc(token.len);
|
||
const len = await this.readBuffer(uint8Array, { position });
|
||
if (len < token.len)
|
||
throw new EndOfStreamError();
|
||
return token.get(uint8Array, 0);
|
||
}
|
||
/**
|
||
* Peek a token from the tokenizer-stream.
|
||
* @param token - Token to peek from the tokenizer-stream.
|
||
* @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
|
||
* @returns Promise with token data
|
||
*/
|
||
async peekToken(token, position = this.position) {
|
||
const uint8Array = node_buffer.Buffer.alloc(token.len);
|
||
const len = await this.peekBuffer(uint8Array, { position });
|
||
if (len < token.len)
|
||
throw new EndOfStreamError();
|
||
return token.get(uint8Array, 0);
|
||
}
|
||
/**
|
||
* Read a numeric token from the stream
|
||
* @param token - Numeric token
|
||
* @returns Promise with number
|
||
*/
|
||
async readNumber(token) {
|
||
const len = await this.readBuffer(this.numBuffer, { length: token.len });
|
||
if (len < token.len)
|
||
throw new EndOfStreamError();
|
||
return token.get(this.numBuffer, 0);
|
||
}
|
||
/**
|
||
* Read a numeric token from the stream
|
||
* @param token - Numeric token
|
||
* @returns Promise with number
|
||
*/
|
||
async peekNumber(token) {
|
||
const len = await this.peekBuffer(this.numBuffer, { length: token.len });
|
||
if (len < token.len)
|
||
throw new EndOfStreamError();
|
||
return token.get(this.numBuffer, 0);
|
||
}
|
||
/**
|
||
* Ignore number of bytes, advances the pointer in under tokenizer-stream.
|
||
* @param length - Number of bytes to ignore
|
||
* @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
|
||
*/
|
||
async ignore(length) {
|
||
if (this.fileInfo.size !== undefined) {
|
||
const bytesLeft = this.fileInfo.size - this.position;
|
||
if (length > bytesLeft) {
|
||
this.position += bytesLeft;
|
||
return bytesLeft;
|
||
}
|
||
}
|
||
this.position += length;
|
||
return length;
|
||
}
|
||
async close() {
|
||
// empty
|
||
}
|
||
normalizeOptions(uint8Array, options) {
|
||
if (options && options.position !== undefined && options.position < this.position) {
|
||
throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
|
||
}
|
||
if (options) {
|
||
return {
|
||
mayBeLess: options.mayBeLess === true,
|
||
offset: options.offset ? options.offset : 0,
|
||
length: options.length ? options.length : (uint8Array.length - (options.offset ? options.offset : 0)),
|
||
position: options.position ? options.position : this.position
|
||
};
|
||
}
|
||
return {
|
||
mayBeLess: false,
|
||
offset: 0,
|
||
length: uint8Array.length,
|
||
position: this.position
|
||
};
|
||
}
|
||
}
|
||
|
||
class BufferTokenizer extends AbstractTokenizer {
|
||
/**
|
||
* Construct BufferTokenizer
|
||
* @param uint8Array - Uint8Array to tokenize
|
||
* @param fileInfo - Pass additional file information to the tokenizer
|
||
*/
|
||
constructor(uint8Array, fileInfo) {
|
||
super(fileInfo);
|
||
this.uint8Array = uint8Array;
|
||
this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
|
||
}
|
||
/**
|
||
* Read buffer from tokenizer
|
||
* @param uint8Array - Uint8Array to tokenize
|
||
* @param options - Read behaviour options
|
||
* @returns {Promise<number>}
|
||
*/
|
||
async readBuffer(uint8Array, options) {
|
||
if (options && options.position) {
|
||
if (options.position < this.position) {
|
||
throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
|
||
}
|
||
this.position = options.position;
|
||
}
|
||
const bytesRead = await this.peekBuffer(uint8Array, options);
|
||
this.position += bytesRead;
|
||
return bytesRead;
|
||
}
|
||
/**
|
||
* Peek (read ahead) buffer from tokenizer
|
||
* @param uint8Array
|
||
* @param options - Read behaviour options
|
||
* @returns {Promise<number>}
|
||
*/
|
||
async peekBuffer(uint8Array, options) {
|
||
const normOptions = this.normalizeOptions(uint8Array, options);
|
||
const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
|
||
if ((!normOptions.mayBeLess) && bytes2read < normOptions.length) {
|
||
throw new EndOfStreamError();
|
||
}
|
||
else {
|
||
uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
|
||
return bytes2read;
|
||
}
|
||
}
|
||
async close() {
|
||
// empty
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Construct ReadStreamTokenizer from given Buffer.
|
||
* @param uint8Array - Uint8Array to tokenize
|
||
* @param fileInfo - Pass additional file information to the tokenizer
|
||
* @returns BufferTokenizer
|
||
*/
|
||
function fromBuffer(uint8Array, fileInfo) {
|
||
return new BufferTokenizer(uint8Array, fileInfo);
|
||
}
|
||
|
||
function stringToBytes(string) {
|
||
return [...string].map(character => character.charCodeAt(0)); // eslint-disable-line unicorn/prefer-code-point
|
||
}
|
||
|
||
/**
|
||
Checks whether the TAR checksum is valid.
|
||
|
||
@param {Buffer} buffer - The TAR header `[offset ... offset + 512]`.
|
||
@param {number} offset - TAR header offset.
|
||
@returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.
|
||
*/
|
||
function tarHeaderChecksumMatches(buffer, offset = 0) {
|
||
const readSum = Number.parseInt(buffer.toString('utf8', 148, 154).replace(/\0.*$/, '').trim(), 8); // Read sum in header
|
||
if (Number.isNaN(readSum)) {
|
||
return false;
|
||
}
|
||
|
||
let sum = 8 * 0x20; // Initialize signed bit sum
|
||
|
||
for (let index = offset; index < offset + 148; index++) {
|
||
sum += buffer[index];
|
||
}
|
||
|
||
for (let index = offset + 156; index < offset + 512; index++) {
|
||
sum += buffer[index];
|
||
}
|
||
|
||
return readSum === sum;
|
||
}
|
||
|
||
/**
|
||
ID3 UINT32 sync-safe tokenizer token.
|
||
28 bits (representing up to 256MB) integer, the msb is 0 to avoid "false syncsignals".
|
||
*/
|
||
const uint32SyncSafeToken = {
|
||
get: (buffer, offset) => (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2]) << 7) | ((buffer[offset + 1]) << 14) | ((buffer[offset]) << 21),
|
||
len: 4,
|
||
};
|
||
|
||
const extensions = [
|
||
'jpg',
|
||
'png',
|
||
'apng',
|
||
'gif',
|
||
'webp',
|
||
'flif',
|
||
'xcf',
|
||
'cr2',
|
||
'cr3',
|
||
'orf',
|
||
'arw',
|
||
'dng',
|
||
'nef',
|
||
'rw2',
|
||
'raf',
|
||
'tif',
|
||
'bmp',
|
||
'icns',
|
||
'jxr',
|
||
'psd',
|
||
'indd',
|
||
'zip',
|
||
'tar',
|
||
'rar',
|
||
'gz',
|
||
'bz2',
|
||
'7z',
|
||
'dmg',
|
||
'mp4',
|
||
'mid',
|
||
'mkv',
|
||
'webm',
|
||
'mov',
|
||
'avi',
|
||
'mpg',
|
||
'mp2',
|
||
'mp3',
|
||
'm4a',
|
||
'oga',
|
||
'ogg',
|
||
'ogv',
|
||
'opus',
|
||
'flac',
|
||
'wav',
|
||
'spx',
|
||
'amr',
|
||
'pdf',
|
||
'epub',
|
||
'elf',
|
||
'exe',
|
||
'swf',
|
||
'rtf',
|
||
'wasm',
|
||
'woff',
|
||
'woff2',
|
||
'eot',
|
||
'ttf',
|
||
'otf',
|
||
'ico',
|
||
'flv',
|
||
'ps',
|
||
'xz',
|
||
'sqlite',
|
||
'nes',
|
||
'crx',
|
||
'xpi',
|
||
'cab',
|
||
'deb',
|
||
'ar',
|
||
'rpm',
|
||
'Z',
|
||
'lz',
|
||
'cfb',
|
||
'mxf',
|
||
'mts',
|
||
'blend',
|
||
'bpg',
|
||
'docx',
|
||
'pptx',
|
||
'xlsx',
|
||
'3gp',
|
||
'3g2',
|
||
'j2c',
|
||
'jp2',
|
||
'jpm',
|
||
'jpx',
|
||
'mj2',
|
||
'aif',
|
||
'qcp',
|
||
'odt',
|
||
'ods',
|
||
'odp',
|
||
'xml',
|
||
'mobi',
|
||
'heic',
|
||
'cur',
|
||
'ktx',
|
||
'ape',
|
||
'wv',
|
||
'dcm',
|
||
'ics',
|
||
'glb',
|
||
'pcap',
|
||
'dsf',
|
||
'lnk',
|
||
'alias',
|
||
'voc',
|
||
'ac3',
|
||
'm4v',
|
||
'm4p',
|
||
'm4b',
|
||
'f4v',
|
||
'f4p',
|
||
'f4b',
|
||
'f4a',
|
||
'mie',
|
||
'asf',
|
||
'ogm',
|
||
'ogx',
|
||
'mpc',
|
||
'arrow',
|
||
'shp',
|
||
'aac',
|
||
'mp1',
|
||
'it',
|
||
's3m',
|
||
'xm',
|
||
'ai',
|
||
'skp',
|
||
'avif',
|
||
'eps',
|
||
'lzh',
|
||
'pgp',
|
||
'asar',
|
||
'stl',
|
||
'chm',
|
||
'3mf',
|
||
'zst',
|
||
'jxl',
|
||
'vcf',
|
||
'jls',
|
||
'pst',
|
||
'dwg',
|
||
'parquet',
|
||
'class',
|
||
'arj',
|
||
'cpio',
|
||
'ace',
|
||
'avro',
|
||
];
|
||
|
||
const mimeTypes = [
|
||
'image/jpeg',
|
||
'image/png',
|
||
'image/gif',
|
||
'image/webp',
|
||
'image/flif',
|
||
'image/x-xcf',
|
||
'image/x-canon-cr2',
|
||
'image/x-canon-cr3',
|
||
'image/tiff',
|
||
'image/bmp',
|
||
'image/vnd.ms-photo',
|
||
'image/vnd.adobe.photoshop',
|
||
'application/x-indesign',
|
||
'application/epub+zip',
|
||
'application/x-xpinstall',
|
||
'application/vnd.oasis.opendocument.text',
|
||
'application/vnd.oasis.opendocument.spreadsheet',
|
||
'application/vnd.oasis.opendocument.presentation',
|
||
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
|
||
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
'application/zip',
|
||
'application/x-tar',
|
||
'application/x-rar-compressed',
|
||
'application/gzip',
|
||
'application/x-bzip2',
|
||
'application/x-7z-compressed',
|
||
'application/x-apple-diskimage',
|
||
'application/x-apache-arrow',
|
||
'video/mp4',
|
||
'audio/midi',
|
||
'video/x-matroska',
|
||
'video/webm',
|
||
'video/quicktime',
|
||
'video/vnd.avi',
|
||
'audio/vnd.wave',
|
||
'audio/qcelp',
|
||
'audio/x-ms-asf',
|
||
'video/x-ms-asf',
|
||
'application/vnd.ms-asf',
|
||
'video/mpeg',
|
||
'video/3gpp',
|
||
'audio/mpeg',
|
||
'audio/mp4', // RFC 4337
|
||
'audio/opus',
|
||
'video/ogg',
|
||
'audio/ogg',
|
||
'application/ogg',
|
||
'audio/x-flac',
|
||
'audio/ape',
|
||
'audio/wavpack',
|
||
'audio/amr',
|
||
'application/pdf',
|
||
'application/x-elf',
|
||
'application/x-msdownload',
|
||
'application/x-shockwave-flash',
|
||
'application/rtf',
|
||
'application/wasm',
|
||
'font/woff',
|
||
'font/woff2',
|
||
'application/vnd.ms-fontobject',
|
||
'font/ttf',
|
||
'font/otf',
|
||
'image/x-icon',
|
||
'video/x-flv',
|
||
'application/postscript',
|
||
'application/eps',
|
||
'application/x-xz',
|
||
'application/x-sqlite3',
|
||
'application/x-nintendo-nes-rom',
|
||
'application/x-google-chrome-extension',
|
||
'application/vnd.ms-cab-compressed',
|
||
'application/x-deb',
|
||
'application/x-unix-archive',
|
||
'application/x-rpm',
|
||
'application/x-compress',
|
||
'application/x-lzip',
|
||
'application/x-cfb',
|
||
'application/x-mie',
|
||
'application/mxf',
|
||
'video/mp2t',
|
||
'application/x-blender',
|
||
'image/bpg',
|
||
'image/j2c',
|
||
'image/jp2',
|
||
'image/jpx',
|
||
'image/jpm',
|
||
'image/mj2',
|
||
'audio/aiff',
|
||
'application/xml',
|
||
'application/x-mobipocket-ebook',
|
||
'image/heif',
|
||
'image/heif-sequence',
|
||
'image/heic',
|
||
'image/heic-sequence',
|
||
'image/icns',
|
||
'image/ktx',
|
||
'application/dicom',
|
||
'audio/x-musepack',
|
||
'text/calendar',
|
||
'text/vcard',
|
||
'model/gltf-binary',
|
||
'application/vnd.tcpdump.pcap',
|
||
'audio/x-dsf', // Non-standard
|
||
'application/x.ms.shortcut', // Invented by us
|
||
'application/x.apple.alias', // Invented by us
|
||
'audio/x-voc',
|
||
'audio/vnd.dolby.dd-raw',
|
||
'audio/x-m4a',
|
||
'image/apng',
|
||
'image/x-olympus-orf',
|
||
'image/x-sony-arw',
|
||
'image/x-adobe-dng',
|
||
'image/x-nikon-nef',
|
||
'image/x-panasonic-rw2',
|
||
'image/x-fujifilm-raf',
|
||
'video/x-m4v',
|
||
'video/3gpp2',
|
||
'application/x-esri-shape',
|
||
'audio/aac',
|
||
'audio/x-it',
|
||
'audio/x-s3m',
|
||
'audio/x-xm',
|
||
'video/MP1S',
|
||
'video/MP2P',
|
||
'application/vnd.sketchup.skp',
|
||
'image/avif',
|
||
'application/x-lzh-compressed',
|
||
'application/pgp-encrypted',
|
||
'application/x-asar',
|
||
'model/stl',
|
||
'application/vnd.ms-htmlhelp',
|
||
'model/3mf',
|
||
'image/jxl',
|
||
'application/zstd',
|
||
'image/jls',
|
||
'application/vnd.ms-outlook',
|
||
'image/vnd.dwg',
|
||
'application/x-parquet',
|
||
'application/java-vm',
|
||
'application/x-arj',
|
||
'application/x-cpio',
|
||
'application/x-ace-compressed',
|
||
'application/avro',
|
||
];
|
||
|
||
const minimumBytes = 4100; // A fair amount of file-types are detectable within this range.
|
||
|
||
async function fileTypeFromBuffer(input) {
|
||
if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
|
||
throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
|
||
}
|
||
|
||
const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
|
||
|
||
if (!(buffer?.length > 1)) {
|
||
return;
|
||
}
|
||
|
||
return fileTypeFromTokenizer(fromBuffer(buffer));
|
||
}
|
||
|
||
function _check(buffer, headers, options) {
|
||
options = {
|
||
offset: 0,
|
||
...options,
|
||
};
|
||
|
||
for (const [index, header] of headers.entries()) {
|
||
// If a bitmask is set
|
||
if (options.mask) {
|
||
// If header doesn't equal `buf` with bits masked off
|
||
if (header !== (options.mask[index] & buffer[index + options.offset])) {
|
||
return false;
|
||
}
|
||
} else if (header !== buffer[index + options.offset]) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
async function fileTypeFromTokenizer(tokenizer) {
|
||
try {
|
||
return new FileTypeParser().parse(tokenizer);
|
||
} catch (error) {
|
||
if (!(error instanceof EndOfStreamError)) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
class FileTypeParser {
|
||
check(header, options) {
|
||
return _check(this.buffer, header, options);
|
||
}
|
||
|
||
checkString(header, options) {
|
||
return this.check(stringToBytes(header), options);
|
||
}
|
||
|
||
async parse(tokenizer) {
|
||
this.buffer = node_buffer.Buffer.alloc(minimumBytes);
|
||
|
||
// Keep reading until EOF if the file size is unknown.
|
||
if (tokenizer.fileInfo.size === undefined) {
|
||
tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
this.tokenizer = tokenizer;
|
||
|
||
await tokenizer.peekBuffer(this.buffer, {length: 12, mayBeLess: true});
|
||
|
||
// -- 2-byte signatures --
|
||
|
||
if (this.check([0x42, 0x4D])) {
|
||
return {
|
||
ext: 'bmp',
|
||
mime: 'image/bmp',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x0B, 0x77])) {
|
||
return {
|
||
ext: 'ac3',
|
||
mime: 'audio/vnd.dolby.dd-raw',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x78, 0x01])) {
|
||
return {
|
||
ext: 'dmg',
|
||
mime: 'application/x-apple-diskimage',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x4D, 0x5A])) {
|
||
return {
|
||
ext: 'exe',
|
||
mime: 'application/x-msdownload',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x25, 0x21])) {
|
||
await tokenizer.peekBuffer(this.buffer, {length: 24, mayBeLess: true});
|
||
|
||
if (
|
||
this.checkString('PS-Adobe-', {offset: 2})
|
||
&& this.checkString(' EPSF-', {offset: 14})
|
||
) {
|
||
return {
|
||
ext: 'eps',
|
||
mime: 'application/eps',
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'ps',
|
||
mime: 'application/postscript',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.check([0x1F, 0xA0])
|
||
|| this.check([0x1F, 0x9D])
|
||
) {
|
||
return {
|
||
ext: 'Z',
|
||
mime: 'application/x-compress',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xC7, 0x71])) {
|
||
return {
|
||
ext: 'cpio',
|
||
mime: 'application/x-cpio',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x60, 0xEA])) {
|
||
return {
|
||
ext: 'arj',
|
||
mime: 'application/x-arj',
|
||
};
|
||
}
|
||
|
||
// -- 3-byte signatures --
|
||
|
||
if (this.check([0xEF, 0xBB, 0xBF])) { // UTF-8-BOM
|
||
// Strip off UTF-8-BOM
|
||
this.tokenizer.ignore(3);
|
||
return this.parse(tokenizer);
|
||
}
|
||
|
||
if (this.check([0x47, 0x49, 0x46])) {
|
||
return {
|
||
ext: 'gif',
|
||
mime: 'image/gif',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x49, 0x49, 0xBC])) {
|
||
return {
|
||
ext: 'jxr',
|
||
mime: 'image/vnd.ms-photo',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x1F, 0x8B, 0x8])) {
|
||
return {
|
||
ext: 'gz',
|
||
mime: 'application/gzip',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x42, 0x5A, 0x68])) {
|
||
return {
|
||
ext: 'bz2',
|
||
mime: 'application/x-bzip2',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('ID3')) {
|
||
await tokenizer.ignore(6); // Skip ID3 header until the header size
|
||
const id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);
|
||
if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
|
||
// Guess file type based on ID3 header for backward compatibility
|
||
return {
|
||
ext: 'mp3',
|
||
mime: 'audio/mpeg',
|
||
};
|
||
}
|
||
|
||
await tokenizer.ignore(id3HeaderLength);
|
||
return fileTypeFromTokenizer(tokenizer); // Skip ID3 header, recursion
|
||
}
|
||
|
||
// Musepack, SV7
|
||
if (this.checkString('MP+')) {
|
||
return {
|
||
ext: 'mpc',
|
||
mime: 'audio/x-musepack',
|
||
};
|
||
}
|
||
|
||
if (
|
||
(this.buffer[0] === 0x43 || this.buffer[0] === 0x46)
|
||
&& this.check([0x57, 0x53], {offset: 1})
|
||
) {
|
||
return {
|
||
ext: 'swf',
|
||
mime: 'application/x-shockwave-flash',
|
||
};
|
||
}
|
||
|
||
// -- 4-byte signatures --
|
||
|
||
// Requires a sample size of 4 bytes
|
||
if (this.check([0xFF, 0xD8, 0xFF])) {
|
||
if (this.check([0xF7], {offset: 3})) { // JPG7/SOF55, indicating a ISO/IEC 14495 / JPEG-LS file
|
||
return {
|
||
ext: 'jls',
|
||
mime: 'image/jls',
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'jpg',
|
||
mime: 'image/jpeg',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x4F, 0x62, 0x6A, 0x01])) {
|
||
return {
|
||
ext: 'avro',
|
||
mime: 'application/avro',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('FLIF')) {
|
||
return {
|
||
ext: 'flif',
|
||
mime: 'image/flif',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('8BPS')) {
|
||
return {
|
||
ext: 'psd',
|
||
mime: 'image/vnd.adobe.photoshop',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('WEBP', {offset: 8})) {
|
||
return {
|
||
ext: 'webp',
|
||
mime: 'image/webp',
|
||
};
|
||
}
|
||
|
||
// Musepack, SV8
|
||
if (this.checkString('MPCK')) {
|
||
return {
|
||
ext: 'mpc',
|
||
mime: 'audio/x-musepack',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('FORM')) {
|
||
return {
|
||
ext: 'aif',
|
||
mime: 'audio/aiff',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('icns', {offset: 0})) {
|
||
return {
|
||
ext: 'icns',
|
||
mime: 'image/icns',
|
||
};
|
||
}
|
||
|
||
// Zip-based file formats
|
||
// Need to be before the `zip` check
|
||
if (this.check([0x50, 0x4B, 0x3, 0x4])) { // Local file header signature
|
||
try {
|
||
while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
|
||
await tokenizer.readBuffer(this.buffer, {length: 30});
|
||
|
||
// https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
|
||
const zipHeader = {
|
||
compressedSize: this.buffer.readUInt32LE(18),
|
||
uncompressedSize: this.buffer.readUInt32LE(22),
|
||
filenameLength: this.buffer.readUInt16LE(26),
|
||
extraFieldLength: this.buffer.readUInt16LE(28),
|
||
};
|
||
|
||
zipHeader.filename = await tokenizer.readToken(new StringType(zipHeader.filenameLength, 'utf-8'));
|
||
await tokenizer.ignore(zipHeader.extraFieldLength);
|
||
|
||
// Assumes signed `.xpi` from addons.mozilla.org
|
||
if (zipHeader.filename === 'META-INF/mozilla.rsa') {
|
||
return {
|
||
ext: 'xpi',
|
||
mime: 'application/x-xpinstall',
|
||
};
|
||
}
|
||
|
||
if (zipHeader.filename.endsWith('.rels') || zipHeader.filename.endsWith('.xml')) {
|
||
const type = zipHeader.filename.split('/')[0];
|
||
switch (type) {
|
||
case '_rels':
|
||
break;
|
||
case 'word':
|
||
return {
|
||
ext: 'docx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
};
|
||
case 'ppt':
|
||
return {
|
||
ext: 'pptx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
|
||
};
|
||
case 'xl':
|
||
return {
|
||
ext: 'xlsx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
};
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (zipHeader.filename.startsWith('xl/')) {
|
||
return {
|
||
ext: 'xlsx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
};
|
||
}
|
||
|
||
if (zipHeader.filename.startsWith('3D/') && zipHeader.filename.endsWith('.model')) {
|
||
return {
|
||
ext: '3mf',
|
||
mime: 'model/3mf',
|
||
};
|
||
}
|
||
|
||
// The docx, xlsx and pptx file types extend the Office Open XML file format:
|
||
// https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
|
||
// We look for:
|
||
// - one entry named '[Content_Types].xml' or '_rels/.rels',
|
||
// - one entry indicating specific type of file.
|
||
// MS Office, OpenOffice and LibreOffice may put the parts in different order, so the check should not rely on it.
|
||
if (zipHeader.filename === 'mimetype' && zipHeader.compressedSize === zipHeader.uncompressedSize) {
|
||
let mimeType = await tokenizer.readToken(new StringType(zipHeader.compressedSize, 'utf-8'));
|
||
mimeType = mimeType.trim();
|
||
|
||
switch (mimeType) {
|
||
case 'application/epub+zip':
|
||
return {
|
||
ext: 'epub',
|
||
mime: 'application/epub+zip',
|
||
};
|
||
case 'application/vnd.oasis.opendocument.text':
|
||
return {
|
||
ext: 'odt',
|
||
mime: 'application/vnd.oasis.opendocument.text',
|
||
};
|
||
case 'application/vnd.oasis.opendocument.spreadsheet':
|
||
return {
|
||
ext: 'ods',
|
||
mime: 'application/vnd.oasis.opendocument.spreadsheet',
|
||
};
|
||
case 'application/vnd.oasis.opendocument.presentation':
|
||
return {
|
||
ext: 'odp',
|
||
mime: 'application/vnd.oasis.opendocument.presentation',
|
||
};
|
||
default:
|
||
}
|
||
}
|
||
|
||
// Try to find next header manually when current one is corrupted
|
||
if (zipHeader.compressedSize === 0) {
|
||
let nextHeaderIndex = -1;
|
||
|
||
while (nextHeaderIndex < 0 && (tokenizer.position < tokenizer.fileInfo.size)) {
|
||
await tokenizer.peekBuffer(this.buffer, {mayBeLess: true});
|
||
|
||
nextHeaderIndex = this.buffer.indexOf('504B0304', 0, 'hex');
|
||
// Move position to the next header if found, skip the whole buffer otherwise
|
||
await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : this.buffer.length);
|
||
}
|
||
} else {
|
||
await tokenizer.ignore(zipHeader.compressedSize);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
if (!(error instanceof EndOfStreamError)) {
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
return {
|
||
ext: 'zip',
|
||
mime: 'application/zip',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('OggS')) {
|
||
// This is an OGG container
|
||
await tokenizer.ignore(28);
|
||
const type = node_buffer.Buffer.alloc(8);
|
||
await tokenizer.readBuffer(type);
|
||
|
||
// Needs to be before `ogg` check
|
||
if (_check(type, [0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64])) {
|
||
return {
|
||
ext: 'opus',
|
||
mime: 'audio/opus',
|
||
};
|
||
}
|
||
|
||
// If ' theora' in header.
|
||
if (_check(type, [0x80, 0x74, 0x68, 0x65, 0x6F, 0x72, 0x61])) {
|
||
return {
|
||
ext: 'ogv',
|
||
mime: 'video/ogg',
|
||
};
|
||
}
|
||
|
||
// If '\x01video' in header.
|
||
if (_check(type, [0x01, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x00])) {
|
||
return {
|
||
ext: 'ogm',
|
||
mime: 'video/ogg',
|
||
};
|
||
}
|
||
|
||
// If ' FLAC' in header https://xiph.org/flac/faq.html
|
||
if (_check(type, [0x7F, 0x46, 0x4C, 0x41, 0x43])) {
|
||
return {
|
||
ext: 'oga',
|
||
mime: 'audio/ogg',
|
||
};
|
||
}
|
||
|
||
// 'Speex ' in header https://en.wikipedia.org/wiki/Speex
|
||
if (_check(type, [0x53, 0x70, 0x65, 0x65, 0x78, 0x20, 0x20])) {
|
||
return {
|
||
ext: 'spx',
|
||
mime: 'audio/ogg',
|
||
};
|
||
}
|
||
|
||
// If '\x01vorbis' in header
|
||
if (_check(type, [0x01, 0x76, 0x6F, 0x72, 0x62, 0x69, 0x73])) {
|
||
return {
|
||
ext: 'ogg',
|
||
mime: 'audio/ogg',
|
||
};
|
||
}
|
||
|
||
// Default OGG container https://www.iana.org/assignments/media-types/application/ogg
|
||
return {
|
||
ext: 'ogx',
|
||
mime: 'application/ogg',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.check([0x50, 0x4B])
|
||
&& (this.buffer[2] === 0x3 || this.buffer[2] === 0x5 || this.buffer[2] === 0x7)
|
||
&& (this.buffer[3] === 0x4 || this.buffer[3] === 0x6 || this.buffer[3] === 0x8)
|
||
) {
|
||
return {
|
||
ext: 'zip',
|
||
mime: 'application/zip',
|
||
};
|
||
}
|
||
|
||
//
|
||
|
||
// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
|
||
// It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.
|
||
// `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
|
||
// Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
|
||
if (
|
||
this.checkString('ftyp', {offset: 4})
|
||
&& (this.buffer[8] & 0x60) !== 0x00 // Brand major, first character ASCII?
|
||
) {
|
||
// They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.
|
||
// For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.
|
||
const brandMajor = this.buffer.toString('binary', 8, 12).replace('\0', ' ').trim();
|
||
switch (brandMajor) {
|
||
case 'avif':
|
||
case 'avis':
|
||
return {ext: 'avif', mime: 'image/avif'};
|
||
case 'mif1':
|
||
return {ext: 'heic', mime: 'image/heif'};
|
||
case 'msf1':
|
||
return {ext: 'heic', mime: 'image/heif-sequence'};
|
||
case 'heic':
|
||
case 'heix':
|
||
return {ext: 'heic', mime: 'image/heic'};
|
||
case 'hevc':
|
||
case 'hevx':
|
||
return {ext: 'heic', mime: 'image/heic-sequence'};
|
||
case 'qt':
|
||
return {ext: 'mov', mime: 'video/quicktime'};
|
||
case 'M4V':
|
||
case 'M4VH':
|
||
case 'M4VP':
|
||
return {ext: 'm4v', mime: 'video/x-m4v'};
|
||
case 'M4P':
|
||
return {ext: 'm4p', mime: 'video/mp4'};
|
||
case 'M4B':
|
||
return {ext: 'm4b', mime: 'audio/mp4'};
|
||
case 'M4A':
|
||
return {ext: 'm4a', mime: 'audio/x-m4a'};
|
||
case 'F4V':
|
||
return {ext: 'f4v', mime: 'video/mp4'};
|
||
case 'F4P':
|
||
return {ext: 'f4p', mime: 'video/mp4'};
|
||
case 'F4A':
|
||
return {ext: 'f4a', mime: 'audio/mp4'};
|
||
case 'F4B':
|
||
return {ext: 'f4b', mime: 'audio/mp4'};
|
||
case 'crx':
|
||
return {ext: 'cr3', mime: 'image/x-canon-cr3'};
|
||
default:
|
||
if (brandMajor.startsWith('3g')) {
|
||
if (brandMajor.startsWith('3g2')) {
|
||
return {ext: '3g2', mime: 'video/3gpp2'};
|
||
}
|
||
|
||
return {ext: '3gp', mime: 'video/3gpp'};
|
||
}
|
||
|
||
return {ext: 'mp4', mime: 'video/mp4'};
|
||
}
|
||
}
|
||
|
||
if (this.checkString('MThd')) {
|
||
return {
|
||
ext: 'mid',
|
||
mime: 'audio/midi',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.checkString('wOFF')
|
||
&& (
|
||
this.check([0x00, 0x01, 0x00, 0x00], {offset: 4})
|
||
|| this.checkString('OTTO', {offset: 4})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'woff',
|
||
mime: 'font/woff',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.checkString('wOF2')
|
||
&& (
|
||
this.check([0x00, 0x01, 0x00, 0x00], {offset: 4})
|
||
|| this.checkString('OTTO', {offset: 4})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'woff2',
|
||
mime: 'font/woff2',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xD4, 0xC3, 0xB2, 0xA1]) || this.check([0xA1, 0xB2, 0xC3, 0xD4])) {
|
||
return {
|
||
ext: 'pcap',
|
||
mime: 'application/vnd.tcpdump.pcap',
|
||
};
|
||
}
|
||
|
||
// Sony DSD Stream File (DSF)
|
||
if (this.checkString('DSD ')) {
|
||
return {
|
||
ext: 'dsf',
|
||
mime: 'audio/x-dsf', // Non-standard
|
||
};
|
||
}
|
||
|
||
if (this.checkString('LZIP')) {
|
||
return {
|
||
ext: 'lz',
|
||
mime: 'application/x-lzip',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('fLaC')) {
|
||
return {
|
||
ext: 'flac',
|
||
mime: 'audio/x-flac',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x42, 0x50, 0x47, 0xFB])) {
|
||
return {
|
||
ext: 'bpg',
|
||
mime: 'image/bpg',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('wvpk')) {
|
||
return {
|
||
ext: 'wv',
|
||
mime: 'audio/wavpack',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('%PDF')) {
|
||
try {
|
||
await tokenizer.ignore(1350);
|
||
const maxBufferSize = 10 * 1024 * 1024;
|
||
const buffer = node_buffer.Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
|
||
await tokenizer.readBuffer(buffer, {mayBeLess: true});
|
||
|
||
// Check if this is an Adobe Illustrator file
|
||
if (buffer.includes(node_buffer.Buffer.from('AIPrivateData'))) {
|
||
return {
|
||
ext: 'ai',
|
||
mime: 'application/postscript',
|
||
};
|
||
}
|
||
} catch (error) {
|
||
// Swallow end of stream error if file is too small for the Adobe AI check
|
||
if (!(error instanceof EndOfStreamError)) {
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
// Assume this is just a normal PDF
|
||
return {
|
||
ext: 'pdf',
|
||
mime: 'application/pdf',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x00, 0x61, 0x73, 0x6D])) {
|
||
return {
|
||
ext: 'wasm',
|
||
mime: 'application/wasm',
|
||
};
|
||
}
|
||
|
||
// TIFF, little-endian type
|
||
if (this.check([0x49, 0x49])) {
|
||
const fileType = await this.readTiffHeader(false);
|
||
if (fileType) {
|
||
return fileType;
|
||
}
|
||
}
|
||
|
||
// TIFF, big-endian type
|
||
if (this.check([0x4D, 0x4D])) {
|
||
const fileType = await this.readTiffHeader(true);
|
||
if (fileType) {
|
||
return fileType;
|
||
}
|
||
}
|
||
|
||
if (this.checkString('MAC ')) {
|
||
return {
|
||
ext: 'ape',
|
||
mime: 'audio/ape',
|
||
};
|
||
}
|
||
|
||
// https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska
|
||
if (this.check([0x1A, 0x45, 0xDF, 0xA3])) { // Root element: EBML
|
||
async function readField() {
|
||
const msb = await tokenizer.peekNumber(UINT8);
|
||
let mask = 0x80;
|
||
let ic = 0; // 0 = A, 1 = B, 2 = C, 3
|
||
// = D
|
||
|
||
while ((msb & mask) === 0 && mask !== 0) {
|
||
++ic;
|
||
mask >>= 1;
|
||
}
|
||
|
||
const id = node_buffer.Buffer.alloc(ic + 1);
|
||
await tokenizer.readBuffer(id);
|
||
return id;
|
||
}
|
||
|
||
async function readElement() {
|
||
const id = await readField();
|
||
const lengthField = await readField();
|
||
lengthField[0] ^= 0x80 >> (lengthField.length - 1);
|
||
const nrLength = Math.min(6, lengthField.length); // JavaScript can max read 6 bytes integer
|
||
return {
|
||
id: id.readUIntBE(0, id.length),
|
||
len: lengthField.readUIntBE(lengthField.length - nrLength, nrLength),
|
||
};
|
||
}
|
||
|
||
async function readChildren(children) {
|
||
while (children > 0) {
|
||
const element = await readElement();
|
||
if (element.id === 0x42_82) {
|
||
const rawValue = await tokenizer.readToken(new StringType(element.len, 'utf-8'));
|
||
return rawValue.replace(/\00.*$/g, ''); // Return DocType
|
||
}
|
||
|
||
await tokenizer.ignore(element.len); // ignore payload
|
||
--children;
|
||
}
|
||
}
|
||
|
||
const re = await readElement();
|
||
const docType = await readChildren(re.len);
|
||
|
||
switch (docType) {
|
||
case 'webm':
|
||
return {
|
||
ext: 'webm',
|
||
mime: 'video/webm',
|
||
};
|
||
|
||
case 'matroska':
|
||
return {
|
||
ext: 'mkv',
|
||
mime: 'video/x-matroska',
|
||
};
|
||
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
|
||
// RIFF file format which might be AVI, WAV, QCP, etc
|
||
if (this.check([0x52, 0x49, 0x46, 0x46])) {
|
||
if (this.check([0x41, 0x56, 0x49], {offset: 8})) {
|
||
return {
|
||
ext: 'avi',
|
||
mime: 'video/vnd.avi',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {
|
||
return {
|
||
ext: 'wav',
|
||
mime: 'audio/vnd.wave',
|
||
};
|
||
}
|
||
|
||
// QLCM, QCP file
|
||
if (this.check([0x51, 0x4C, 0x43, 0x4D], {offset: 8})) {
|
||
return {
|
||
ext: 'qcp',
|
||
mime: 'audio/qcelp',
|
||
};
|
||
}
|
||
}
|
||
|
||
if (this.checkString('SQLi')) {
|
||
return {
|
||
ext: 'sqlite',
|
||
mime: 'application/x-sqlite3',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x4E, 0x45, 0x53, 0x1A])) {
|
||
return {
|
||
ext: 'nes',
|
||
mime: 'application/x-nintendo-nes-rom',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('Cr24')) {
|
||
return {
|
||
ext: 'crx',
|
||
mime: 'application/x-google-chrome-extension',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.checkString('MSCF')
|
||
|| this.checkString('ISc(')
|
||
) {
|
||
return {
|
||
ext: 'cab',
|
||
mime: 'application/vnd.ms-cab-compressed',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xED, 0xAB, 0xEE, 0xDB])) {
|
||
return {
|
||
ext: 'rpm',
|
||
mime: 'application/x-rpm',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xC5, 0xD0, 0xD3, 0xC6])) {
|
||
return {
|
||
ext: 'eps',
|
||
mime: 'application/eps',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x28, 0xB5, 0x2F, 0xFD])) {
|
||
return {
|
||
ext: 'zst',
|
||
mime: 'application/zstd',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x7F, 0x45, 0x4C, 0x46])) {
|
||
return {
|
||
ext: 'elf',
|
||
mime: 'application/x-elf',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x21, 0x42, 0x44, 0x4E])) {
|
||
return {
|
||
ext: 'pst',
|
||
mime: 'application/vnd.ms-outlook',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('PAR1')) {
|
||
return {
|
||
ext: 'parquet',
|
||
mime: 'application/x-parquet',
|
||
};
|
||
}
|
||
|
||
// -- 5-byte signatures --
|
||
|
||
if (this.check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {
|
||
return {
|
||
ext: 'otf',
|
||
mime: 'font/otf',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('#!AMR')) {
|
||
return {
|
||
ext: 'amr',
|
||
mime: 'audio/amr',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('{\\rtf')) {
|
||
return {
|
||
ext: 'rtf',
|
||
mime: 'application/rtf',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x46, 0x4C, 0x56, 0x01])) {
|
||
return {
|
||
ext: 'flv',
|
||
mime: 'video/x-flv',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('IMPM')) {
|
||
return {
|
||
ext: 'it',
|
||
mime: 'audio/x-it',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.checkString('-lh0-', {offset: 2})
|
||
|| this.checkString('-lh1-', {offset: 2})
|
||
|| this.checkString('-lh2-', {offset: 2})
|
||
|| this.checkString('-lh3-', {offset: 2})
|
||
|| this.checkString('-lh4-', {offset: 2})
|
||
|| this.checkString('-lh5-', {offset: 2})
|
||
|| this.checkString('-lh6-', {offset: 2})
|
||
|| this.checkString('-lh7-', {offset: 2})
|
||
|| this.checkString('-lzs-', {offset: 2})
|
||
|| this.checkString('-lz4-', {offset: 2})
|
||
|| this.checkString('-lz5-', {offset: 2})
|
||
|| this.checkString('-lhd-', {offset: 2})
|
||
) {
|
||
return {
|
||
ext: 'lzh',
|
||
mime: 'application/x-lzh-compressed',
|
||
};
|
||
}
|
||
|
||
// MPEG program stream (PS or MPEG-PS)
|
||
if (this.check([0x00, 0x00, 0x01, 0xBA])) {
|
||
// MPEG-PS, MPEG-1 Part 1
|
||
if (this.check([0x21], {offset: 4, mask: [0xF1]})) {
|
||
return {
|
||
ext: 'mpg', // May also be .ps, .mpeg
|
||
mime: 'video/MP1S',
|
||
};
|
||
}
|
||
|
||
// MPEG-PS, MPEG-2 Part 1
|
||
if (this.check([0x44], {offset: 4, mask: [0xC4]})) {
|
||
return {
|
||
ext: 'mpg', // May also be .mpg, .m2p, .vob or .sub
|
||
mime: 'video/MP2P',
|
||
};
|
||
}
|
||
}
|
||
|
||
if (this.checkString('ITSF')) {
|
||
return {
|
||
ext: 'chm',
|
||
mime: 'application/vnd.ms-htmlhelp',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xCA, 0xFE, 0xBA, 0xBE])) {
|
||
return {
|
||
ext: 'class',
|
||
mime: 'application/java-vm',
|
||
};
|
||
}
|
||
|
||
// -- 6-byte signatures --
|
||
|
||
if (this.check([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00])) {
|
||
return {
|
||
ext: 'xz',
|
||
mime: 'application/x-xz',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('<?xml ')) {
|
||
return {
|
||
ext: 'xml',
|
||
mime: 'application/xml',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])) {
|
||
return {
|
||
ext: '7z',
|
||
mime: 'application/x-7z-compressed',
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7])
|
||
&& (this.buffer[6] === 0x0 || this.buffer[6] === 0x1)
|
||
) {
|
||
return {
|
||
ext: 'rar',
|
||
mime: 'application/x-rar-compressed',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('solid ')) {
|
||
return {
|
||
ext: 'stl',
|
||
mime: 'model/stl',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('AC')) {
|
||
const version = this.buffer.toString('binary', 2, 6);
|
||
if (version.match('^d*') && version >= 1000 && version <= 1050) {
|
||
return {
|
||
ext: 'dwg',
|
||
mime: 'image/vnd.dwg',
|
||
};
|
||
}
|
||
}
|
||
|
||
if (this.checkString('070707')) {
|
||
return {
|
||
ext: 'cpio',
|
||
mime: 'application/x-cpio',
|
||
};
|
||
}
|
||
|
||
// -- 7-byte signatures --
|
||
|
||
if (this.checkString('BLENDER')) {
|
||
return {
|
||
ext: 'blend',
|
||
mime: 'application/x-blender',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('!<arch>')) {
|
||
await tokenizer.ignore(8);
|
||
const string = await tokenizer.readToken(new StringType(13, 'ascii'));
|
||
if (string === 'debian-binary') {
|
||
return {
|
||
ext: 'deb',
|
||
mime: 'application/x-deb',
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'ar',
|
||
mime: 'application/x-unix-archive',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('**ACE', {offset: 7})) {
|
||
await tokenizer.peekBuffer(this.buffer, {length: 14, mayBeLess: true});
|
||
if (this.checkString('**', {offset: 12})) {
|
||
return {
|
||
ext: 'ace',
|
||
mime: 'application/x-ace-compressed',
|
||
};
|
||
}
|
||
}
|
||
|
||
// -- 8-byte signatures --
|
||
|
||
if (this.check([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
||
// APNG format (https://wiki.mozilla.org/APNG_Specification)
|
||
// 1. Find the first IDAT (image data) chunk (49 44 41 54)
|
||
// 2. Check if there is an "acTL" chunk before the IDAT one (61 63 54 4C)
|
||
|
||
// Offset calculated as follows:
|
||
// - 8 bytes: PNG signature
|
||
// - 4 (length) + 4 (chunk type) + 13 (chunk data) + 4 (CRC): IHDR chunk
|
||
|
||
await tokenizer.ignore(8); // ignore PNG signature
|
||
|
||
async function readChunkHeader() {
|
||
return {
|
||
length: await tokenizer.readToken(INT32_BE),
|
||
type: await tokenizer.readToken(new StringType(4, 'binary')),
|
||
};
|
||
}
|
||
|
||
do {
|
||
const chunk = await readChunkHeader();
|
||
if (chunk.length < 0) {
|
||
return; // Invalid chunk length
|
||
}
|
||
|
||
switch (chunk.type) {
|
||
case 'IDAT':
|
||
return {
|
||
ext: 'png',
|
||
mime: 'image/png',
|
||
};
|
||
case 'acTL':
|
||
return {
|
||
ext: 'apng',
|
||
mime: 'image/apng',
|
||
};
|
||
default:
|
||
await tokenizer.ignore(chunk.length + 4); // Ignore chunk-data + CRC
|
||
}
|
||
} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
|
||
|
||
return {
|
||
ext: 'png',
|
||
mime: 'image/png',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'arrow',
|
||
mime: 'application/x-apache-arrow',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x67, 0x6C, 0x54, 0x46, 0x02, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'glb',
|
||
mime: 'model/gltf-binary',
|
||
};
|
||
}
|
||
|
||
// `mov` format variants
|
||
if (
|
||
this.check([0x66, 0x72, 0x65, 0x65], {offset: 4}) // `free`
|
||
|| this.check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) // `mdat` MJPEG
|
||
|| this.check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) // `moov`
|
||
|| this.check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`
|
||
) {
|
||
return {
|
||
ext: 'mov',
|
||
mime: 'video/quicktime',
|
||
};
|
||
}
|
||
|
||
// -- 9-byte signatures --
|
||
|
||
if (this.check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {
|
||
return {
|
||
ext: 'orf',
|
||
mime: 'image/x-olympus-orf',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('gimp xcf ')) {
|
||
return {
|
||
ext: 'xcf',
|
||
mime: 'image/x-xcf',
|
||
};
|
||
}
|
||
|
||
// -- 12-byte signatures --
|
||
|
||
if (this.check([0x49, 0x49, 0x55, 0x00, 0x18, 0x00, 0x00, 0x00, 0x88, 0xE7, 0x74, 0xD8])) {
|
||
return {
|
||
ext: 'rw2',
|
||
mime: 'image/x-panasonic-rw2',
|
||
};
|
||
}
|
||
|
||
// ASF_Header_Object first 80 bytes
|
||
if (this.check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {
|
||
async function readHeader() {
|
||
const guid = node_buffer.Buffer.alloc(16);
|
||
await tokenizer.readBuffer(guid);
|
||
return {
|
||
id: guid,
|
||
size: Number(await tokenizer.readToken(UINT64_LE)),
|
||
};
|
||
}
|
||
|
||
await tokenizer.ignore(30);
|
||
// Search for header should be in first 1KB of file.
|
||
while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
|
||
const header = await readHeader();
|
||
let payload = header.size - 24;
|
||
if (_check(header.id, [0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65])) {
|
||
// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
|
||
const typeId = node_buffer.Buffer.alloc(16);
|
||
payload -= await tokenizer.readBuffer(typeId);
|
||
|
||
if (_check(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
||
// Found audio:
|
||
return {
|
||
ext: 'asf',
|
||
mime: 'audio/x-ms-asf',
|
||
};
|
||
}
|
||
|
||
if (_check(typeId, [0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
||
// Found video:
|
||
return {
|
||
ext: 'asf',
|
||
mime: 'video/x-ms-asf',
|
||
};
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
await tokenizer.ignore(payload);
|
||
}
|
||
|
||
// Default to ASF generic extension
|
||
return {
|
||
ext: 'asf',
|
||
mime: 'application/vnd.ms-asf',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
||
return {
|
||
ext: 'ktx',
|
||
mime: 'image/ktx',
|
||
};
|
||
}
|
||
|
||
if ((this.check([0x7E, 0x10, 0x04]) || this.check([0x7E, 0x18, 0x04])) && this.check([0x30, 0x4D, 0x49, 0x45], {offset: 4})) {
|
||
return {
|
||
ext: 'mie',
|
||
mime: 'application/x-mie',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], {offset: 2})) {
|
||
return {
|
||
ext: 'shp',
|
||
mime: 'application/x-esri-shape',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xFF, 0x4F, 0xFF, 0x51])) {
|
||
return {
|
||
ext: 'j2c',
|
||
mime: 'image/j2c',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A])) {
|
||
// JPEG-2000 family
|
||
|
||
await tokenizer.ignore(20);
|
||
const type = await tokenizer.readToken(new StringType(4, 'ascii'));
|
||
switch (type) {
|
||
case 'jp2 ':
|
||
return {
|
||
ext: 'jp2',
|
||
mime: 'image/jp2',
|
||
};
|
||
case 'jpx ':
|
||
return {
|
||
ext: 'jpx',
|
||
mime: 'image/jpx',
|
||
};
|
||
case 'jpm ':
|
||
return {
|
||
ext: 'jpm',
|
||
mime: 'image/jpm',
|
||
};
|
||
case 'mjp2':
|
||
return {
|
||
ext: 'mj2',
|
||
mime: 'image/mj2',
|
||
};
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (
|
||
this.check([0xFF, 0x0A])
|
||
|| this.check([0x00, 0x00, 0x00, 0x0C, 0x4A, 0x58, 0x4C, 0x20, 0x0D, 0x0A, 0x87, 0x0A])
|
||
) {
|
||
return {
|
||
ext: 'jxl',
|
||
mime: 'image/jxl',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xFE, 0xFF])) { // UTF-16-BOM-LE
|
||
if (this.check([0, 60, 0, 63, 0, 120, 0, 109, 0, 108], {offset: 2})) {
|
||
return {
|
||
ext: 'xml',
|
||
mime: 'application/xml',
|
||
};
|
||
}
|
||
|
||
return undefined; // Some unknown text based format
|
||
}
|
||
|
||
// -- Unsafe signatures --
|
||
|
||
if (
|
||
this.check([0x0, 0x0, 0x1, 0xBA])
|
||
|| this.check([0x0, 0x0, 0x1, 0xB3])
|
||
) {
|
||
return {
|
||
ext: 'mpg',
|
||
mime: 'video/mpeg',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x00, 0x01, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'ttf',
|
||
mime: 'font/ttf',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x00, 0x00, 0x01, 0x00])) {
|
||
return {
|
||
ext: 'ico',
|
||
mime: 'image/x-icon',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x00, 0x00, 0x02, 0x00])) {
|
||
return {
|
||
ext: 'cur',
|
||
mime: 'image/x-icon',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1])) {
|
||
// Detected Microsoft Compound File Binary File (MS-CFB) Format.
|
||
return {
|
||
ext: 'cfb',
|
||
mime: 'application/x-cfb',
|
||
};
|
||
}
|
||
|
||
// Increase sample size from 12 to 256.
|
||
await tokenizer.peekBuffer(this.buffer, {length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true});
|
||
|
||
// -- 15-byte signatures --
|
||
|
||
if (this.checkString('BEGIN:')) {
|
||
if (this.checkString('VCARD', {offset: 6})) {
|
||
return {
|
||
ext: 'vcf',
|
||
mime: 'text/vcard',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('VCALENDAR', {offset: 6})) {
|
||
return {
|
||
ext: 'ics',
|
||
mime: 'text/calendar',
|
||
};
|
||
}
|
||
}
|
||
|
||
// `raf` is here just to keep all the raw image detectors together.
|
||
if (this.checkString('FUJIFILMCCD-RAW')) {
|
||
return {
|
||
ext: 'raf',
|
||
mime: 'image/x-fujifilm-raf',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('Extended Module:')) {
|
||
return {
|
||
ext: 'xm',
|
||
mime: 'audio/x-xm',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('Creative Voice File')) {
|
||
return {
|
||
ext: 'voc',
|
||
mime: 'audio/x-voc',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x04, 0x00, 0x00, 0x00]) && this.buffer.length >= 16) { // Rough & quick check Pickle/ASAR
|
||
const jsonSize = this.buffer.readUInt32LE(12);
|
||
if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
|
||
try {
|
||
const header = this.buffer.slice(16, jsonSize + 16).toString();
|
||
const json = JSON.parse(header);
|
||
// Check if Pickle is ASAR
|
||
if (json.files) { // Final check, assuring Pickle/ASAR format
|
||
return {
|
||
ext: 'asar',
|
||
mime: 'application/x-asar',
|
||
};
|
||
}
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
if (this.check([0x06, 0x0E, 0x2B, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0D, 0x01, 0x02, 0x01, 0x01, 0x02])) {
|
||
return {
|
||
ext: 'mxf',
|
||
mime: 'application/mxf',
|
||
};
|
||
}
|
||
|
||
if (this.checkString('SCRM', {offset: 44})) {
|
||
return {
|
||
ext: 's3m',
|
||
mime: 'audio/x-s3m',
|
||
};
|
||
}
|
||
|
||
// Raw MPEG-2 transport stream (188-byte packets)
|
||
if (this.check([0x47]) && this.check([0x47], {offset: 188})) {
|
||
return {
|
||
ext: 'mts',
|
||
mime: 'video/mp2t',
|
||
};
|
||
}
|
||
|
||
// Blu-ray Disc Audio-Video (BDAV) MPEG-2 transport stream has 4-byte TP_extra_header before each 188-byte packet
|
||
if (this.check([0x47], {offset: 4}) && this.check([0x47], {offset: 196})) {
|
||
return {
|
||
ext: 'mts',
|
||
mime: 'video/mp2t',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x42, 0x4F, 0x4F, 0x4B, 0x4D, 0x4F, 0x42, 0x49], {offset: 60})) {
|
||
return {
|
||
ext: 'mobi',
|
||
mime: 'application/x-mobipocket-ebook',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x44, 0x49, 0x43, 0x4D], {offset: 128})) {
|
||
return {
|
||
ext: 'dcm',
|
||
mime: 'application/dicom',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {
|
||
return {
|
||
ext: 'lnk',
|
||
mime: 'application/x.ms.shortcut', // Invented by us
|
||
};
|
||
}
|
||
|
||
if (this.check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'alias',
|
||
mime: 'application/x.apple.alias', // Invented by us
|
||
};
|
||
}
|
||
|
||
if (
|
||
this.check([0x4C, 0x50], {offset: 34})
|
||
&& (
|
||
this.check([0x00, 0x00, 0x01], {offset: 8})
|
||
|| this.check([0x01, 0x00, 0x02], {offset: 8})
|
||
|| this.check([0x02, 0x00, 0x02], {offset: 8})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'eot',
|
||
mime: 'application/vnd.ms-fontobject',
|
||
};
|
||
}
|
||
|
||
if (this.check([0x06, 0x06, 0xED, 0xF5, 0xD8, 0x1D, 0x46, 0xE5, 0xBD, 0x31, 0xEF, 0xE7, 0xFE, 0x74, 0xB7, 0x1D])) {
|
||
return {
|
||
ext: 'indd',
|
||
mime: 'application/x-indesign',
|
||
};
|
||
}
|
||
|
||
// Increase sample size from 256 to 512
|
||
await tokenizer.peekBuffer(this.buffer, {length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true});
|
||
|
||
// Requires a buffer size of 512 bytes
|
||
if (tarHeaderChecksumMatches(this.buffer)) {
|
||
return {
|
||
ext: 'tar',
|
||
mime: 'application/x-tar',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xFF, 0xFE])) { // UTF-16-BOM-BE
|
||
if (this.check([60, 0, 63, 0, 120, 0, 109, 0, 108, 0], {offset: 2})) {
|
||
return {
|
||
ext: 'xml',
|
||
mime: 'application/xml',
|
||
};
|
||
}
|
||
|
||
if (this.check([0xFF, 0x0E, 0x53, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x55, 0x00, 0x70, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00], {offset: 2})) {
|
||
return {
|
||
ext: 'skp',
|
||
mime: 'application/vnd.sketchup.skp',
|
||
};
|
||
}
|
||
|
||
return undefined; // Some text based format
|
||
}
|
||
|
||
if (this.checkString('-----BEGIN PGP MESSAGE-----')) {
|
||
return {
|
||
ext: 'pgp',
|
||
mime: 'application/pgp-encrypted',
|
||
};
|
||
}
|
||
|
||
// Check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE)
|
||
if (this.buffer.length >= 2 && this.check([0xFF, 0xE0], {offset: 0, mask: [0xFF, 0xE0]})) {
|
||
if (this.check([0x10], {offset: 1, mask: [0x16]})) {
|
||
// Check for (ADTS) MPEG-2
|
||
if (this.check([0x08], {offset: 1, mask: [0x08]})) {
|
||
return {
|
||
ext: 'aac',
|
||
mime: 'audio/aac',
|
||
};
|
||
}
|
||
|
||
// Must be (ADTS) MPEG-4
|
||
return {
|
||
ext: 'aac',
|
||
mime: 'audio/aac',
|
||
};
|
||
}
|
||
|
||
// MPEG 1 or 2 Layer 3 header
|
||
// Check for MPEG layer 3
|
||
if (this.check([0x02], {offset: 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp3',
|
||
mime: 'audio/mpeg',
|
||
};
|
||
}
|
||
|
||
// Check for MPEG layer 2
|
||
if (this.check([0x04], {offset: 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp2',
|
||
mime: 'audio/mpeg',
|
||
};
|
||
}
|
||
|
||
// Check for MPEG layer 1
|
||
if (this.check([0x06], {offset: 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp1',
|
||
mime: 'audio/mpeg',
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
async readTiffTag(bigEndian) {
|
||
const tagId = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
|
||
this.tokenizer.ignore(10);
|
||
switch (tagId) {
|
||
case 50_341:
|
||
return {
|
||
ext: 'arw',
|
||
mime: 'image/x-sony-arw',
|
||
};
|
||
case 50_706:
|
||
return {
|
||
ext: 'dng',
|
||
mime: 'image/x-adobe-dng',
|
||
};
|
||
}
|
||
}
|
||
|
||
async readTiffIFD(bigEndian) {
|
||
const numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
|
||
for (let n = 0; n < numberOfTags; ++n) {
|
||
const fileType = await this.readTiffTag(bigEndian);
|
||
if (fileType) {
|
||
return fileType;
|
||
}
|
||
}
|
||
}
|
||
|
||
async readTiffHeader(bigEndian) {
|
||
const version = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
|
||
const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
|
||
|
||
if (version === 42) {
|
||
// TIFF file header
|
||
if (ifdOffset >= 6) {
|
||
if (this.checkString('CR', {offset: 8})) {
|
||
return {
|
||
ext: 'cr2',
|
||
mime: 'image/x-canon-cr2',
|
||
};
|
||
}
|
||
|
||
if (ifdOffset >= 8 && (this.check([0x1C, 0x00, 0xFE, 0x00], {offset: 8}) || this.check([0x1F, 0x00, 0x0B, 0x00], {offset: 8}))) {
|
||
return {
|
||
ext: 'nef',
|
||
mime: 'image/x-nikon-nef',
|
||
};
|
||
}
|
||
}
|
||
|
||
await this.tokenizer.ignore(ifdOffset);
|
||
const fileType = await this.readTiffIFD(bigEndian);
|
||
return fileType ?? {
|
||
ext: 'tif',
|
||
mime: 'image/tiff',
|
||
};
|
||
}
|
||
|
||
if (version === 43) { // Big TIFF file header
|
||
return {
|
||
ext: 'tif',
|
||
mime: 'image/tiff',
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
new Set(extensions);
|
||
new Set(mimeTypes);
|
||
|
||
const imageExtensions = new Set([
|
||
'jpg',
|
||
'png',
|
||
'gif',
|
||
'webp',
|
||
'flif',
|
||
'cr2',
|
||
'tif',
|
||
'bmp',
|
||
'jxr',
|
||
'psd',
|
||
'ico',
|
||
'bpg',
|
||
'jp2',
|
||
'jpm',
|
||
'jpx',
|
||
'heic',
|
||
'cur',
|
||
'dcm',
|
||
'avif',
|
||
]);
|
||
|
||
async function imageType(input) {
|
||
const result = await fileTypeFromBuffer(input);
|
||
return imageExtensions.has(result?.ext) && result;
|
||
}
|
||
|
||
var IMAGE_EXT_LIST = [
|
||
".png",
|
||
".jpg",
|
||
".jpeg",
|
||
".bmp",
|
||
".gif",
|
||
".svg",
|
||
".tiff",
|
||
".webp",
|
||
".avif",
|
||
];
|
||
function isAnImage(ext) {
|
||
return IMAGE_EXT_LIST.includes(ext.toLowerCase());
|
||
}
|
||
function isAssetTypeAnImage(path) {
|
||
return isAnImage(require$$0$1.extname(path));
|
||
}
|
||
function getOS() {
|
||
var appVersion = navigator.appVersion;
|
||
if (appVersion.indexOf("Win") !== -1) {
|
||
return "Windows";
|
||
}
|
||
else if (appVersion.indexOf("Mac") !== -1) {
|
||
return "MacOS";
|
||
}
|
||
else if (appVersion.indexOf("X11") !== -1) {
|
||
return "Linux";
|
||
}
|
||
else {
|
||
return "Unknown OS";
|
||
}
|
||
}
|
||
function streamToString(stream) {
|
||
var _a, stream_1, stream_1_1;
|
||
var _b, e_1, _c, _d;
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var chunks, chunk, e_1_1;
|
||
return __generator(this, function (_e) {
|
||
switch (_e.label) {
|
||
case 0:
|
||
chunks = [];
|
||
_e.label = 1;
|
||
case 1:
|
||
_e.trys.push([1, 6, 7, 12]);
|
||
_a = true, stream_1 = __asyncValues(stream);
|
||
_e.label = 2;
|
||
case 2: return [4 /*yield*/, stream_1.next()];
|
||
case 3:
|
||
if (!(stream_1_1 = _e.sent(), _b = stream_1_1.done, !_b)) return [3 /*break*/, 5];
|
||
_d = stream_1_1.value;
|
||
_a = false;
|
||
try {
|
||
chunk = _d;
|
||
chunks.push(Buffer.from(chunk));
|
||
}
|
||
finally {
|
||
_a = true;
|
||
}
|
||
_e.label = 4;
|
||
case 4: return [3 /*break*/, 2];
|
||
case 5: return [3 /*break*/, 12];
|
||
case 6:
|
||
e_1_1 = _e.sent();
|
||
e_1 = { error: e_1_1 };
|
||
return [3 /*break*/, 12];
|
||
case 7:
|
||
_e.trys.push([7, , 10, 11]);
|
||
if (!(!_a && !_b && (_c = stream_1.return))) return [3 /*break*/, 9];
|
||
return [4 /*yield*/, _c.call(stream_1)];
|
||
case 8:
|
||
_e.sent();
|
||
_e.label = 9;
|
||
case 9: return [3 /*break*/, 11];
|
||
case 10:
|
||
if (e_1) throw e_1.error;
|
||
return [7 /*endfinally*/];
|
||
case 11: return [7 /*endfinally*/];
|
||
case 12: return [2 /*return*/, Buffer.concat(chunks).toString("utf-8")];
|
||
}
|
||
});
|
||
});
|
||
}
|
||
function getUrlAsset(url) {
|
||
return (url = url.substr(1 + url.lastIndexOf("/")).split("?")[0]).split("#")[0];
|
||
}
|
||
function getLastImage(list) {
|
||
var reversedList = list.reverse();
|
||
var lastImage;
|
||
reversedList.forEach(function (item) {
|
||
if (item && item.startsWith("http")) {
|
||
lastImage = item;
|
||
return item;
|
||
}
|
||
});
|
||
return lastImage;
|
||
}
|
||
function arrayToObject(arr, key) {
|
||
var obj = {};
|
||
arr.forEach(function (element) {
|
||
obj[element[key]] = element;
|
||
});
|
||
return obj;
|
||
}
|
||
|
||
var PicGoUploader = /** @class */ (function () {
|
||
function PicGoUploader(settings, plugin) {
|
||
this.settings = settings;
|
||
this.plugin = plugin;
|
||
}
|
||
PicGoUploader.prototype.uploadFiles = function (fileList) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response, data, uploadUrlFullResultList;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, obsidian.requestUrl({
|
||
url: this.settings.uploadServer,
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ list: fileList }),
|
||
})];
|
||
case 1:
|
||
response = _a.sent();
|
||
return [4 /*yield*/, response.json];
|
||
case 2:
|
||
data = _a.sent();
|
||
// piclist
|
||
if (data.fullResult) {
|
||
uploadUrlFullResultList = data.fullResult || [];
|
||
this.settings.uploadedImages = __spreadArray(__spreadArray([], __read((this.settings.uploadedImages || [])), false), __read(uploadUrlFullResultList), false);
|
||
}
|
||
return [2 /*return*/, data];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
PicGoUploader.prototype.uploadFileByClipboard = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var res, data, uploadUrlFullResultList;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, obsidian.requestUrl({
|
||
url: this.settings.uploadServer,
|
||
method: "POST",
|
||
})];
|
||
case 1:
|
||
res = _a.sent();
|
||
return [4 /*yield*/, res.json];
|
||
case 2:
|
||
data = _a.sent();
|
||
// piclist
|
||
if (data.fullResult) {
|
||
uploadUrlFullResultList = data.fullResult || [];
|
||
this.settings.uploadedImages = __spreadArray(__spreadArray([], __read((this.settings.uploadedImages || [])), false), __read(uploadUrlFullResultList), false);
|
||
this.plugin.saveSettings();
|
||
}
|
||
if (res.status !== 200) {
|
||
({ response: data, body: data.msg });
|
||
return [2 /*return*/, {
|
||
code: -1,
|
||
msg: data.msg,
|
||
data: "",
|
||
}];
|
||
}
|
||
else {
|
||
return [2 /*return*/, {
|
||
code: 0,
|
||
msg: "success",
|
||
data: typeof data.result == "string" ? data.result : data.result[0],
|
||
}];
|
||
}
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return PicGoUploader;
|
||
}());
|
||
var PicGoCoreUploader = /** @class */ (function () {
|
||
function PicGoCoreUploader(settings, plugin) {
|
||
this.settings = settings;
|
||
this.plugin = plugin;
|
||
}
|
||
PicGoCoreUploader.prototype.uploadFiles = function (fileList) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var length, cli, command, res, splitList, splitListLength, data;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
length = fileList.length;
|
||
cli = this.settings.picgoCorePath || "picgo";
|
||
command = "".concat(cli, " upload ").concat(fileList
|
||
.map(function (item) { return "\"".concat(item, "\""); })
|
||
.join(" "));
|
||
return [4 /*yield*/, this.exec(command)];
|
||
case 1:
|
||
res = _a.sent();
|
||
splitList = res.split("\n");
|
||
splitListLength = splitList.length;
|
||
data = splitList.splice(splitListLength - 1 - length, length);
|
||
if (res.includes("PicGo ERROR")) {
|
||
console.log(command, res);
|
||
return [2 /*return*/, {
|
||
success: false,
|
||
msg: "失败",
|
||
}];
|
||
}
|
||
else {
|
||
return [2 /*return*/, {
|
||
success: true,
|
||
result: data,
|
||
}];
|
||
}
|
||
}
|
||
});
|
||
});
|
||
};
|
||
// PicGo-Core 上传处理
|
||
PicGoCoreUploader.prototype.uploadFileByClipboard = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var res, splitList, lastImage;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.uploadByClip()];
|
||
case 1:
|
||
res = _a.sent();
|
||
splitList = res.split("\n");
|
||
lastImage = getLastImage(splitList);
|
||
if (lastImage) {
|
||
return [2 /*return*/, {
|
||
code: 0,
|
||
msg: "success",
|
||
data: lastImage,
|
||
}];
|
||
}
|
||
else {
|
||
console.log(splitList);
|
||
// new Notice(`"Please check PicGo-Core config"\n${res}`);
|
||
return [2 /*return*/, {
|
||
code: -1,
|
||
msg: "\"Please check PicGo-Core config\"\n".concat(res),
|
||
data: "",
|
||
}];
|
||
}
|
||
}
|
||
});
|
||
});
|
||
};
|
||
// PicGo-Core的剪切上传反馈
|
||
PicGoCoreUploader.prototype.uploadByClip = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var command, res;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
if (this.settings.picgoCorePath) {
|
||
command = "".concat(this.settings.picgoCorePath, " upload");
|
||
}
|
||
else {
|
||
command = "picgo upload";
|
||
}
|
||
return [4 /*yield*/, this.exec(command)];
|
||
case 1:
|
||
res = _a.sent();
|
||
// const res = await this.spawnChild();
|
||
return [2 /*return*/, res];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
PicGoCoreUploader.prototype.exec = function (command) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var stdout, res;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, require$$0$2.exec(command)];
|
||
case 1:
|
||
stdout = (_a.sent()).stdout;
|
||
return [4 /*yield*/, streamToString(stdout)];
|
||
case 2:
|
||
res = _a.sent();
|
||
return [2 /*return*/, res];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
PicGoCoreUploader.prototype.spawnChild = function () {
|
||
var _a, e_1, _b, _c, _d, e_2, _e, _f;
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var spawn, child, data, _g, _h, _j, chunk, e_1_1, error, _k, _l, _m, chunk, e_2_1, exitCode;
|
||
return __generator(this, function (_o) {
|
||
switch (_o.label) {
|
||
case 0:
|
||
spawn = require("child_process").spawn;
|
||
child = spawn("picgo", ["upload"], {
|
||
shell: true,
|
||
});
|
||
data = "";
|
||
_o.label = 1;
|
||
case 1:
|
||
_o.trys.push([1, 6, 7, 12]);
|
||
_g = true, _h = __asyncValues(child.stdout);
|
||
_o.label = 2;
|
||
case 2: return [4 /*yield*/, _h.next()];
|
||
case 3:
|
||
if (!(_j = _o.sent(), _a = _j.done, !_a)) return [3 /*break*/, 5];
|
||
_c = _j.value;
|
||
_g = false;
|
||
try {
|
||
chunk = _c;
|
||
data += chunk;
|
||
}
|
||
finally {
|
||
_g = true;
|
||
}
|
||
_o.label = 4;
|
||
case 4: return [3 /*break*/, 2];
|
||
case 5: return [3 /*break*/, 12];
|
||
case 6:
|
||
e_1_1 = _o.sent();
|
||
e_1 = { error: e_1_1 };
|
||
return [3 /*break*/, 12];
|
||
case 7:
|
||
_o.trys.push([7, , 10, 11]);
|
||
if (!(!_g && !_a && (_b = _h.return))) return [3 /*break*/, 9];
|
||
return [4 /*yield*/, _b.call(_h)];
|
||
case 8:
|
||
_o.sent();
|
||
_o.label = 9;
|
||
case 9: return [3 /*break*/, 11];
|
||
case 10:
|
||
if (e_1) throw e_1.error;
|
||
return [7 /*endfinally*/];
|
||
case 11: return [7 /*endfinally*/];
|
||
case 12:
|
||
error = "";
|
||
_o.label = 13;
|
||
case 13:
|
||
_o.trys.push([13, 18, 19, 24]);
|
||
_k = true, _l = __asyncValues(child.stderr);
|
||
_o.label = 14;
|
||
case 14: return [4 /*yield*/, _l.next()];
|
||
case 15:
|
||
if (!(_m = _o.sent(), _d = _m.done, !_d)) return [3 /*break*/, 17];
|
||
_f = _m.value;
|
||
_k = false;
|
||
try {
|
||
chunk = _f;
|
||
error += chunk;
|
||
}
|
||
finally {
|
||
_k = true;
|
||
}
|
||
_o.label = 16;
|
||
case 16: return [3 /*break*/, 14];
|
||
case 17: return [3 /*break*/, 24];
|
||
case 18:
|
||
e_2_1 = _o.sent();
|
||
e_2 = { error: e_2_1 };
|
||
return [3 /*break*/, 24];
|
||
case 19:
|
||
_o.trys.push([19, , 22, 23]);
|
||
if (!(!_k && !_d && (_e = _l.return))) return [3 /*break*/, 21];
|
||
return [4 /*yield*/, _e.call(_l)];
|
||
case 20:
|
||
_o.sent();
|
||
_o.label = 21;
|
||
case 21: return [3 /*break*/, 23];
|
||
case 22:
|
||
if (e_2) throw e_2.error;
|
||
return [7 /*endfinally*/];
|
||
case 23: return [7 /*endfinally*/];
|
||
case 24: return [4 /*yield*/, new Promise(function (resolve, reject) {
|
||
child.on("close", resolve);
|
||
})];
|
||
case 25:
|
||
exitCode = _o.sent();
|
||
if (exitCode) {
|
||
throw new Error("subprocess error exit ".concat(exitCode, ", ").concat(error));
|
||
}
|
||
return [2 /*return*/, data];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return PicGoCoreUploader;
|
||
}());
|
||
|
||
var PicGoDeleter = /** @class */ (function () {
|
||
function PicGoDeleter(plugin) {
|
||
this.plugin = plugin;
|
||
}
|
||
PicGoDeleter.prototype.deleteImage = function (configMap) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response, data;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, obsidian.requestUrl({
|
||
url: this.plugin.settings.deleteServer,
|
||
method: "POST",
|
||
headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({
|
||
list: configMap,
|
||
}),
|
||
})];
|
||
case 1:
|
||
response = _a.sent();
|
||
data = response.json;
|
||
return [2 /*return*/, data];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return PicGoDeleter;
|
||
}());
|
||
|
||
//  local image should has ext
|
||
//  internet image should not has ext
|
||
var REGEX_FILE = /\!\[(.*?)\]\((\S+\.\w+)\)|\!\[(.*?)\]\((https?:\/\/.*?)\)/g;
|
||
var REGEX_WIKI_FILE = /\!\[\[(.*?)(\s*?\|.*?)?\]\]/g;
|
||
var Helper = /** @class */ (function () {
|
||
function Helper(app) {
|
||
this.app = app;
|
||
}
|
||
Helper.prototype.getFrontmatterValue = function (key, defaultValue) {
|
||
if (defaultValue === void 0) { defaultValue = undefined; }
|
||
var file = this.app.workspace.getActiveFile();
|
||
if (!file) {
|
||
return undefined;
|
||
}
|
||
var path = file.path;
|
||
var cache = this.app.metadataCache.getCache(path);
|
||
var value = defaultValue;
|
||
if ((cache === null || cache === void 0 ? void 0 : cache.frontmatter) && cache.frontmatter.hasOwnProperty(key)) {
|
||
value = cache.frontmatter[key];
|
||
}
|
||
return value;
|
||
};
|
||
Helper.prototype.getEditor = function () {
|
||
var mdView = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);
|
||
if (mdView) {
|
||
return mdView.editor;
|
||
}
|
||
else {
|
||
return null;
|
||
}
|
||
};
|
||
Helper.prototype.getValue = function () {
|
||
var editor = this.getEditor();
|
||
return editor.getValue();
|
||
};
|
||
Helper.prototype.setValue = function (value) {
|
||
var editor = this.getEditor();
|
||
var _a = editor.getScrollInfo(), left = _a.left, top = _a.top;
|
||
var position = editor.getCursor();
|
||
editor.setValue(value);
|
||
editor.scrollTo(left, top);
|
||
editor.setCursor(position);
|
||
};
|
||
// get all file urls, include local and internet
|
||
Helper.prototype.getAllFiles = function () {
|
||
var editor = this.getEditor();
|
||
var value = editor.getValue();
|
||
return this.getImageLink(value);
|
||
};
|
||
Helper.prototype.getImageLink = function (value) {
|
||
var e_1, _a, e_2, _b;
|
||
var matches = value.matchAll(REGEX_FILE);
|
||
var WikiMatches = value.matchAll(REGEX_WIKI_FILE);
|
||
var fileArray = [];
|
||
try {
|
||
for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
|
||
var match = matches_1_1.value;
|
||
var source = match[0];
|
||
var name_1 = match[1];
|
||
var path = match[2];
|
||
if (name_1 === undefined) {
|
||
name_1 = match[3];
|
||
}
|
||
if (path === undefined) {
|
||
path = match[4];
|
||
}
|
||
fileArray.push({
|
||
path: path,
|
||
name: name_1,
|
||
source: source,
|
||
});
|
||
}
|
||
}
|
||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
finally {
|
||
try {
|
||
if (matches_1_1 && !matches_1_1.done && (_a = matches_1.return)) _a.call(matches_1);
|
||
}
|
||
finally { if (e_1) throw e_1.error; }
|
||
}
|
||
try {
|
||
for (var WikiMatches_1 = __values(WikiMatches), WikiMatches_1_1 = WikiMatches_1.next(); !WikiMatches_1_1.done; WikiMatches_1_1 = WikiMatches_1.next()) {
|
||
var match = WikiMatches_1_1.value;
|
||
console.log(match);
|
||
var name_2 = require$$0$1.parse(match[1]).name;
|
||
var path = match[1];
|
||
var source = match[0];
|
||
if (match[2]) {
|
||
name_2 = "".concat(name_2).concat(match[2]);
|
||
}
|
||
fileArray.push({
|
||
path: path,
|
||
name: name_2,
|
||
source: source,
|
||
});
|
||
}
|
||
}
|
||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||
finally {
|
||
try {
|
||
if (WikiMatches_1_1 && !WikiMatches_1_1.done && (_b = WikiMatches_1.return)) _b.call(WikiMatches_1);
|
||
}
|
||
finally { if (e_2) throw e_2.error; }
|
||
}
|
||
console.log(fileArray);
|
||
return fileArray;
|
||
};
|
||
Helper.prototype.hasBlackDomain = function (src, blackDomains) {
|
||
if (blackDomains.trim() === "") {
|
||
return false;
|
||
}
|
||
var blackDomainList = blackDomains.split(",").filter(function (item) { return item !== ""; });
|
||
var url = new URL(src);
|
||
var domain = url.hostname;
|
||
return blackDomainList.some(function (blackDomain) { return domain.includes(blackDomain); });
|
||
};
|
||
return Helper;
|
||
}());
|
||
|
||
// العربية
|
||
var ar = {};
|
||
|
||
// čeština
|
||
var cz = {};
|
||
|
||
// Dansk
|
||
var da = {};
|
||
|
||
// Deutsch
|
||
var de = {};
|
||
|
||
// English
|
||
var en = {
|
||
// setting.ts
|
||
"Plugin Settings": "Plugin Settings",
|
||
"Auto pasted upload": "Auto pasted upload",
|
||
"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)": "If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)",
|
||
"Default uploader": "Default uploader",
|
||
"PicGo server": "PicGo server",
|
||
"Please input PicGo server": "Please input PicGo server",
|
||
"PicGo delete server": "PicGo server delete route(you need to use PicList app)",
|
||
"PicList desc": "Search PicList on Github to download and install",
|
||
"Please input PicGo delete server": "Please input PicGo delete server",
|
||
"Delete image using PicList": "Delete image using PicList",
|
||
"PicGo-Core path": "PicGo-Core path",
|
||
"Delete successfully": "Delete successfully",
|
||
"Delete failed": "Delete failed",
|
||
"Image size suffix": "Image size suffix",
|
||
"Image size suffix Description": "like |300 for resize image in ob.",
|
||
"Please input image size suffix": "Please input image size suffix",
|
||
"Error, could not delete": "Error, could not delete",
|
||
"Please input PicGo-Core path, default using environment variables": "Please input PicGo-Core path, default using environment variables",
|
||
"Work on network": "Work on network",
|
||
"Work on network Description": "Allow upload network image by 'Upload all' command.\n Or when you paste, md standard image link in your clipboard will be auto upload.",
|
||
fixPath: "fixPath",
|
||
fixPathWarning: "This option is used to fix PicGo-core upload failures on Linux and Mac. It modifies the PATH variable within Obsidian. If Obsidian encounters any bugs, turn off the option, try again! ",
|
||
"Upload when clipboard has image and text together": "Upload when clipboard has image and text together",
|
||
"When you copy, some application like Excel will image and text to clipboard, you can upload or not.": "When you copy, some application like Excel will image and text to clipboard, you can upload or not.",
|
||
"Network Domain Black List": "Network Domain Black List",
|
||
"Network Domain Black List Description": "Image in the domain list will not be upload,use comma separated",
|
||
"Delete source file after you upload file": "Delete source file after you upload file",
|
||
"Delete source file in ob assets after you upload file.": "Delete source file in ob assets after you upload file.",
|
||
"Image desc": "Image desc",
|
||
reserve: "default",
|
||
"remove all": "none",
|
||
"remove default": "remove image.png",
|
||
};
|
||
|
||
// British English
|
||
var enGB = {};
|
||
|
||
// Español
|
||
var es = {};
|
||
|
||
// français
|
||
var fr = {};
|
||
|
||
// हिन्दी
|
||
var hi = {};
|
||
|
||
// Bahasa Indonesia
|
||
var id = {};
|
||
|
||
// Italiano
|
||
var it = {};
|
||
|
||
// 日本語
|
||
var ja = {};
|
||
|
||
// 한국어
|
||
var ko = {};
|
||
|
||
// Nederlands
|
||
var nl = {};
|
||
|
||
// Norsk
|
||
var no = {};
|
||
|
||
// język polski
|
||
var pl = {};
|
||
|
||
// Português
|
||
var pt = {};
|
||
|
||
// Português do Brasil
|
||
// Brazilian Portuguese
|
||
var ptBR = {};
|
||
|
||
// Română
|
||
var ro = {};
|
||
|
||
// русский
|
||
var ru = {};
|
||
|
||
// Türkçe
|
||
var tr = {};
|
||
|
||
// 简体中文
|
||
var zhCN = {
|
||
// setting.ts
|
||
"Plugin Settings": "插件设置",
|
||
"Auto pasted upload": "剪切板自动上传",
|
||
"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)": "启用该选项后，黏贴图片时会自动上传（你需要正确配置picgo）",
|
||
"Default uploader": "默认上传器",
|
||
"PicGo server": "PicGo server",
|
||
"Please input PicGo server": "请输入 PicGo server",
|
||
"PicGo delete server": "PicGo server 删除接口(请使用PicList来启用此功能)",
|
||
"PicList desc": "PicList是PicGo二次开发版，请Github搜索PicList下载",
|
||
"Please input PicGo delete server": "请输入 PicGo server 删除接口",
|
||
"Delete image using PicList": "使用 PicList 删除图片",
|
||
"PicGo-Core path": "PicGo-Core 路径",
|
||
"Delete successfully": "删除成功",
|
||
"Delete failed": "删除失败",
|
||
"Error, could not delete": "错误，无法删除",
|
||
"Image size suffix": "图片大小后缀",
|
||
"Image size suffix Description": "比如：|300 用于调整图片大小",
|
||
"Please input image size suffix": "请输入图片大小后缀",
|
||
"Please input PicGo-Core path, default using environment variables": "请输入 PicGo-Core path，默认使用环境变量",
|
||
"Work on network": "应用网络图片",
|
||
"Work on network Description": "当你上传所有图片时，也会上传网络图片。以及当你进行黏贴时，剪切板中的标准 md 图片会被上传",
|
||
fixPath: "修正PATH变量",
|
||
fixPathWarning: "此选项用于修复Linux和Mac上 PicGo-Core 上传失败的问题。它会修改 Obsidian 内的 PATH 变量，如果 Obsidian 遇到任何BUG，先关闭这个选项试试！",
|
||
"Upload when clipboard has image and text together": "当剪切板同时拥有文本和图片剪切板数据时是否上传图片",
|
||
"When you copy, some application like Excel will image and text to clipboard, you can upload or not.": "当你复制时，某些应用例如 Excel 会在剪切板同时文本和图像数据，确认是否上传。",
|
||
"Network Domain Black List": "网络图片域名黑名单",
|
||
"Network Domain Black List Description": "黑名单域名中的图片将不会被上传，用英文逗号分割",
|
||
"Delete source file after you upload file": "上传文件后移除源文件",
|
||
"Delete source file in ob assets after you upload file.": "上传文件后移除在ob附件文件夹中的文件",
|
||
"Image desc": "图片描述",
|
||
reserve: "默认",
|
||
"remove all": "无",
|
||
"remove default": "移除image.png",
|
||
};
|
||
|
||
// 繁體中文
|
||
var zhTW = {};
|
||
|
||
var localeMap = {
|
||
ar: ar,
|
||
cs: cz,
|
||
da: da,
|
||
de: de,
|
||
en: en,
|
||
'en-gb': enGB,
|
||
es: es,
|
||
fr: fr,
|
||
hi: hi,
|
||
id: id,
|
||
it: it,
|
||
ja: ja,
|
||
ko: ko,
|
||
nl: nl,
|
||
nn: no,
|
||
pl: pl,
|
||
pt: pt,
|
||
'pt-br': ptBR,
|
||
ro: ro,
|
||
ru: ru,
|
||
tr: tr,
|
||
'zh-cn': zhCN,
|
||
'zh-tw': zhTW,
|
||
};
|
||
var locale = localeMap[obsidian.moment.locale()];
|
||
function t(str) {
|
||
return (locale && locale[str]) || en[str];
|
||
}
|
||
|
||
var DEFAULT_SETTINGS = {
|
||
uploadByClipSwitch: true,
|
||
uploader: "PicGo",
|
||
uploadServer: "http://127.0.0.1:36677/upload",
|
||
deleteServer: "http://127.0.0.1:36677/delete",
|
||
imageSizeSuffix: "",
|
||
picgoCorePath: "",
|
||
workOnNetWork: false,
|
||
fixPath: false,
|
||
applyImage: true,
|
||
newWorkBlackDomains: "",
|
||
deleteSource: false,
|
||
imageDesc: "origin",
|
||
};
|
||
var SettingTab = /** @class */ (function (_super) {
|
||
__extends(SettingTab, _super);
|
||
function SettingTab(app, plugin) {
|
||
var _this = _super.call(this, app, plugin) || this;
|
||
_this.plugin = plugin;
|
||
return _this;
|
||
}
|
||
SettingTab.prototype.display = function () {
|
||
var _this = this;
|
||
var containerEl = this.containerEl;
|
||
var os = getOS();
|
||
containerEl.empty();
|
||
containerEl.createEl("h2", { text: t("Plugin Settings") });
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Auto pasted upload"))
|
||
.setDesc(t("If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)"))
|
||
.addToggle(function (toggle) {
|
||
return toggle
|
||
.setValue(_this.plugin.settings.uploadByClipSwitch)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.uploadByClipSwitch = value;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Default uploader"))
|
||
.setDesc(t("Default uploader"))
|
||
.addDropdown(function (cb) {
|
||
return cb
|
||
.addOption("PicGo", "PicGo(app)")
|
||
.addOption("PicGo-Core", "PicGo-Core")
|
||
.setValue(_this.plugin.settings.uploader)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.uploader = value;
|
||
this.display();
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
if (this.plugin.settings.uploader === "PicGo") {
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("PicGo server"))
|
||
.setDesc(t("PicGo server"))
|
||
.addText(function (text) {
|
||
return text
|
||
.setPlaceholder(t("Please input PicGo server"))
|
||
.setValue(_this.plugin.settings.uploadServer)
|
||
.onChange(function (key) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.uploadServer = key;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("PicGo delete server"))
|
||
.setDesc(t("PicList desc"))
|
||
.addText(function (text) {
|
||
return text
|
||
.setPlaceholder(t("Please input PicGo delete server"))
|
||
.setValue(_this.plugin.settings.deleteServer)
|
||
.onChange(function (key) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.deleteServer = key;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
}
|
||
if (this.plugin.settings.uploader === "PicGo-Core") {
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("PicGo-Core path"))
|
||
.setDesc(t("Please input PicGo-Core path, default using environment variables"))
|
||
.addText(function (text) {
|
||
return text
|
||
.setPlaceholder("")
|
||
.setValue(_this.plugin.settings.picgoCorePath)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.picgoCorePath = value;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
if (os !== "Windows") {
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("fixPath"))
|
||
.setDesc(t("fixPathWarning"))
|
||
.addToggle(function (toggle) {
|
||
return toggle
|
||
.setValue(_this.plugin.settings.fixPath)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.fixPath = value;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
}
|
||
}
|
||
// image desc setting
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Image desc"))
|
||
.setDesc(t("Image desc"))
|
||
.addDropdown(function (cb) {
|
||
return cb
|
||
.addOption("origin", t("reserve")) // 保留全部
|
||
.addOption("none", t("remove all")) // 移除全部
|
||
.addOption("removeDefault", t("remove default")) // 只移除默认即 image.png
|
||
.setValue(_this.plugin.settings.imageDesc)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.imageDesc = value;
|
||
this.display();
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Image size suffix"))
|
||
.setDesc(t("Image size suffix Description"))
|
||
.addText(function (text) {
|
||
return text
|
||
.setPlaceholder(t("Please input image size suffix"))
|
||
.setValue(_this.plugin.settings.imageSizeSuffix)
|
||
.onChange(function (key) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.imageSizeSuffix = key;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Work on network"))
|
||
.setDesc(t("Work on network Description"))
|
||
.addToggle(function (toggle) {
|
||
return toggle
|
||
.setValue(_this.plugin.settings.workOnNetWork)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.workOnNetWork = value;
|
||
this.display();
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Network Domain Black List"))
|
||
.setDesc(t("Network Domain Black List Description"))
|
||
.addTextArea(function (textArea) {
|
||
return textArea
|
||
.setValue(_this.plugin.settings.newWorkBlackDomains)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.newWorkBlackDomains = value;
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Upload when clipboard has image and text together"))
|
||
.setDesc(t("When you copy, some application like Excel will image and text to clipboard, you can upload or not."))
|
||
.addToggle(function (toggle) {
|
||
return toggle
|
||
.setValue(_this.plugin.settings.applyImage)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.applyImage = value;
|
||
this.display();
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
new obsidian.Setting(containerEl)
|
||
.setName(t("Delete source file after you upload file"))
|
||
.setDesc(t("Delete source file in ob assets after you upload file."))
|
||
.addToggle(function (toggle) {
|
||
return toggle
|
||
.setValue(_this.plugin.settings.deleteSource)
|
||
.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.plugin.settings.deleteSource = value;
|
||
this.display();
|
||
return [4 /*yield*/, this.plugin.saveSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
};
|
||
return SettingTab;
|
||
}(obsidian.PluginSettingTab));
|
||
|
||
var imageAutoUploadPlugin = /** @class */ (function (_super) {
|
||
__extends(imageAutoUploadPlugin, _super);
|
||
function imageAutoUploadPlugin() {
|
||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||
_this.addMenu = function (menu, imgPath, editor) {
|
||
menu.addItem(function (item) {
|
||
return item
|
||
.setIcon("trash-2")
|
||
.setTitle(t("Delete image using PicList"))
|
||
.onClick(function () { return __awaiter(_this, void 0, void 0, function () {
|
||
var selectedItem, res, selection;
|
||
return __generator(this, function (_b) {
|
||
switch (_b.label) {
|
||
case 0:
|
||
_b.trys.push([0, 3, , 4]);
|
||
selectedItem = this.settings.uploadedImages.find(function (item) { return item.imgUrl === imgPath; });
|
||
if (!selectedItem) return [3 /*break*/, 2];
|
||
return [4 /*yield*/, this.picGoDeleter.deleteImage([selectedItem])];
|
||
case 1:
|
||
res = _b.sent();
|
||
if (res.success) {
|
||
new obsidian.Notice(t("Delete successfully"));
|
||
selection = editor.getSelection();
|
||
if (selection) {
|
||
editor.replaceSelection("");
|
||
}
|
||
this.settings.uploadedImages =
|
||
this.settings.uploadedImages.filter(function (item) { return item.imgUrl !== imgPath; });
|
||
this.saveSettings();
|
||
}
|
||
else {
|
||
new obsidian.Notice(t("Delete failed"));
|
||
}
|
||
_b.label = 2;
|
||
case 2: return [3 /*break*/, 4];
|
||
case 3:
|
||
_b.sent();
|
||
new obsidian.Notice(t("Error, could not delete"));
|
||
return [3 /*break*/, 4];
|
||
case 4: return [2 /*return*/];
|
||
}
|
||
});
|
||
}); });
|
||
});
|
||
};
|
||
return _this;
|
||
}
|
||
imageAutoUploadPlugin.prototype.loadSettings = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _a, _b, _c, _d;
|
||
return __generator(this, function (_e) {
|
||
switch (_e.label) {
|
||
case 0:
|
||
_a = this;
|
||
_c = (_b = Object).assign;
|
||
_d = [DEFAULT_SETTINGS];
|
||
return [4 /*yield*/, this.loadData()];
|
||
case 1:
|
||
_a.settings = _c.apply(_b, _d.concat([_e.sent()]));
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.saveSettings = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.saveData(this.settings)];
|
||
case 1:
|
||
_a.sent();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.onunload = function () { };
|
||
imageAutoUploadPlugin.prototype.onload = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.loadSettings()];
|
||
case 1:
|
||
_a.sent();
|
||
this.helper = new Helper(this.app);
|
||
this.picGoUploader = new PicGoUploader(this.settings, this);
|
||
this.picGoDeleter = new PicGoDeleter(this);
|
||
this.picGoCoreUploader = new PicGoCoreUploader(this.settings, this);
|
||
if (this.settings.uploader === "PicGo") {
|
||
this.uploader = this.picGoUploader;
|
||
}
|
||
else if (this.settings.uploader === "PicGo-Core") {
|
||
this.uploader = this.picGoCoreUploader;
|
||
if (this.settings.fixPath) {
|
||
fixPath();
|
||
}
|
||
}
|
||
else {
|
||
new obsidian.Notice("unknown uploader");
|
||
}
|
||
obsidian.addIcon("upload", "<svg t=\"1636630783429\" class=\"icon\" viewBox=\"0 0 100 100\" version=\"1.1\" p-id=\"4649\" xmlns=\"http://www.w3.org/2000/svg\">\n <path d=\"M 71.638 35.336 L 79.408 35.336 C 83.7 35.336 87.178 38.662 87.178 42.765 L 87.178 84.864 C 87.178 88.969 83.7 92.295 79.408 92.295 L 17.249 92.295 C 12.957 92.295 9.479 88.969 9.479 84.864 L 9.479 42.765 C 9.479 38.662 12.957 35.336 17.249 35.336 L 25.019 35.336 L 25.019 42.765 L 17.249 42.765 L 17.249 84.864 L 79.408 84.864 L 79.408 42.765 L 71.638 42.765 L 71.638 35.336 Z M 49.014 10.179 L 67.326 27.688 L 61.835 32.942 L 52.849 24.352 L 52.849 59.731 L 45.078 59.731 L 45.078 24.455 L 36.194 32.947 L 30.702 27.692 L 49.012 10.181 Z\" p-id=\"4650\" fill=\"#8a8a8a\"></path>\n </svg>");
|
||
this.addSettingTab(new SettingTab(this.app, this));
|
||
this.addCommand({
|
||
id: "Upload all images",
|
||
name: "Upload all images",
|
||
checkCallback: function (checking) {
|
||
var leaf = _this.app.workspace.activeLeaf;
|
||
if (leaf) {
|
||
if (!checking) {
|
||
_this.uploadAllFile();
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
},
|
||
});
|
||
this.addCommand({
|
||
id: "Download all images",
|
||
name: "Download all images",
|
||
checkCallback: function (checking) {
|
||
var leaf = _this.app.workspace.activeLeaf;
|
||
if (leaf) {
|
||
if (!checking) {
|
||
_this.downloadAllImageFiles();
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
},
|
||
});
|
||
this.setupPasteHandler();
|
||
this.registerFileMenu();
|
||
this.registerSelection();
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.registerSelection = function () {
|
||
var _this = this;
|
||
this.registerEvent(this.app.workspace.on("editor-menu", function (menu, editor, info) {
|
||
if (_this.app.workspace.getLeavesOfType("markdown").length === 0) {
|
||
return;
|
||
}
|
||
var selection = editor.getSelection();
|
||
if (selection) {
|
||
var markdownRegex = /!\[.*\]\((.*)\)/g;
|
||
var markdownMatch = markdownRegex.exec(selection);
|
||
if (markdownMatch && markdownMatch.length > 1) {
|
||
var markdownUrl_1 = markdownMatch[1];
|
||
if (_this.settings.uploadedImages.find(function (item) { return item.imgUrl === markdownUrl_1; })) {
|
||
_this.addMenu(menu, markdownUrl_1, editor);
|
||
}
|
||
}
|
||
}
|
||
}));
|
||
};
|
||
imageAutoUploadPlugin.prototype.downloadAllImageFiles = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var folderPath, fileArray, imageArray, nameSet, fileArray_1, fileArray_1_1, file, url, asset, name_1, response, activeFolder, abstractActiveFolder, e_1_1, value;
|
||
var e_1, _a;
|
||
var _this = this;
|
||
return __generator(this, function (_b) {
|
||
switch (_b.label) {
|
||
case 0:
|
||
folderPath = this.getFileAssetPath();
|
||
fileArray = this.helper.getAllFiles();
|
||
if (!require$$0.existsSync(folderPath)) {
|
||
require$$0.mkdirSync(folderPath);
|
||
}
|
||
imageArray = [];
|
||
nameSet = new Set();
|
||
_b.label = 1;
|
||
case 1:
|
||
_b.trys.push([1, 6, 7, 8]);
|
||
fileArray_1 = __values(fileArray), fileArray_1_1 = fileArray_1.next();
|
||
_b.label = 2;
|
||
case 2:
|
||
if (!!fileArray_1_1.done) return [3 /*break*/, 5];
|
||
file = fileArray_1_1.value;
|
||
if (!file.path.startsWith("http")) {
|
||
return [3 /*break*/, 4];
|
||
}
|
||
url = file.path;
|
||
asset = getUrlAsset(url);
|
||
name_1 = decodeURI(require$$0$1.parse(asset).name).replaceAll(/[\\\\/:*?\"<>|]/g, "-");
|
||
// 如果文件名已存在，则用随机值替换，不对文件后缀进行判断
|
||
if (require$$0.existsSync(require$$0$1.join(folderPath))) {
|
||
name_1 = (Math.random() + 1).toString(36).substr(2, 5);
|
||
}
|
||
if (nameSet.has(name_1)) {
|
||
name_1 = "".concat(name_1, "-").concat((Math.random() + 1).toString(36).substr(2, 5));
|
||
}
|
||
nameSet.add(name_1);
|
||
return [4 /*yield*/, this.download(url, folderPath, name_1)];
|
||
case 3:
|
||
response = _b.sent();
|
||
if (response.ok) {
|
||
activeFolder = obsidian.normalizePath(this.app.workspace.getActiveFile().parent.path);
|
||
abstractActiveFolder = this.app.vault.adapter.getFullPath(activeFolder);
|
||
imageArray.push({
|
||
source: file.source,
|
||
name: name_1,
|
||
path: obsidian.normalizePath(require$$0$1.relative(abstractActiveFolder, response.path)),
|
||
});
|
||
}
|
||
_b.label = 4;
|
||
case 4:
|
||
fileArray_1_1 = fileArray_1.next();
|
||
return [3 /*break*/, 2];
|
||
case 5: return [3 /*break*/, 8];
|
||
case 6:
|
||
e_1_1 = _b.sent();
|
||
e_1 = { error: e_1_1 };
|
||
return [3 /*break*/, 8];
|
||
case 7:
|
||
try {
|
||
if (fileArray_1_1 && !fileArray_1_1.done && (_a = fileArray_1.return)) _a.call(fileArray_1);
|
||
}
|
||
finally { if (e_1) throw e_1.error; }
|
||
return [7 /*endfinally*/];
|
||
case 8:
|
||
value = this.helper.getValue();
|
||
imageArray.map(function (image) {
|
||
var name = _this.handleName(image.name);
|
||
value = value.replace(image.source, "![".concat(name, "](").concat(encodeURI(image.path), ")"));
|
||
});
|
||
this.helper.setValue(value);
|
||
new obsidian.Notice("all: ".concat(fileArray.length, "\nsuccess: ").concat(imageArray.length, "\nfailed: ").concat(fileArray.length - imageArray.length));
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
// 获取当前文件所属的附件文件夹
|
||
imageAutoUploadPlugin.prototype.getFileAssetPath = function () {
|
||
var basePath = this.app.vault.adapter.getBasePath();
|
||
// @ts-ignore
|
||
var assetFolder = this.app.vault.config.attachmentFolderPath;
|
||
var activeFile = this.app.vault.getAbstractFileByPath(this.app.workspace.getActiveFile().path);
|
||
// 当前文件夹下的子文件夹
|
||
if (assetFolder.startsWith("./")) {
|
||
var activeFolder = decodeURI(require$$0$1.resolve(basePath, activeFile.parent.path));
|
||
return require$$0$1.join(activeFolder, assetFolder);
|
||
}
|
||
else {
|
||
// 根文件夹
|
||
return require$$0$1.join(basePath, assetFolder);
|
||
}
|
||
};
|
||
imageAutoUploadPlugin.prototype.download = function (url, folderPath, name) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response, type, buffer, path;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, obsidian.requestUrl({ url: url })];
|
||
case 1:
|
||
response = _a.sent();
|
||
return [4 /*yield*/, imageType(new Uint8Array(response.arrayBuffer))];
|
||
case 2:
|
||
type = _a.sent();
|
||
if (response.status !== 200) {
|
||
return [2 /*return*/, {
|
||
ok: false,
|
||
msg: "error",
|
||
}];
|
||
}
|
||
if (!type) {
|
||
return [2 /*return*/, {
|
||
ok: false,
|
||
msg: "error",
|
||
}];
|
||
}
|
||
buffer = Buffer.from(response.arrayBuffer);
|
||
try {
|
||
path = require$$0$1.join(folderPath, "".concat(name, ".").concat(type.ext));
|
||
require$$0.writeFileSync(path, buffer);
|
||
return [2 /*return*/, {
|
||
ok: true,
|
||
msg: "ok",
|
||
path: path,
|
||
type: type,
|
||
}];
|
||
}
|
||
catch (err) {
|
||
return [2 /*return*/, {
|
||
ok: false,
|
||
msg: err,
|
||
}];
|
||
}
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.registerFileMenu = function () {
|
||
var _this = this;
|
||
this.registerEvent(this.app.workspace.on("file-menu", function (menu, file, source, leaf) {
|
||
if (source === "canvas-menu")
|
||
return false;
|
||
if (!isAssetTypeAnImage(file.path))
|
||
return false;
|
||
menu.addItem(function (item) {
|
||
item
|
||
.setTitle("Upload")
|
||
.setIcon("upload")
|
||
.onClick(function () {
|
||
if (!(file instanceof obsidian.TFile)) {
|
||
return false;
|
||
}
|
||
_this.fileMenuUpload(file);
|
||
});
|
||
});
|
||
}));
|
||
};
|
||
imageAutoUploadPlugin.prototype.fileMenuUpload = function (file) {
|
||
var e_2, _a;
|
||
var _this = this;
|
||
var content = this.helper.getValue();
|
||
var basePath = this.app.vault.adapter.getBasePath();
|
||
var imageList = [];
|
||
var fileArray = this.helper.getAllFiles();
|
||
try {
|
||
for (var fileArray_2 = __values(fileArray), fileArray_2_1 = fileArray_2.next(); !fileArray_2_1.done; fileArray_2_1 = fileArray_2.next()) {
|
||
var match = fileArray_2_1.value;
|
||
var imageName = match.name;
|
||
var encodedUri = match.path;
|
||
var fileName = require$$0$1.basename(decodeURI(encodedUri));
|
||
if (file && file.name === fileName) {
|
||
var abstractImageFile = require$$0$1.join(basePath, file.path);
|
||
if (isAssetTypeAnImage(abstractImageFile)) {
|
||
imageList.push({
|
||
path: abstractImageFile,
|
||
name: imageName,
|
||
source: match.source,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||
finally {
|
||
try {
|
||
if (fileArray_2_1 && !fileArray_2_1.done && (_a = fileArray_2.return)) _a.call(fileArray_2);
|
||
}
|
||
finally { if (e_2) throw e_2.error; }
|
||
}
|
||
if (imageList.length === 0) {
|
||
new obsidian.Notice("没有解析到图像文件");
|
||
return;
|
||
}
|
||
this.uploader.uploadFiles(imageList.map(function (item) { return item.path; })).then(function (res) {
|
||
if (res.success) {
|
||
var uploadUrlList_1 = res.result;
|
||
imageList.map(function (item) {
|
||
var uploadImage = uploadUrlList_1.shift();
|
||
var name = _this.handleName(item.name);
|
||
content = content.replaceAll(item.source, "![".concat(name, "](").concat(uploadImage, ")"));
|
||
});
|
||
_this.helper.setValue(content);
|
||
if (_this.settings.deleteSource) {
|
||
imageList.map(function (image) {
|
||
if (!image.path.startsWith("http")) {
|
||
require$$0.unlink(image.path, function () { });
|
||
}
|
||
});
|
||
}
|
||
}
|
||
else {
|
||
new obsidian.Notice("Upload error");
|
||
}
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.filterFile = function (fileArray) {
|
||
var e_3, _a;
|
||
var imageList = [];
|
||
try {
|
||
for (var fileArray_3 = __values(fileArray), fileArray_3_1 = fileArray_3.next(); !fileArray_3_1.done; fileArray_3_1 = fileArray_3.next()) {
|
||
var match = fileArray_3_1.value;
|
||
if (match.path.startsWith("http")) {
|
||
if (this.settings.workOnNetWork) {
|
||
if (!this.helper.hasBlackDomain(match.path, this.settings.newWorkBlackDomains)) {
|
||
imageList.push({
|
||
path: match.path,
|
||
name: match.name,
|
||
source: match.source,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
imageList.push({
|
||
path: match.path,
|
||
name: match.name,
|
||
source: match.source,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||
finally {
|
||
try {
|
||
if (fileArray_3_1 && !fileArray_3_1.done && (_a = fileArray_3.return)) _a.call(fileArray_3);
|
||
}
|
||
finally { if (e_3) throw e_3.error; }
|
||
}
|
||
return imageList;
|
||
};
|
||
imageAutoUploadPlugin.prototype.getFile = function (fileName, fileMap) {
|
||
if (!fileMap) {
|
||
fileMap = arrayToObject(this.app.vault.getFiles(), "name");
|
||
}
|
||
return fileMap[fileName];
|
||
};
|
||
// uploda all file
|
||
imageAutoUploadPlugin.prototype.uploadAllFile = function () {
|
||
var e_4, _a;
|
||
var _this = this;
|
||
var content = this.helper.getValue();
|
||
var basePath = this.app.vault.adapter.getBasePath();
|
||
var activeFile = this.app.workspace.getActiveFile();
|
||
var fileMap = arrayToObject(this.app.vault.getFiles(), "name");
|
||
var filePathMap = arrayToObject(this.app.vault.getFiles(), "path");
|
||
var imageList = [];
|
||
var fileArray = this.filterFile(this.helper.getAllFiles());
|
||
try {
|
||
for (var fileArray_4 = __values(fileArray), fileArray_4_1 = fileArray_4.next(); !fileArray_4_1.done; fileArray_4_1 = fileArray_4.next()) {
|
||
var match = fileArray_4_1.value;
|
||
var imageName = match.name;
|
||
var encodedUri = match.path;
|
||
if (encodedUri.startsWith("http")) {
|
||
imageList.push({
|
||
path: match.path,
|
||
name: imageName,
|
||
source: match.source,
|
||
});
|
||
}
|
||
else {
|
||
var fileName = require$$0$1.basename(decodeURI(encodedUri));
|
||
var file = void 0;
|
||
// 绝对路径
|
||
if (filePathMap[decodeURI(encodedUri)]) {
|
||
file = filePathMap[decodeURI(encodedUri)];
|
||
}
|
||
// 相对路径
|
||
if ((!file && decodeURI(encodedUri).startsWith("./")) ||
|
||
decodeURI(encodedUri).startsWith("../")) {
|
||
var filePath = require$$0$1.resolve(require$$0$1.join(basePath, require$$0$1.dirname(activeFile.path)), decodeURI(encodedUri));
|
||
if (require$$0.existsSync(filePath)) {
|
||
var path = obsidian.normalizePath(require$$0$1.relative(basePath, require$$0$1.resolve(require$$0$1.join(basePath, require$$0$1.dirname(activeFile.path)), decodeURI(encodedUri))));
|
||
file = filePathMap[path];
|
||
}
|
||
}
|
||
// 尽可能短路径
|
||
if (!file) {
|
||
file = this.getFile(fileName, fileMap);
|
||
}
|
||
if (file) {
|
||
var abstractImageFile = require$$0$1.join(basePath, file.path);
|
||
if (isAssetTypeAnImage(abstractImageFile)) {
|
||
imageList.push({
|
||
path: abstractImageFile,
|
||
name: imageName,
|
||
source: match.source,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||
finally {
|
||
try {
|
||
if (fileArray_4_1 && !fileArray_4_1.done && (_a = fileArray_4.return)) _a.call(fileArray_4);
|
||
}
|
||
finally { if (e_4) throw e_4.error; }
|
||
}
|
||
if (imageList.length === 0) {
|
||
new obsidian.Notice("没有解析到图像文件");
|
||
return;
|
||
}
|
||
else {
|
||
new obsidian.Notice("\u5171\u627E\u5230".concat(imageList.length, "\u4E2A\u56FE\u50CF\u6587\u4EF6\uFF0C\u5F00\u59CB\u4E0A\u4F20"));
|
||
}
|
||
this.uploader.uploadFiles(imageList.map(function (item) { return item.path; })).then(function (res) {
|
||
if (res.success) {
|
||
var uploadUrlList_2 = res.result;
|
||
imageList.map(function (item) {
|
||
var uploadImage = uploadUrlList_2.shift();
|
||
var name = _this.handleName(item.name);
|
||
content = content.replaceAll(item.source, "![".concat(name, "](").concat(uploadImage, ")"));
|
||
});
|
||
_this.helper.setValue(content);
|
||
if (_this.settings.deleteSource) {
|
||
imageList.map(function (image) {
|
||
if (!image.path.startsWith("http")) {
|
||
require$$0.unlink(image.path, function () { });
|
||
}
|
||
});
|
||
}
|
||
}
|
||
else {
|
||
new obsidian.Notice("Upload error");
|
||
}
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.setupPasteHandler = function () {
|
||
var _this = this;
|
||
this.registerEvent(this.app.workspace.on("editor-paste", function (evt, editor, markdownView) {
|
||
var allowUpload = _this.helper.getFrontmatterValue("image-auto-upload", _this.settings.uploadByClipSwitch);
|
||
evt.clipboardData.files;
|
||
if (!allowUpload) {
|
||
return;
|
||
}
|
||
// 剪贴板内容有md格式的图片时
|
||
if (_this.settings.workOnNetWork) {
|
||
var clipboardValue = evt.clipboardData.getData("text/plain");
|
||
var imageList_1 = _this.helper
|
||
.getImageLink(clipboardValue)
|
||
.filter(function (image) { return image.path.startsWith("http"); })
|
||
.filter(function (image) {
|
||
return !_this.helper.hasBlackDomain(image.path, _this.settings.newWorkBlackDomains);
|
||
});
|
||
if (imageList_1.length !== 0) {
|
||
_this.uploader
|
||
.uploadFiles(imageList_1.map(function (item) { return item.path; }))
|
||
.then(function (res) {
|
||
var value = _this.helper.getValue();
|
||
if (res.success) {
|
||
var uploadUrlList_3 = res.result;
|
||
imageList_1.map(function (item) {
|
||
var uploadImage = uploadUrlList_3.shift();
|
||
var name = _this.handleName(item.name);
|
||
value = value.replaceAll(item.source, "![".concat(name, "](").concat(uploadImage, ")"));
|
||
});
|
||
_this.helper.setValue(value);
|
||
}
|
||
else {
|
||
new obsidian.Notice("Upload error");
|
||
}
|
||
});
|
||
}
|
||
}
|
||
// 剪贴板中是图片时进行上传
|
||
if (_this.canUpload(evt.clipboardData)) {
|
||
_this.uploadFileAndEmbedImgurImage(editor, function (editor, pasteId) { return __awaiter(_this, void 0, void 0, function () {
|
||
var res, url;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.uploader.uploadFileByClipboard()];
|
||
case 1:
|
||
res = _a.sent();
|
||
if (res.code !== 0) {
|
||
this.handleFailedUpload(editor, pasteId, res.msg);
|
||
return [2 /*return*/];
|
||
}
|
||
url = res.data;
|
||
return [2 /*return*/, url];
|
||
}
|
||
});
|
||
}); }, evt.clipboardData).catch();
|
||
evt.preventDefault();
|
||
}
|
||
}));
|
||
this.registerEvent(this.app.workspace.on("editor-drop", function (evt, editor, markdownView) { return __awaiter(_this, void 0, void 0, function () {
|
||
var allowUpload, files, sendFiles_1, files_1, data;
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
allowUpload = this.helper.getFrontmatterValue("image-auto-upload", this.settings.uploadByClipSwitch);
|
||
files = evt.dataTransfer.files;
|
||
if (!allowUpload) {
|
||
return [2 /*return*/];
|
||
}
|
||
if (!(files.length !== 0 && files[0].type.startsWith("image"))) return [3 /*break*/, 2];
|
||
sendFiles_1 = [];
|
||
files_1 = evt.dataTransfer.files;
|
||
Array.from(files_1).forEach(function (item, index) {
|
||
sendFiles_1.push(item.path);
|
||
});
|
||
evt.preventDefault();
|
||
return [4 /*yield*/, this.uploader.uploadFiles(sendFiles_1)];
|
||
case 1:
|
||
data = _a.sent();
|
||
if (data.success) {
|
||
data.result.map(function (value) {
|
||
var pasteId = (Math.random() + 1).toString(36).substr(2, 5);
|
||
_this.insertTemporaryText(editor, pasteId);
|
||
_this.embedMarkDownImage(editor, pasteId, value, files_1[0].name);
|
||
});
|
||
}
|
||
else {
|
||
new obsidian.Notice("Upload error");
|
||
}
|
||
_a.label = 2;
|
||
case 2: return [2 /*return*/];
|
||
}
|
||
});
|
||
}); }));
|
||
};
|
||
imageAutoUploadPlugin.prototype.canUpload = function (clipboardData) {
|
||
this.settings.applyImage;
|
||
var files = clipboardData.files;
|
||
var text = clipboardData.getData("text");
|
||
var hasImageFile = files.length !== 0 && files[0].type.startsWith("image");
|
||
if (hasImageFile) {
|
||
if (!!text) {
|
||
return this.settings.applyImage;
|
||
}
|
||
else {
|
||
return true;
|
||
}
|
||
}
|
||
else {
|
||
return false;
|
||
}
|
||
};
|
||
imageAutoUploadPlugin.prototype.uploadFileAndEmbedImgurImage = function (editor, callback, clipboardData) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var pasteId, name, url, e_5;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
pasteId = (Math.random() + 1).toString(36).substr(2, 5);
|
||
this.insertTemporaryText(editor, pasteId);
|
||
name = clipboardData.files[0].name;
|
||
_a.label = 1;
|
||
case 1:
|
||
_a.trys.push([1, 3, , 4]);
|
||
return [4 /*yield*/, callback(editor, pasteId)];
|
||
case 2:
|
||
url = _a.sent();
|
||
this.embedMarkDownImage(editor, pasteId, url, name);
|
||
return [3 /*break*/, 4];
|
||
case 3:
|
||
e_5 = _a.sent();
|
||
this.handleFailedUpload(editor, pasteId, e_5);
|
||
return [3 /*break*/, 4];
|
||
case 4: return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
imageAutoUploadPlugin.prototype.insertTemporaryText = function (editor, pasteId) {
|
||
var progressText = imageAutoUploadPlugin.progressTextFor(pasteId);
|
||
editor.replaceSelection(progressText + "\n");
|
||
};
|
||
imageAutoUploadPlugin.progressTextFor = function (id) {
|
||
return "![Uploading file...".concat(id, "]()");
|
||
};
|
||
imageAutoUploadPlugin.prototype.embedMarkDownImage = function (editor, pasteId, imageUrl, name) {
|
||
if (name === void 0) { name = ""; }
|
||
var progressText = imageAutoUploadPlugin.progressTextFor(pasteId);
|
||
name = this.handleName(name);
|
||
var markDownImage = "![".concat(name, "](").concat(imageUrl, ")");
|
||
imageAutoUploadPlugin.replaceFirstOccurrence(editor, progressText, markDownImage);
|
||
};
|
||
imageAutoUploadPlugin.prototype.handleFailedUpload = function (editor, pasteId, reason) {
|
||
new obsidian.Notice(reason);
|
||
console.error("Failed request: ", reason);
|
||
var progressText = imageAutoUploadPlugin.progressTextFor(pasteId);
|
||
imageAutoUploadPlugin.replaceFirstOccurrence(editor, progressText, "⚠️upload failed, check dev console");
|
||
};
|
||
imageAutoUploadPlugin.prototype.handleName = function (name) {
|
||
var imageSizeSuffix = this.settings.imageSizeSuffix || "";
|
||
if (this.settings.imageDesc === "origin") {
|
||
return "".concat(name).concat(imageSizeSuffix);
|
||
}
|
||
else if (this.settings.imageDesc === "none") {
|
||
return "";
|
||
}
|
||
else if (this.settings.imageDesc === "removeDefault") {
|
||
if (name === "image.png") {
|
||
return "";
|
||
}
|
||
else {
|
||
return "".concat(name).concat(imageSizeSuffix);
|
||
}
|
||
}
|
||
else {
|
||
return "".concat(name).concat(imageSizeSuffix);
|
||
}
|
||
};
|
||
imageAutoUploadPlugin.replaceFirstOccurrence = function (editor, target, replacement) {
|
||
var lines = editor.getValue().split("\n");
|
||
for (var i = 0; i < lines.length; i++) {
|
||
var ch = lines[i].indexOf(target);
|
||
if (ch != -1) {
|
||
var from = { line: i, ch: ch };
|
||
var to = { line: i, ch: ch + target.length };
|
||
editor.replaceRange(replacement, from, to);
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
return imageAutoUploadPlugin;
|
||
}(obsidian.Plugin));
|
||
|
||
module.exports = imageAutoUploadPlugin;
|
||
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","node_modules/isexe/windows.js","node_modules/isexe/mode.js","node_modules/isexe/index.js","node_modules/which/which.js","node_modules/path-key/index.js","node_modules/cross-spawn/lib/util/resolveCommand.js","node_modules/cross-spawn/lib/util/escape.js","node_modules/shebang-regex/index.js","node_modules/shebang-command/index.js","node_modules/cross-spawn/lib/util/readShebang.js","node_modules/cross-spawn/lib/parse.js","node_modules/cross-spawn/lib/enoent.js","node_modules/cross-spawn/index.js","node_modules/strip-final-newline/index.js","node_modules/npm-run-path/index.js","node_modules/mimic-fn/index.js","node_modules/onetime/index.js","node_modules/human-signals/build/src/core.js","node_modules/human-signals/build/src/realtime.js","node_modules/human-signals/build/src/signals.js","node_modules/human-signals/build/src/main.js","node_modules/execa/lib/error.js","node_modules/execa/lib/stdio.js","node_modules/signal-exit/signals.js","node_modules/signal-exit/index.js","node_modules/execa/lib/kill.js","node_modules/is-stream/index.js","node_modules/execa/node_modules/get-stream/buffer-stream.js","node_modules/execa/node_modules/get-stream/index.js","node_modules/merge-stream/index.js","node_modules/execa/lib/stream.js","node_modules/execa/lib/promise.js","node_modules/execa/lib/command.js","node_modules/execa/index.js","node_modules/ansi-regex/index.js","node_modules/strip-ansi/index.js","node_modules/default-shell/index.js","node_modules/shell-env/index.js","node_modules/shell-path/index.js","node_modules/fix-path/index.js","node_modules/readable-stream/lib/internal/streams/stream.js","node_modules/readable-stream/lib/internal/streams/buffer_list.js","node_modules/readable-stream/lib/internal/streams/destroy.js","node_modules/readable-stream/errors.js","node_modules/readable-stream/lib/internal/streams/state.js","node_modules/inherits/inherits_browser.js","node_modules/inherits/inherits.js","node_modules/util-deprecate/node.js","node_modules/readable-stream/lib/_stream_writable.js","node_modules/readable-stream/lib/_stream_duplex.js","node_modules/safe-buffer/index.js","node_modules/string_decoder/lib/string_decoder.js","node_modules/readable-stream/lib/internal/streams/end-of-stream.js","node_modules/readable-stream/lib/internal/streams/async_iterator.js","node_modules/readable-stream/lib/internal/streams/from.js","node_modules/readable-stream/lib/_stream_readable.js","node_modules/readable-stream/lib/_stream_transform.js","node_modules/readable-stream/lib/_stream_passthrough.js","node_modules/readable-stream/lib/internal/streams/pipeline.js","node_modules/readable-stream/readable.js","node_modules/readable-web-to-node-stream/lib/index.js","node_modules/token-types/lib/index.js","node_modules/peek-readable/lib/EndOfFileStream.js","node_modules/strtok3/lib/AbstractTokenizer.js","node_modules/strtok3/lib/BufferTokenizer.js","node_modules/strtok3/lib/core.js","node_modules/file-type/util.js","node_modules/file-type/supported.js","node_modules/file-type/core.js","node_modules/image-type/index.js","src/utils.ts","src/uploader.ts","src/deleter.ts","src/helper.ts","src/lang/locale/ar.ts","src/lang/locale/cz.ts","src/lang/locale/da.ts","src/lang/locale/de.ts","src/lang/locale/en.ts","src/lang/locale/en-gb.ts","src/lang/locale/es.ts","src/lang/locale/fr.ts","src/lang/locale/hi.ts","src/lang/locale/id.ts","src/lang/locale/it.ts","src/lang/locale/ja.ts","src/lang/locale/ko.ts","src/lang/locale/nl.ts","src/lang/locale/no.ts","src/lang/locale/pl.ts","src/lang/locale/pt.ts","src/lang/locale/pt-br.ts","src/lang/locale/ro.ts","src/lang/locale/ru.ts","src/lang/locale/tr.ts","src/lang/locale/zh-cn.ts","src/lang/locale/zh-tw.ts","src/lang/helpers.ts","src/setting.ts","src/main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.push(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.push(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","module.exports = isexe\nisexe.sync = sync\n\nvar fs = require('fs')\n\nfunction checkPathExt (path, options) {\n  var pathext = options.pathExt !== undefined ?\n    options.pathExt : process.env.PATHEXT\n\n  if (!pathext) {\n    return true\n  }\n\n  pathext = pathext.split(';')\n  if (pathext.indexOf('') !== -1) {\n    return true\n  }\n  for (var i = 0; i < pathext.length; i++) {\n    var p = pathext[i].toLowerCase()\n    if (p && path.substr(-p.length).toLowerCase() === p) {\n      return true\n    }\n  }\n  return false\n}\n\nfunction checkStat (stat, path, options) {\n  if (!stat.isSymbolicLink() && !stat.isFile()) {\n    return false\n  }\n  return checkPathExt(path, options)\n}\n\nfunction isexe (path, options, cb) {\n  fs.stat(path, function (er, stat) {\n    cb(er, er ? false : checkStat(stat, path, options))\n  })\n}\n\nfunction sync (path, options) {\n  return checkStat(fs.statSync(path), path, options)\n}\n","module.exports = isexe\nisexe.sync = sync\n\nvar fs = require('fs')\n\nfunction isexe (path, options, cb) {\n  fs.stat(path, function (er, stat) {\n    cb(er, er ? false : checkStat(stat, options))\n  })\n}\n\nfunction sync (path, options) {\n  return checkStat(fs.statSync(path), options)\n}\n\nfunction checkStat (stat, options) {\n  return stat.isFile() && checkMode(stat, options)\n}\n\nfunction checkMode (stat, options) {\n  var mod = stat.mode\n  var uid = stat.uid\n  var gid = stat.gid\n\n  var myUid = options.uid !== undefined ?\n    options.uid : process.getuid && process.getuid()\n  var myGid = options.gid !== undefined ?\n    options.gid : process.getgid && process.getgid()\n\n  var u = parseInt('100', 8)\n  var g = parseInt('010', 8)\n  var o = parseInt('001', 8)\n  var ug = u | g\n\n  var ret = (mod & o) ||\n    (mod & g) && gid === myGid ||\n    (mod & u) && uid === myUid ||\n    (mod & ug) && myUid === 0\n\n  return ret\n}\n","var fs = require('fs')\nvar core\nif (process.platform === 'win32' || global.TESTING_WINDOWS) {\n  core = require('./windows.js')\n} else {\n  core = require('./mode.js')\n}\n\nmodule.exports = isexe\nisexe.sync = sync\n\nfunction isexe (path, options, cb) {\n  if (typeof options === 'function') {\n    cb = options\n    options = {}\n  }\n\n  if (!cb) {\n    if (typeof Promise !== 'function') {\n      throw new TypeError('callback not provided')\n    }\n\n    return new Promise(function (resolve, reject) {\n      isexe(path, options || {}, function (er, is) {\n        if (er) {\n          reject(er)\n        } else {\n          resolve(is)\n        }\n      })\n    })\n  }\n\n  core(path, options || {}, function (er, is) {\n    // ignore EACCES because that just means we aren't allowed to run it\n    if (er) {\n      if (er.code === 'EACCES' || options && options.ignoreErrors) {\n        er = null\n        is = false\n      }\n    }\n    cb(er, is)\n  })\n}\n\nfunction sync (path, options) {\n  // my kingdom for a filtered catch\n  try {\n    return core.sync(path, options || {})\n  } catch (er) {\n    if (options && options.ignoreErrors || er.code === 'EACCES') {\n      return false\n    } else {\n      throw er\n    }\n  }\n}\n","const isWindows = process.platform === 'win32' ||\n    process.env.OSTYPE === 'cygwin' ||\n    process.env.OSTYPE === 'msys'\n\nconst path = require('path')\nconst COLON = isWindows ? ';' : ':'\nconst isexe = require('isexe')\n\nconst getNotFoundError = (cmd) =>\n  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' })\n\nconst getPathInfo = (cmd, opt) => {\n  const colon = opt.colon || COLON\n\n  // If it has a slash, then we don't bother searching the pathenv.\n  // just check the file itself, and that's it.\n  const pathEnv = cmd.match(/\\//) || isWindows && cmd.match(/\\\\/) ? ['']\n    : (\n      [\n        // windows always checks the cwd first\n        ...(isWindows ? [process.cwd()] : []),\n        ...(opt.path || process.env.PATH ||\n          /* istanbul ignore next: very unusual */ '').split(colon),\n      ]\n    )\n  const pathExtExe = isWindows\n    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'\n    : ''\n  const pathExt = isWindows ? pathExtExe.split(colon) : ['']\n\n  if (isWindows) {\n    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')\n      pathExt.unshift('')\n  }\n\n  return {\n    pathEnv,\n    pathExt,\n    pathExtExe,\n  }\n}\n\nconst which = (cmd, opt, cb) => {\n  if (typeof opt === 'function') {\n    cb = opt\n    opt = {}\n  }\n  if (!opt)\n    opt = {}\n\n  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)\n  const found = []\n\n  const step = i => new Promise((resolve, reject) => {\n    if (i === pathEnv.length)\n      return opt.all && found.length ? resolve(found)\n        : reject(getNotFoundError(cmd))\n\n    const ppRaw = pathEnv[i]\n    const pathPart = /^\".*\"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw\n\n    const pCmd = path.join(pathPart, cmd)\n    const p = !pathPart && /^\\.[\\\\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd\n      : pCmd\n\n    resolve(subStep(p, i, 0))\n  })\n\n  const subStep = (p, i, ii) => new Promise((resolve, reject) => {\n    if (ii === pathExt.length)\n      return resolve(step(i + 1))\n    const ext = pathExt[ii]\n    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {\n      if (!er && is) {\n        if (opt.all)\n          found.push(p + ext)\n        else\n          return resolve(p + ext)\n      }\n      return resolve(subStep(p, i, ii + 1))\n    })\n  })\n\n  return cb ? step(0).then(res => cb(null, res), cb) : step(0)\n}\n\nconst whichSync = (cmd, opt) => {\n  opt = opt || {}\n\n  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)\n  const found = []\n\n  for (let i = 0; i < pathEnv.length; i ++) {\n    const ppRaw = pathEnv[i]\n    const pathPart = /^\".*\"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw\n\n    const pCmd = path.join(pathPart, cmd)\n    const p = !pathPart && /^\\.[\\\\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd\n      : pCmd\n\n    for (let j = 0; j < pathExt.length; j ++) {\n      const cur = p + pathExt[j]\n      try {\n        const is = isexe.sync(cur, { pathExt: pathExtExe })\n        if (is) {\n          if (opt.all)\n            found.push(cur)\n          else\n            return cur\n        }\n      } catch (ex) {}\n    }\n  }\n\n  if (opt.all && found.length)\n    return found\n\n  if (opt.nothrow)\n    return null\n\n  throw getNotFoundError(cmd)\n}\n\nmodule.exports = which\nwhich.sync = whichSync\n","'use strict';\n\nconst pathKey = (options = {}) => {\n\tconst environment = options.env || process.env;\n\tconst platform = options.platform || process.platform;\n\n\tif (platform !== 'win32') {\n\t\treturn 'PATH';\n\t}\n\n\treturn Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';\n};\n\nmodule.exports = pathKey;\n// TODO: Remove this for the next major release\nmodule.exports.default = pathKey;\n","'use strict';\n\nconst path = require('path');\nconst which = require('which');\nconst getPathKey = require('path-key');\n\nfunction resolveCommandAttempt(parsed, withoutPathExt) {\n    const env = parsed.options.env || process.env;\n    const cwd = process.cwd();\n    const hasCustomCwd = parsed.options.cwd != null;\n    // Worker threads do not have process.chdir()\n    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;\n\n    // If a custom `cwd` was specified, we need to change the process cwd\n    // because `which` will do stat calls but does not support a custom cwd\n    if (shouldSwitchCwd) {\n        try {\n            process.chdir(parsed.options.cwd);\n        } catch (err) {\n            /* Empty */\n        }\n    }\n\n    let resolved;\n\n    try {\n        resolved = which.sync(parsed.command, {\n            path: env[getPathKey({ env })],\n            pathExt: withoutPathExt ? path.delimiter : undefined,\n        });\n    } catch (e) {\n        /* Empty */\n    } finally {\n        if (shouldSwitchCwd) {\n            process.chdir(cwd);\n        }\n    }\n\n    // If we successfully resolved, ensure that an absolute path is returned\n    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it\n    if (resolved) {\n        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);\n    }\n\n    return resolved;\n}\n\nfunction resolveCommand(parsed) {\n    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);\n}\n\nmodule.exports = resolveCommand;\n","'use strict';\n\n// See http://www.robvanderwoude.com/escapechars.php\nconst metaCharsRegExp = /([()\\][%!^\"`<>&|;, *?])/g;\n\nfunction escapeCommand(arg) {\n    // Escape meta chars\n    arg = arg.replace(metaCharsRegExp, '^$1');\n\n    return arg;\n}\n\nfunction escapeArgument(arg, doubleEscapeMetaChars) {\n    // Convert to string\n    arg = `${arg}`;\n\n    // Algorithm below is based on https://qntm.org/cmd\n\n    // Sequence of backslashes followed by a double quote:\n    // double up all the backslashes and escape the double quote\n    arg = arg.replace(/(\\\\*)\"/g, '$1$1\\\\\"');\n\n    // Sequence of backslashes followed by the end of the string\n    // (which will become a double quote later):\n    // double up all the backslashes\n    arg = arg.replace(/(\\\\*)$/, '$1$1');\n\n    // All other backslashes occur literally\n\n    // Quote the whole thing:\n    arg = `\"${arg}\"`;\n\n    // Escape meta chars\n    arg = arg.replace(metaCharsRegExp, '^$1');\n\n    // Double escape meta chars if necessary\n    if (doubleEscapeMetaChars) {\n        arg = arg.replace(metaCharsRegExp, '^$1');\n    }\n\n    return arg;\n}\n\nmodule.exports.command = escapeCommand;\nmodule.exports.argument = escapeArgument;\n","'use strict';\nmodule.exports = /^#!(.*)/;\n","'use strict';\nconst shebangRegex = require('shebang-regex');\n\nmodule.exports = (string = '') => {\n\tconst match = string.match(shebangRegex);\n\n\tif (!match) {\n\t\treturn null;\n\t}\n\n\tconst [path, argument] = match[0].replace(/#! ?/, '').split(' ');\n\tconst binary = path.split('/').pop();\n\n\tif (binary === 'env') {\n\t\treturn argument;\n\t}\n\n\treturn argument ? `${binary} ${argument}` : binary;\n};\n","'use strict';\n\nconst fs = require('fs');\nconst shebangCommand = require('shebang-command');\n\nfunction readShebang(command) {\n    // Read the first 150 bytes from the file\n    const size = 150;\n    const buffer = Buffer.alloc(size);\n\n    let fd;\n\n    try {\n        fd = fs.openSync(command, 'r');\n        fs.readSync(fd, buffer, 0, size, 0);\n        fs.closeSync(fd);\n    } catch (e) { /* Empty */ }\n\n    // Attempt to extract shebang (null is returned if not a shebang)\n    return shebangCommand(buffer.toString());\n}\n\nmodule.exports = readShebang;\n","'use strict';\n\nconst path = require('path');\nconst resolveCommand = require('./util/resolveCommand');\nconst escape = require('./util/escape');\nconst readShebang = require('./util/readShebang');\n\nconst isWin = process.platform === 'win32';\nconst isExecutableRegExp = /\\.(?:com|exe)$/i;\nconst isCmdShimRegExp = /node_modules[\\\\/].bin[\\\\/][^\\\\/]+\\.cmd$/i;\n\nfunction detectShebang(parsed) {\n    parsed.file = resolveCommand(parsed);\n\n    const shebang = parsed.file && readShebang(parsed.file);\n\n    if (shebang) {\n        parsed.args.unshift(parsed.file);\n        parsed.command = shebang;\n\n        return resolveCommand(parsed);\n    }\n\n    return parsed.file;\n}\n\nfunction parseNonShell(parsed) {\n    if (!isWin) {\n        return parsed;\n    }\n\n    // Detect & add support for shebangs\n    const commandFile = detectShebang(parsed);\n\n    // We don't need a shell if the command filename is an executable\n    const needsShell = !isExecutableRegExp.test(commandFile);\n\n    // If a shell is required, use cmd.exe and take care of escaping everything correctly\n    // Note that `forceShell` is an hidden option used only in tests\n    if (parsed.options.forceShell || needsShell) {\n        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`\n        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument\n        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,\n        // we need to double escape them\n        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);\n\n        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\\bar)\n        // This is necessary otherwise it will always fail with ENOENT in those cases\n        parsed.command = path.normalize(parsed.command);\n\n        // Escape command & arguments\n        parsed.command = escape.command(parsed.command);\n        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));\n\n        const shellCommand = [parsed.command].concat(parsed.args).join(' ');\n\n        parsed.args = ['/d', '/s', '/c', `\"${shellCommand}\"`];\n        parsed.command = process.env.comspec || 'cmd.exe';\n        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped\n    }\n\n    return parsed;\n}\n\nfunction parse(command, args, options) {\n    // Normalize arguments, similar to nodejs\n    if (args && !Array.isArray(args)) {\n        options = args;\n        args = null;\n    }\n\n    args = args ? args.slice(0) : []; // Clone array to avoid changing the original\n    options = Object.assign({}, options); // Clone object to avoid changing the original\n\n    // Build our parsed object\n    const parsed = {\n        command,\n        args,\n        options,\n        file: undefined,\n        original: {\n            command,\n            args,\n        },\n    };\n\n    // Delegate further parsing to shell or non-shell\n    return options.shell ? parsed : parseNonShell(parsed);\n}\n\nmodule.exports = parse;\n","'use strict';\n\nconst isWin = process.platform === 'win32';\n\nfunction notFoundError(original, syscall) {\n    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {\n        code: 'ENOENT',\n        errno: 'ENOENT',\n        syscall: `${syscall} ${original.command}`,\n        path: original.command,\n        spawnargs: original.args,\n    });\n}\n\nfunction hookChildProcess(cp, parsed) {\n    if (!isWin) {\n        return;\n    }\n\n    const originalEmit = cp.emit;\n\n    cp.emit = function (name, arg1) {\n        // If emitting \"exit\" event and exit code is 1, we need to check if\n        // the command exists and emit an \"error\" instead\n        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16\n        if (name === 'exit') {\n            const err = verifyENOENT(arg1, parsed, 'spawn');\n\n            if (err) {\n                return originalEmit.call(cp, 'error', err);\n            }\n        }\n\n        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params\n    };\n}\n\nfunction verifyENOENT(status, parsed) {\n    if (isWin && status === 1 && !parsed.file) {\n        return notFoundError(parsed.original, 'spawn');\n    }\n\n    return null;\n}\n\nfunction verifyENOENTSync(status, parsed) {\n    if (isWin && status === 1 && !parsed.file) {\n        return notFoundError(parsed.original, 'spawnSync');\n    }\n\n    return null;\n}\n\nmodule.exports = {\n    hookChildProcess,\n    verifyENOENT,\n    verifyENOENTSync,\n    notFoundError,\n};\n","'use strict';\n\nconst cp = require('child_process');\nconst parse = require('./lib/parse');\nconst enoent = require('./lib/enoent');\n\nfunction spawn(command, args, options) {\n    // Parse the arguments\n    const parsed = parse(command, args, options);\n\n    // Spawn the child process\n    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);\n\n    // Hook into child process \"exit\" event to emit an error if the command\n    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16\n    enoent.hookChildProcess(spawned, parsed);\n\n    return spawned;\n}\n\nfunction spawnSync(command, args, options) {\n    // Parse the arguments\n    const parsed = parse(command, args, options);\n\n    // Spawn the child process\n    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);\n\n    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16\n    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);\n\n    return result;\n}\n\nmodule.exports = spawn;\nmodule.exports.spawn = spawn;\nmodule.exports.sync = spawnSync;\n\nmodule.exports._parse = parse;\nmodule.exports._enoent = enoent;\n","'use strict';\n\nmodule.exports = input => {\n\tconst LF = typeof input === 'string' ? '\\n' : '\\n'.charCodeAt();\n\tconst CR = typeof input === 'string' ? '\\r' : '\\r'.charCodeAt();\n\n\tif (input[input.length - 1] === LF) {\n\t\tinput = input.slice(0, input.length - 1);\n\t}\n\n\tif (input[input.length - 1] === CR) {\n\t\tinput = input.slice(0, input.length - 1);\n\t}\n\n\treturn input;\n};\n","'use strict';\nconst path = require('path');\nconst pathKey = require('path-key');\n\nconst npmRunPath = options => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\tpath: process.env[pathKey()],\n\t\texecPath: process.execPath,\n\t\t...options\n\t};\n\n\tlet previous;\n\tlet cwdPath = path.resolve(options.cwd);\n\tconst result = [];\n\n\twhile (previous !== cwdPath) {\n\t\tresult.push(path.join(cwdPath, 'node_modules/.bin'));\n\t\tprevious = cwdPath;\n\t\tcwdPath = path.resolve(cwdPath, '..');\n\t}\n\n\t// Ensure the running `node` binary is used\n\tconst execPathDir = path.resolve(options.cwd, options.execPath, '..');\n\tresult.push(execPathDir);\n\n\treturn result.concat(options.path).join(path.delimiter);\n};\n\nmodule.exports = npmRunPath;\n// TODO: Remove this for the next major release\nmodule.exports.default = npmRunPath;\n\nmodule.exports.env = options => {\n\toptions = {\n\t\tenv: process.env,\n\t\t...options\n\t};\n\n\tconst env = {...options.env};\n\tconst path = pathKey({env});\n\n\toptions.path = env[path];\n\tenv[path] = module.exports(options);\n\n\treturn env;\n};\n","'use strict';\n\nconst mimicFn = (to, from) => {\n\tfor (const prop of Reflect.ownKeys(from)) {\n\t\tObject.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));\n\t}\n\n\treturn to;\n};\n\nmodule.exports = mimicFn;\n// TODO: Remove this for the next major release\nmodule.exports.default = mimicFn;\n","'use strict';\nconst mimicFn = require('mimic-fn');\n\nconst calledFunctions = new WeakMap();\n\nconst onetime = (function_, options = {}) => {\n\tif (typeof function_ !== 'function') {\n\t\tthrow new TypeError('Expected a function');\n\t}\n\n\tlet returnValue;\n\tlet callCount = 0;\n\tconst functionName = function_.displayName || function_.name || '<anonymous>';\n\n\tconst onetime = function (...arguments_) {\n\t\tcalledFunctions.set(onetime, ++callCount);\n\n\t\tif (callCount === 1) {\n\t\t\treturnValue = function_.apply(this, arguments_);\n\t\t\tfunction_ = null;\n\t\t} else if (options.throw === true) {\n\t\t\tthrow new Error(`Function \\`${functionName}\\` can only be called once`);\n\t\t}\n\n\t\treturn returnValue;\n\t};\n\n\tmimicFn(onetime, function_);\n\tcalledFunctions.set(onetime, callCount);\n\n\treturn onetime;\n};\n\nmodule.exports = onetime;\n// TODO: Remove this for the next major release\nmodule.exports.default = onetime;\n\nmodule.exports.callCount = function_ => {\n\tif (!calledFunctions.has(function_)) {\n\t\tthrow new Error(`The given function \\`${function_.name}\\` is not wrapped by the \\`onetime\\` package`);\n\t}\n\n\treturn calledFunctions.get(function_);\n};\n","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.SIGNALS=void 0;\n\nconst SIGNALS=[\n{\nname:\"SIGHUP\",\nnumber:1,\naction:\"terminate\",\ndescription:\"Terminal closed\",\nstandard:\"posix\"},\n\n{\nname:\"SIGINT\",\nnumber:2,\naction:\"terminate\",\ndescription:\"User interruption with CTRL-C\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGQUIT\",\nnumber:3,\naction:\"core\",\ndescription:\"User interruption with CTRL-\\\\\",\nstandard:\"posix\"},\n\n{\nname:\"SIGILL\",\nnumber:4,\naction:\"core\",\ndescription:\"Invalid machine instruction\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGTRAP\",\nnumber:5,\naction:\"core\",\ndescription:\"Debugger breakpoint\",\nstandard:\"posix\"},\n\n{\nname:\"SIGABRT\",\nnumber:6,\naction:\"core\",\ndescription:\"Aborted\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGIOT\",\nnumber:6,\naction:\"core\",\ndescription:\"Aborted\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGBUS\",\nnumber:7,\naction:\"core\",\ndescription:\n\"Bus error due to misaligned, non-existing address or paging error\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGEMT\",\nnumber:7,\naction:\"terminate\",\ndescription:\"Command should be emulated but is not implemented\",\nstandard:\"other\"},\n\n{\nname:\"SIGFPE\",\nnumber:8,\naction:\"core\",\ndescription:\"Floating point arithmetic error\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGKILL\",\nnumber:9,\naction:\"terminate\",\ndescription:\"Forced termination\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGUSR1\",\nnumber:10,\naction:\"terminate\",\ndescription:\"Application-specific signal\",\nstandard:\"posix\"},\n\n{\nname:\"SIGSEGV\",\nnumber:11,\naction:\"core\",\ndescription:\"Segmentation fault\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGUSR2\",\nnumber:12,\naction:\"terminate\",\ndescription:\"Application-specific signal\",\nstandard:\"posix\"},\n\n{\nname:\"SIGPIPE\",\nnumber:13,\naction:\"terminate\",\ndescription:\"Broken pipe or socket\",\nstandard:\"posix\"},\n\n{\nname:\"SIGALRM\",\nnumber:14,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"posix\"},\n\n{\nname:\"SIGTERM\",\nnumber:15,\naction:\"terminate\",\ndescription:\"Termination\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGSTKFLT\",\nnumber:16,\naction:\"terminate\",\ndescription:\"Stack is empty or overflowed\",\nstandard:\"other\"},\n\n{\nname:\"SIGCHLD\",\nnumber:17,\naction:\"ignore\",\ndescription:\"Child process terminated, paused or unpaused\",\nstandard:\"posix\"},\n\n{\nname:\"SIGCLD\",\nnumber:17,\naction:\"ignore\",\ndescription:\"Child process terminated, paused or unpaused\",\nstandard:\"other\"},\n\n{\nname:\"SIGCONT\",\nnumber:18,\naction:\"unpause\",\ndescription:\"Unpaused\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGSTOP\",\nnumber:19,\naction:\"pause\",\ndescription:\"Paused\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGTSTP\",\nnumber:20,\naction:\"pause\",\ndescription:\"Paused using CTRL-Z or \\\"suspend\\\"\",\nstandard:\"posix\"},\n\n{\nname:\"SIGTTIN\",\nnumber:21,\naction:\"pause\",\ndescription:\"Background process cannot read terminal input\",\nstandard:\"posix\"},\n\n{\nname:\"SIGBREAK\",\nnumber:21,\naction:\"terminate\",\ndescription:\"User interruption with CTRL-BREAK\",\nstandard:\"other\"},\n\n{\nname:\"SIGTTOU\",\nnumber:22,\naction:\"pause\",\ndescription:\"Background process cannot write to terminal output\",\nstandard:\"posix\"},\n\n{\nname:\"SIGURG\",\nnumber:23,\naction:\"ignore\",\ndescription:\"Socket received out-of-band data\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGXCPU\",\nnumber:24,\naction:\"core\",\ndescription:\"Process timed out\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGXFSZ\",\nnumber:25,\naction:\"core\",\ndescription:\"File too big\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGVTALRM\",\nnumber:26,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGPROF\",\nnumber:27,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGWINCH\",\nnumber:28,\naction:\"ignore\",\ndescription:\"Terminal window size changed\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGIO\",\nnumber:29,\naction:\"terminate\",\ndescription:\"I/O is available\",\nstandard:\"other\"},\n\n{\nname:\"SIGPOLL\",\nnumber:29,\naction:\"terminate\",\ndescription:\"Watched event\",\nstandard:\"other\"},\n\n{\nname:\"SIGINFO\",\nnumber:29,\naction:\"ignore\",\ndescription:\"Request for process information\",\nstandard:\"other\"},\n\n{\nname:\"SIGPWR\",\nnumber:30,\naction:\"terminate\",\ndescription:\"Device running out of power\",\nstandard:\"systemv\"},\n\n{\nname:\"SIGSYS\",\nnumber:31,\naction:\"core\",\ndescription:\"Invalid system call\",\nstandard:\"other\"},\n\n{\nname:\"SIGUNUSED\",\nnumber:31,\naction:\"terminate\",\ndescription:\"Invalid system call\",\nstandard:\"other\"}];exports.SIGNALS=SIGNALS;\n//# sourceMappingURL=core.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.SIGRTMAX=exports.getRealtimeSignals=void 0;\nconst getRealtimeSignals=function(){\nconst length=SIGRTMAX-SIGRTMIN+1;\nreturn Array.from({length},getRealtimeSignal);\n};exports.getRealtimeSignals=getRealtimeSignals;\n\nconst getRealtimeSignal=function(value,index){\nreturn{\nname:`SIGRT${index+1}`,\nnumber:SIGRTMIN+index,\naction:\"terminate\",\ndescription:\"Application-specific signal (realtime)\",\nstandard:\"posix\"};\n\n};\n\nconst SIGRTMIN=34;\nconst SIGRTMAX=64;exports.SIGRTMAX=SIGRTMAX;\n//# sourceMappingURL=realtime.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.getSignals=void 0;var _os=require(\"os\");\n\nvar _core=require(\"./core.js\");\nvar _realtime=require(\"./realtime.js\");\n\n\n\nconst getSignals=function(){\nconst realtimeSignals=(0,_realtime.getRealtimeSignals)();\nconst signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);\nreturn signals;\n};exports.getSignals=getSignals;\n\n\n\n\n\n\n\nconst normalizeSignal=function({\nname,\nnumber:defaultNumber,\ndescription,\naction,\nforced=false,\nstandard})\n{\nconst{\nsignals:{[name]:constantSignal}}=\n_os.constants;\nconst supported=constantSignal!==undefined;\nconst number=supported?constantSignal:defaultNumber;\nreturn{name,number,description,supported,action,forced,standard};\n};\n//# sourceMappingURL=signals.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.signalsByNumber=exports.signalsByName=void 0;var _os=require(\"os\");\n\nvar _signals=require(\"./signals.js\");\nvar _realtime=require(\"./realtime.js\");\n\n\n\nconst getSignalsByName=function(){\nconst signals=(0,_signals.getSignals)();\nreturn signals.reduce(getSignalByName,{});\n};\n\nconst getSignalByName=function(\nsignalByNameMemo,\n{name,number,description,supported,action,forced,standard})\n{\nreturn{\n...signalByNameMemo,\n[name]:{name,number,description,supported,action,forced,standard}};\n\n};\n\nconst signalsByName=getSignalsByName();exports.signalsByName=signalsByName;\n\n\n\n\nconst getSignalsByNumber=function(){\nconst signals=(0,_signals.getSignals)();\nconst length=_realtime.SIGRTMAX+1;\nconst signalsA=Array.from({length},(value,number)=>\ngetSignalByNumber(number,signals));\n\nreturn Object.assign({},...signalsA);\n};\n\nconst getSignalByNumber=function(number,signals){\nconst signal=findSignalByNumber(number,signals);\n\nif(signal===undefined){\nreturn{};\n}\n\nconst{name,description,supported,action,forced,standard}=signal;\nreturn{\n[number]:{\nname,\nnumber,\ndescription,\nsupported,\naction,\nforced,\nstandard}};\n\n\n};\n\n\n\nconst findSignalByNumber=function(number,signals){\nconst signal=signals.find(({name})=>_os.constants.signals[name]===number);\n\nif(signal!==undefined){\nreturn signal;\n}\n\nreturn signals.find(signalA=>signalA.number===number);\n};\n\nconst signalsByNumber=getSignalsByNumber();exports.signalsByNumber=signalsByNumber;\n//# sourceMappingURL=main.js.map","'use strict';\nconst {signalsByName} = require('human-signals');\n\nconst getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {\n\tif (timedOut) {\n\t\treturn `timed out after ${timeout} milliseconds`;\n\t}\n\n\tif (isCanceled) {\n\t\treturn 'was canceled';\n\t}\n\n\tif (errorCode !== undefined) {\n\t\treturn `failed with ${errorCode}`;\n\t}\n\n\tif (signal !== undefined) {\n\t\treturn `was killed with ${signal} (${signalDescription})`;\n\t}\n\n\tif (exitCode !== undefined) {\n\t\treturn `failed with exit code ${exitCode}`;\n\t}\n\n\treturn 'failed';\n};\n\nconst makeError = ({\n\tstdout,\n\tstderr,\n\tall,\n\terror,\n\tsignal,\n\texitCode,\n\tcommand,\n\tescapedCommand,\n\ttimedOut,\n\tisCanceled,\n\tkilled,\n\tparsed: {options: {timeout}}\n}) => {\n\t// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.\n\t// We normalize them to `undefined`\n\texitCode = exitCode === null ? undefined : exitCode;\n\tsignal = signal === null ? undefined : signal;\n\tconst signalDescription = signal === undefined ? undefined : signalsByName[signal].description;\n\n\tconst errorCode = error && error.code;\n\n\tconst prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});\n\tconst execaMessage = `Command ${prefix}: ${command}`;\n\tconst isError = Object.prototype.toString.call(error) === '[object Error]';\n\tconst shortMessage = isError ? `${execaMessage}\\n${error.message}` : execaMessage;\n\tconst message = [shortMessage, stderr, stdout].filter(Boolean).join('\\n');\n\n\tif (isError) {\n\t\terror.originalMessage = error.message;\n\t\terror.message = message;\n\t} else {\n\t\terror = new Error(message);\n\t}\n\n\terror.shortMessage = shortMessage;\n\terror.command = command;\n\terror.escapedCommand = escapedCommand;\n\terror.exitCode = exitCode;\n\terror.signal = signal;\n\terror.signalDescription = signalDescription;\n\terror.stdout = stdout;\n\terror.stderr = stderr;\n\n\tif (all !== undefined) {\n\t\terror.all = all;\n\t}\n\n\tif ('bufferedData' in error) {\n\t\tdelete error.bufferedData;\n\t}\n\n\terror.failed = true;\n\terror.timedOut = Boolean(timedOut);\n\terror.isCanceled = isCanceled;\n\terror.killed = killed && !timedOut;\n\n\treturn error;\n};\n\nmodule.exports = makeError;\n","'use strict';\nconst aliases = ['stdin', 'stdout', 'stderr'];\n\nconst hasAlias = options => aliases.some(alias => options[alias] !== undefined);\n\nconst normalizeStdio = options => {\n\tif (!options) {\n\t\treturn;\n\t}\n\n\tconst {stdio} = options;\n\n\tif (stdio === undefined) {\n\t\treturn aliases.map(alias => options[alias]);\n\t}\n\n\tif (hasAlias(options)) {\n\t\tthrow new Error(`It's not possible to provide \\`stdio\\` in combination with one of ${aliases.map(alias => `\\`${alias}\\``).join(', ')}`);\n\t}\n\n\tif (typeof stdio === 'string') {\n\t\treturn stdio;\n\t}\n\n\tif (!Array.isArray(stdio)) {\n\t\tthrow new TypeError(`Expected \\`stdio\\` to be of type \\`string\\` or \\`Array\\`, got \\`${typeof stdio}\\``);\n\t}\n\n\tconst length = Math.max(stdio.length, aliases.length);\n\treturn Array.from({length}, (value, index) => stdio[index]);\n};\n\nmodule.exports = normalizeStdio;\n\n// `ipc` is pushed unless it is already present\nmodule.exports.node = options => {\n\tconst stdio = normalizeStdio(options);\n\n\tif (stdio === 'ipc') {\n\t\treturn 'ipc';\n\t}\n\n\tif (stdio === undefined || typeof stdio === 'string') {\n\t\treturn [stdio, stdio, stdio, 'ipc'];\n\t}\n\n\tif (stdio.includes('ipc')) {\n\t\treturn stdio;\n\t}\n\n\treturn [...stdio, 'ipc'];\n};\n","// This is not the set of all possible signals.\n//\n// It IS, however, the set of all signals that trigger\n// an exit on either Linux or BSD systems.  Linux is a\n// superset of the signal names supported on BSD, and\n// the unknown signals just fail to register, so we can\n// catch that easily enough.\n//\n// Don't bother with SIGKILL.  It's uncatchable, which\n// means that we can't fire any callbacks anyway.\n//\n// If a user does happen to register a handler on a non-\n// fatal signal like SIGWINCH or something, and then\n// exit, it'll end up firing `process.emit('exit')`, so\n// the handler will be fired anyway.\n//\n// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised\n// artificially, inherently leave the process in a\n// state from which it is not safe to try and enter JS\n// listeners.\nmodule.exports = [\n  'SIGABRT',\n  'SIGALRM',\n  'SIGHUP',\n  'SIGINT',\n  'SIGTERM'\n]\n\nif (process.platform !== 'win32') {\n  module.exports.push(\n    'SIGVTALRM',\n    'SIGXCPU',\n    'SIGXFSZ',\n    'SIGUSR2',\n    'SIGTRAP',\n    'SIGSYS',\n    'SIGQUIT',\n    'SIGIOT'\n    // should detect profiler and enable/disable accordingly.\n    // see #21\n    // 'SIGPROF'\n  )\n}\n\nif (process.platform === 'linux') {\n  module.exports.push(\n    'SIGIO',\n    'SIGPOLL',\n    'SIGPWR',\n    'SIGSTKFLT',\n    'SIGUNUSED'\n  )\n}\n","// Note: since nyc uses this module to output coverage, any lines\n// that are in the direct sync flow of nyc's outputCoverage are\n// ignored, since we can never get coverage for them.\n// grab a reference to node's real process object right away\nvar process = global.process\n\nconst processOk = function (process) {\n  return process &&\n    typeof process === 'object' &&\n    typeof process.removeListener === 'function' &&\n    typeof process.emit === 'function' &&\n    typeof process.reallyExit === 'function' &&\n    typeof process.listeners === 'function' &&\n    typeof process.kill === 'function' &&\n    typeof process.pid === 'number' &&\n    typeof process.on === 'function'\n}\n\n// some kind of non-node environment, just no-op\n/* istanbul ignore if */\nif (!processOk(process)) {\n  module.exports = function () {\n    return function () {}\n  }\n} else {\n  var assert = require('assert')\n  var signals = require('./signals.js')\n  var isWin = /^win/i.test(process.platform)\n\n  var EE = require('events')\n  /* istanbul ignore if */\n  if (typeof EE !== 'function') {\n    EE = EE.EventEmitter\n  }\n\n  var emitter\n  if (process.__signal_exit_emitter__) {\n    emitter = process.__signal_exit_emitter__\n  } else {\n    emitter = process.__signal_exit_emitter__ = new EE()\n    emitter.count = 0\n    emitter.emitted = {}\n  }\n\n  // Because this emitter is a global, we have to check to see if a\n  // previous version of this library failed to enable infinite listeners.\n  // I know what you're about to say.  But literally everything about\n  // signal-exit is a compromise with evil.  Get used to it.\n  if (!emitter.infinite) {\n    emitter.setMaxListeners(Infinity)\n    emitter.infinite = true\n  }\n\n  module.exports = function (cb, opts) {\n    /* istanbul ignore if */\n    if (!processOk(global.process)) {\n      return function () {}\n    }\n    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')\n\n    if (loaded === false) {\n      load()\n    }\n\n    var ev = 'exit'\n    if (opts && opts.alwaysLast) {\n      ev = 'afterexit'\n    }\n\n    var remove = function () {\n      emitter.removeListener(ev, cb)\n      if (emitter.listeners('exit').length === 0 &&\n          emitter.listeners('afterexit').length === 0) {\n        unload()\n      }\n    }\n    emitter.on(ev, cb)\n\n    return remove\n  }\n\n  var unload = function unload () {\n    if (!loaded || !processOk(global.process)) {\n      return\n    }\n    loaded = false\n\n    signals.forEach(function (sig) {\n      try {\n        process.removeListener(sig, sigListeners[sig])\n      } catch (er) {}\n    })\n    process.emit = originalProcessEmit\n    process.reallyExit = originalProcessReallyExit\n    emitter.count -= 1\n  }\n  module.exports.unload = unload\n\n  var emit = function emit (event, code, signal) {\n    /* istanbul ignore if */\n    if (emitter.emitted[event]) {\n      return\n    }\n    emitter.emitted[event] = true\n    emitter.emit(event, code, signal)\n  }\n\n  // { <signal>: <listener fn>, ... }\n  var sigListeners = {}\n  signals.forEach(function (sig) {\n    sigListeners[sig] = function listener () {\n      /* istanbul ignore if */\n      if (!processOk(global.process)) {\n        return\n      }\n      // If there are no other listeners, an exit is coming!\n      // Simplest way: remove us and then re-send the signal.\n      // We know that this will kill the process, so we can\n      // safely emit now.\n      var listeners = process.listeners(sig)\n      if (listeners.length === emitter.count) {\n        unload()\n        emit('exit', null, sig)\n        /* istanbul ignore next */\n        emit('afterexit', null, sig)\n        /* istanbul ignore next */\n        if (isWin && sig === 'SIGHUP') {\n          // \"SIGHUP\" throws an `ENOSYS` error on Windows,\n          // so use a supported signal instead\n          sig = 'SIGINT'\n        }\n        /* istanbul ignore next */\n        process.kill(process.pid, sig)\n      }\n    }\n  })\n\n  module.exports.signals = function () {\n    return signals\n  }\n\n  var loaded = false\n\n  var load = function load () {\n    if (loaded || !processOk(global.process)) {\n      return\n    }\n    loaded = true\n\n    // This is the number of onSignalExit's that are in play.\n    // It's important so that we can count the correct number of\n    // listeners on signals, and don't wait for the other one to\n    // handle it instead of us.\n    emitter.count += 1\n\n    signals = signals.filter(function (sig) {\n      try {\n        process.on(sig, sigListeners[sig])\n        return true\n      } catch (er) {\n        return false\n      }\n    })\n\n    process.emit = processEmit\n    process.reallyExit = processReallyExit\n  }\n  module.exports.load = load\n\n  var originalProcessReallyExit = process.reallyExit\n  var processReallyExit = function processReallyExit (code) {\n    /* istanbul ignore if */\n    if (!processOk(global.process)) {\n      return\n    }\n    process.exitCode = code || /* istanbul ignore next */ 0\n    emit('exit', process.exitCode, null)\n    /* istanbul ignore next */\n    emit('afterexit', process.exitCode, null)\n    /* istanbul ignore next */\n    originalProcessReallyExit.call(process, process.exitCode)\n  }\n\n  var originalProcessEmit = process.emit\n  var processEmit = function processEmit (ev, arg) {\n    if (ev === 'exit' && processOk(global.process)) {\n      /* istanbul ignore else */\n      if (arg !== undefined) {\n        process.exitCode = arg\n      }\n      var ret = originalProcessEmit.apply(this, arguments)\n      /* istanbul ignore next */\n      emit('exit', process.exitCode, null)\n      /* istanbul ignore next */\n      emit('afterexit', process.exitCode, null)\n      /* istanbul ignore next */\n      return ret\n    } else {\n      return originalProcessEmit.apply(this, arguments)\n    }\n  }\n}\n","'use strict';\nconst os = require('os');\nconst onExit = require('signal-exit');\n\nconst DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;\n\n// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior\nconst spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {\n\tconst killResult = kill(signal);\n\tsetKillTimeout(kill, signal, options, killResult);\n\treturn killResult;\n};\n\nconst setKillTimeout = (kill, signal, options, killResult) => {\n\tif (!shouldForceKill(signal, options, killResult)) {\n\t\treturn;\n\t}\n\n\tconst timeout = getForceKillAfterTimeout(options);\n\tconst t = setTimeout(() => {\n\t\tkill('SIGKILL');\n\t}, timeout);\n\n\t// Guarded because there's no `.unref()` when `execa` is used in the renderer\n\t// process in Electron. This cannot be tested since we don't run tests in\n\t// Electron.\n\t// istanbul ignore else\n\tif (t.unref) {\n\t\tt.unref();\n\t}\n};\n\nconst shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {\n\treturn isSigterm(signal) && forceKillAfterTimeout !== false && killResult;\n};\n\nconst isSigterm = signal => {\n\treturn signal === os.constants.signals.SIGTERM ||\n\t\t(typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');\n};\n\nconst getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {\n\tif (forceKillAfterTimeout === true) {\n\t\treturn DEFAULT_FORCE_KILL_TIMEOUT;\n\t}\n\n\tif (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {\n\t\tthrow new TypeError(`Expected the \\`forceKillAfterTimeout\\` option to be a non-negative integer, got \\`${forceKillAfterTimeout}\\` (${typeof forceKillAfterTimeout})`);\n\t}\n\n\treturn forceKillAfterTimeout;\n};\n\n// `childProcess.cancel()`\nconst spawnedCancel = (spawned, context) => {\n\tconst killResult = spawned.kill();\n\n\tif (killResult) {\n\t\tcontext.isCanceled = true;\n\t}\n};\n\nconst timeoutKill = (spawned, signal, reject) => {\n\tspawned.kill(signal);\n\treject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));\n};\n\n// `timeout` option handling\nconst setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {\n\tif (timeout === 0 || timeout === undefined) {\n\t\treturn spawnedPromise;\n\t}\n\n\tlet timeoutId;\n\tconst timeoutPromise = new Promise((resolve, reject) => {\n\t\ttimeoutId = setTimeout(() => {\n\t\t\ttimeoutKill(spawned, killSignal, reject);\n\t\t}, timeout);\n\t});\n\n\tconst safeSpawnedPromise = spawnedPromise.finally(() => {\n\t\tclearTimeout(timeoutId);\n\t});\n\n\treturn Promise.race([timeoutPromise, safeSpawnedPromise]);\n};\n\nconst validateTimeout = ({timeout}) => {\n\tif (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {\n\t\tthrow new TypeError(`Expected the \\`timeout\\` option to be a non-negative integer, got \\`${timeout}\\` (${typeof timeout})`);\n\t}\n};\n\n// `cleanup` option handling\nconst setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {\n\tif (!cleanup || detached) {\n\t\treturn timedPromise;\n\t}\n\n\tconst removeExitHandler = onExit(() => {\n\t\tspawned.kill();\n\t});\n\n\treturn timedPromise.finally(() => {\n\t\tremoveExitHandler();\n\t});\n};\n\nmodule.exports = {\n\tspawnedKill,\n\tspawnedCancel,\n\tsetupTimeout,\n\tvalidateTimeout,\n\tsetExitHandler\n};\n","'use strict';\n\nconst isStream = stream =>\n\tstream !== null &&\n\ttypeof stream === 'object' &&\n\ttypeof stream.pipe === 'function';\n\nisStream.writable = stream =>\n\tisStream(stream) &&\n\tstream.writable !== false &&\n\ttypeof stream._write === 'function' &&\n\ttypeof stream._writableState === 'object';\n\nisStream.readable = stream =>\n\tisStream(stream) &&\n\tstream.readable !== false &&\n\ttypeof stream._read === 'function' &&\n\ttypeof stream._readableState === 'object';\n\nisStream.duplex = stream =>\n\tisStream.writable(stream) &&\n\tisStream.readable(stream);\n\nisStream.transform = stream =>\n\tisStream.duplex(stream) &&\n\ttypeof stream._transform === 'function';\n\nmodule.exports = isStream;\n","'use strict';\nconst {PassThrough: PassThroughStream} = require('stream');\n\nmodule.exports = options => {\n\toptions = {...options};\n\n\tconst {array} = options;\n\tlet {encoding} = options;\n\tconst isBuffer = encoding === 'buffer';\n\tlet objectMode = false;\n\n\tif (array) {\n\t\tobjectMode = !(encoding || isBuffer);\n\t} else {\n\t\tencoding = encoding || 'utf8';\n\t}\n\n\tif (isBuffer) {\n\t\tencoding = null;\n\t}\n\n\tconst stream = new PassThroughStream({objectMode});\n\n\tif (encoding) {\n\t\tstream.setEncoding(encoding);\n\t}\n\n\tlet length = 0;\n\tconst chunks = [];\n\n\tstream.on('data', chunk => {\n\t\tchunks.push(chunk);\n\n\t\tif (objectMode) {\n\t\t\tlength = chunks.length;\n\t\t} else {\n\t\t\tlength += chunk.length;\n\t\t}\n\t});\n\n\tstream.getBufferedValue = () => {\n\t\tif (array) {\n\t\t\treturn chunks;\n\t\t}\n\n\t\treturn isBuffer ? Buffer.concat(chunks, length) : chunks.join('');\n\t};\n\n\tstream.getBufferedLength = () => length;\n\n\treturn stream;\n};\n","'use strict';\nconst {constants: BufferConstants} = require('buffer');\nconst stream = require('stream');\nconst {promisify} = require('util');\nconst bufferStream = require('./buffer-stream');\n\nconst streamPipelinePromisified = promisify(stream.pipeline);\n\nclass MaxBufferError extends Error {\n\tconstructor() {\n\t\tsuper('maxBuffer exceeded');\n\t\tthis.name = 'MaxBufferError';\n\t}\n}\n\nasync function getStream(inputStream, options) {\n\tif (!inputStream) {\n\t\tthrow new Error('Expected a stream');\n\t}\n\n\toptions = {\n\t\tmaxBuffer: Infinity,\n\t\t...options\n\t};\n\n\tconst {maxBuffer} = options;\n\tconst stream = bufferStream(options);\n\n\tawait new Promise((resolve, reject) => {\n\t\tconst rejectPromise = error => {\n\t\t\t// Don't retrieve an oversized buffer.\n\t\t\tif (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {\n\t\t\t\terror.bufferedData = stream.getBufferedValue();\n\t\t\t}\n\n\t\t\treject(error);\n\t\t};\n\n\t\t(async () => {\n\t\t\ttry {\n\t\t\t\tawait streamPipelinePromisified(inputStream, stream);\n\t\t\t\tresolve();\n\t\t\t} catch (error) {\n\t\t\t\trejectPromise(error);\n\t\t\t}\n\t\t})();\n\n\t\tstream.on('data', () => {\n\t\t\tif (stream.getBufferedLength() > maxBuffer) {\n\t\t\t\trejectPromise(new MaxBufferError());\n\t\t\t}\n\t\t});\n\t});\n\n\treturn stream.getBufferedValue();\n}\n\nmodule.exports = getStream;\nmodule.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});\nmodule.exports.array = (stream, options) => getStream(stream, {...options, array: true});\nmodule.exports.MaxBufferError = MaxBufferError;\n","'use strict';\n\nconst { PassThrough } = require('stream');\n\nmodule.exports = function (/*streams...*/) {\n  var sources = []\n  var output  = new PassThrough({objectMode: true})\n\n  output.setMaxListeners(0)\n\n  output.add = add\n  output.isEmpty = isEmpty\n\n  output.on('unpipe', remove)\n\n  Array.prototype.slice.call(arguments).forEach(add)\n\n  return output\n\n  function add (source) {\n    if (Array.isArray(source)) {\n      source.forEach(add)\n      return this\n    }\n\n    sources.push(source);\n    source.once('end', remove.bind(null, source))\n    source.once('error', output.emit.bind(output, 'error'))\n    source.pipe(output, {end: false})\n    return this\n  }\n\n  function isEmpty () {\n    return sources.length == 0;\n  }\n\n  function remove (source) {\n    sources = sources.filter(function (it) { return it !== source })\n    if (!sources.length && output.readable) { output.end() }\n  }\n}\n","'use strict';\nconst isStream = require('is-stream');\nconst getStream = require('get-stream');\nconst mergeStream = require('merge-stream');\n\n// `input` option\nconst handleInput = (spawned, input) => {\n\t// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852\n\t// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0\n\tif (input === undefined || spawned.stdin === undefined) {\n\t\treturn;\n\t}\n\n\tif (isStream(input)) {\n\t\tinput.pipe(spawned.stdin);\n\t} else {\n\t\tspawned.stdin.end(input);\n\t}\n};\n\n// `all` interleaves `stdout` and `stderr`\nconst makeAllStream = (spawned, {all}) => {\n\tif (!all || (!spawned.stdout && !spawned.stderr)) {\n\t\treturn;\n\t}\n\n\tconst mixed = mergeStream();\n\n\tif (spawned.stdout) {\n\t\tmixed.add(spawned.stdout);\n\t}\n\n\tif (spawned.stderr) {\n\t\tmixed.add(spawned.stderr);\n\t}\n\n\treturn mixed;\n};\n\n// On failure, `result.stdout|stderr|all` should contain the currently buffered stream\nconst getBufferedData = async (stream, streamPromise) => {\n\tif (!stream) {\n\t\treturn;\n\t}\n\n\tstream.destroy();\n\n\ttry {\n\t\treturn await streamPromise;\n\t} catch (error) {\n\t\treturn error.bufferedData;\n\t}\n};\n\nconst getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {\n\tif (!stream || !buffer) {\n\t\treturn;\n\t}\n\n\tif (encoding) {\n\t\treturn getStream(stream, {encoding, maxBuffer});\n\t}\n\n\treturn getStream.buffer(stream, {maxBuffer});\n};\n\n// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)\nconst getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {\n\tconst stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});\n\tconst stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});\n\tconst allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});\n\n\ttry {\n\t\treturn await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);\n\t} catch (error) {\n\t\treturn Promise.all([\n\t\t\t{error, signal: error.signal, timedOut: error.timedOut},\n\t\t\tgetBufferedData(stdout, stdoutPromise),\n\t\t\tgetBufferedData(stderr, stderrPromise),\n\t\t\tgetBufferedData(all, allPromise)\n\t\t]);\n\t}\n};\n\nconst validateInputSync = ({input}) => {\n\tif (isStream(input)) {\n\t\tthrow new TypeError('The `input` option cannot be a stream in sync mode');\n\t}\n};\n\nmodule.exports = {\n\thandleInput,\n\tmakeAllStream,\n\tgetSpawnedResult,\n\tvalidateInputSync\n};\n\n","'use strict';\n\nconst nativePromisePrototype = (async () => {})().constructor.prototype;\nconst descriptors = ['then', 'catch', 'finally'].map(property => [\n\tproperty,\n\tReflect.getOwnPropertyDescriptor(nativePromisePrototype, property)\n]);\n\n// The return value is a mixin of `childProcess` and `Promise`\nconst mergePromise = (spawned, promise) => {\n\tfor (const [property, descriptor] of descriptors) {\n\t\t// Starting the main `promise` is deferred to avoid consuming streams\n\t\tconst value = typeof promise === 'function' ?\n\t\t\t(...args) => Reflect.apply(descriptor.value, promise(), args) :\n\t\t\tdescriptor.value.bind(promise);\n\n\t\tReflect.defineProperty(spawned, property, {...descriptor, value});\n\t}\n\n\treturn spawned;\n};\n\n// Use promises instead of `child_process` events\nconst getSpawnedPromise = spawned => {\n\treturn new Promise((resolve, reject) => {\n\t\tspawned.on('exit', (exitCode, signal) => {\n\t\t\tresolve({exitCode, signal});\n\t\t});\n\n\t\tspawned.on('error', error => {\n\t\t\treject(error);\n\t\t});\n\n\t\tif (spawned.stdin) {\n\t\t\tspawned.stdin.on('error', error => {\n\t\t\t\treject(error);\n\t\t\t});\n\t\t}\n\t});\n};\n\nmodule.exports = {\n\tmergePromise,\n\tgetSpawnedPromise\n};\n\n","'use strict';\nconst normalizeArgs = (file, args = []) => {\n\tif (!Array.isArray(args)) {\n\t\treturn [file];\n\t}\n\n\treturn [file, ...args];\n};\n\nconst NO_ESCAPE_REGEXP = /^[\\w.-]+$/;\nconst DOUBLE_QUOTES_REGEXP = /\"/g;\n\nconst escapeArg = arg => {\n\tif (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {\n\t\treturn arg;\n\t}\n\n\treturn `\"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\\\\"')}\"`;\n};\n\nconst joinCommand = (file, args) => {\n\treturn normalizeArgs(file, args).join(' ');\n};\n\nconst getEscapedCommand = (file, args) => {\n\treturn normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');\n};\n\nconst SPACES_REGEXP = / +/g;\n\n// Handle `execa.command()`\nconst parseCommand = command => {\n\tconst tokens = [];\n\tfor (const token of command.trim().split(SPACES_REGEXP)) {\n\t\t// Allow spaces to be escaped by a backslash if not meant as a delimiter\n\t\tconst previousToken = tokens[tokens.length - 1];\n\t\tif (previousToken && previousToken.endsWith('\\\\')) {\n\t\t\t// Merge previous token with current one\n\t\t\ttokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;\n\t\t} else {\n\t\t\ttokens.push(token);\n\t\t}\n\t}\n\n\treturn tokens;\n};\n\nmodule.exports = {\n\tjoinCommand,\n\tgetEscapedCommand,\n\tparseCommand\n};\n","'use strict';\nconst path = require('path');\nconst childProcess = require('child_process');\nconst crossSpawn = require('cross-spawn');\nconst stripFinalNewline = require('strip-final-newline');\nconst npmRunPath = require('npm-run-path');\nconst onetime = require('onetime');\nconst makeError = require('./lib/error');\nconst normalizeStdio = require('./lib/stdio');\nconst {spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler} = require('./lib/kill');\nconst {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = require('./lib/stream');\nconst {mergePromise, getSpawnedPromise} = require('./lib/promise');\nconst {joinCommand, parseCommand, getEscapedCommand} = require('./lib/command');\n\nconst DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;\n\nconst getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {\n\tconst env = extendEnv ? {...process.env, ...envOption} : envOption;\n\n\tif (preferLocal) {\n\t\treturn npmRunPath.env({env, cwd: localDir, execPath});\n\t}\n\n\treturn env;\n};\n\nconst handleArguments = (file, args, options = {}) => {\n\tconst parsed = crossSpawn._parse(file, args, options);\n\tfile = parsed.command;\n\targs = parsed.args;\n\toptions = parsed.options;\n\n\toptions = {\n\t\tmaxBuffer: DEFAULT_MAX_BUFFER,\n\t\tbuffer: true,\n\t\tstripFinalNewline: true,\n\t\textendEnv: true,\n\t\tpreferLocal: false,\n\t\tlocalDir: options.cwd || process.cwd(),\n\t\texecPath: process.execPath,\n\t\tencoding: 'utf8',\n\t\treject: true,\n\t\tcleanup: true,\n\t\tall: false,\n\t\twindowsHide: true,\n\t\t...options\n\t};\n\n\toptions.env = getEnv(options);\n\n\toptions.stdio = normalizeStdio(options);\n\n\tif (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {\n\t\t// #116\n\t\targs.unshift('/q');\n\t}\n\n\treturn {file, args, options, parsed};\n};\n\nconst handleOutput = (options, value, error) => {\n\tif (typeof value !== 'string' && !Buffer.isBuffer(value)) {\n\t\t// When `execa.sync()` errors, we normalize it to '' to mimic `execa()`\n\t\treturn error === undefined ? undefined : '';\n\t}\n\n\tif (options.stripFinalNewline) {\n\t\treturn stripFinalNewline(value);\n\t}\n\n\treturn value;\n};\n\nconst execa = (file, args, options) => {\n\tconst parsed = handleArguments(file, args, options);\n\tconst command = joinCommand(file, args);\n\tconst escapedCommand = getEscapedCommand(file, args);\n\n\tvalidateTimeout(parsed.options);\n\n\tlet spawned;\n\ttry {\n\t\tspawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);\n\t} catch (error) {\n\t\t// Ensure the returned error is always both a promise and a child process\n\t\tconst dummySpawned = new childProcess.ChildProcess();\n\t\tconst errorPromise = Promise.reject(makeError({\n\t\t\terror,\n\t\t\tstdout: '',\n\t\t\tstderr: '',\n\t\t\tall: '',\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t}));\n\t\treturn mergePromise(dummySpawned, errorPromise);\n\t}\n\n\tconst spawnedPromise = getSpawnedPromise(spawned);\n\tconst timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);\n\tconst processDone = setExitHandler(spawned, parsed.options, timedPromise);\n\n\tconst context = {isCanceled: false};\n\n\tspawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));\n\tspawned.cancel = spawnedCancel.bind(null, spawned, context);\n\n\tconst handlePromise = async () => {\n\t\tconst [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);\n\t\tconst stdout = handleOutput(parsed.options, stdoutResult);\n\t\tconst stderr = handleOutput(parsed.options, stderrResult);\n\t\tconst all = handleOutput(parsed.options, allResult);\n\n\t\tif (error || exitCode !== 0 || signal !== null) {\n\t\t\tconst returnedError = makeError({\n\t\t\t\terror,\n\t\t\t\texitCode,\n\t\t\t\tsignal,\n\t\t\t\tstdout,\n\t\t\t\tstderr,\n\t\t\t\tall,\n\t\t\t\tcommand,\n\t\t\t\tescapedCommand,\n\t\t\t\tparsed,\n\t\t\t\ttimedOut,\n\t\t\t\tisCanceled: context.isCanceled,\n\t\t\t\tkilled: spawned.killed\n\t\t\t});\n\n\t\t\tif (!parsed.options.reject) {\n\t\t\t\treturn returnedError;\n\t\t\t}\n\n\t\t\tthrow returnedError;\n\t\t}\n\n\t\treturn {\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\texitCode: 0,\n\t\t\tstdout,\n\t\t\tstderr,\n\t\t\tall,\n\t\t\tfailed: false,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t};\n\t};\n\n\tconst handlePromiseOnce = onetime(handlePromise);\n\n\thandleInput(spawned, parsed.options.input);\n\n\tspawned.all = makeAllStream(spawned, parsed.options);\n\n\treturn mergePromise(spawned, handlePromiseOnce);\n};\n\nmodule.exports = execa;\n\nmodule.exports.sync = (file, args, options) => {\n\tconst parsed = handleArguments(file, args, options);\n\tconst command = joinCommand(file, args);\n\tconst escapedCommand = getEscapedCommand(file, args);\n\n\tvalidateInputSync(parsed.options);\n\n\tlet result;\n\ttry {\n\t\tresult = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);\n\t} catch (error) {\n\t\tthrow makeError({\n\t\t\terror,\n\t\t\tstdout: '',\n\t\t\tstderr: '',\n\t\t\tall: '',\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t});\n\t}\n\n\tconst stdout = handleOutput(parsed.options, result.stdout, result.error);\n\tconst stderr = handleOutput(parsed.options, result.stderr, result.error);\n\n\tif (result.error || result.status !== 0 || result.signal !== null) {\n\t\tconst error = makeError({\n\t\t\tstdout,\n\t\t\tstderr,\n\t\t\terror: result.error,\n\t\t\tsignal: result.signal,\n\t\t\texitCode: result.status,\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: result.error && result.error.code === 'ETIMEDOUT',\n\t\t\tisCanceled: false,\n\t\t\tkilled: result.signal !== null\n\t\t});\n\n\t\tif (!parsed.options.reject) {\n\t\t\treturn error;\n\t\t}\n\n\t\tthrow error;\n\t}\n\n\treturn {\n\t\tcommand,\n\t\tescapedCommand,\n\t\texitCode: 0,\n\t\tstdout,\n\t\tstderr,\n\t\tfailed: false,\n\t\ttimedOut: false,\n\t\tisCanceled: false,\n\t\tkilled: false\n\t};\n};\n\nmodule.exports.command = (command, options) => {\n\tconst [file, ...args] = parseCommand(command);\n\treturn execa(file, args, options);\n};\n\nmodule.exports.commandSync = (command, options) => {\n\tconst [file, ...args] = parseCommand(command);\n\treturn execa.sync(file, args, options);\n};\n\nmodule.exports.node = (scriptPath, args, options = {}) => {\n\tif (args && !Array.isArray(args) && typeof args === 'object') {\n\t\toptions = args;\n\t\targs = [];\n\t}\n\n\tconst stdio = normalizeStdio.node(options);\n\tconst defaultExecArgv = process.execArgv.filter(arg => !arg.startsWith('--inspect'));\n\n\tconst {\n\t\tnodePath = process.execPath,\n\t\tnodeOptions = defaultExecArgv\n\t} = options;\n\n\treturn execa(\n\t\tnodePath,\n\t\t[\n\t\t\t...nodeOptions,\n\t\t\tscriptPath,\n\t\t\t...(Array.isArray(args) ? args : [])\n\t\t],\n\t\t{\n\t\t\t...options,\n\t\t\tstdin: undefined,\n\t\t\tstdout: undefined,\n\t\t\tstderr: undefined,\n\t\t\tstdio,\n\t\t\tshell: false\n\t\t}\n\t);\n};\n","export default function ansiRegex({onlyFirst = false} = {}) {\n\tconst pattern = [\n\t    '[\\\\u001B\\\\u009B][[\\\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\\\d\\\\/#&.:=?%@~_]+)*|[a-zA-Z\\\\d]+(?:;[-a-zA-Z\\\\d\\\\/#&.:=?%@~_]*)*)?\\\\u0007)',\n\t\t'(?:(?:\\\\d{1,4}(?:;\\\\d{0,4})*)?[\\\\dA-PR-TZcf-ntqry=><~]))'\n\t].join('|');\n\n\treturn new RegExp(pattern, onlyFirst ? undefined : 'g');\n}\n","import ansiRegex from 'ansi-regex';\n\nexport default function stripAnsi(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError(`Expected a \\`string\\`, got \\`${typeof string}\\``);\n\t}\n\n\treturn string.replace(ansiRegex(), '');\n}\n","import process from 'node:process';\nimport {userInfo} from 'node:os';\n\nexport const detectDefaultShell = () => {\n\tconst {env} = process;\n\n\tif (process.platform === 'win32') {\n\t\treturn env.COMSPEC || 'cmd.exe';\n\t}\n\n\ttry {\n\t\tconst {shell} = userInfo();\n\t\tif (shell) {\n\t\t\treturn shell;\n\t\t}\n\t} catch {}\n\n\tif (process.platform === 'darwin') {\n\t\treturn env.SHELL || '/bin/zsh';\n\t}\n\n\treturn env.SHELL || '/bin/sh';\n};\n\n// Stores default shell when imported.\nconst defaultShell = detectDefaultShell();\n\nexport default defaultShell;\n","import process from 'node:process';\nimport execa from 'execa';\nimport stripAnsi from 'strip-ansi';\nimport defaultShell from 'default-shell';\n\nconst args = [\n\t'-ilc',\n\t'echo -n \"_SHELL_ENV_DELIMITER_\"; env; echo -n \"_SHELL_ENV_DELIMITER_\"; exit',\n];\n\nconst env = {\n\t// Disables Oh My Zsh auto-update thing that can block the process.\n\tDISABLE_AUTO_UPDATE: 'true',\n};\n\nconst parseEnv = env => {\n\tenv = env.split('_SHELL_ENV_DELIMITER_')[1];\n\tconst returnValue = {};\n\n\tfor (const line of stripAnsi(env).split('\\n').filter(line => Boolean(line))) {\n\t\tconst [key, ...values] = line.split('=');\n\t\treturnValue[key] = values.join('=');\n\t}\n\n\treturn returnValue;\n};\n\nexport async function shellEnv(shell) {\n\tif (process.platform === 'win32') {\n\t\treturn process.env;\n\t}\n\n\ttry {\n\t\tconst {stdout} = await execa(shell || defaultShell, args, {env});\n\t\treturn parseEnv(stdout);\n\t} catch (error) {\n\t\tif (shell) {\n\t\t\tthrow error;\n\t\t} else {\n\t\t\treturn process.env;\n\t\t}\n\t}\n}\n\nexport function shellEnvSync(shell) {\n\tif (process.platform === 'win32') {\n\t\treturn process.env;\n\t}\n\n\ttry {\n\t\tconst {stdout} = execa.sync(shell || defaultShell, args, {env});\n\t\treturn parseEnv(stdout);\n\t} catch (error) {\n\t\tif (shell) {\n\t\t\tthrow error;\n\t\t} else {\n\t\t\treturn process.env;\n\t\t}\n\t}\n}\n","import {shellEnv, shellEnvSync} from 'shell-env';\n\nexport async function shellPath() {\n\tconst {PATH} = await shellEnv();\n\treturn PATH;\n}\n\nexport function shellPathSync() {\n\tconst {PATH} = shellEnvSync();\n\treturn PATH;\n}\n","import process from 'node:process';\nimport {shellPathSync} from 'shell-path';\n\nexport default function fixPath() {\n\tif (process.platform === 'win32') {\n\t\treturn;\n\t}\n\n\tprocess.env.PATH = shellPathSync() || [\n\t\t'./node_modules/.bin',\n\t\t'/.nodebrew/current/bin',\n\t\t'/usr/local/bin',\n\t\tprocess.env.PATH,\n\t].join(':');\n}\n","module.exports = require('stream');\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar _require = require('buffer'),\n  Buffer = _require.Buffer;\nvar _require2 = require('util'),\n  inspect = _require2.inspect;\nvar custom = inspect && inspect.custom || 'inspect';\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\nmodule.exports = /*#__PURE__*/function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n      while (p = p.next) ret += s + p.data;\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes or characters from the buffered data.\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    }\n\n    // Consumes a specified amount of characters from the buffered data.\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes from the buffered data.\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Make sure the linked list only shows the minimal necessary information.\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n  return BufferList;\n}();","'use strict';\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n  return this;\n}\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","'use strict';\n\nconst codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error\n  }\n\n  function getMessage (arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message\n    } else {\n      return message(arg1, arg2, arg3)\n    }\n  }\n\n  class NodeError extends Base {\n    constructor (arg1, arg2, arg3) {\n      super(getMessage(arg1, arg2, arg3));\n    }\n  }\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n\n  codes[code] = NodeError;\n}\n\n// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    const len = expected.length;\n    expected = expected.map((i) => String(i));\n    if (len > 2) {\n      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +\n             expected[len - 1];\n    } else if (len === 2) {\n      return `one of ${thing} ${expected[0]} or ${expected[1]}`;\n    } else {\n      return `of ${thing} ${expected[0]}`;\n    }\n  } else {\n    return `of ${thing} ${String(expected)}`;\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\nfunction startsWith(str, search, pos) {\n\treturn str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\nfunction endsWith(str, search, this_len) {\n\tif (this_len === undefined || this_len > str.length) {\n\t\tthis_len = str.length;\n\t}\n\treturn str.substring(this_len - search.length, this_len) === search;\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"'\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  let determiner;\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  let msg;\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;\n  } else {\n    const type = includes(name, '.') ? 'property' : 'argument';\n    msg = `The \"${name}\" ${type} ${determiner} ${oneOf(expected, 'type')}`;\n  }\n\n  msg += `. Received type ${typeof actual}`;\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented'\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\n\nmodule.exports.codes = codes;\n","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n    return Math.floor(hwm);\n  }\n\n  // Default value\n  return state.objectMode ? 16 : 16 * 1024;\n}\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","try {\n  var util = require('util');\n  /* istanbul ignore next */\n  if (typeof util.inherits !== 'function') throw '';\n  module.exports = util.inherits;\n} catch (e) {\n  /* istanbul ignore next */\n  module.exports = require('./inherits_browser.js');\n}\n","\n/**\n * For Node.js, simply re-export the core `util.deprecate` function.\n */\n\nmodule.exports = require('util').deprecate;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n  ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nrequire('inherits')(Writable, Stream);\nfunction nop() {}\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'finish' (and potentially 'end')\n  this.autoDestroy = !!options.autoDestroy;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex);\n\n  // legacy.\n  this.writable = true;\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END();\n  // TODO: defer error events consistently everywhere, not just the cb\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n  return true;\n}\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n  return ret;\n}\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\nWritable.prototype._writev = null;\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n  return need;\n}\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n\n  // reuse the free corkReq.\n  state.corkedRequestsFree.next = corkReq;\n}\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\nrequire('inherits')(Duplex, Readable);\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(onEndNT, this);\n}\nfunction onEndNT(self) {\n  self.end();\n}\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    callback.apply(this, args);\n  };\n}\nfunction noop() {}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n  var writableEnded = stream._writableState && stream._writableState.finished;\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n  var onclose = function onclose() {\n    var err;\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\nmodule.exports = eos;","'use strict';\n\nvar _Object$setPrototypeO;\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar finished = require('./end-of-stream');\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n  if (resolve !== null) {\n    var data = iter[kStream].read();\n    // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n  next: function next() {\n    var _this = this;\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    }\n\n    // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n    var lastPromise = this[kLastPromise];\n    var promise;\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n      promise = new Promise(this[kHandlePromise]);\n    }\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject];\n      // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n      iterator[kError] = err;\n      return;\n    }\n    var resolve = iterator[kLastResolve];\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\nmodule.exports = createReadableStreamAsyncIterator;","'use strict';\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }\nfunction _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err); } _next(undefined); }); }; }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar ERR_INVALID_ARG_TYPE = require('../../../errors').codes.ERR_INVALID_ARG_TYPE;\nfunction from(Readable, iterable, opts) {\n  var iterator;\n  if (iterable && typeof iterable.next === 'function') {\n    iterator = iterable;\n  } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);\n  var readable = new Readable(_objectSpread({\n    objectMode: true\n  }, opts));\n  // Reading boolean to protect against _read\n  // being called before last iteration completion.\n  var reading = false;\n  readable._read = function () {\n    if (!reading) {\n      reading = true;\n      next();\n    }\n  };\n  function next() {\n    return _next2.apply(this, arguments);\n  }\n  function _next2() {\n    _next2 = _asyncToGenerator(function* () {\n      try {\n        var _yield$iterator$next = yield iterator.next(),\n          value = _yield$iterator$next.value,\n          done = _yield$iterator$next.done;\n        if (done) {\n          readable.push(null);\n        } else if (readable.push(yield value)) {\n          next();\n        } else {\n          reading = false;\n        }\n      } catch (err) {\n        readable.destroy(err);\n      }\n    });\n    return _next2.apply(this, arguments);\n  }\n  return readable;\n}\nmodule.exports = from;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/buffer_list');\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\n// Lazy loaded to improve the startup performance.\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\nrequire('inherits')(Readable, Stream);\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'end' (and potentially 'finish')\n  this.autoDestroy = !!options.autoDestroy;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex);\n\n  // legacy\n  this.readable = true;\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n  Stream.call(this);\n}\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  }\n\n  // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n  return er;\n}\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder;\n  // If setEncoding(null), decoder.encoding equals utf8\n  this._readableState.encoding = this._readableState.decoder.encoding;\n\n  // Iterate over current buffer to convert already stored Buffers:\n  var p = this._readableState.buffer.head;\n  var content = '';\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n  this._readableState.buffer.clear();\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n};\n\n// Don't raise the hwm > 1GB\nvar MAX_HWM = 0x40000000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  }\n\n  // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n  return dest;\n};\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {\n      hasUnpiped: false\n    });\n    return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0;\n\n    // Try start flowing on next tick if stream isn't explicitly paused\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true;\n\n    // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n  state.paused = false;\n  return this;\n};\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n  if (!state.reading) {\n    stream.read(0);\n  }\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  this._readableState.paused = true;\n  return this;\n};\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null);\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n  return this;\n};\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n    return createReadableStreamAsyncIterator(this);\n  };\n}\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n});\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length);\n\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n    return from(Readable, iterable, opts);\n  };\n}\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\nvar _require$codes = require('../errors').codes,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\nvar Duplex = require('./_stream_duplex');\nrequire('inherits')(Transform, Duplex);\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\nfunction prefinish() {\n  var _this = this;\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\nvar Transform = require('./_stream_transform');\nrequire('inherits')(PassThrough, Transform);\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar eos;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\nvar _require$codes = require('../../../errors').codes,\n  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true;\n\n    // request.destroy just do .end - .abort is what we want\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\nfunction call(fn) {\n  fn();\n}\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\nmodule.exports = pipeline;","var Stream = require('stream');\nif (process.env.READABLE_STREAM === 'disable' && Stream) {\n  module.exports = Stream.Readable;\n  Object.assign(module.exports, Stream);\n  module.exports.Stream = Stream;\n} else {\n  exports = module.exports = require('./lib/_stream_readable.js');\n  exports.Stream = Stream || exports;\n  exports.Readable = exports;\n  exports.Writable = require('./lib/_stream_writable.js');\n  exports.Duplex = require('./lib/_stream_duplex.js');\n  exports.Transform = require('./lib/_stream_transform.js');\n  exports.PassThrough = require('./lib/_stream_passthrough.js');\n  exports.finished = require('./lib/internal/streams/end-of-stream.js');\n  exports.pipeline = require('./lib/internal/streams/pipeline.js');\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ReadableWebToNodeStream = void 0;\nconst readable_stream_1 = require(\"readable-stream\");\n/**\n * Converts a Web-API stream into Node stream.Readable class\n * Node stream readable: https://nodejs.org/api/stream.html#stream_readable_streams\n * Web API readable-stream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream\n * Node readable stream: https://nodejs.org/api/stream.html#stream_readable_streams\n */\nclass ReadableWebToNodeStream extends readable_stream_1.Readable {\n    /**\n     *\n     * @param stream Readable​Stream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream\n     */\n    constructor(stream) {\n        super();\n        this.bytesRead = 0;\n        this.released = false;\n        this.reader = stream.getReader();\n    }\n    /**\n     * Implementation of readable._read(size).\n     * When readable._read() is called, if data is available from the resource,\n     * the implementation should begin pushing that data into the read queue\n     * https://nodejs.org/api/stream.html#stream_readable_read_size_1\n     */\n    async _read() {\n        // Should start pushing data into the queue\n        // Read data from the underlying Web-API-readable-stream\n        if (this.released) {\n            this.push(null); // Signal EOF\n            return;\n        }\n        this.pendingRead = this.reader.read();\n        const data = await this.pendingRead;\n        // clear the promise before pushing pushing new data to the queue and allow sequential calls to _read()\n        delete this.pendingRead;\n        if (data.done || this.released) {\n            this.push(null); // Signal EOF\n        }\n        else {\n            this.bytesRead += data.value.length;\n            this.push(data.value); // Push new data to the queue\n        }\n    }\n    /**\n     * If there is no unresolved read call to Web-API Readable​Stream immediately returns;\n     * otherwise will wait until the read is resolved.\n     */\n    async waitForReadToComplete() {\n        if (this.pendingRead) {\n            await this.pendingRead;\n        }\n    }\n    /**\n     * Close wrapper\n     */\n    async close() {\n        await this.syncAndRelease();\n    }\n    async syncAndRelease() {\n        this.released = true;\n        await this.waitForReadToComplete();\n        await this.reader.releaseLock();\n    }\n}\nexports.ReadableWebToNodeStream = ReadableWebToNodeStream;\n//# sourceMappingURL=index.js.map","import * as ieee754 from 'ieee754';\nimport { Buffer } from 'node:buffer';\n// Primitive types\nfunction dv(array) {\n    return new DataView(array.buffer, array.byteOffset);\n}\n/**\n * 8-bit unsigned integer\n */\nexport const UINT8 = {\n    len: 1,\n    get(array, offset) {\n        return dv(array).getUint8(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setUint8(offset, value);\n        return offset + 1;\n    }\n};\n/**\n * 16-bit unsigned integer, Little Endian byte order\n */\nexport const UINT16_LE = {\n    len: 2,\n    get(array, offset) {\n        return dv(array).getUint16(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setUint16(offset, value, true);\n        return offset + 2;\n    }\n};\n/**\n * 16-bit unsigned integer, Big Endian byte order\n */\nexport const UINT16_BE = {\n    len: 2,\n    get(array, offset) {\n        return dv(array).getUint16(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setUint16(offset, value);\n        return offset + 2;\n    }\n};\n/**\n * 24-bit unsigned integer, Little Endian byte order\n */\nexport const UINT24_LE = {\n    len: 3,\n    get(array, offset) {\n        const dataView = dv(array);\n        return dataView.getUint8(offset) + (dataView.getUint16(offset + 1, true) << 8);\n    },\n    put(array, offset, value) {\n        const dataView = dv(array);\n        dataView.setUint8(offset, value & 0xff);\n        dataView.setUint16(offset + 1, value >> 8, true);\n        return offset + 3;\n    }\n};\n/**\n * 24-bit unsigned integer, Big Endian byte order\n */\nexport const UINT24_BE = {\n    len: 3,\n    get(array, offset) {\n        const dataView = dv(array);\n        return (dataView.getUint16(offset) << 8) + dataView.getUint8(offset + 2);\n    },\n    put(array, offset, value) {\n        const dataView = dv(array);\n        dataView.setUint16(offset, value >> 8);\n        dataView.setUint8(offset + 2, value & 0xff);\n        return offset + 3;\n    }\n};\n/**\n * 32-bit unsigned integer, Little Endian byte order\n */\nexport const UINT32_LE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getUint32(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setUint32(offset, value, true);\n        return offset + 4;\n    }\n};\n/**\n * 32-bit unsigned integer, Big Endian byte order\n */\nexport const UINT32_BE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getUint32(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setUint32(offset, value);\n        return offset + 4;\n    }\n};\n/**\n * 8-bit signed integer\n */\nexport const INT8 = {\n    len: 1,\n    get(array, offset) {\n        return dv(array).getInt8(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setInt8(offset, value);\n        return offset + 1;\n    }\n};\n/**\n * 16-bit signed integer, Big Endian byte order\n */\nexport const INT16_BE = {\n    len: 2,\n    get(array, offset) {\n        return dv(array).getInt16(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setInt16(offset, value);\n        return offset + 2;\n    }\n};\n/**\n * 16-bit signed integer, Little Endian byte order\n */\nexport const INT16_LE = {\n    len: 2,\n    get(array, offset) {\n        return dv(array).getInt16(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setInt16(offset, value, true);\n        return offset + 2;\n    }\n};\n/**\n * 24-bit signed integer, Little Endian byte order\n */\nexport const INT24_LE = {\n    len: 3,\n    get(array, offset) {\n        const unsigned = UINT24_LE.get(array, offset);\n        return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;\n    },\n    put(array, offset, value) {\n        const dataView = dv(array);\n        dataView.setUint8(offset, value & 0xff);\n        dataView.setUint16(offset + 1, value >> 8, true);\n        return offset + 3;\n    }\n};\n/**\n * 24-bit signed integer, Big Endian byte order\n */\nexport const INT24_BE = {\n    len: 3,\n    get(array, offset) {\n        const unsigned = UINT24_BE.get(array, offset);\n        return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;\n    },\n    put(array, offset, value) {\n        const dataView = dv(array);\n        dataView.setUint16(offset, value >> 8);\n        dataView.setUint8(offset + 2, value & 0xff);\n        return offset + 3;\n    }\n};\n/**\n * 32-bit signed integer, Big Endian byte order\n */\nexport const INT32_BE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getInt32(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setInt32(offset, value);\n        return offset + 4;\n    }\n};\n/**\n * 32-bit signed integer, Big Endian byte order\n */\nexport const INT32_LE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getInt32(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setInt32(offset, value, true);\n        return offset + 4;\n    }\n};\n/**\n * 64-bit unsigned integer, Little Endian byte order\n */\nexport const UINT64_LE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getBigUint64(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setBigUint64(offset, value, true);\n        return offset + 8;\n    }\n};\n/**\n * 64-bit signed integer, Little Endian byte order\n */\nexport const INT64_LE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getBigInt64(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setBigInt64(offset, value, true);\n        return offset + 8;\n    }\n};\n/**\n * 64-bit unsigned integer, Big Endian byte order\n */\nexport const UINT64_BE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getBigUint64(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setBigUint64(offset, value);\n        return offset + 8;\n    }\n};\n/**\n * 64-bit signed integer, Big Endian byte order\n */\nexport const INT64_BE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getBigInt64(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setBigInt64(offset, value);\n        return offset + 8;\n    }\n};\n/**\n * IEEE 754 16-bit (half precision) float, big endian\n */\nexport const Float16_BE = {\n    len: 2,\n    get(dataView, offset) {\n        return ieee754.read(dataView, offset, false, 10, this.len);\n    },\n    put(dataView, offset, value) {\n        ieee754.write(dataView, value, offset, false, 10, this.len);\n        return offset + this.len;\n    }\n};\n/**\n * IEEE 754 16-bit (half precision) float, little endian\n */\nexport const Float16_LE = {\n    len: 2,\n    get(array, offset) {\n        return ieee754.read(array, offset, true, 10, this.len);\n    },\n    put(array, offset, value) {\n        ieee754.write(array, value, offset, true, 10, this.len);\n        return offset + this.len;\n    }\n};\n/**\n * IEEE 754 32-bit (single precision) float, big endian\n */\nexport const Float32_BE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getFloat32(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setFloat32(offset, value);\n        return offset + 4;\n    }\n};\n/**\n * IEEE 754 32-bit (single precision) float, little endian\n */\nexport const Float32_LE = {\n    len: 4,\n    get(array, offset) {\n        return dv(array).getFloat32(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setFloat32(offset, value, true);\n        return offset + 4;\n    }\n};\n/**\n * IEEE 754 64-bit (double precision) float, big endian\n */\nexport const Float64_BE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getFloat64(offset);\n    },\n    put(array, offset, value) {\n        dv(array).setFloat64(offset, value);\n        return offset + 8;\n    }\n};\n/**\n * IEEE 754 64-bit (double precision) float, little endian\n */\nexport const Float64_LE = {\n    len: 8,\n    get(array, offset) {\n        return dv(array).getFloat64(offset, true);\n    },\n    put(array, offset, value) {\n        dv(array).setFloat64(offset, value, true);\n        return offset + 8;\n    }\n};\n/**\n * IEEE 754 80-bit (extended precision) float, big endian\n */\nexport const Float80_BE = {\n    len: 10,\n    get(array, offset) {\n        return ieee754.read(array, offset, false, 63, this.len);\n    },\n    put(array, offset, value) {\n        ieee754.write(array, value, offset, false, 63, this.len);\n        return offset + this.len;\n    }\n};\n/**\n * IEEE 754 80-bit (extended precision) float, little endian\n */\nexport const Float80_LE = {\n    len: 10,\n    get(array, offset) {\n        return ieee754.read(array, offset, true, 63, this.len);\n    },\n    put(array, offset, value) {\n        ieee754.write(array, value, offset, true, 63, this.len);\n        return offset + this.len;\n    }\n};\n/**\n * Ignore a given number of bytes\n */\nexport class IgnoreType {\n    /**\n     * @param len number of bytes to ignore\n     */\n    constructor(len) {\n        this.len = len;\n    }\n    // ToDo: don't read, but skip data\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    get(array, off) {\n    }\n}\nexport class Uint8ArrayType {\n    constructor(len) {\n        this.len = len;\n    }\n    get(array, offset) {\n        return array.subarray(offset, offset + this.len);\n    }\n}\nexport class BufferType {\n    constructor(len) {\n        this.len = len;\n    }\n    get(uint8Array, off) {\n        return Buffer.from(uint8Array.subarray(off, off + this.len));\n    }\n}\n/**\n * Consume a fixed number of bytes from the stream and return a string with a specified encoding.\n */\nexport class StringType {\n    constructor(len, encoding) {\n        this.len = len;\n        this.encoding = encoding;\n    }\n    get(uint8Array, offset) {\n        return Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);\n    }\n}\n/**\n * ANSI Latin 1 String\n * Using windows-1252 / ISO 8859-1 decoding\n */\nexport class AnsiStringType {\n    constructor(len) {\n        this.len = len;\n    }\n    static decode(buffer, offset, until) {\n        let str = '';\n        for (let i = offset; i < until; ++i) {\n            str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));\n        }\n        return str;\n    }\n    static inRange(a, min, max) {\n        return min <= a && a <= max;\n    }\n    static codePointToString(cp) {\n        if (cp <= 0xFFFF) {\n            return String.fromCharCode(cp);\n        }\n        else {\n            cp -= 0x10000;\n            return String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00);\n        }\n    }\n    static singleByteDecoder(bite) {\n        if (AnsiStringType.inRange(bite, 0x00, 0x7F)) {\n            return bite;\n        }\n        const codePoint = AnsiStringType.windows1252[bite - 0x80];\n        if (codePoint === null) {\n            throw Error('invaliding encoding');\n        }\n        return codePoint;\n    }\n    get(buffer, offset = 0) {\n        return AnsiStringType.decode(buffer, offset, offset + this.len);\n    }\n}\nAnsiStringType.windows1252 = [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352,\n    8249, 338, 141, 381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732,\n    8482, 353, 8250, 339, 157, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n    169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,\n    185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,\n    201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,\n    217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,\n    233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,\n    248, 249, 250, 251, 252, 253, 254, 255];\n","export const defaultMessages = 'End-Of-Stream';\n/**\n * Thrown on read operation of the end of file or stream has been reached\n */\nexport class EndOfStreamError extends Error {\n    constructor() {\n        super(defaultMessages);\n    }\n}\n","import { EndOfStreamError } from 'peek-readable';\nimport { Buffer } from 'node:buffer';\n/**\n * Core tokenizer\n */\nexport class AbstractTokenizer {\n    constructor(fileInfo) {\n        /**\n         * Tokenizer-stream position\n         */\n        this.position = 0;\n        this.numBuffer = new Uint8Array(8);\n        this.fileInfo = fileInfo ? fileInfo : {};\n    }\n    /**\n     * Read a token from the tokenizer-stream\n     * @param token - The token to read\n     * @param position - If provided, the desired position in the tokenizer-stream\n     * @returns Promise with token data\n     */\n    async readToken(token, position = this.position) {\n        const uint8Array = Buffer.alloc(token.len);\n        const len = await this.readBuffer(uint8Array, { position });\n        if (len < token.len)\n            throw new EndOfStreamError();\n        return token.get(uint8Array, 0);\n    }\n    /**\n     * Peek a token from the tokenizer-stream.\n     * @param token - Token to peek from the tokenizer-stream.\n     * @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.\n     * @returns Promise with token data\n     */\n    async peekToken(token, position = this.position) {\n        const uint8Array = Buffer.alloc(token.len);\n        const len = await this.peekBuffer(uint8Array, { position });\n        if (len < token.len)\n            throw new EndOfStreamError();\n        return token.get(uint8Array, 0);\n    }\n    /**\n     * Read a numeric token from the stream\n     * @param token - Numeric token\n     * @returns Promise with number\n     */\n    async readNumber(token) {\n        const len = await this.readBuffer(this.numBuffer, { length: token.len });\n        if (len < token.len)\n            throw new EndOfStreamError();\n        return token.get(this.numBuffer, 0);\n    }\n    /**\n     * Read a numeric token from the stream\n     * @param token - Numeric token\n     * @returns Promise with number\n     */\n    async peekNumber(token) {\n        const len = await this.peekBuffer(this.numBuffer, { length: token.len });\n        if (len < token.len)\n            throw new EndOfStreamError();\n        return token.get(this.numBuffer, 0);\n    }\n    /**\n     * Ignore number of bytes, advances the pointer in under tokenizer-stream.\n     * @param length - Number of bytes to ignore\n     * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available\n     */\n    async ignore(length) {\n        if (this.fileInfo.size !== undefined) {\n            const bytesLeft = this.fileInfo.size - this.position;\n            if (length > bytesLeft) {\n                this.position += bytesLeft;\n                return bytesLeft;\n            }\n        }\n        this.position += length;\n        return length;\n    }\n    async close() {\n        // empty\n    }\n    normalizeOptions(uint8Array, options) {\n        if (options && options.position !== undefined && options.position < this.position) {\n            throw new Error('`options.position` must be equal or greater than `tokenizer.position`');\n        }\n        if (options) {\n            return {\n                mayBeLess: options.mayBeLess === true,\n                offset: options.offset ? options.offset : 0,\n                length: options.length ? options.length : (uint8Array.length - (options.offset ? options.offset : 0)),\n                position: options.position ? options.position : this.position\n            };\n        }\n        return {\n            mayBeLess: false,\n            offset: 0,\n            length: uint8Array.length,\n            position: this.position\n        };\n    }\n}\n","import { EndOfStreamError } from 'peek-readable';\nimport { AbstractTokenizer } from './AbstractTokenizer.js';\nexport class BufferTokenizer extends AbstractTokenizer {\n    /**\n     * Construct BufferTokenizer\n     * @param uint8Array - Uint8Array to tokenize\n     * @param fileInfo - Pass additional file information to the tokenizer\n     */\n    constructor(uint8Array, fileInfo) {\n        super(fileInfo);\n        this.uint8Array = uint8Array;\n        this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;\n    }\n    /**\n     * Read buffer from tokenizer\n     * @param uint8Array - Uint8Array to tokenize\n     * @param options - Read behaviour options\n     * @returns {Promise<number>}\n     */\n    async readBuffer(uint8Array, options) {\n        if (options && options.position) {\n            if (options.position < this.position) {\n                throw new Error('`options.position` must be equal or greater than `tokenizer.position`');\n            }\n            this.position = options.position;\n        }\n        const bytesRead = await this.peekBuffer(uint8Array, options);\n        this.position += bytesRead;\n        return bytesRead;\n    }\n    /**\n     * Peek (read ahead) buffer from tokenizer\n     * @param uint8Array\n     * @param options - Read behaviour options\n     * @returns {Promise<number>}\n     */\n    async peekBuffer(uint8Array, options) {\n        const normOptions = this.normalizeOptions(uint8Array, options);\n        const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);\n        if ((!normOptions.mayBeLess) && bytes2read < normOptions.length) {\n            throw new EndOfStreamError();\n        }\n        else {\n            uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);\n            return bytes2read;\n        }\n    }\n    async close() {\n        // empty\n    }\n}\n","import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';\nimport { BufferTokenizer } from './BufferTokenizer.js';\nexport { EndOfStreamError } from 'peek-readable';\n/**\n * Construct ReadStreamTokenizer from given Stream.\n * Will set fileSize, if provided given Stream has set the .path property/\n * @param stream - Read from Node.js Stream.Readable\n * @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.\n * @returns ReadStreamTokenizer\n */\nexport function fromStream(stream, fileInfo) {\n    fileInfo = fileInfo ? fileInfo : {};\n    return new ReadStreamTokenizer(stream, fileInfo);\n}\n/**\n * Construct ReadStreamTokenizer from given Buffer.\n * @param uint8Array - Uint8Array to tokenize\n * @param fileInfo - Pass additional file information to the tokenizer\n * @returns BufferTokenizer\n */\nexport function fromBuffer(uint8Array, fileInfo) {\n    return new BufferTokenizer(uint8Array, fileInfo);\n}\n","export function stringToBytes(string) {\n\treturn [...string].map(character => character.charCodeAt(0)); // eslint-disable-line unicorn/prefer-code-point\n}\n\n/**\nChecks whether the TAR checksum is valid.\n\n@param {Buffer} buffer - The TAR header `[offset ... offset + 512]`.\n@param {number} offset - TAR header offset.\n@returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.\n*/\nexport function tarHeaderChecksumMatches(buffer, offset = 0) {\n\tconst readSum = Number.parseInt(buffer.toString('utf8', 148, 154).replace(/\\0.*$/, '').trim(), 8); // Read sum in header\n\tif (Number.isNaN(readSum)) {\n\t\treturn false;\n\t}\n\n\tlet sum = 8 * 0x20; // Initialize signed bit sum\n\n\tfor (let index = offset; index < offset + 148; index++) {\n\t\tsum += buffer[index];\n\t}\n\n\tfor (let index = offset + 156; index < offset + 512; index++) {\n\t\tsum += buffer[index];\n\t}\n\n\treturn readSum === sum;\n}\n\n/**\nID3 UINT32 sync-safe tokenizer token.\n28 bits (representing up to 256MB) integer, the msb is 0 to avoid \"false syncsignals\".\n*/\nexport const uint32SyncSafeToken = {\n\tget: (buffer, offset) => (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2]) << 7) | ((buffer[offset + 1]) << 14) | ((buffer[offset]) << 21),\n\tlen: 4,\n};\n","export const extensions = [\n\t'jpg',\n\t'png',\n\t'apng',\n\t'gif',\n\t'webp',\n\t'flif',\n\t'xcf',\n\t'cr2',\n\t'cr3',\n\t'orf',\n\t'arw',\n\t'dng',\n\t'nef',\n\t'rw2',\n\t'raf',\n\t'tif',\n\t'bmp',\n\t'icns',\n\t'jxr',\n\t'psd',\n\t'indd',\n\t'zip',\n\t'tar',\n\t'rar',\n\t'gz',\n\t'bz2',\n\t'7z',\n\t'dmg',\n\t'mp4',\n\t'mid',\n\t'mkv',\n\t'webm',\n\t'mov',\n\t'avi',\n\t'mpg',\n\t'mp2',\n\t'mp3',\n\t'm4a',\n\t'oga',\n\t'ogg',\n\t'ogv',\n\t'opus',\n\t'flac',\n\t'wav',\n\t'spx',\n\t'amr',\n\t'pdf',\n\t'epub',\n\t'elf',\n\t'exe',\n\t'swf',\n\t'rtf',\n\t'wasm',\n\t'woff',\n\t'woff2',\n\t'eot',\n\t'ttf',\n\t'otf',\n\t'ico',\n\t'flv',\n\t'ps',\n\t'xz',\n\t'sqlite',\n\t'nes',\n\t'crx',\n\t'xpi',\n\t'cab',\n\t'deb',\n\t'ar',\n\t'rpm',\n\t'Z',\n\t'lz',\n\t'cfb',\n\t'mxf',\n\t'mts',\n\t'blend',\n\t'bpg',\n\t'docx',\n\t'pptx',\n\t'xlsx',\n\t'3gp',\n\t'3g2',\n\t'j2c',\n\t'jp2',\n\t'jpm',\n\t'jpx',\n\t'mj2',\n\t'aif',\n\t'qcp',\n\t'odt',\n\t'ods',\n\t'odp',\n\t'xml',\n\t'mobi',\n\t'heic',\n\t'cur',\n\t'ktx',\n\t'ape',\n\t'wv',\n\t'dcm',\n\t'ics',\n\t'glb',\n\t'pcap',\n\t'dsf',\n\t'lnk',\n\t'alias',\n\t'voc',\n\t'ac3',\n\t'm4v',\n\t'm4p',\n\t'm4b',\n\t'f4v',\n\t'f4p',\n\t'f4b',\n\t'f4a',\n\t'mie',\n\t'asf',\n\t'ogm',\n\t'ogx',\n\t'mpc',\n\t'arrow',\n\t'shp',\n\t'aac',\n\t'mp1',\n\t'it',\n\t's3m',\n\t'xm',\n\t'ai',\n\t'skp',\n\t'avif',\n\t'eps',\n\t'lzh',\n\t'pgp',\n\t'asar',\n\t'stl',\n\t'chm',\n\t'3mf',\n\t'zst',\n\t'jxl',\n\t'vcf',\n\t'jls',\n\t'pst',\n\t'dwg',\n\t'parquet',\n\t'class',\n\t'arj',\n\t'cpio',\n\t'ace',\n\t'avro',\n];\n\nexport const mimeTypes = [\n\t'image/jpeg',\n\t'image/png',\n\t'image/gif',\n\t'image/webp',\n\t'image/flif',\n\t'image/x-xcf',\n\t'image/x-canon-cr2',\n\t'image/x-canon-cr3',\n\t'image/tiff',\n\t'image/bmp',\n\t'image/vnd.ms-photo',\n\t'image/vnd.adobe.photoshop',\n\t'application/x-indesign',\n\t'application/epub+zip',\n\t'application/x-xpinstall',\n\t'application/vnd.oasis.opendocument.text',\n\t'application/vnd.oasis.opendocument.spreadsheet',\n\t'application/vnd.oasis.opendocument.presentation',\n\t'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n\t'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n\t'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n\t'application/zip',\n\t'application/x-tar',\n\t'application/x-rar-compressed',\n\t'application/gzip',\n\t'application/x-bzip2',\n\t'application/x-7z-compressed',\n\t'application/x-apple-diskimage',\n\t'application/x-apache-arrow',\n\t'video/mp4',\n\t'audio/midi',\n\t'video/x-matroska',\n\t'video/webm',\n\t'video/quicktime',\n\t'video/vnd.avi',\n\t'audio/vnd.wave',\n\t'audio/qcelp',\n\t'audio/x-ms-asf',\n\t'video/x-ms-asf',\n\t'application/vnd.ms-asf',\n\t'video/mpeg',\n\t'video/3gpp',\n\t'audio/mpeg',\n\t'audio/mp4', // RFC 4337\n\t'audio/opus',\n\t'video/ogg',\n\t'audio/ogg',\n\t'application/ogg',\n\t'audio/x-flac',\n\t'audio/ape',\n\t'audio/wavpack',\n\t'audio/amr',\n\t'application/pdf',\n\t'application/x-elf',\n\t'application/x-msdownload',\n\t'application/x-shockwave-flash',\n\t'application/rtf',\n\t'application/wasm',\n\t'font/woff',\n\t'font/woff2',\n\t'application/vnd.ms-fontobject',\n\t'font/ttf',\n\t'font/otf',\n\t'image/x-icon',\n\t'video/x-flv',\n\t'application/postscript',\n\t'application/eps',\n\t'application/x-xz',\n\t'application/x-sqlite3',\n\t'application/x-nintendo-nes-rom',\n\t'application/x-google-chrome-extension',\n\t'application/vnd.ms-cab-compressed',\n\t'application/x-deb',\n\t'application/x-unix-archive',\n\t'application/x-rpm',\n\t'application/x-compress',\n\t'application/x-lzip',\n\t'application/x-cfb',\n\t'application/x-mie',\n\t'application/mxf',\n\t'video/mp2t',\n\t'application/x-blender',\n\t'image/bpg',\n\t'image/j2c',\n\t'image/jp2',\n\t'image/jpx',\n\t'image/jpm',\n\t'image/mj2',\n\t'audio/aiff',\n\t'application/xml',\n\t'application/x-mobipocket-ebook',\n\t'image/heif',\n\t'image/heif-sequence',\n\t'image/heic',\n\t'image/heic-sequence',\n\t'image/icns',\n\t'image/ktx',\n\t'application/dicom',\n\t'audio/x-musepack',\n\t'text/calendar',\n\t'text/vcard',\n\t'model/gltf-binary',\n\t'application/vnd.tcpdump.pcap',\n\t'audio/x-dsf', // Non-standard\n\t'application/x.ms.shortcut', // Invented by us\n\t'application/x.apple.alias', // Invented by us\n\t'audio/x-voc',\n\t'audio/vnd.dolby.dd-raw',\n\t'audio/x-m4a',\n\t'image/apng',\n\t'image/x-olympus-orf',\n\t'image/x-sony-arw',\n\t'image/x-adobe-dng',\n\t'image/x-nikon-nef',\n\t'image/x-panasonic-rw2',\n\t'image/x-fujifilm-raf',\n\t'video/x-m4v',\n\t'video/3gpp2',\n\t'application/x-esri-shape',\n\t'audio/aac',\n\t'audio/x-it',\n\t'audio/x-s3m',\n\t'audio/x-xm',\n\t'video/MP1S',\n\t'video/MP2P',\n\t'application/vnd.sketchup.skp',\n\t'image/avif',\n\t'application/x-lzh-compressed',\n\t'application/pgp-encrypted',\n\t'application/x-asar',\n\t'model/stl',\n\t'application/vnd.ms-htmlhelp',\n\t'model/3mf',\n\t'image/jxl',\n\t'application/zstd',\n\t'image/jls',\n\t'application/vnd.ms-outlook',\n\t'image/vnd.dwg',\n\t'application/x-parquet',\n\t'application/java-vm',\n\t'application/x-arj',\n\t'application/x-cpio',\n\t'application/x-ace-compressed',\n\t'application/avro',\n];\n","import {Buffer} from 'node:buffer';\nimport * as Token from 'token-types';\nimport * as strtok3 from 'strtok3/core'; // eslint-disable-line n/file-extension-in-import\nimport {\n\tstringToBytes,\n\ttarHeaderChecksumMatches,\n\tuint32SyncSafeToken,\n} from './util.js';\nimport {extensions, mimeTypes} from './supported.js';\n\nconst minimumBytes = 4100; // A fair amount of file-types are detectable within this range.\n\nexport async function fileTypeFromStream(stream) {\n\tconst tokenizer = await strtok3.fromStream(stream);\n\ttry {\n\t\treturn await fileTypeFromTokenizer(tokenizer);\n\t} finally {\n\t\tawait tokenizer.close();\n\t}\n}\n\nexport async function fileTypeFromBuffer(input) {\n\tif (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {\n\t\tthrow new TypeError(`Expected the \\`input\\` argument to be of type \\`Uint8Array\\` or \\`Buffer\\` or \\`ArrayBuffer\\`, got \\`${typeof input}\\``);\n\t}\n\n\tconst buffer = input instanceof Uint8Array ? input : new Uint8Array(input);\n\n\tif (!(buffer?.length > 1)) {\n\t\treturn;\n\t}\n\n\treturn fileTypeFromTokenizer(strtok3.fromBuffer(buffer));\n}\n\nexport async function fileTypeFromBlob(blob) {\n\tconst buffer = await blob.arrayBuffer();\n\treturn fileTypeFromBuffer(new Uint8Array(buffer));\n}\n\nfunction _check(buffer, headers, options) {\n\toptions = {\n\t\toffset: 0,\n\t\t...options,\n\t};\n\n\tfor (const [index, header] of headers.entries()) {\n\t\t// If a bitmask is set\n\t\tif (options.mask) {\n\t\t\t// If header doesn't equal `buf` with bits masked off\n\t\t\tif (header !== (options.mask[index] & buffer[index + options.offset])) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else if (header !== buffer[index + options.offset]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\nexport async function fileTypeFromTokenizer(tokenizer) {\n\ttry {\n\t\treturn new FileTypeParser().parse(tokenizer);\n\t} catch (error) {\n\t\tif (!(error instanceof strtok3.EndOfStreamError)) {\n\t\t\tthrow error;\n\t\t}\n\t}\n}\n\nclass FileTypeParser {\n\tcheck(header, options) {\n\t\treturn _check(this.buffer, header, options);\n\t}\n\n\tcheckString(header, options) {\n\t\treturn this.check(stringToBytes(header), options);\n\t}\n\n\tasync parse(tokenizer) {\n\t\tthis.buffer = Buffer.alloc(minimumBytes);\n\n\t\t// Keep reading until EOF if the file size is unknown.\n\t\tif (tokenizer.fileInfo.size === undefined) {\n\t\t\ttokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;\n\t\t}\n\n\t\tthis.tokenizer = tokenizer;\n\n\t\tawait tokenizer.peekBuffer(this.buffer, {length: 12, mayBeLess: true});\n\n\t\t// -- 2-byte signatures --\n\n\t\tif (this.check([0x42, 0x4D])) {\n\t\t\treturn {\n\t\t\t\text: 'bmp',\n\t\t\t\tmime: 'image/bmp',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x0B, 0x77])) {\n\t\t\treturn {\n\t\t\t\text: 'ac3',\n\t\t\t\tmime: 'audio/vnd.dolby.dd-raw',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x78, 0x01])) {\n\t\t\treturn {\n\t\t\t\text: 'dmg',\n\t\t\t\tmime: 'application/x-apple-diskimage',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x4D, 0x5A])) {\n\t\t\treturn {\n\t\t\t\text: 'exe',\n\t\t\t\tmime: 'application/x-msdownload',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x25, 0x21])) {\n\t\t\tawait tokenizer.peekBuffer(this.buffer, {length: 24, mayBeLess: true});\n\n\t\t\tif (\n\t\t\t\tthis.checkString('PS-Adobe-', {offset: 2})\n\t\t\t\t&& this.checkString(' EPSF-', {offset: 14})\n\t\t\t) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'eps',\n\t\t\t\t\tmime: 'application/eps',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\text: 'ps',\n\t\t\t\tmime: 'application/postscript',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.check([0x1F, 0xA0])\n\t\t\t|| this.check([0x1F, 0x9D])\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'Z',\n\t\t\t\tmime: 'application/x-compress',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xC7, 0x71])) {\n\t\t\treturn {\n\t\t\t\text: 'cpio',\n\t\t\t\tmime: 'application/x-cpio',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x60, 0xEA])) {\n\t\t\treturn {\n\t\t\t\text: 'arj',\n\t\t\t\tmime: 'application/x-arj',\n\t\t\t};\n\t\t}\n\n\t\t// -- 3-byte signatures --\n\n\t\tif (this.check([0xEF, 0xBB, 0xBF])) { // UTF-8-BOM\n\t\t\t// Strip off UTF-8-BOM\n\t\t\tthis.tokenizer.ignore(3);\n\t\t\treturn this.parse(tokenizer);\n\t\t}\n\n\t\tif (this.check([0x47, 0x49, 0x46])) {\n\t\t\treturn {\n\t\t\t\text: 'gif',\n\t\t\t\tmime: 'image/gif',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x49, 0x49, 0xBC])) {\n\t\t\treturn {\n\t\t\t\text: 'jxr',\n\t\t\t\tmime: 'image/vnd.ms-photo',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x1F, 0x8B, 0x8])) {\n\t\t\treturn {\n\t\t\t\text: 'gz',\n\t\t\t\tmime: 'application/gzip',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x42, 0x5A, 0x68])) {\n\t\t\treturn {\n\t\t\t\text: 'bz2',\n\t\t\t\tmime: 'application/x-bzip2',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('ID3')) {\n\t\t\tawait tokenizer.ignore(6); // Skip ID3 header until the header size\n\t\t\tconst id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);\n\t\t\tif (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {\n\t\t\t\t// Guess file type based on ID3 header for backward compatibility\n\t\t\t\treturn {\n\t\t\t\t\text: 'mp3',\n\t\t\t\t\tmime: 'audio/mpeg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tawait tokenizer.ignore(id3HeaderLength);\n\t\t\treturn fileTypeFromTokenizer(tokenizer); // Skip ID3 header, recursion\n\t\t}\n\n\t\t// Musepack, SV7\n\t\tif (this.checkString('MP+')) {\n\t\t\treturn {\n\t\t\t\text: 'mpc',\n\t\t\t\tmime: 'audio/x-musepack',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\t(this.buffer[0] === 0x43 || this.buffer[0] === 0x46)\n\t\t\t&& this.check([0x57, 0x53], {offset: 1})\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'swf',\n\t\t\t\tmime: 'application/x-shockwave-flash',\n\t\t\t};\n\t\t}\n\n\t\t// -- 4-byte signatures --\n\n\t\t// Requires a sample size of 4 bytes\n\t\tif (this.check([0xFF, 0xD8, 0xFF])) {\n\t\t\tif (this.check([0xF7], {offset: 3})) { // JPG7/SOF55, indicating a ISO/IEC 14495 / JPEG-LS file\n\t\t\t\treturn {\n\t\t\t\t\text: 'jls',\n\t\t\t\t\tmime: 'image/jls',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\text: 'jpg',\n\t\t\t\tmime: 'image/jpeg',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x4F, 0x62, 0x6A, 0x01])) {\n\t\t\treturn {\n\t\t\t\text: 'avro',\n\t\t\t\tmime: 'application/avro',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('FLIF')) {\n\t\t\treturn {\n\t\t\t\text: 'flif',\n\t\t\t\tmime: 'image/flif',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('8BPS')) {\n\t\t\treturn {\n\t\t\t\text: 'psd',\n\t\t\t\tmime: 'image/vnd.adobe.photoshop',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('WEBP', {offset: 8})) {\n\t\t\treturn {\n\t\t\t\text: 'webp',\n\t\t\t\tmime: 'image/webp',\n\t\t\t};\n\t\t}\n\n\t\t// Musepack, SV8\n\t\tif (this.checkString('MPCK')) {\n\t\t\treturn {\n\t\t\t\text: 'mpc',\n\t\t\t\tmime: 'audio/x-musepack',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('FORM')) {\n\t\t\treturn {\n\t\t\t\text: 'aif',\n\t\t\t\tmime: 'audio/aiff',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('icns', {offset: 0})) {\n\t\t\treturn {\n\t\t\t\text: 'icns',\n\t\t\t\tmime: 'image/icns',\n\t\t\t};\n\t\t}\n\n\t\t// Zip-based file formats\n\t\t// Need to be before the `zip` check\n\t\tif (this.check([0x50, 0x4B, 0x3, 0x4])) { // Local file header signature\n\t\t\ttry {\n\t\t\t\twhile (tokenizer.position + 30 < tokenizer.fileInfo.size) {\n\t\t\t\t\tawait tokenizer.readBuffer(this.buffer, {length: 30});\n\n\t\t\t\t\t// https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers\n\t\t\t\t\tconst zipHeader = {\n\t\t\t\t\t\tcompressedSize: this.buffer.readUInt32LE(18),\n\t\t\t\t\t\tuncompressedSize: this.buffer.readUInt32LE(22),\n\t\t\t\t\t\tfilenameLength: this.buffer.readUInt16LE(26),\n\t\t\t\t\t\textraFieldLength: this.buffer.readUInt16LE(28),\n\t\t\t\t\t};\n\n\t\t\t\t\tzipHeader.filename = await tokenizer.readToken(new Token.StringType(zipHeader.filenameLength, 'utf-8'));\n\t\t\t\t\tawait tokenizer.ignore(zipHeader.extraFieldLength);\n\n\t\t\t\t\t// Assumes signed `.xpi` from addons.mozilla.org\n\t\t\t\t\tif (zipHeader.filename === 'META-INF/mozilla.rsa') {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'xpi',\n\t\t\t\t\t\t\tmime: 'application/x-xpinstall',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\tif (zipHeader.filename.endsWith('.rels') || zipHeader.filename.endsWith('.xml')) {\n\t\t\t\t\t\tconst type = zipHeader.filename.split('/')[0];\n\t\t\t\t\t\tswitch (type) {\n\t\t\t\t\t\t\tcase '_rels':\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tcase 'word':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'docx',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tcase 'ppt':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'pptx',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tcase 'xl':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'xlsx',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (zipHeader.filename.startsWith('xl/')) {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'xlsx',\n\t\t\t\t\t\t\tmime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\tif (zipHeader.filename.startsWith('3D/') && zipHeader.filename.endsWith('.model')) {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: '3mf',\n\t\t\t\t\t\t\tmime: 'model/3mf',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\t// The docx, xlsx and pptx file types extend the Office Open XML file format:\n\t\t\t\t\t// https://en.wikipedia.org/wiki/Office_Open_XML_file_formats\n\t\t\t\t\t// We look for:\n\t\t\t\t\t// - one entry named '[Content_Types].xml' or '_rels/.rels',\n\t\t\t\t\t// - one entry indicating specific type of file.\n\t\t\t\t\t// MS Office, OpenOffice and LibreOffice may put the parts in different order, so the check should not rely on it.\n\t\t\t\t\tif (zipHeader.filename === 'mimetype' && zipHeader.compressedSize === zipHeader.uncompressedSize) {\n\t\t\t\t\t\tlet mimeType = await tokenizer.readToken(new Token.StringType(zipHeader.compressedSize, 'utf-8'));\n\t\t\t\t\t\tmimeType = mimeType.trim();\n\n\t\t\t\t\t\tswitch (mimeType) {\n\t\t\t\t\t\t\tcase 'application/epub+zip':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'epub',\n\t\t\t\t\t\t\t\t\tmime: 'application/epub+zip',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tcase 'application/vnd.oasis.opendocument.text':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'odt',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.oasis.opendocument.text',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tcase 'application/vnd.oasis.opendocument.spreadsheet':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'ods',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.oasis.opendocument.spreadsheet',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tcase 'application/vnd.oasis.opendocument.presentation':\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\text: 'odp',\n\t\t\t\t\t\t\t\t\tmime: 'application/vnd.oasis.opendocument.presentation',\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Try to find next header manually when current one is corrupted\n\t\t\t\t\tif (zipHeader.compressedSize === 0) {\n\t\t\t\t\t\tlet nextHeaderIndex = -1;\n\n\t\t\t\t\t\twhile (nextHeaderIndex < 0 && (tokenizer.position < tokenizer.fileInfo.size)) {\n\t\t\t\t\t\t\tawait tokenizer.peekBuffer(this.buffer, {mayBeLess: true});\n\n\t\t\t\t\t\t\tnextHeaderIndex = this.buffer.indexOf('504B0304', 0, 'hex');\n\t\t\t\t\t\t\t// Move position to the next header if found, skip the whole buffer otherwise\n\t\t\t\t\t\t\tawait tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : this.buffer.length);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tawait tokenizer.ignore(zipHeader.compressedSize);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tif (!(error instanceof strtok3.EndOfStreamError)) {\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\text: 'zip',\n\t\t\t\tmime: 'application/zip',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('OggS')) {\n\t\t\t// This is an OGG container\n\t\t\tawait tokenizer.ignore(28);\n\t\t\tconst type = Buffer.alloc(8);\n\t\t\tawait tokenizer.readBuffer(type);\n\n\t\t\t// Needs to be before `ogg` check\n\t\t\tif (_check(type, [0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'opus',\n\t\t\t\t\tmime: 'audio/opus',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// If ' theora' in header.\n\t\t\tif (_check(type, [0x80, 0x74, 0x68, 0x65, 0x6F, 0x72, 0x61])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'ogv',\n\t\t\t\t\tmime: 'video/ogg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// If '\\x01video' in header.\n\t\t\tif (_check(type, [0x01, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x00])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'ogm',\n\t\t\t\t\tmime: 'video/ogg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// If ' FLAC' in header  https://xiph.org/flac/faq.html\n\t\t\tif (_check(type, [0x7F, 0x46, 0x4C, 0x41, 0x43])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'oga',\n\t\t\t\t\tmime: 'audio/ogg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// 'Speex  ' in header https://en.wikipedia.org/wiki/Speex\n\t\t\tif (_check(type, [0x53, 0x70, 0x65, 0x65, 0x78, 0x20, 0x20])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'spx',\n\t\t\t\t\tmime: 'audio/ogg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// If '\\x01vorbis' in header\n\t\t\tif (_check(type, [0x01, 0x76, 0x6F, 0x72, 0x62, 0x69, 0x73])) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'ogg',\n\t\t\t\t\tmime: 'audio/ogg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Default OGG container https://www.iana.org/assignments/media-types/application/ogg\n\t\t\treturn {\n\t\t\t\text: 'ogx',\n\t\t\t\tmime: 'application/ogg',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.check([0x50, 0x4B])\n\t\t\t&& (this.buffer[2] === 0x3 || this.buffer[2] === 0x5 || this.buffer[2] === 0x7)\n\t\t\t&& (this.buffer[3] === 0x4 || this.buffer[3] === 0x6 || this.buffer[3] === 0x8)\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'zip',\n\t\t\t\tmime: 'application/zip',\n\t\t\t};\n\t\t}\n\n\t\t//\n\n\t\t// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)\n\t\t// It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.\n\t\t// `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.\n\t\t// Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).\n\t\tif (\n\t\t\tthis.checkString('ftyp', {offset: 4})\n\t\t\t&& (this.buffer[8] & 0x60) !== 0x00 // Brand major, first character ASCII?\n\t\t) {\n\t\t\t// They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.\n\t\t\t// For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.\n\t\t\tconst brandMajor = this.buffer.toString('binary', 8, 12).replace('\\0', ' ').trim();\n\t\t\tswitch (brandMajor) {\n\t\t\t\tcase 'avif':\n\t\t\t\tcase 'avis':\n\t\t\t\t\treturn {ext: 'avif', mime: 'image/avif'};\n\t\t\t\tcase 'mif1':\n\t\t\t\t\treturn {ext: 'heic', mime: 'image/heif'};\n\t\t\t\tcase 'msf1':\n\t\t\t\t\treturn {ext: 'heic', mime: 'image/heif-sequence'};\n\t\t\t\tcase 'heic':\n\t\t\t\tcase 'heix':\n\t\t\t\t\treturn {ext: 'heic', mime: 'image/heic'};\n\t\t\t\tcase 'hevc':\n\t\t\t\tcase 'hevx':\n\t\t\t\t\treturn {ext: 'heic', mime: 'image/heic-sequence'};\n\t\t\t\tcase 'qt':\n\t\t\t\t\treturn {ext: 'mov', mime: 'video/quicktime'};\n\t\t\t\tcase 'M4V':\n\t\t\t\tcase 'M4VH':\n\t\t\t\tcase 'M4VP':\n\t\t\t\t\treturn {ext: 'm4v', mime: 'video/x-m4v'};\n\t\t\t\tcase 'M4P':\n\t\t\t\t\treturn {ext: 'm4p', mime: 'video/mp4'};\n\t\t\t\tcase 'M4B':\n\t\t\t\t\treturn {ext: 'm4b', mime: 'audio/mp4'};\n\t\t\t\tcase 'M4A':\n\t\t\t\t\treturn {ext: 'm4a', mime: 'audio/x-m4a'};\n\t\t\t\tcase 'F4V':\n\t\t\t\t\treturn {ext: 'f4v', mime: 'video/mp4'};\n\t\t\t\tcase 'F4P':\n\t\t\t\t\treturn {ext: 'f4p', mime: 'video/mp4'};\n\t\t\t\tcase 'F4A':\n\t\t\t\t\treturn {ext: 'f4a', mime: 'audio/mp4'};\n\t\t\t\tcase 'F4B':\n\t\t\t\t\treturn {ext: 'f4b', mime: 'audio/mp4'};\n\t\t\t\tcase 'crx':\n\t\t\t\t\treturn {ext: 'cr3', mime: 'image/x-canon-cr3'};\n\t\t\t\tdefault:\n\t\t\t\t\tif (brandMajor.startsWith('3g')) {\n\t\t\t\t\t\tif (brandMajor.startsWith('3g2')) {\n\t\t\t\t\t\t\treturn {ext: '3g2', mime: 'video/3gpp2'};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn {ext: '3gp', mime: 'video/3gpp'};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn {ext: 'mp4', mime: 'video/mp4'};\n\t\t\t}\n\t\t}\n\n\t\tif (this.checkString('MThd')) {\n\t\t\treturn {\n\t\t\t\text: 'mid',\n\t\t\t\tmime: 'audio/midi',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.checkString('wOFF')\n\t\t\t&& (\n\t\t\t\tthis.check([0x00, 0x01, 0x00, 0x00], {offset: 4})\n\t\t\t\t|| this.checkString('OTTO', {offset: 4})\n\t\t\t)\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'woff',\n\t\t\t\tmime: 'font/woff',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.checkString('wOF2')\n\t\t\t&& (\n\t\t\t\tthis.check([0x00, 0x01, 0x00, 0x00], {offset: 4})\n\t\t\t\t|| this.checkString('OTTO', {offset: 4})\n\t\t\t)\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'woff2',\n\t\t\t\tmime: 'font/woff2',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xD4, 0xC3, 0xB2, 0xA1]) || this.check([0xA1, 0xB2, 0xC3, 0xD4])) {\n\t\t\treturn {\n\t\t\t\text: 'pcap',\n\t\t\t\tmime: 'application/vnd.tcpdump.pcap',\n\t\t\t};\n\t\t}\n\n\t\t// Sony DSD Stream File (DSF)\n\t\tif (this.checkString('DSD ')) {\n\t\t\treturn {\n\t\t\t\text: 'dsf',\n\t\t\t\tmime: 'audio/x-dsf', // Non-standard\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('LZIP')) {\n\t\t\treturn {\n\t\t\t\text: 'lz',\n\t\t\t\tmime: 'application/x-lzip',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('fLaC')) {\n\t\t\treturn {\n\t\t\t\text: 'flac',\n\t\t\t\tmime: 'audio/x-flac',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x42, 0x50, 0x47, 0xFB])) {\n\t\t\treturn {\n\t\t\t\text: 'bpg',\n\t\t\t\tmime: 'image/bpg',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('wvpk')) {\n\t\t\treturn {\n\t\t\t\text: 'wv',\n\t\t\t\tmime: 'audio/wavpack',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('%PDF')) {\n\t\t\ttry {\n\t\t\t\tawait tokenizer.ignore(1350);\n\t\t\t\tconst maxBufferSize = 10 * 1024 * 1024;\n\t\t\t\tconst buffer = Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));\n\t\t\t\tawait tokenizer.readBuffer(buffer, {mayBeLess: true});\n\n\t\t\t\t// Check if this is an Adobe Illustrator file\n\t\t\t\tif (buffer.includes(Buffer.from('AIPrivateData'))) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'ai',\n\t\t\t\t\t\tmime: 'application/postscript',\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\t// Swallow end of stream error if file is too small for the Adobe AI check\n\t\t\t\tif (!(error instanceof strtok3.EndOfStreamError)) {\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Assume this is just a normal PDF\n\t\t\treturn {\n\t\t\t\text: 'pdf',\n\t\t\t\tmime: 'application/pdf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x00, 0x61, 0x73, 0x6D])) {\n\t\t\treturn {\n\t\t\t\text: 'wasm',\n\t\t\t\tmime: 'application/wasm',\n\t\t\t};\n\t\t}\n\n\t\t// TIFF, little-endian type\n\t\tif (this.check([0x49, 0x49])) {\n\t\t\tconst fileType = await this.readTiffHeader(false);\n\t\t\tif (fileType) {\n\t\t\t\treturn fileType;\n\t\t\t}\n\t\t}\n\n\t\t// TIFF, big-endian type\n\t\tif (this.check([0x4D, 0x4D])) {\n\t\t\tconst fileType = await this.readTiffHeader(true);\n\t\t\tif (fileType) {\n\t\t\t\treturn fileType;\n\t\t\t}\n\t\t}\n\n\t\tif (this.checkString('MAC ')) {\n\t\t\treturn {\n\t\t\t\text: 'ape',\n\t\t\t\tmime: 'audio/ape',\n\t\t\t};\n\t\t}\n\n\t\t// https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska\n\t\tif (this.check([0x1A, 0x45, 0xDF, 0xA3])) { // Root element: EBML\n\t\t\tasync function readField() {\n\t\t\t\tconst msb = await tokenizer.peekNumber(Token.UINT8);\n\t\t\t\tlet mask = 0x80;\n\t\t\t\tlet ic = 0; // 0 = A, 1 = B, 2 = C, 3\n\t\t\t\t// = D\n\n\t\t\t\twhile ((msb & mask) === 0 && mask !== 0) {\n\t\t\t\t\t++ic;\n\t\t\t\t\tmask >>= 1;\n\t\t\t\t}\n\n\t\t\t\tconst id = Buffer.alloc(ic + 1);\n\t\t\t\tawait tokenizer.readBuffer(id);\n\t\t\t\treturn id;\n\t\t\t}\n\n\t\t\tasync function readElement() {\n\t\t\t\tconst id = await readField();\n\t\t\t\tconst lengthField = await readField();\n\t\t\t\tlengthField[0] ^= 0x80 >> (lengthField.length - 1);\n\t\t\t\tconst nrLength = Math.min(6, lengthField.length); // JavaScript can max read 6 bytes integer\n\t\t\t\treturn {\n\t\t\t\t\tid: id.readUIntBE(0, id.length),\n\t\t\t\t\tlen: lengthField.readUIntBE(lengthField.length - nrLength, nrLength),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tasync function readChildren(children) {\n\t\t\t\twhile (children > 0) {\n\t\t\t\t\tconst element = await readElement();\n\t\t\t\t\tif (element.id === 0x42_82) {\n\t\t\t\t\t\tconst rawValue = await tokenizer.readToken(new Token.StringType(element.len, 'utf-8'));\n\t\t\t\t\t\treturn rawValue.replace(/\\00.*$/g, ''); // Return DocType\n\t\t\t\t\t}\n\n\t\t\t\t\tawait tokenizer.ignore(element.len); // ignore payload\n\t\t\t\t\t--children;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst re = await readElement();\n\t\t\tconst docType = await readChildren(re.len);\n\n\t\t\tswitch (docType) {\n\t\t\t\tcase 'webm':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'webm',\n\t\t\t\t\t\tmime: 'video/webm',\n\t\t\t\t\t};\n\n\t\t\t\tcase 'matroska':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'mkv',\n\t\t\t\t\t\tmime: 'video/x-matroska',\n\t\t\t\t\t};\n\n\t\t\t\tdefault:\n\t\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\t// RIFF file format which might be AVI, WAV, QCP, etc\n\t\tif (this.check([0x52, 0x49, 0x46, 0x46])) {\n\t\t\tif (this.check([0x41, 0x56, 0x49], {offset: 8})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'avi',\n\t\t\t\t\tmime: 'video/vnd.avi',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (this.check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'wav',\n\t\t\t\t\tmime: 'audio/vnd.wave',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// QLCM, QCP file\n\t\t\tif (this.check([0x51, 0x4C, 0x43, 0x4D], {offset: 8})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'qcp',\n\t\t\t\t\tmime: 'audio/qcelp',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif (this.checkString('SQLi')) {\n\t\t\treturn {\n\t\t\t\text: 'sqlite',\n\t\t\t\tmime: 'application/x-sqlite3',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x4E, 0x45, 0x53, 0x1A])) {\n\t\t\treturn {\n\t\t\t\text: 'nes',\n\t\t\t\tmime: 'application/x-nintendo-nes-rom',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('Cr24')) {\n\t\t\treturn {\n\t\t\t\text: 'crx',\n\t\t\t\tmime: 'application/x-google-chrome-extension',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.checkString('MSCF')\n\t\t\t|| this.checkString('ISc(')\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'cab',\n\t\t\t\tmime: 'application/vnd.ms-cab-compressed',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xED, 0xAB, 0xEE, 0xDB])) {\n\t\t\treturn {\n\t\t\t\text: 'rpm',\n\t\t\t\tmime: 'application/x-rpm',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xC5, 0xD0, 0xD3, 0xC6])) {\n\t\t\treturn {\n\t\t\t\text: 'eps',\n\t\t\t\tmime: 'application/eps',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x28, 0xB5, 0x2F, 0xFD])) {\n\t\t\treturn {\n\t\t\t\text: 'zst',\n\t\t\t\tmime: 'application/zstd',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x7F, 0x45, 0x4C, 0x46])) {\n\t\t\treturn {\n\t\t\t\text: 'elf',\n\t\t\t\tmime: 'application/x-elf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x21, 0x42, 0x44, 0x4E])) {\n\t\t\treturn {\n\t\t\t\text: 'pst',\n\t\t\t\tmime: 'application/vnd.ms-outlook',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('PAR1')) {\n\t\t\treturn {\n\t\t\t\text: 'parquet',\n\t\t\t\tmime: 'application/x-parquet',\n\t\t\t};\n\t\t}\n\n\t\t// -- 5-byte signatures --\n\n\t\tif (this.check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'otf',\n\t\t\t\tmime: 'font/otf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('#!AMR')) {\n\t\t\treturn {\n\t\t\t\text: 'amr',\n\t\t\t\tmime: 'audio/amr',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('{\\\\rtf')) {\n\t\t\treturn {\n\t\t\t\text: 'rtf',\n\t\t\t\tmime: 'application/rtf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x46, 0x4C, 0x56, 0x01])) {\n\t\t\treturn {\n\t\t\t\text: 'flv',\n\t\t\t\tmime: 'video/x-flv',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('IMPM')) {\n\t\t\treturn {\n\t\t\t\text: 'it',\n\t\t\t\tmime: 'audio/x-it',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.checkString('-lh0-', {offset: 2})\n\t\t\t|| this.checkString('-lh1-', {offset: 2})\n\t\t\t|| this.checkString('-lh2-', {offset: 2})\n\t\t\t|| this.checkString('-lh3-', {offset: 2})\n\t\t\t|| this.checkString('-lh4-', {offset: 2})\n\t\t\t|| this.checkString('-lh5-', {offset: 2})\n\t\t\t|| this.checkString('-lh6-', {offset: 2})\n\t\t\t|| this.checkString('-lh7-', {offset: 2})\n\t\t\t|| this.checkString('-lzs-', {offset: 2})\n\t\t\t|| this.checkString('-lz4-', {offset: 2})\n\t\t\t|| this.checkString('-lz5-', {offset: 2})\n\t\t\t|| this.checkString('-lhd-', {offset: 2})\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'lzh',\n\t\t\t\tmime: 'application/x-lzh-compressed',\n\t\t\t};\n\t\t}\n\n\t\t// MPEG program stream (PS or MPEG-PS)\n\t\tif (this.check([0x00, 0x00, 0x01, 0xBA])) {\n\t\t\t//  MPEG-PS, MPEG-1 Part 1\n\t\t\tif (this.check([0x21], {offset: 4, mask: [0xF1]})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'mpg', // May also be .ps, .mpeg\n\t\t\t\t\tmime: 'video/MP1S',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// MPEG-PS, MPEG-2 Part 1\n\t\t\tif (this.check([0x44], {offset: 4, mask: [0xC4]})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'mpg', // May also be .mpg, .m2p, .vob or .sub\n\t\t\t\t\tmime: 'video/MP2P',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif (this.checkString('ITSF')) {\n\t\t\treturn {\n\t\t\t\text: 'chm',\n\t\t\t\tmime: 'application/vnd.ms-htmlhelp',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xCA, 0xFE, 0xBA, 0xBE])) {\n\t\t\treturn {\n\t\t\t\text: 'class',\n\t\t\t\tmime: 'application/java-vm',\n\t\t\t};\n\t\t}\n\n\t\t// -- 6-byte signatures --\n\n\t\tif (this.check([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'xz',\n\t\t\t\tmime: 'application/x-xz',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('<?xml ')) {\n\t\t\treturn {\n\t\t\t\text: 'xml',\n\t\t\t\tmime: 'application/xml',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])) {\n\t\t\treturn {\n\t\t\t\text: '7z',\n\t\t\t\tmime: 'application/x-7z-compressed',\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7])\n\t\t\t&& (this.buffer[6] === 0x0 || this.buffer[6] === 0x1)\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'rar',\n\t\t\t\tmime: 'application/x-rar-compressed',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('solid ')) {\n\t\t\treturn {\n\t\t\t\text: 'stl',\n\t\t\t\tmime: 'model/stl',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('AC')) {\n\t\t\tconst version = this.buffer.toString('binary', 2, 6);\n\t\t\tif (version.match('^d*') && version >= 1000 && version <= 1050) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'dwg',\n\t\t\t\t\tmime: 'image/vnd.dwg',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif (this.checkString('070707')) {\n\t\t\treturn {\n\t\t\t\text: 'cpio',\n\t\t\t\tmime: 'application/x-cpio',\n\t\t\t};\n\t\t}\n\n\t\t// -- 7-byte signatures --\n\n\t\tif (this.checkString('BLENDER')) {\n\t\t\treturn {\n\t\t\t\text: 'blend',\n\t\t\t\tmime: 'application/x-blender',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('!<arch>')) {\n\t\t\tawait tokenizer.ignore(8);\n\t\t\tconst string = await tokenizer.readToken(new Token.StringType(13, 'ascii'));\n\t\t\tif (string === 'debian-binary') {\n\t\t\t\treturn {\n\t\t\t\t\text: 'deb',\n\t\t\t\t\tmime: 'application/x-deb',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\text: 'ar',\n\t\t\t\tmime: 'application/x-unix-archive',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('**ACE', {offset: 7})) {\n\t\t\tawait tokenizer.peekBuffer(this.buffer, {length: 14, mayBeLess: true});\n\t\t\tif (this.checkString('**', {offset: 12})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'ace',\n\t\t\t\t\tmime: 'application/x-ace-compressed',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\t// -- 8-byte signatures --\n\n\t\tif (this.check([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {\n\t\t\t// APNG format (https://wiki.mozilla.org/APNG_Specification)\n\t\t\t// 1. Find the first IDAT (image data) chunk (49 44 41 54)\n\t\t\t// 2. Check if there is an \"acTL\" chunk before the IDAT one (61 63 54 4C)\n\n\t\t\t// Offset calculated as follows:\n\t\t\t// - 8 bytes: PNG signature\n\t\t\t// - 4 (length) + 4 (chunk type) + 13 (chunk data) + 4 (CRC): IHDR chunk\n\n\t\t\tawait tokenizer.ignore(8); // ignore PNG signature\n\n\t\t\tasync function readChunkHeader() {\n\t\t\t\treturn {\n\t\t\t\t\tlength: await tokenizer.readToken(Token.INT32_BE),\n\t\t\t\t\ttype: await tokenizer.readToken(new Token.StringType(4, 'binary')),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tdo {\n\t\t\t\tconst chunk = await readChunkHeader();\n\t\t\t\tif (chunk.length < 0) {\n\t\t\t\t\treturn; // Invalid chunk length\n\t\t\t\t}\n\n\t\t\t\tswitch (chunk.type) {\n\t\t\t\t\tcase 'IDAT':\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'png',\n\t\t\t\t\t\t\tmime: 'image/png',\n\t\t\t\t\t\t};\n\t\t\t\t\tcase 'acTL':\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'apng',\n\t\t\t\t\t\t\tmime: 'image/apng',\n\t\t\t\t\t\t};\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tawait tokenizer.ignore(chunk.length + 4); // Ignore chunk-data + CRC\n\t\t\t\t}\n\t\t\t} while (tokenizer.position + 8 < tokenizer.fileInfo.size);\n\n\t\t\treturn {\n\t\t\t\text: 'png',\n\t\t\t\tmime: 'image/png',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'arrow',\n\t\t\t\tmime: 'application/x-apache-arrow',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x67, 0x6C, 0x54, 0x46, 0x02, 0x00, 0x00, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'glb',\n\t\t\t\tmime: 'model/gltf-binary',\n\t\t\t};\n\t\t}\n\n\t\t// `mov` format variants\n\t\tif (\n\t\t\tthis.check([0x66, 0x72, 0x65, 0x65], {offset: 4}) // `free`\n\t\t\t|| this.check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) // `mdat` MJPEG\n\t\t\t|| this.check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) // `moov`\n\t\t\t|| this.check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'mov',\n\t\t\t\tmime: 'video/quicktime',\n\t\t\t};\n\t\t}\n\n\t\t// -- 9-byte signatures --\n\n\t\tif (this.check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {\n\t\t\treturn {\n\t\t\t\text: 'orf',\n\t\t\t\tmime: 'image/x-olympus-orf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('gimp xcf ')) {\n\t\t\treturn {\n\t\t\t\text: 'xcf',\n\t\t\t\tmime: 'image/x-xcf',\n\t\t\t};\n\t\t}\n\n\t\t// -- 12-byte signatures --\n\n\t\tif (this.check([0x49, 0x49, 0x55, 0x00, 0x18, 0x00, 0x00, 0x00, 0x88, 0xE7, 0x74, 0xD8])) {\n\t\t\treturn {\n\t\t\t\text: 'rw2',\n\t\t\t\tmime: 'image/x-panasonic-rw2',\n\t\t\t};\n\t\t}\n\n\t\t// ASF_Header_Object first 80 bytes\n\t\tif (this.check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {\n\t\t\tasync function readHeader() {\n\t\t\t\tconst guid = Buffer.alloc(16);\n\t\t\t\tawait tokenizer.readBuffer(guid);\n\t\t\t\treturn {\n\t\t\t\t\tid: guid,\n\t\t\t\t\tsize: Number(await tokenizer.readToken(Token.UINT64_LE)),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tawait tokenizer.ignore(30);\n\t\t\t// Search for header should be in first 1KB of file.\n\t\t\twhile (tokenizer.position + 24 < tokenizer.fileInfo.size) {\n\t\t\t\tconst header = await readHeader();\n\t\t\t\tlet payload = header.size - 24;\n\t\t\t\tif (_check(header.id, [0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65])) {\n\t\t\t\t\t// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)\n\t\t\t\t\tconst typeId = Buffer.alloc(16);\n\t\t\t\t\tpayload -= await tokenizer.readBuffer(typeId);\n\n\t\t\t\t\tif (_check(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {\n\t\t\t\t\t\t// Found audio:\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'asf',\n\t\t\t\t\t\t\tmime: 'audio/x-ms-asf',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\tif (_check(typeId, [0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {\n\t\t\t\t\t\t// Found video:\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'asf',\n\t\t\t\t\t\t\tmime: 'video/x-ms-asf',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tawait tokenizer.ignore(payload);\n\t\t\t}\n\n\t\t\t// Default to ASF generic extension\n\t\t\treturn {\n\t\t\t\text: 'asf',\n\t\t\t\tmime: 'application/vnd.ms-asf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {\n\t\t\treturn {\n\t\t\t\text: 'ktx',\n\t\t\t\tmime: 'image/ktx',\n\t\t\t};\n\t\t}\n\n\t\tif ((this.check([0x7E, 0x10, 0x04]) || this.check([0x7E, 0x18, 0x04])) && this.check([0x30, 0x4D, 0x49, 0x45], {offset: 4})) {\n\t\t\treturn {\n\t\t\t\text: 'mie',\n\t\t\t\tmime: 'application/x-mie',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], {offset: 2})) {\n\t\t\treturn {\n\t\t\t\text: 'shp',\n\t\t\t\tmime: 'application/x-esri-shape',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xFF, 0x4F, 0xFF, 0x51])) {\n\t\t\treturn {\n\t\t\t\text: 'j2c',\n\t\t\t\tmime: 'image/j2c',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A])) {\n\t\t\t// JPEG-2000 family\n\n\t\t\tawait tokenizer.ignore(20);\n\t\t\tconst type = await tokenizer.readToken(new Token.StringType(4, 'ascii'));\n\t\t\tswitch (type) {\n\t\t\t\tcase 'jp2 ':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'jp2',\n\t\t\t\t\t\tmime: 'image/jp2',\n\t\t\t\t\t};\n\t\t\t\tcase 'jpx ':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'jpx',\n\t\t\t\t\t\tmime: 'image/jpx',\n\t\t\t\t\t};\n\t\t\t\tcase 'jpm ':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'jpm',\n\t\t\t\t\t\tmime: 'image/jpm',\n\t\t\t\t\t};\n\t\t\t\tcase 'mjp2':\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'mj2',\n\t\t\t\t\t\tmime: 'image/mj2',\n\t\t\t\t\t};\n\t\t\t\tdefault:\n\t\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tif (\n\t\t\tthis.check([0xFF, 0x0A])\n\t\t\t|| this.check([0x00, 0x00, 0x00, 0x0C, 0x4A, 0x58, 0x4C, 0x20, 0x0D, 0x0A, 0x87, 0x0A])\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'jxl',\n\t\t\t\tmime: 'image/jxl',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xFE, 0xFF])) { // UTF-16-BOM-LE\n\t\t\tif (this.check([0, 60, 0, 63, 0, 120, 0, 109, 0, 108], {offset: 2})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'xml',\n\t\t\t\t\tmime: 'application/xml',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn undefined; // Some unknown text based format\n\t\t}\n\n\t\t// -- Unsafe signatures --\n\n\t\tif (\n\t\t\tthis.check([0x0, 0x0, 0x1, 0xBA])\n\t\t\t|| this.check([0x0, 0x0, 0x1, 0xB3])\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'mpg',\n\t\t\t\tmime: 'video/mpeg',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x00, 0x01, 0x00, 0x00, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'ttf',\n\t\t\t\tmime: 'font/ttf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x00, 0x00, 0x01, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'ico',\n\t\t\t\tmime: 'image/x-icon',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x00, 0x00, 0x02, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'cur',\n\t\t\t\tmime: 'image/x-icon',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1])) {\n\t\t\t// Detected Microsoft Compound File Binary File (MS-CFB) Format.\n\t\t\treturn {\n\t\t\t\text: 'cfb',\n\t\t\t\tmime: 'application/x-cfb',\n\t\t\t};\n\t\t}\n\n\t\t// Increase sample size from 12 to 256.\n\t\tawait tokenizer.peekBuffer(this.buffer, {length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true});\n\n\t\t// -- 15-byte signatures --\n\n\t\tif (this.checkString('BEGIN:')) {\n\t\t\tif (this.checkString('VCARD', {offset: 6})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'vcf',\n\t\t\t\t\tmime: 'text/vcard',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (this.checkString('VCALENDAR', {offset: 6})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'ics',\n\t\t\t\t\tmime: 'text/calendar',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\t// `raf` is here just to keep all the raw image detectors together.\n\t\tif (this.checkString('FUJIFILMCCD-RAW')) {\n\t\t\treturn {\n\t\t\t\text: 'raf',\n\t\t\t\tmime: 'image/x-fujifilm-raf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('Extended Module:')) {\n\t\t\treturn {\n\t\t\t\text: 'xm',\n\t\t\t\tmime: 'audio/x-xm',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('Creative Voice File')) {\n\t\t\treturn {\n\t\t\t\text: 'voc',\n\t\t\t\tmime: 'audio/x-voc',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x04, 0x00, 0x00, 0x00]) && this.buffer.length >= 16) { // Rough & quick check Pickle/ASAR\n\t\t\tconst jsonSize = this.buffer.readUInt32LE(12);\n\t\t\tif (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {\n\t\t\t\ttry {\n\t\t\t\t\tconst header = this.buffer.slice(16, jsonSize + 16).toString();\n\t\t\t\t\tconst json = JSON.parse(header);\n\t\t\t\t\t// Check if Pickle is ASAR\n\t\t\t\t\tif (json.files) { // Final check, assuring Pickle/ASAR format\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\text: 'asar',\n\t\t\t\t\t\t\tmime: 'application/x-asar',\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t} catch {}\n\t\t\t}\n\t\t}\n\n\t\tif (this.check([0x06, 0x0E, 0x2B, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0D, 0x01, 0x02, 0x01, 0x01, 0x02])) {\n\t\t\treturn {\n\t\t\t\text: 'mxf',\n\t\t\t\tmime: 'application/mxf',\n\t\t\t};\n\t\t}\n\n\t\tif (this.checkString('SCRM', {offset: 44})) {\n\t\t\treturn {\n\t\t\t\text: 's3m',\n\t\t\t\tmime: 'audio/x-s3m',\n\t\t\t};\n\t\t}\n\n\t\t// Raw MPEG-2 transport stream (188-byte packets)\n\t\tif (this.check([0x47]) && this.check([0x47], {offset: 188})) {\n\t\t\treturn {\n\t\t\t\text: 'mts',\n\t\t\t\tmime: 'video/mp2t',\n\t\t\t};\n\t\t}\n\n\t\t// Blu-ray Disc Audio-Video (BDAV) MPEG-2 transport stream has 4-byte TP_extra_header before each 188-byte packet\n\t\tif (this.check([0x47], {offset: 4}) && this.check([0x47], {offset: 196})) {\n\t\t\treturn {\n\t\t\t\text: 'mts',\n\t\t\t\tmime: 'video/mp2t',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x42, 0x4F, 0x4F, 0x4B, 0x4D, 0x4F, 0x42, 0x49], {offset: 60})) {\n\t\t\treturn {\n\t\t\t\text: 'mobi',\n\t\t\t\tmime: 'application/x-mobipocket-ebook',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x44, 0x49, 0x43, 0x4D], {offset: 128})) {\n\t\t\treturn {\n\t\t\t\text: 'dcm',\n\t\t\t\tmime: 'application/dicom',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {\n\t\t\treturn {\n\t\t\t\text: 'lnk',\n\t\t\t\tmime: 'application/x.ms.shortcut', // Invented by us\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {\n\t\t\treturn {\n\t\t\t\text: 'alias',\n\t\t\t\tmime: 'application/x.apple.alias', // Invented by us\n\t\t\t};\n\t\t}\n\n\t\tif (\n\t\t\tthis.check([0x4C, 0x50], {offset: 34})\n\t\t\t&& (\n\t\t\t\tthis.check([0x00, 0x00, 0x01], {offset: 8})\n\t\t\t\t|| this.check([0x01, 0x00, 0x02], {offset: 8})\n\t\t\t\t|| this.check([0x02, 0x00, 0x02], {offset: 8})\n\t\t\t)\n\t\t) {\n\t\t\treturn {\n\t\t\t\text: 'eot',\n\t\t\t\tmime: 'application/vnd.ms-fontobject',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0x06, 0x06, 0xED, 0xF5, 0xD8, 0x1D, 0x46, 0xE5, 0xBD, 0x31, 0xEF, 0xE7, 0xFE, 0x74, 0xB7, 0x1D])) {\n\t\t\treturn {\n\t\t\t\text: 'indd',\n\t\t\t\tmime: 'application/x-indesign',\n\t\t\t};\n\t\t}\n\n\t\t// Increase sample size from 256 to 512\n\t\tawait tokenizer.peekBuffer(this.buffer, {length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true});\n\n\t\t// Requires a buffer size of 512 bytes\n\t\tif (tarHeaderChecksumMatches(this.buffer)) {\n\t\t\treturn {\n\t\t\t\text: 'tar',\n\t\t\t\tmime: 'application/x-tar',\n\t\t\t};\n\t\t}\n\n\t\tif (this.check([0xFF, 0xFE])) { // UTF-16-BOM-BE\n\t\t\tif (this.check([60, 0, 63, 0, 120, 0, 109, 0, 108, 0], {offset: 2})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'xml',\n\t\t\t\t\tmime: 'application/xml',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (this.check([0xFF, 0x0E, 0x53, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x55, 0x00, 0x70, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00], {offset: 2})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'skp',\n\t\t\t\t\tmime: 'application/vnd.sketchup.skp',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn undefined; // Some text based format\n\t\t}\n\n\t\tif (this.checkString('-----BEGIN PGP MESSAGE-----')) {\n\t\t\treturn {\n\t\t\t\text: 'pgp',\n\t\t\t\tmime: 'application/pgp-encrypted',\n\t\t\t};\n\t\t}\n\n\t\t// Check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE)\n\t\tif (this.buffer.length >= 2 && this.check([0xFF, 0xE0], {offset: 0, mask: [0xFF, 0xE0]})) {\n\t\t\tif (this.check([0x10], {offset: 1, mask: [0x16]})) {\n\t\t\t\t// Check for (ADTS) MPEG-2\n\t\t\t\tif (this.check([0x08], {offset: 1, mask: [0x08]})) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'aac',\n\t\t\t\t\t\tmime: 'audio/aac',\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Must be (ADTS) MPEG-4\n\t\t\t\treturn {\n\t\t\t\t\text: 'aac',\n\t\t\t\t\tmime: 'audio/aac',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// MPEG 1 or 2 Layer 3 header\n\t\t\t// Check for MPEG layer 3\n\t\t\tif (this.check([0x02], {offset: 1, mask: [0x06]})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'mp3',\n\t\t\t\t\tmime: 'audio/mpeg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Check for MPEG layer 2\n\t\t\tif (this.check([0x04], {offset: 1, mask: [0x06]})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'mp2',\n\t\t\t\t\tmime: 'audio/mpeg',\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Check for MPEG layer 1\n\t\t\tif (this.check([0x06], {offset: 1, mask: [0x06]})) {\n\t\t\t\treturn {\n\t\t\t\t\text: 'mp1',\n\t\t\t\t\tmime: 'audio/mpeg',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n\n\tasync readTiffTag(bigEndian) {\n\t\tconst tagId = await this.tokenizer.readToken(bigEndian ? Token.UINT16_BE : Token.UINT16_LE);\n\t\tthis.tokenizer.ignore(10);\n\t\tswitch (tagId) {\n\t\t\tcase 50_341:\n\t\t\t\treturn {\n\t\t\t\t\text: 'arw',\n\t\t\t\t\tmime: 'image/x-sony-arw',\n\t\t\t\t};\n\t\t\tcase 50_706:\n\t\t\t\treturn {\n\t\t\t\t\text: 'dng',\n\t\t\t\t\tmime: 'image/x-adobe-dng',\n\t\t\t\t};\n\t\t\tdefault:\n\t\t}\n\t}\n\n\tasync readTiffIFD(bigEndian) {\n\t\tconst numberOfTags = await this.tokenizer.readToken(bigEndian ? Token.UINT16_BE : Token.UINT16_LE);\n\t\tfor (let n = 0; n < numberOfTags; ++n) {\n\t\t\tconst fileType = await this.readTiffTag(bigEndian);\n\t\t\tif (fileType) {\n\t\t\t\treturn fileType;\n\t\t\t}\n\t\t}\n\t}\n\n\tasync readTiffHeader(bigEndian) {\n\t\tconst version = (bigEndian ? Token.UINT16_BE : Token.UINT16_LE).get(this.buffer, 2);\n\t\tconst ifdOffset = (bigEndian ? Token.UINT32_BE : Token.UINT32_LE).get(this.buffer, 4);\n\n\t\tif (version === 42) {\n\t\t\t// TIFF file header\n\t\t\tif (ifdOffset >= 6) {\n\t\t\t\tif (this.checkString('CR', {offset: 8})) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'cr2',\n\t\t\t\t\t\tmime: 'image/x-canon-cr2',\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tif (ifdOffset >= 8 && (this.check([0x1C, 0x00, 0xFE, 0x00], {offset: 8}) || this.check([0x1F, 0x00, 0x0B, 0x00], {offset: 8}))) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\text: 'nef',\n\t\t\t\t\t\tmime: 'image/x-nikon-nef',\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tawait this.tokenizer.ignore(ifdOffset);\n\t\t\tconst fileType = await this.readTiffIFD(bigEndian);\n\t\t\treturn fileType ?? {\n\t\t\t\text: 'tif',\n\t\t\t\tmime: 'image/tiff',\n\t\t\t};\n\t\t}\n\n\t\tif (version === 43) {\t// Big TIFF file header\n\t\t\treturn {\n\t\t\t\text: 'tif',\n\t\t\t\tmime: 'image/tiff',\n\t\t\t};\n\t\t}\n\t}\n}\n\nexport async function fileTypeStream(readableStream, {sampleSize = minimumBytes} = {}) {\n\tconst {default: stream} = await import('node:stream');\n\n\treturn new Promise((resolve, reject) => {\n\t\treadableStream.on('error', reject);\n\n\t\treadableStream.once('readable', () => {\n\t\t\t(async () => {\n\t\t\t\ttry {\n\t\t\t\t\t// Set up output stream\n\t\t\t\t\tconst pass = new stream.PassThrough();\n\t\t\t\t\tconst outputStream = stream.pipeline ? stream.pipeline(readableStream, pass, () => {}) : readableStream.pipe(pass);\n\n\t\t\t\t\t// Read the input stream and detect the filetype\n\t\t\t\t\tconst chunk = readableStream.read(sampleSize) ?? readableStream.read() ?? Buffer.alloc(0);\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst fileType = await fileTypeFromBuffer(chunk);\n\t\t\t\t\t\tpass.fileType = fileType;\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tif (error instanceof strtok3.EndOfStreamError) {\n\t\t\t\t\t\t\tpass.fileType = undefined;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tresolve(outputStream);\n\t\t\t\t} catch (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t}\n\t\t\t})();\n\t\t});\n\t});\n}\n\nexport const supportedExtensions = new Set(extensions);\nexport const supportedMimeTypes = new Set(mimeTypes);\n","import {fileTypeFromBuffer} from 'file-type';\n\nconst imageExtensions = new Set([\n\t'jpg',\n\t'png',\n\t'gif',\n\t'webp',\n\t'flif',\n\t'cr2',\n\t'tif',\n\t'bmp',\n\t'jxr',\n\t'psd',\n\t'ico',\n\t'bpg',\n\t'jp2',\n\t'jpm',\n\t'jpx',\n\t'heic',\n\t'cur',\n\t'dcm',\n\t'avif',\n]);\n\nexport default async function imageType(input) {\n\tconst result = await fileTypeFromBuffer(input);\n\treturn imageExtensions.has(result?.ext) && result;\n}\n\nexport const minimumBytes = 4100;\n","import { resolve, extname, relative, join, parse, posix } from \"path\";\nimport { Readable } from \"stream\";\nimport { clipboard } from \"electron\";\n\nexport interface IStringKeyMap<T> {\n  [key: string]: T;\n}\n\nconst IMAGE_EXT_LIST = [\n  \".png\",\n  \".jpg\",\n  \".jpeg\",\n  \".bmp\",\n  \".gif\",\n  \".svg\",\n  \".tiff\",\n  \".webp\",\n  \".avif\",\n];\n\nexport function isAnImage(ext: string) {\n  return IMAGE_EXT_LIST.includes(ext.toLowerCase());\n}\nexport function isAssetTypeAnImage(path: string): Boolean {\n  return isAnImage(extname(path));\n}\n\nexport function getOS() {\n  const { appVersion } = navigator;\n  if (appVersion.indexOf(\"Win\") !== -1) {\n    return \"Windows\";\n  } else if (appVersion.indexOf(\"Mac\") !== -1) {\n    return \"MacOS\";\n  } else if (appVersion.indexOf(\"X11\") !== -1) {\n    return \"Linux\";\n  } else {\n    return \"Unknown OS\";\n  }\n}\nexport async function streamToString(stream: Readable) {\n  const chunks = [];\n\n  for await (const chunk of stream) {\n    chunks.push(Buffer.from(chunk));\n  }\n\n  return Buffer.concat(chunks).toString(\"utf-8\");\n}\n\nexport function getUrlAsset(url: string) {\n  return (url = url.substr(1 + url.lastIndexOf(\"/\")).split(\"?\")[0]).split(\n    \"#\"\n  )[0];\n}\n\nexport function isCopyImageFile() {\n  let filePath = \"\";\n  const os = getOS();\n\n  if (os === \"Windows\") {\n    var rawFilePath = clipboard.read(\"FileNameW\");\n    filePath = rawFilePath.replace(new RegExp(String.fromCharCode(0), \"g\"), \"\");\n  } else if (os === \"MacOS\") {\n    filePath = clipboard.read(\"public.file-url\").replace(\"file://\", \"\");\n  } else {\n    filePath = \"\";\n  }\n  return isAssetTypeAnImage(filePath);\n}\n\nexport function getLastImage(list: string[]) {\n  const reversedList = list.reverse();\n  let lastImage;\n  reversedList.forEach(item => {\n    if (item && item.startsWith(\"http\")) {\n      lastImage = item;\n      return item;\n    }\n  });\n  return lastImage;\n}\n\ninterface AnyObj {\n  [key: string]: any;\n}\n\nexport function arrayToObject<T extends AnyObj>(\n  arr: T[],\n  key: string\n): { [key: string]: T } {\n  const obj: { [key: string]: T } = {};\n  arr.forEach(element => {\n    obj[element[key]] = element;\n  });\n  return obj;\n}\n","import { PluginSettings } from \"./setting\";\nimport { streamToString, getLastImage } from \"./utils\";\nimport { exec, spawnSync, spawn } from \"child_process\";\nimport { Notice, requestUrl } from \"obsidian\";\nimport imageAutoUploadPlugin from \"./main\";\n\nexport interface PicGoResponse {\n  success: string;\n  msg: string;\n  result: string[];\n  fullResult: Record<string, any>[];\n}\n\nexport class PicGoUploader {\n  settings: PluginSettings;\n  plugin: imageAutoUploadPlugin;\n\n  constructor(settings: PluginSettings, plugin: imageAutoUploadPlugin) {\n    this.settings = settings;\n    this.plugin = plugin;\n  }\n\n  async uploadFiles(fileList: Array<String>): Promise<any> {\n    const response = await requestUrl({\n      url: this.settings.uploadServer,\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify({ list: fileList }),\n    });\n\n    const data = await response.json;\n\n    // piclist\n    if (data.fullResult) {\n      const uploadUrlFullResultList = data.fullResult || [];\n      this.settings.uploadedImages = [\n        ...(this.settings.uploadedImages || []),\n        ...uploadUrlFullResultList,\n      ];\n    }\n\n    return data;\n  }\n\n  async uploadFileByClipboard(): Promise<any> {\n    const res = await requestUrl({\n      url: this.settings.uploadServer,\n      method: \"POST\",\n    });\n\n    let data: PicGoResponse = await res.json;\n\n    // piclist\n    if (data.fullResult) {\n      const uploadUrlFullResultList = data.fullResult || [];\n      this.settings.uploadedImages = [\n        ...(this.settings.uploadedImages || []),\n        ...uploadUrlFullResultList,\n      ];\n      this.plugin.saveSettings();\n    }\n\n    if (res.status !== 200) {\n      let err = { response: data, body: data.msg };\n      return {\n        code: -1,\n        msg: data.msg,\n        data: \"\",\n      };\n    } else {\n      return {\n        code: 0,\n        msg: \"success\",\n        data: typeof data.result == \"string\" ? data.result : data.result[0],\n      };\n    }\n  }\n}\n\nexport class PicGoCoreUploader {\n  settings: PluginSettings;\n  plugin: imageAutoUploadPlugin;\n\n  constructor(settings: PluginSettings, plugin: imageAutoUploadPlugin) {\n    this.settings = settings;\n    this.plugin = plugin;\n  }\n\n  async uploadFiles(fileList: Array<String>): Promise<any> {\n    const length = fileList.length;\n    let cli = this.settings.picgoCorePath || \"picgo\";\n    let command = `${cli} upload ${fileList\n      .map(item => `\"${item}\"`)\n      .join(\" \")}`;\n\n    const res = await this.exec(command);\n    const splitList = res.split(\"\\n\");\n    const splitListLength = splitList.length;\n\n    const data = splitList.splice(splitListLength - 1 - length, length);\n\n    if (res.includes(\"PicGo ERROR\")) {\n      console.log(command, res);\n\n      return {\n        success: false,\n        msg: \"失败\",\n      };\n    } else {\n      return {\n        success: true,\n        result: data,\n      };\n    }\n    // {success:true,result:[]}\n  }\n\n  // PicGo-Core 上传处理\n  async uploadFileByClipboard() {\n    const res = await this.uploadByClip();\n    const splitList = res.split(\"\\n\");\n    const lastImage = getLastImage(splitList);\n\n    if (lastImage) {\n      return {\n        code: 0,\n        msg: \"success\",\n        data: lastImage,\n      };\n    } else {\n      console.log(splitList);\n\n      // new Notice(`\"Please check PicGo-Core config\"\\n${res}`);\n      return {\n        code: -1,\n        msg: `\"Please check PicGo-Core config\"\\n${res}`,\n        data: \"\",\n      };\n    }\n  }\n\n  // PicGo-Core的剪切上传反馈\n  async uploadByClip() {\n    let command;\n    if (this.settings.picgoCorePath) {\n      command = `${this.settings.picgoCorePath} upload`;\n    } else {\n      command = `picgo upload`;\n    }\n    const res = await this.exec(command);\n    // const res = await this.spawnChild();\n\n    return res;\n  }\n\n  async exec(command: string) {\n    let { stdout } = await exec(command);\n    const res = await streamToString(stdout);\n    return res;\n  }\n\n  async spawnChild() {\n    const { spawn } = require(\"child_process\");\n    const child = spawn(\"picgo\", [\"upload\"], {\n      shell: true,\n    });\n\n    let data = \"\";\n    for await (const chunk of child.stdout) {\n      data += chunk;\n    }\n    let error = \"\";\n    for await (const chunk of child.stderr) {\n      error += chunk;\n    }\n    const exitCode = await new Promise((resolve, reject) => {\n      child.on(\"close\", resolve);\n    });\n\n    if (exitCode) {\n      throw new Error(`subprocess error exit ${exitCode}, ${error}`);\n    }\n    return data;\n  }\n}\n","import { IStringKeyMap } from \"./utils\";\nimport { App, requestUrl } from \"obsidian\";\nimport imageAutoUploadPlugin from \"./main\";\n\nexport class PicGoDeleter {\n  plugin: imageAutoUploadPlugin;\n\n  constructor(plugin: imageAutoUploadPlugin) {\n    this.plugin = plugin;\n  }\n\n  async deleteImage(configMap: IStringKeyMap<any>[]) {\n    const response = await requestUrl({\n      url: this.plugin.settings.deleteServer,\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify({\n        list: configMap,\n      }),\n    });\n    const data = response.json;\n    return data;\n  }\n}\n","import { MarkdownView, App } from \"obsidian\";\nimport { parse } from \"path\";\n\ninterface Image {\n  path: string;\n  name: string;\n  source: string;\n}\n// ![](./dsa/aa.png) local image should has ext\n// ![](https://dasdasda) internet image should not has ext\nconst REGEX_FILE = /\\!\\[(.*?)\\]\\((\\S+\\.\\w+)\\)|\\!\\[(.*?)\\]\\((https?:\\/\\/.*?)\\)/g;\nconst REGEX_WIKI_FILE = /\\!\\[\\[(.*?)(\\s*?\\|.*?)?\\]\\]/g;\nexport default class Helper {\n  app: App;\n\n  constructor(app: App) {\n    this.app = app;\n  }\n  getFrontmatterValue(key: string, defaultValue: any = undefined) {\n    const file = this.app.workspace.getActiveFile();\n    if (!file) {\n      return undefined;\n    }\n    const path = file.path;\n    const cache = this.app.metadataCache.getCache(path);\n\n    let value = defaultValue;\n    if (cache?.frontmatter && cache.frontmatter.hasOwnProperty(key)) {\n      value = cache.frontmatter[key];\n    }\n    return value;\n  }\n\n  getEditor() {\n    const mdView = this.app.workspace.getActiveViewOfType(MarkdownView);\n    if (mdView) {\n      return mdView.editor;\n    } else {\n      return null;\n    }\n  }\n  getValue() {\n    const editor = this.getEditor();\n    return editor.getValue();\n  }\n\n  setValue(value: string) {\n    const editor = this.getEditor();\n    const { left, top } = editor.getScrollInfo();\n    const position = editor.getCursor();\n\n    editor.setValue(value);\n    editor.scrollTo(left, top);\n    editor.setCursor(position);\n  }\n\n  // get all file urls, include local and internet\n  getAllFiles(): Image[] {\n    const editor = this.getEditor();\n    let value = editor.getValue();\n    return this.getImageLink(value);\n  }\n  getImageLink(value: string): Image[] {\n    const matches = value.matchAll(REGEX_FILE);\n    const WikiMatches = value.matchAll(REGEX_WIKI_FILE);\n\n    let fileArray: Image[] = [];\n\n    for (const match of matches) {\n      const source = match[0];\n\n      let name = match[1];\n      let path = match[2];\n      if (name === undefined) {\n        name = match[3];\n      }\n      if (path === undefined) {\n        path = match[4];\n      }\n\n      fileArray.push({\n        path: path,\n        name: name,\n        source: source,\n      });\n    }\n\n    for (const match of WikiMatches) {\n      console.log(match);\n\n      let name = parse(match[1]).name;\n      const path = match[1];\n      const source = match[0];\n      if (match[2]) {\n        name = `${name}${match[2]}`;\n      }\n      fileArray.push({\n        path: path,\n        name: name,\n        source: source,\n      });\n    }\n    console.log(fileArray);\n\n    return fileArray;\n  }\n\n  hasBlackDomain(src: string, blackDomains: string) {\n    if (blackDomains.trim() === \"\") {\n      return false;\n    }\n    const blackDomainList = blackDomains.split(\",\").filter(item => item !== \"\");\n    let url = new URL(src);\n    const domain = url.hostname;\n\n    return blackDomainList.some(blackDomain => domain.includes(blackDomain));\n  }\n}\n","// العربية\n\nexport default {};\n","// čeština\n\nexport default {};\n","// Dansk\n\nexport default {};\n","// Deutsch\n\nexport default {};","// English\n\nexport default {\n  // setting.ts\n  \"Plugin Settings\": \"Plugin Settings\",\n  \"Auto pasted upload\": \"Auto pasted upload\",\n  \"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)\":\n    \"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)\",\n  \"Default uploader\": \"Default uploader\",\n  \"PicGo server\": \"PicGo server\",\n  \"Please input PicGo server\": \"Please input PicGo server\",\n  \"PicGo delete server\":\n    \"PicGo server delete route(you need to use PicList app)\",\n  \"PicList desc\": \"Search PicList on Github to download and install\",\n  \"Please input PicGo delete server\": \"Please input PicGo delete server\",\n  \"Delete image using PicList\": \"Delete image using PicList\",\n  \"PicGo-Core path\": \"PicGo-Core path\",\n  \"Delete successfully\": \"Delete successfully\",\n  \"Delete failed\": \"Delete failed\",\n  \"Image size suffix\": \"Image size suffix\",\n  \"Image size suffix Description\": \"like |300 for resize image in ob.\",\n  \"Please input image size suffix\": \"Please input image size suffix\",\n  \"Error, could not delete\": \"Error, could not delete\",\n  \"Please input PicGo-Core path, default using environment variables\":\n    \"Please input PicGo-Core path, default using environment variables\",\n  \"Work on network\": \"Work on network\",\n  \"Work on network Description\":\n    \"Allow upload network image by 'Upload all' command.\\n Or when you paste, md standard image link in your clipboard will be auto upload.\",\n  fixPath: \"fixPath\",\n  fixPathWarning:\n    \"This option is used to fix PicGo-core upload failures on Linux and Mac. It modifies the PATH variable within Obsidian. If Obsidian encounters any bugs, turn off the option, try again! \",\n  \"Upload when clipboard has image and text together\":\n    \"Upload when clipboard has image and text together\",\n  \"When you copy, some application like Excel will image and text to clipboard, you can upload or not.\":\n    \"When you copy, some application like Excel will image and text to clipboard, you can upload or not.\",\n  \"Network Domain Black List\": \"Network Domain Black List\",\n  \"Network Domain Black List Description\":\n    \"Image in the domain list will not be upload,use comma separated\",\n  \"Delete source file after you upload file\":\n    \"Delete source file after you upload file\",\n  \"Delete source file in ob assets after you upload file.\":\n    \"Delete source file in ob assets after you upload file.\",\n  \"Image desc\": \"Image desc\",\n  reserve: \"default\",\n  \"remove all\": \"none\",\n  \"remove default\": \"remove image.png\",\n};\n","// British English\n\nexport default {};\n","// Español\n\nexport default {};\n","// français\n\nexport default {};\n","// हिन्दी\n\nexport default {};\n","// Bahasa Indonesia\n\nexport default {};\n","// Italiano\n\nexport default {};\n","// 日本語\n\nexport default {};","// 한국어\n\nexport default {};\n","// Nederlands\n\nexport default {};\n","// Norsk\n\nexport default {};\n","// język polski\n\nexport default {};\n","// Português\n\nexport default {};\n","// Português do Brasil\n// Brazilian Portuguese\n\nexport default {};","// Română\n\nexport default {};\n","// русский\n\nexport default {};\n","// Türkçe\n\nexport default {};\n","// 简体中文\n\nexport default {\n  // setting.ts\n  \"Plugin Settings\": \"插件设置\",\n  \"Auto pasted upload\": \"剪切板自动上传\",\n  \"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)\":\n    \"启用该选项后，黏贴图片时会自动上传（你需要正确配置picgo）\",\n  \"Default uploader\": \"默认上传器\",\n  \"PicGo server\": \"PicGo server\",\n  \"Please input PicGo server\": \"请输入 PicGo server\",\n  \"PicGo delete server\": \"PicGo server 删除接口(请使用PicList来启用此功能)\",\n  \"PicList desc\": \"PicList是PicGo二次开发版，请Github搜索PicList下载\",\n  \"Please input PicGo delete server\": \"请输入 PicGo server 删除接口\",\n  \"Delete image using PicList\": \"使用 PicList 删除图片\",\n  \"PicGo-Core path\": \"PicGo-Core 路径\",\n  \"Delete successfully\": \"删除成功\",\n  \"Delete failed\": \"删除失败\",\n  \"Error, could not delete\": \"错误，无法删除\",\n  \"Image size suffix\": \"图片大小后缀\",\n  \"Image size suffix Description\": \"比如：|300 用于调整图片大小\",\n  \"Please input image size suffix\": \"请输入图片大小后缀\",\n  \"Please input PicGo-Core path, default using environment variables\":\n    \"请输入 PicGo-Core path，默认使用环境变量\",\n  \"Work on network\": \"应用网络图片\",\n  \"Work on network Description\":\n    \"当你上传所有图片时，也会上传网络图片。以及当你进行黏贴时，剪切板中的标准 md 图片会被上传\",\n  fixPath: \"修正PATH变量\",\n  fixPathWarning:\n    \"此选项用于修复Linux和Mac上 PicGo-Core 上传失败的问题。它会修改 Obsidian 内的 PATH 变量，如果 Obsidian 遇到任何BUG，先关闭这个选项试试！\",\n  \"Upload when clipboard has image and text together\":\n    \"当剪切板同时拥有文本和图片剪切板数据时是否上传图片\",\n  \"When you copy, some application like Excel will image and text to clipboard, you can upload or not.\":\n    \"当你复制时，某些应用例如 Excel 会在剪切板同时文本和图像数据，确认是否上传。\",\n  \"Network Domain Black List\": \"网络图片域名黑名单\",\n  \"Network Domain Black List Description\":\n    \"黑名单域名中的图片将不会被上传，用英文逗号分割\",\n  \"Delete source file after you upload file\": \"上传文件后移除源文件\",\n  \"Delete source file in ob assets after you upload file.\":\n    \"上传文件后移除在ob附件文件夹中的文件\",\n  \"Image desc\": \"图片描述\",\n  reserve: \"默认\",\n  \"remove all\": \"无\",\n  \"remove default\": \"移除image.png\",\n};\n","// 繁體中文\n\nexport default {};\n","import { moment } from 'obsidian';\n\nimport ar from './locale/ar';\nimport cz from './locale/cz';\nimport da from './locale/da';\nimport de from './locale/de';\nimport en from './locale/en';\nimport enGB from './locale/en-gb';\nimport es from './locale/es';\nimport fr from './locale/fr';\nimport hi from './locale/hi';\nimport id from './locale/id';\nimport it from './locale/it';\nimport ja from './locale/ja';\nimport ko from './locale/ko';\nimport nl from './locale/nl';\nimport no from './locale/no';\nimport pl from './locale/pl';\nimport pt from './locale/pt';\nimport ptBR from './locale/pt-br';\nimport ro from './locale/ro';\nimport ru from './locale/ru';\nimport tr from './locale/tr';\nimport zhCN from './locale/zh-cn';\nimport zhTW from './locale/zh-tw';\n\nconst localeMap: { [k: string]: Partial<typeof en> } = {\n  ar,\n  cs: cz,\n  da,\n  de,\n  en,\n  'en-gb': enGB,\n  es,\n  fr,\n  hi,\n  id,\n  it,\n  ja,\n  ko,\n  nl,\n  nn: no,\n  pl,\n  pt,\n  'pt-br': ptBR,\n  ro,\n  ru,\n  tr,\n  'zh-cn': zhCN,\n  'zh-tw': zhTW,\n};\n\nconst locale = localeMap[moment.locale()];\n\nexport function t(str: keyof typeof en): string {\n  return (locale && locale[str]) || en[str];\n}\n","import { App, PluginSettingTab, Setting } from \"obsidian\";\nimport imageAutoUploadPlugin from \"./main\";\nimport { t } from \"./lang/helpers\";\nimport { getOS } from \"./utils\";\n\nexport interface PluginSettings {\n  uploadByClipSwitch: boolean;\n  uploadServer: string;\n  deleteServer: string;\n  imageSizeSuffix: string;\n  uploader: string;\n  picgoCorePath: string;\n  workOnNetWork: boolean;\n  newWorkBlackDomains: string;\n  fixPath: boolean;\n  applyImage: boolean;\n  deleteSource: boolean;\n  imageDesc: \"origin\" | \"none\" | \"removeDefault\";\n  [propName: string]: any;\n}\n\nexport const DEFAULT_SETTINGS: PluginSettings = {\n  uploadByClipSwitch: true,\n  uploader: \"PicGo\",\n  uploadServer: \"http://127.0.0.1:36677/upload\",\n  deleteServer: \"http://127.0.0.1:36677/delete\",\n  imageSizeSuffix: \"\",\n  picgoCorePath: \"\",\n  workOnNetWork: false,\n  fixPath: false,\n  applyImage: true,\n  newWorkBlackDomains: \"\",\n  deleteSource: false,\n  imageDesc: \"origin\",\n};\n\nexport class SettingTab extends PluginSettingTab {\n  plugin: imageAutoUploadPlugin;\n\n  constructor(app: App, plugin: imageAutoUploadPlugin) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    let { containerEl } = this;\n\n    const os = getOS();\n\n    containerEl.empty();\n    containerEl.createEl(\"h2\", { text: t(\"Plugin Settings\") });\n    new Setting(containerEl)\n      .setName(t(\"Auto pasted upload\"))\n      .setDesc(\n        t(\n          \"If you set this value true, when you paste image, it will be auto uploaded(you should set the picGo server rightly)\"\n        )\n      )\n      .addToggle(toggle =>\n        toggle\n          .setValue(this.plugin.settings.uploadByClipSwitch)\n          .onChange(async value => {\n            this.plugin.settings.uploadByClipSwitch = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Default uploader\"))\n      .setDesc(t(\"Default uploader\"))\n      .addDropdown(cb =>\n        cb\n          .addOption(\"PicGo\", \"PicGo(app)\")\n          .addOption(\"PicGo-Core\", \"PicGo-Core\")\n          .setValue(this.plugin.settings.uploader)\n          .onChange(async value => {\n            this.plugin.settings.uploader = value;\n            this.display();\n            await this.plugin.saveSettings();\n          })\n      );\n\n    if (this.plugin.settings.uploader === \"PicGo\") {\n      new Setting(containerEl)\n        .setName(t(\"PicGo server\"))\n        .setDesc(t(\"PicGo server\"))\n        .addText(text =>\n          text\n            .setPlaceholder(t(\"Please input PicGo server\"))\n            .setValue(this.plugin.settings.uploadServer)\n            .onChange(async key => {\n              this.plugin.settings.uploadServer = key;\n              await this.plugin.saveSettings();\n            })\n        );\n\n      new Setting(containerEl)\n        .setName(t(\"PicGo delete server\"))\n        .setDesc(t(\"PicList desc\"))\n        .addText(text =>\n          text\n            .setPlaceholder(t(\"Please input PicGo delete server\"))\n            .setValue(this.plugin.settings.deleteServer)\n            .onChange(async key => {\n              this.plugin.settings.deleteServer = key;\n              await this.plugin.saveSettings();\n            })\n        );\n    }\n\n    if (this.plugin.settings.uploader === \"PicGo-Core\") {\n      new Setting(containerEl)\n        .setName(t(\"PicGo-Core path\"))\n        .setDesc(\n          t(\"Please input PicGo-Core path, default using environment variables\")\n        )\n        .addText(text =>\n          text\n            .setPlaceholder(\"\")\n            .setValue(this.plugin.settings.picgoCorePath)\n            .onChange(async value => {\n              this.plugin.settings.picgoCorePath = value;\n              await this.plugin.saveSettings();\n            })\n        );\n\n      if (os !== \"Windows\") {\n        new Setting(containerEl)\n          .setName(t(\"fixPath\"))\n          .setDesc(t(\"fixPathWarning\"))\n          .addToggle(toggle =>\n            toggle\n              .setValue(this.plugin.settings.fixPath)\n              .onChange(async value => {\n                this.plugin.settings.fixPath = value;\n                await this.plugin.saveSettings();\n              })\n          );\n      }\n    }\n\n    // image desc setting\n    new Setting(containerEl)\n      .setName(t(\"Image desc\"))\n      .setDesc(t(\"Image desc\"))\n      .addDropdown(cb =>\n        cb\n          .addOption(\"origin\", t(\"reserve\")) // 保留全部\n          .addOption(\"none\", t(\"remove all\")) // 移除全部\n          .addOption(\"removeDefault\", t(\"remove default\")) // 只移除默认即 image.png\n          .setValue(this.plugin.settings.imageDesc)\n          .onChange(async (value: \"origin\" | \"none\" | \"removeDefault\") => {\n            this.plugin.settings.imageDesc = value;\n            this.display();\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Image size suffix\"))\n      .setDesc(t(\"Image size suffix Description\"))\n      .addText(text =>\n        text\n          .setPlaceholder(t(\"Please input image size suffix\"))\n          .setValue(this.plugin.settings.imageSizeSuffix)\n          .onChange(async key => {\n            this.plugin.settings.imageSizeSuffix = key;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Work on network\"))\n      .setDesc(t(\"Work on network Description\"))\n      .addToggle(toggle =>\n        toggle\n          .setValue(this.plugin.settings.workOnNetWork)\n          .onChange(async value => {\n            this.plugin.settings.workOnNetWork = value;\n            this.display();\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Network Domain Black List\"))\n      .setDesc(t(\"Network Domain Black List Description\"))\n      .addTextArea(textArea =>\n        textArea\n          .setValue(this.plugin.settings.newWorkBlackDomains)\n          .onChange(async value => {\n            this.plugin.settings.newWorkBlackDomains = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Upload when clipboard has image and text together\"))\n      .setDesc(\n        t(\n          \"When you copy, some application like Excel will image and text to clipboard, you can upload or not.\"\n        )\n      )\n      .addToggle(toggle =>\n        toggle\n          .setValue(this.plugin.settings.applyImage)\n          .onChange(async value => {\n            this.plugin.settings.applyImage = value;\n            this.display();\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(t(\"Delete source file after you upload file\"))\n      .setDesc(t(\"Delete source file in ob assets after you upload file.\"))\n      .addToggle(toggle =>\n        toggle\n          .setValue(this.plugin.settings.deleteSource)\n          .onChange(async value => {\n            this.plugin.settings.deleteSource = value;\n            this.display();\n            await this.plugin.saveSettings();\n          })\n      );\n  }\n}\n","import {\n  MarkdownView,\n  Plugin,\n  FileSystemAdapter,\n  Editor,\n  Menu,\n  MenuItem,\n  TFile,\n  normalizePath,\n  Notice,\n  addIcon,\n  requestUrl,\n  MarkdownFileInfo,\n} from \"obsidian\";\n\nimport { resolve, relative, join, parse, posix, basename, dirname } from \"path\";\nimport { existsSync, mkdirSync, writeFileSync, unlink } from \"fs\";\n\nimport fixPath from \"fix-path\";\nimport imageType from \"image-type\";\n\nimport {\n  isAssetTypeAnImage,\n  isAnImage,\n  getUrlAsset,\n  arrayToObject,\n} from \"./utils\";\nimport { PicGoUploader, PicGoCoreUploader } from \"./uploader\";\nimport { PicGoDeleter } from \"./deleter\";\nimport Helper from \"./helper\";\nimport { t } from \"./lang/helpers\";\n\nimport { SettingTab, PluginSettings, DEFAULT_SETTINGS } from \"./setting\";\n\ninterface Image {\n  path: string;\n  name: string;\n  source: string;\n}\n\nexport default class imageAutoUploadPlugin extends Plugin {\n  settings: PluginSettings;\n  helper: Helper;\n  editor: Editor;\n  picGoUploader: PicGoUploader;\n  picGoDeleter: PicGoDeleter;\n  picGoCoreUploader: PicGoCoreUploader;\n  uploader: PicGoUploader | PicGoCoreUploader;\n\n  async loadSettings() {\n    this.settings = Object.assign(DEFAULT_SETTINGS, await this.loadData());\n  }\n\n  async saveSettings() {\n    await this.saveData(this.settings);\n  }\n\n  onunload() {}\n\n  async onload() {\n    await this.loadSettings();\n\n    this.helper = new Helper(this.app);\n    this.picGoUploader = new PicGoUploader(this.settings, this);\n    this.picGoDeleter = new PicGoDeleter(this);\n    this.picGoCoreUploader = new PicGoCoreUploader(this.settings, this);\n\n    if (this.settings.uploader === \"PicGo\") {\n      this.uploader = this.picGoUploader;\n    } else if (this.settings.uploader === \"PicGo-Core\") {\n      this.uploader = this.picGoCoreUploader;\n      if (this.settings.fixPath) {\n        fixPath();\n      }\n    } else {\n      new Notice(\"unknown uploader\");\n    }\n\n    addIcon(\n      \"upload\",\n      `<svg t=\"1636630783429\" class=\"icon\" viewBox=\"0 0 100 100\" version=\"1.1\" p-id=\"4649\" xmlns=\"http://www.w3.org/2000/svg\">\n      <path d=\"M 71.638 35.336 L 79.408 35.336 C 83.7 35.336 87.178 38.662 87.178 42.765 L 87.178 84.864 C 87.178 88.969 83.7 92.295 79.408 92.295 L 17.249 92.295 C 12.957 92.295 9.479 88.969 9.479 84.864 L 9.479 42.765 C 9.479 38.662 12.957 35.336 17.249 35.336 L 25.019 35.336 L 25.019 42.765 L 17.249 42.765 L 17.249 84.864 L 79.408 84.864 L 79.408 42.765 L 71.638 42.765 L 71.638 35.336 Z M 49.014 10.179 L 67.326 27.688 L 61.835 32.942 L 52.849 24.352 L 52.849 59.731 L 45.078 59.731 L 45.078 24.455 L 36.194 32.947 L 30.702 27.692 L 49.012 10.181 Z\" p-id=\"4650\" fill=\"#8a8a8a\"></path>\n    </svg>`\n    );\n\n    this.addSettingTab(new SettingTab(this.app, this));\n\n    this.addCommand({\n      id: \"Upload all images\",\n      name: \"Upload all images\",\n      checkCallback: (checking: boolean) => {\n        let leaf = this.app.workspace.activeLeaf;\n        if (leaf) {\n          if (!checking) {\n            this.uploadAllFile();\n          }\n          return true;\n        }\n        return false;\n      },\n    });\n    this.addCommand({\n      id: \"Download all images\",\n      name: \"Download all images\",\n      checkCallback: (checking: boolean) => {\n        let leaf = this.app.workspace.activeLeaf;\n        if (leaf) {\n          if (!checking) {\n            this.downloadAllImageFiles();\n          }\n          return true;\n        }\n        return false;\n      },\n    });\n\n    this.setupPasteHandler();\n    this.registerFileMenu();\n\n    this.registerSelection();\n  }\n\n  registerSelection() {\n    this.registerEvent(\n      this.app.workspace.on(\n        \"editor-menu\",\n        (menu: Menu, editor: Editor, info: MarkdownView | MarkdownFileInfo) => {\n          if (this.app.workspace.getLeavesOfType(\"markdown\").length === 0) {\n            return;\n          }\n          const selection = editor.getSelection();\n          if (selection) {\n            const markdownRegex = /!\\[.*\\]\\((.*)\\)/g;\n            const markdownMatch = markdownRegex.exec(selection);\n            if (markdownMatch && markdownMatch.length > 1) {\n              const markdownUrl = markdownMatch[1];\n              if (\n                this.settings.uploadedImages.find(\n                  (item: { imgUrl: string }) => item.imgUrl === markdownUrl\n                )\n              ) {\n                this.addMenu(menu, markdownUrl, editor);\n              }\n            }\n          }\n        }\n      )\n    );\n  }\n\n  addMenu = (menu: Menu, imgPath: string, editor: Editor) => {\n    menu.addItem((item: MenuItem) =>\n      item\n        .setIcon(\"trash-2\")\n        .setTitle(t(\"Delete image using PicList\"))\n        .onClick(async () => {\n          try {\n            const selectedItem = this.settings.uploadedImages.find(\n              (item: { imgUrl: string }) => item.imgUrl === imgPath\n            );\n            if (selectedItem) {\n              const res = await this.picGoDeleter.deleteImage([selectedItem]);\n              if (res.success) {\n                new Notice(t(\"Delete successfully\"));\n                const selection = editor.getSelection();\n                if (selection) {\n                  editor.replaceSelection(\"\");\n                }\n                this.settings.uploadedImages =\n                  this.settings.uploadedImages.filter(\n                    (item: { imgUrl: string }) => item.imgUrl !== imgPath\n                  );\n                this.saveSettings();\n              } else {\n                new Notice(t(\"Delete failed\"));\n              }\n            }\n          } catch {\n            new Notice(t(\"Error, could not delete\"));\n          }\n        })\n    );\n  };\n\n  async downloadAllImageFiles() {\n    const folderPath = this.getFileAssetPath();\n    const fileArray = this.helper.getAllFiles();\n    if (!existsSync(folderPath)) {\n      mkdirSync(folderPath);\n    }\n\n    let imageArray = [];\n    const nameSet = new Set();\n    for (const file of fileArray) {\n      if (!file.path.startsWith(\"http\")) {\n        continue;\n      }\n\n      const url = file.path;\n      const asset = getUrlAsset(url);\n      let name = decodeURI(parse(asset).name).replaceAll(\n        /[\\\\\\\\/:*?\\\"<>|]/g,\n        \"-\"\n      );\n\n      // 如果文件名已存在，则用随机值替换，不对文件后缀进行判断\n      if (existsSync(join(folderPath))) {\n        name = (Math.random() + 1).toString(36).substr(2, 5);\n      }\n      if (nameSet.has(name)) {\n        name = `${name}-${(Math.random() + 1).toString(36).substr(2, 5)}`;\n      }\n      nameSet.add(name);\n\n      const response = await this.download(url, folderPath, name);\n      if (response.ok) {\n        const activeFolder = normalizePath(\n          this.app.workspace.getActiveFile().parent.path\n        );\n        const abstractActiveFolder = (\n          this.app.vault.adapter as FileSystemAdapter\n        ).getFullPath(activeFolder);\n\n        imageArray.push({\n          source: file.source,\n          name: name,\n          path: normalizePath(relative(abstractActiveFolder, response.path)),\n        });\n      }\n    }\n\n    let value = this.helper.getValue();\n    imageArray.map(image => {\n      let name = this.handleName(image.name);\n\n      value = value.replace(\n        image.source,\n        `![${name}](${encodeURI(image.path)})`\n      );\n    });\n\n    this.helper.setValue(value);\n\n    new Notice(\n      `all: ${fileArray.length}\\nsuccess: ${imageArray.length}\\nfailed: ${\n        fileArray.length - imageArray.length\n      }`\n    );\n  }\n\n  // 获取当前文件所属的附件文件夹\n  getFileAssetPath() {\n    const basePath = (\n      this.app.vault.adapter as FileSystemAdapter\n    ).getBasePath();\n\n    // @ts-ignore\n    const assetFolder: string = this.app.vault.config.attachmentFolderPath;\n    const activeFile = this.app.vault.getAbstractFileByPath(\n      this.app.workspace.getActiveFile().path\n    );\n\n    // 当前文件夹下的子文件夹\n    if (assetFolder.startsWith(\"./\")) {\n      const activeFolder = decodeURI(resolve(basePath, activeFile.parent.path));\n      return join(activeFolder, assetFolder);\n    } else {\n      // 根文件夹\n      return join(basePath, assetFolder);\n    }\n  }\n\n  async download(url: string, folderPath: string, name: string) {\n    const response = await requestUrl({ url });\n    const type = await imageType(new Uint8Array(response.arrayBuffer));\n\n    if (response.status !== 200) {\n      return {\n        ok: false,\n        msg: \"error\",\n      };\n    }\n    if (!type) {\n      return {\n        ok: false,\n        msg: \"error\",\n      };\n    }\n\n    const buffer = Buffer.from(response.arrayBuffer);\n\n    try {\n      const path = join(folderPath, `${name}.${type.ext}`);\n\n      writeFileSync(path, buffer);\n      return {\n        ok: true,\n        msg: \"ok\",\n        path: path,\n        type,\n      };\n    } catch (err) {\n      return {\n        ok: false,\n        msg: err,\n      };\n    }\n  }\n\n  registerFileMenu() {\n    this.registerEvent(\n      this.app.workspace.on(\n        \"file-menu\",\n        (menu: Menu, file: TFile, source: string, leaf) => {\n          if (source === \"canvas-menu\") return false;\n          if (!isAssetTypeAnImage(file.path)) return false;\n\n          menu.addItem((item: MenuItem) => {\n            item\n              .setTitle(\"Upload\")\n              .setIcon(\"upload\")\n              .onClick(() => {\n                if (!(file instanceof TFile)) {\n                  return false;\n                }\n                this.fileMenuUpload(file);\n              });\n          });\n        }\n      )\n    );\n  }\n\n  fileMenuUpload(file: TFile) {\n    let content = this.helper.getValue();\n\n    const basePath = (\n      this.app.vault.adapter as FileSystemAdapter\n    ).getBasePath();\n    let imageList: Image[] = [];\n    const fileArray = this.helper.getAllFiles();\n\n    for (const match of fileArray) {\n      const imageName = match.name;\n      const encodedUri = match.path;\n\n      const fileName = basename(decodeURI(encodedUri));\n\n      if (file && file.name === fileName) {\n        const abstractImageFile = join(basePath, file.path);\n\n        if (isAssetTypeAnImage(abstractImageFile)) {\n          imageList.push({\n            path: abstractImageFile,\n            name: imageName,\n            source: match.source,\n          });\n        }\n      }\n    }\n\n    if (imageList.length === 0) {\n      new Notice(\"没有解析到图像文件\");\n      return;\n    }\n\n    this.uploader.uploadFiles(imageList.map(item => item.path)).then(res => {\n      if (res.success) {\n        let uploadUrlList = res.result;\n        imageList.map(item => {\n          const uploadImage = uploadUrlList.shift();\n          let name = this.handleName(item.name);\n\n          content = content.replaceAll(\n            item.source,\n            `![${name}](${uploadImage})`\n          );\n        });\n        this.helper.setValue(content);\n\n        if (this.settings.deleteSource) {\n          imageList.map(image => {\n            if (!image.path.startsWith(\"http\")) {\n              unlink(image.path, () => {});\n            }\n          });\n        }\n      } else {\n        new Notice(\"Upload error\");\n      }\n    });\n  }\n\n  filterFile(fileArray: Image[]) {\n    const imageList: Image[] = [];\n\n    for (const match of fileArray) {\n      if (match.path.startsWith(\"http\")) {\n        if (this.settings.workOnNetWork) {\n          if (\n            !this.helper.hasBlackDomain(\n              match.path,\n              this.settings.newWorkBlackDomains\n            )\n          ) {\n            imageList.push({\n              path: match.path,\n              name: match.name,\n              source: match.source,\n            });\n          }\n        }\n      } else {\n        imageList.push({\n          path: match.path,\n          name: match.name,\n          source: match.source,\n        });\n      }\n    }\n\n    return imageList;\n  }\n  getFile(fileName: string, fileMap: any) {\n    if (!fileMap) {\n      fileMap = arrayToObject(this.app.vault.getFiles(), \"name\");\n    }\n    return fileMap[fileName];\n  }\n  // uploda all file\n  uploadAllFile() {\n    let content = this.helper.getValue();\n\n    const basePath = (\n      this.app.vault.adapter as FileSystemAdapter\n    ).getBasePath();\n    const activeFile = this.app.workspace.getActiveFile();\n    const fileMap = arrayToObject(this.app.vault.getFiles(), \"name\");\n    const filePathMap = arrayToObject(this.app.vault.getFiles(), \"path\");\n    let imageList: Image[] = [];\n    const fileArray = this.filterFile(this.helper.getAllFiles());\n\n    for (const match of fileArray) {\n      const imageName = match.name;\n      const encodedUri = match.path;\n\n      if (encodedUri.startsWith(\"http\")) {\n        imageList.push({\n          path: match.path,\n          name: imageName,\n          source: match.source,\n        });\n      } else {\n        const fileName = basename(decodeURI(encodedUri));\n        let file;\n        // 绝对路径\n        if (filePathMap[decodeURI(encodedUri)]) {\n          file = filePathMap[decodeURI(encodedUri)];\n        }\n\n        // 相对路径\n        if (\n          (!file && decodeURI(encodedUri).startsWith(\"./\")) ||\n          decodeURI(encodedUri).startsWith(\"../\")\n        ) {\n          const filePath = resolve(\n            join(basePath, dirname(activeFile.path)),\n            decodeURI(encodedUri)\n          );\n\n          if (existsSync(filePath)) {\n            const path = normalizePath(\n              relative(\n                basePath,\n                resolve(\n                  join(basePath, dirname(activeFile.path)),\n                  decodeURI(encodedUri)\n                )\n              )\n            );\n\n            file = filePathMap[path];\n          }\n        }\n        // 尽可能短路径\n        if (!file) {\n          file = this.getFile(fileName, fileMap);\n        }\n\n        if (file) {\n          const abstractImageFile = join(basePath, file.path);\n\n          if (isAssetTypeAnImage(abstractImageFile)) {\n            imageList.push({\n              path: abstractImageFile,\n              name: imageName,\n              source: match.source,\n            });\n          }\n        }\n      }\n    }\n\n    if (imageList.length === 0) {\n      new Notice(\"没有解析到图像文件\");\n      return;\n    } else {\n      new Notice(`共找到${imageList.length}个图像文件，开始上传`);\n    }\n\n    this.uploader.uploadFiles(imageList.map(item => item.path)).then(res => {\n      if (res.success) {\n        let uploadUrlList = res.result;\n\n        imageList.map(item => {\n          const uploadImage = uploadUrlList.shift();\n\n          let name = this.handleName(item.name);\n          content = content.replaceAll(\n            item.source,\n            `![${name}](${uploadImage})`\n          );\n        });\n        this.helper.setValue(content);\n\n        if (this.settings.deleteSource) {\n          imageList.map(image => {\n            if (!image.path.startsWith(\"http\")) {\n              unlink(image.path, () => {});\n            }\n          });\n        }\n      } else {\n        new Notice(\"Upload error\");\n      }\n    });\n  }\n\n  setupPasteHandler() {\n    this.registerEvent(\n      this.app.workspace.on(\n        \"editor-paste\",\n        (evt: ClipboardEvent, editor: Editor, markdownView: MarkdownView) => {\n          const allowUpload = this.helper.getFrontmatterValue(\n            \"image-auto-upload\",\n            this.settings.uploadByClipSwitch\n          );\n\n          let files = evt.clipboardData.files;\n          if (!allowUpload) {\n            return;\n          }\n\n          // 剪贴板内容有md格式的图片时\n          if (this.settings.workOnNetWork) {\n            const clipboardValue = evt.clipboardData.getData(\"text/plain\");\n            const imageList = this.helper\n              .getImageLink(clipboardValue)\n              .filter(image => image.path.startsWith(\"http\"))\n              .filter(\n                image =>\n                  !this.helper.hasBlackDomain(\n                    image.path,\n                    this.settings.newWorkBlackDomains\n                  )\n              );\n\n            if (imageList.length !== 0) {\n              this.uploader\n                .uploadFiles(imageList.map(item => item.path))\n                .then(res => {\n                  let value = this.helper.getValue();\n                  if (res.success) {\n                    let uploadUrlList = res.result;\n                    imageList.map(item => {\n                      const uploadImage = uploadUrlList.shift();\n                      let name = this.handleName(item.name);\n\n                      value = value.replaceAll(\n                        item.source,\n                        `![${name}](${uploadImage})`\n                      );\n                    });\n                    this.helper.setValue(value);\n                  } else {\n                    new Notice(\"Upload error\");\n                  }\n                });\n            }\n          }\n\n          // 剪贴板中是图片时进行上传\n          if (this.canUpload(evt.clipboardData)) {\n            this.uploadFileAndEmbedImgurImage(\n              editor,\n              async (editor: Editor, pasteId: string) => {\n                let res = await this.uploader.uploadFileByClipboard();\n                if (res.code !== 0) {\n                  this.handleFailedUpload(editor, pasteId, res.msg);\n                  return;\n                }\n                const url = res.data;\n\n                return url;\n              },\n              evt.clipboardData\n            ).catch();\n            evt.preventDefault();\n          }\n        }\n      )\n    );\n    this.registerEvent(\n      this.app.workspace.on(\n        \"editor-drop\",\n        async (evt: DragEvent, editor: Editor, markdownView: MarkdownView) => {\n          const allowUpload = this.helper.getFrontmatterValue(\n            \"image-auto-upload\",\n            this.settings.uploadByClipSwitch\n          );\n          let files = evt.dataTransfer.files;\n\n          if (!allowUpload) {\n            return;\n          }\n\n          if (files.length !== 0 && files[0].type.startsWith(\"image\")) {\n            let sendFiles: Array<String> = [];\n            let files = evt.dataTransfer.files;\n            Array.from(files).forEach((item, index) => {\n              sendFiles.push(item.path);\n            });\n            evt.preventDefault();\n\n            const data = await this.uploader.uploadFiles(sendFiles);\n\n            if (data.success) {\n              data.result.map((value: string) => {\n                let pasteId = (Math.random() + 1).toString(36).substr(2, 5);\n                this.insertTemporaryText(editor, pasteId);\n                this.embedMarkDownImage(editor, pasteId, value, files[0].name);\n              });\n            } else {\n              new Notice(\"Upload error\");\n            }\n          }\n        }\n      )\n    );\n  }\n\n  canUpload(clipboardData: DataTransfer) {\n    this.settings.applyImage;\n    const files = clipboardData.files;\n    const text = clipboardData.getData(\"text\");\n\n    const hasImageFile =\n      files.length !== 0 && files[0].type.startsWith(\"image\");\n    if (hasImageFile) {\n      if (!!text) {\n        return this.settings.applyImage;\n      } else {\n        return true;\n      }\n    } else {\n      return false;\n    }\n  }\n\n  async uploadFileAndEmbedImgurImage(\n    editor: Editor,\n    callback: Function,\n    clipboardData: DataTransfer\n  ) {\n    let pasteId = (Math.random() + 1).toString(36).substr(2, 5);\n    this.insertTemporaryText(editor, pasteId);\n    const name = clipboardData.files[0].name;\n\n    try {\n      const url = await callback(editor, pasteId);\n      this.embedMarkDownImage(editor, pasteId, url, name);\n    } catch (e) {\n      this.handleFailedUpload(editor, pasteId, e);\n    }\n  }\n\n  insertTemporaryText(editor: Editor, pasteId: string) {\n    let progressText = imageAutoUploadPlugin.progressTextFor(pasteId);\n    editor.replaceSelection(progressText + \"\\n\");\n  }\n\n  private static progressTextFor(id: string) {\n    return `![Uploading file...${id}]()`;\n  }\n\n  embedMarkDownImage(\n    editor: Editor,\n    pasteId: string,\n    imageUrl: any,\n    name: string = \"\"\n  ) {\n    let progressText = imageAutoUploadPlugin.progressTextFor(pasteId);\n    name = this.handleName(name);\n\n    let markDownImage = `![${name}](${imageUrl})`;\n\n    imageAutoUploadPlugin.replaceFirstOccurrence(\n      editor,\n      progressText,\n      markDownImage\n    );\n  }\n\n  handleFailedUpload(editor: Editor, pasteId: string, reason: any) {\n    new Notice(reason);\n    console.error(\"Failed request: \", reason);\n    let progressText = imageAutoUploadPlugin.progressTextFor(pasteId);\n    imageAutoUploadPlugin.replaceFirstOccurrence(\n      editor,\n      progressText,\n      \"⚠️upload failed, check dev console\"\n    );\n  }\n\n  handleName(name: string) {\n    const imageSizeSuffix = this.settings.imageSizeSuffix || \"\";\n\n    if (this.settings.imageDesc === \"origin\") {\n      return `${name}${imageSizeSuffix}`;\n    } else if (this.settings.imageDesc === \"none\") {\n      return \"\";\n    } else if (this.settings.imageDesc === \"removeDefault\") {\n      if (name === \"image.png\") {\n        return \"\";\n      } else {\n        return `${name}${imageSizeSuffix}`;\n      }\n    } else {\n      return `${name}${imageSizeSuffix}`;\n    }\n  }\n\n  static replaceFirstOccurrence(\n    editor: Editor,\n    target: string,\n    replacement: string\n  ) {\n    let lines = editor.getValue().split(\"\\n\");\n    for (let i = 0; i < lines.length; i++) {\n      let ch = lines[i].indexOf(target);\n      if (ch != -1) {\n        let from = { line: i, ch: ch };\n        let to = { line: i, ch: ch + target.length };\n        editor.replaceRange(replacement, from, to);\n        break;\n      }\n    }\n  }\n}\n"],"names":["core","global","require$$1","require$$2","isexe","path","require$$0","which","pathKeyModule","resolveCommand","shebangRegex","shebangCommand","readShebang","require$$3","isWin","parse","enoent","crossSpawnModule","stripFinalNewline","mimicFn","mimicFnModule","onetime","onetimeModule","signals","_os","_realtime","signalsByName","makeError","normalizeStdio","stdioModule","process","signalExitModule","spawnedKill","spawnedCancel","setupTimeout","validateTimeout","setExitHandler","isStream","bufferStream","stream","getStream","getStreamModule","mergeStream","handleInput","makeAllStream","getSpawnedResult","validateInputSync","mergePromise","getSpawnedPromise","joinCommand","getEscapedCommand","parseCommand","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","execaModule","userInfo","execa","inherits_browserModule","inheritsModule","require$$12","Buffer","strtok3.fromBuffer","strtok3.EndOfStreamError","Token.StringType","Token.UINT8","Token.INT32_BE","Token.UINT64_LE","Token.UINT16_BE","Token.UINT16_LE","Token.UINT32_BE","Token.UINT32_LE","extname","requestUrl","exec","MarkdownView","moment","Setting","PluginSettingTab","Notice","addIcon","existsSync","mkdirSync","join","normalizePath","relative","resolve","writeFileSync","TFile","basename","unlink","dirname","Plugin"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70]}
|