Raven Scott
346bb71ffe
sh, diff/patch, sort, printf, find, test, getfacl/setfacl/xattr), expanded /proc and metrics (process table, syscalls, replication, net, security posture, worker budget, swarm/replication hints), initd DAG supervision metadata and richer restart journal telemetry, synthetic process groups via IPC (assignProcessGroup/signalProcessGroup) mirrored into process_table, optional kernel.ext.d incremental hot reload (BARE_OS_KERNEL_EXT_D_HOT_RELOAD) with reload audit NDJSON, features proc for hyperblobs dedup and systemd subset documentation, vault threat model doc plus posture fields for AEAD, Pear enclave pointer, account rotation continuity, and Ed25519 consistency across boot manifest / extensions / replication. Adds or extends tests and keeps kernel/ and packages/bare-os-seeder/kernel/ in parity; guest init is bundled from kernel/lib/init/init-main.js via bundle-kernel-init.
8877 lines
299 KiB
JavaScript
8877 lines
299 KiB
JavaScript
var __bare_os_bundle_exports__ = (() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
}) : x)(function(x) {
|
|
if (typeof require !== "undefined") return require.apply(this, arguments);
|
|
throw Error('Dynamic require of "' + x + '" is not supported');
|
|
});
|
|
var __commonJS = (cb, mod) => function __require2() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// ../../node_modules/bare-encoding/lib/utf8-decoder.js
|
|
var require_utf8_decoder = __commonJS({
|
|
"../../node_modules/bare-encoding/lib/utf8-decoder.js"(exports, module) {
|
|
module.exports = class UTF8Decoder {
|
|
constructor() {
|
|
this.codePoint = 0;
|
|
this.bytesSeen = 0;
|
|
this.bytesNeeded = 0;
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
}
|
|
get remaining() {
|
|
return this.bytesSeen;
|
|
}
|
|
decode(data) {
|
|
if (ArrayBuffer.isView(data)) {
|
|
data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
|
|
} else {
|
|
data = Buffer.from(data);
|
|
}
|
|
if (this.bytesNeeded === 0) {
|
|
let isBoundary = true;
|
|
for (let i = Math.max(0, data.byteLength - 4), n = data.byteLength; i < n && isBoundary; i++) {
|
|
isBoundary = data[i] <= 127;
|
|
}
|
|
if (isBoundary) return data.toString("utf8");
|
|
}
|
|
let result = "";
|
|
for (let i = 0, n = data.byteLength; i < n; i++) {
|
|
const byte = data[i];
|
|
if (this.bytesNeeded === 0) {
|
|
if (byte <= 127) {
|
|
this.bytesSeen = 0;
|
|
result += String.fromCharCode(byte);
|
|
} else {
|
|
this.bytesSeen = 1;
|
|
if (byte >= 194 && byte <= 223) {
|
|
this.bytesNeeded = 2;
|
|
this.codePoint = byte & 31;
|
|
} else if (byte >= 224 && byte <= 239) {
|
|
if (byte === 224) this.lowerBoundary = 160;
|
|
else if (byte === 237) this.upperBoundary = 159;
|
|
this.bytesNeeded = 3;
|
|
this.codePoint = byte & 15;
|
|
} else if (byte >= 240 && byte <= 244) {
|
|
if (byte === 240) this.lowerBoundary = 144;
|
|
if (byte === 244) this.upperBoundary = 143;
|
|
this.bytesNeeded = 4;
|
|
this.codePoint = byte & 7;
|
|
} else {
|
|
result += "\uFFFD";
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (byte < this.lowerBoundary || byte > this.upperBoundary) {
|
|
this.codePoint = 0;
|
|
this.bytesNeeded = 0;
|
|
this.bytesSeen = 0;
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
result += "\uFFFD";
|
|
i--;
|
|
continue;
|
|
}
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
this.codePoint = this.codePoint << 6 | byte & 63;
|
|
this.bytesSeen++;
|
|
if (this.bytesSeen !== this.bytesNeeded) continue;
|
|
result += String.fromCodePoint(this.codePoint);
|
|
this.codePoint = 0;
|
|
this.bytesNeeded = 0;
|
|
this.bytesSeen = 0;
|
|
}
|
|
return result;
|
|
}
|
|
flush() {
|
|
const result = this.bytesNeeded > 0 ? "\uFFFD" : "";
|
|
this.codePoint = 0;
|
|
this.bytesNeeded = 0;
|
|
this.bytesSeen = 0;
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
return result;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-encoding/lib/pass-through-decoder.js
|
|
var require_pass_through_decoder = __commonJS({
|
|
"../../node_modules/bare-encoding/lib/pass-through-decoder.js"(exports, module) {
|
|
module.exports = class PassThroughDecoder {
|
|
constructor(encoding) {
|
|
this.encoding = encoding;
|
|
}
|
|
get remaining() {
|
|
return 0;
|
|
}
|
|
decode(data) {
|
|
if (ArrayBuffer.isView(data)) {
|
|
data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
|
|
} else {
|
|
data = Buffer.from(data);
|
|
}
|
|
return data.toString(this.encoding);
|
|
}
|
|
flush() {
|
|
return "";
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-encoding/lib/errors.js
|
|
var require_errors = __commonJS({
|
|
"../../node_modules/bare-encoding/lib/errors.js"(exports, module) {
|
|
module.exports = class EncodingError extends Error {
|
|
constructor(msg, code, fn = EncodingError) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "EncodingError";
|
|
}
|
|
static INVALID_LABEL(msg) {
|
|
return new EncodingError(msg, "INVALID_LABEL", EncodingError.INVALID_LABEL);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-encoding/index.js
|
|
var require_bare_encoding = __commonJS({
|
|
"../../node_modules/bare-encoding/index.js"(exports) {
|
|
var UTF8Decoder = require_utf8_decoder();
|
|
var PassThroughDecoder = require_pass_through_decoder();
|
|
var errors = require_errors();
|
|
exports.TextEncoder = class TextEncoder {
|
|
// https://encoding.spec.whatwg.org/#dom-textencoder-encoding
|
|
get encoding() {
|
|
return "utf-8";
|
|
}
|
|
// https://encoding.spec.whatwg.org/#dom-textencoder-encode
|
|
encode(input) {
|
|
return Buffer.from(input);
|
|
}
|
|
// https://encoding.spec.whatwg.org/#dom-textencoder-encodeinto
|
|
encodeInto(input, destination) {
|
|
if (ArrayBuffer.isView(destination)) {
|
|
destination = Buffer.from(
|
|
destination.buffer,
|
|
destination.byteOffset,
|
|
destination.byteLength
|
|
);
|
|
} else {
|
|
destination = Buffer.from(destination);
|
|
}
|
|
return {
|
|
read: input.length,
|
|
written: destination.write(input)
|
|
};
|
|
}
|
|
};
|
|
exports.TextDecoder = class TextDecoder {
|
|
// https://encoding.spec.whatwg.org/#dom-textdecoder
|
|
constructor(label = "utf-8") {
|
|
this.encoding = getEncoding(label);
|
|
switch (this.encoding) {
|
|
case "utf-8":
|
|
this.decoder = new UTF8Decoder();
|
|
break;
|
|
default:
|
|
this.decoder = new PassThroughDecoder(this.encoding);
|
|
break;
|
|
}
|
|
}
|
|
// https://encoding.spec.whatwg.org/#dom-textdecoder-decode
|
|
decode(input, options = {}) {
|
|
const result = this.decoder.decode(input);
|
|
if (options.stream) return result;
|
|
return result + this.decoder.flush();
|
|
}
|
|
};
|
|
function getEncoding(label) {
|
|
switch (label.trim().toLowerCase()) {
|
|
case "unicode-1-1-utf-8":
|
|
case "unicode11utf8":
|
|
case "unicode11utf8":
|
|
case "unicode20utf8":
|
|
case "utf-8":
|
|
case "utf8":
|
|
case "x-unicode20utf8":
|
|
return "utf-8";
|
|
default:
|
|
throw errors.INVALID_LABEL(`The label '${label}' is not a valid encoding`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-os/binding.js
|
|
var require_binding = __commonJS({
|
|
"../../node_modules/bare-os/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-os/lib/errors.js
|
|
var require_errors2 = __commonJS({
|
|
"../../node_modules/bare-os/lib/errors.js"(exports, module) {
|
|
module.exports = class OSError extends Error {
|
|
constructor(msg, code, fn = OSError) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "OSError";
|
|
}
|
|
static UNKNOWN_SIGNAL(msg) {
|
|
return new OSError(msg, "UNKNOWN_SIGNAL", OSError.UNKNOWN_SIGNAL);
|
|
}
|
|
static TITLE_OVERFLOW(msg) {
|
|
return new OSError(msg, "TITLE_OVERFLOW", OSError.TITLE_OVERFLOW);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-os/lib/constants.js
|
|
var require_constants = __commonJS({
|
|
"../../node_modules/bare-os/lib/constants.js"(exports, module) {
|
|
var binding = require_binding();
|
|
module.exports = {
|
|
signals: binding.signals,
|
|
errnos: binding.errnos,
|
|
priority: binding.priority
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-os/index.js
|
|
var require_bare_os = __commonJS({
|
|
"../../node_modules/bare-os/index.js"(exports) {
|
|
var binding = require_binding();
|
|
var errors = require_errors2();
|
|
var constants = require_constants();
|
|
exports.constants = constants;
|
|
exports.EOL = binding.platform === "win32" ? "\r\n" : "\n";
|
|
exports.devNull = binding.platform === "win32" ? "\\\\.\\nul" : "/dev/null";
|
|
exports.platform = function platform() {
|
|
return binding.platform;
|
|
};
|
|
exports.arch = function arch() {
|
|
return binding.arch;
|
|
};
|
|
exports.type = binding.type;
|
|
exports.version = binding.version;
|
|
exports.release = binding.release;
|
|
exports.machine = binding.machine;
|
|
exports.execPath = binding.execPath;
|
|
exports.pid = binding.pid;
|
|
exports.ppid = binding.ppid;
|
|
exports.cwd = binding.cwd;
|
|
exports.chdir = binding.chdir;
|
|
exports.tmpdir = binding.tmpdir;
|
|
exports.homedir = binding.homedir;
|
|
exports.hostname = binding.hostname;
|
|
exports.userInfo = binding.userInfo;
|
|
exports.networkInterfaces = function networkInterfaces() {
|
|
const result = {};
|
|
for (const entry of binding.networkInterfaces()) {
|
|
const { name, ...properties } = entry;
|
|
if (result[name]) result[name].push(properties);
|
|
else result[name] = [properties];
|
|
}
|
|
return result;
|
|
};
|
|
exports.kill = function kill(pid, signal = constants.signals.SIGTERM) {
|
|
if (typeof signal === "string") {
|
|
if (signal in constants.signals === false) {
|
|
throw errors.UNKNOWN_SIGNAL("Unknown signal: " + signal);
|
|
}
|
|
signal = constants.signals[signal];
|
|
}
|
|
binding.kill(pid, signal);
|
|
};
|
|
exports.endianness = function endianness() {
|
|
return binding.isLittleEndian ? "LE" : "BE";
|
|
};
|
|
exports.availableParallelism = binding.availableParallelism;
|
|
exports.cpuUsage = function cpuUsage(previous) {
|
|
const current = binding.cpuUsage();
|
|
if (previous) {
|
|
return {
|
|
user: current.user - previous.user,
|
|
system: current.system - previous.system
|
|
};
|
|
}
|
|
return current;
|
|
};
|
|
exports.threadCpuUsage = function threadCpuUsage(previous) {
|
|
const current = binding.threadCpuUsage();
|
|
if (previous) {
|
|
return {
|
|
user: current.user - previous.user,
|
|
system: current.system - previous.system
|
|
};
|
|
}
|
|
return current;
|
|
};
|
|
exports.resourceUsage = binding.resourceUsage;
|
|
exports.memoryUsage = binding.memoryUsage;
|
|
exports.freemem = binding.freemem;
|
|
exports.totalmem = binding.totalmem;
|
|
exports.availableMemory = binding.availableMemory;
|
|
exports.constrainedMemory = binding.constrainedMemory;
|
|
exports.uptime = binding.uptime;
|
|
exports.loadavg = binding.loadavg;
|
|
exports.cpus = binding.cpus;
|
|
exports.getProcessTitle = binding.getProcessTitle;
|
|
exports.setProcessTitle = function setProcessTitle(title) {
|
|
if (typeof title !== "string") title = title.toString();
|
|
if (title.length >= 256) {
|
|
throw errors.TITLE_OVERFLOW("Process title is too long");
|
|
}
|
|
binding.setProcessTitle(title);
|
|
};
|
|
exports.getPriority = function getPriority(pid = 0) {
|
|
return binding.getPriority(pid);
|
|
};
|
|
exports.setPriority = function setPriority(pid, priority) {
|
|
if (priority === void 0) {
|
|
priority = pid;
|
|
pid = 0;
|
|
}
|
|
binding.setPriority(pid, priority);
|
|
};
|
|
exports.getEnvKeys = binding.getEnvKeys;
|
|
exports.getEnv = binding.getEnv;
|
|
exports.hasEnv = binding.hasEnv;
|
|
exports.setEnv = binding.setEnv;
|
|
exports.unsetEnv = binding.unsetEnv;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-debug-log/index.js
|
|
var require_bare_debug_log = __commonJS({
|
|
"../../node_modules/bare-debug-log/index.js"(exports, module) {
|
|
var os = require_bare_os();
|
|
var pid = os.pid();
|
|
var env = os.getEnv("BARE_DEBUG") || os.getEnv("NODE_DEBUG") || "";
|
|
var test = new RegExp(
|
|
`^${env.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^")}$`,
|
|
"i"
|
|
);
|
|
module.exports = function debug(section) {
|
|
section = section.toUpperCase();
|
|
const enabled = test.test(section);
|
|
function debug2(...args) {
|
|
if (enabled) console.error("%s %s:", section, pid, ...args);
|
|
}
|
|
debug2.enabled = enabled;
|
|
return debug2;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-ansi-escapes/index.js
|
|
var require_bare_ansi_escapes = __commonJS({
|
|
"../../node_modules/bare-ansi-escapes/index.js"(exports) {
|
|
var ESC = "\x1B";
|
|
var CSI = ESC + "[";
|
|
var SGR = (n) => CSI + n + "m";
|
|
exports.constants = {
|
|
ESC,
|
|
CSI,
|
|
SGR
|
|
};
|
|
exports.cursorHide = CSI + "?25l";
|
|
exports.cursorShow = CSI + "?25h";
|
|
exports.cursorUp = function cursorUp(n = 1) {
|
|
return CSI + n + "A";
|
|
};
|
|
exports.cursorDown = function cursorDown(n = 1) {
|
|
return CSI + n + "B";
|
|
};
|
|
exports.cursorForward = function cursorForward(n = 1) {
|
|
return CSI + n + "C";
|
|
};
|
|
exports.cursorBack = function cursorBack(n = 1) {
|
|
return CSI + n + "D";
|
|
};
|
|
exports.cursorNextLine = function cursorNextLine(n = 1) {
|
|
return CSI + n + "E";
|
|
};
|
|
exports.cursorPreviousLine = function cursorPreviousLine(n = 1) {
|
|
return CSI + n + "F";
|
|
};
|
|
exports.cursorPosition = function cursorPosition(column, row = 0) {
|
|
if (row === 0) return CSI + (column + 1) + "G";
|
|
return CSI + (row + 1) + ";" + (column + 1) + "H";
|
|
};
|
|
exports.eraseDisplayEnd = CSI + "J";
|
|
exports.eraseDisplayStart = CSI + "1J";
|
|
exports.eraseDisplay = CSI + "2J";
|
|
exports.eraseLineEnd = CSI + "K";
|
|
exports.eraseLineStart = CSI + "1K";
|
|
exports.eraseLine = CSI + "2K";
|
|
exports.scrollUp = function scrollUp(n = 1) {
|
|
return CSI + n + "S";
|
|
};
|
|
exports.scrollDown = function scrollDown(n = 1) {
|
|
return CSI + n + "T";
|
|
};
|
|
exports.modifierReset = SGR(0);
|
|
exports.modifierBold = SGR(1);
|
|
exports.modifierDim = SGR(2);
|
|
exports.modifierItalic = SGR(3);
|
|
exports.modifierUnderline = SGR(4);
|
|
exports.modifierNormal = SGR(22);
|
|
exports.modifierNotItalic = SGR(23);
|
|
exports.modifierNotUnderline = SGR(24);
|
|
exports.colorBlack = SGR(30);
|
|
exports.colorRed = SGR(31);
|
|
exports.colorGreen = SGR(32);
|
|
exports.colorYellow = SGR(33);
|
|
exports.colorBlue = SGR(34);
|
|
exports.colorMagenta = SGR(35);
|
|
exports.colorCyan = SGR(36);
|
|
exports.colorWhite = SGR(37);
|
|
exports.colorDefault = SGR(39);
|
|
exports.colorBrightBlack = SGR(90);
|
|
exports.colorBrightRed = SGR(91);
|
|
exports.colorBrightGreen = SGR(92);
|
|
exports.colorBrightYellow = SGR(93);
|
|
exports.colorBrightBlue = SGR(94);
|
|
exports.colorBrightMagenta = SGR(95);
|
|
exports.colorBrightCyan = SGR(96);
|
|
exports.colorBrightWhite = SGR(97);
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-type/binding.js
|
|
var require_binding2 = __commonJS({
|
|
"../../node_modules/bare-type/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-type/index.js
|
|
var require_bare_type = __commonJS({
|
|
"../../node_modules/bare-type/index.js"(exports, module) {
|
|
var binding = require_binding2();
|
|
var t = binding.constants;
|
|
var Type = class {
|
|
constructor(type) {
|
|
this._type = type;
|
|
}
|
|
isUndefined() {
|
|
return this._type === t.UNDEFINED;
|
|
}
|
|
isNull() {
|
|
return this._type === t.NULL;
|
|
}
|
|
isBoolean() {
|
|
return this._type === t.BOOLEAN;
|
|
}
|
|
isNumber() {
|
|
return (this._type & 255) === t.NUMBER;
|
|
}
|
|
isInt32() {
|
|
return (this._type & (255 | t.INT32)) === (t.NUMBER | t.INT32);
|
|
}
|
|
isUint32() {
|
|
return (this._type & (255 | t.UINT32)) === (t.NUMBER | t.UINT32);
|
|
}
|
|
isString() {
|
|
return this._type === t.STRING;
|
|
}
|
|
isSymbol() {
|
|
return this._type === t.SYMBOL;
|
|
}
|
|
isObject() {
|
|
return (this._type & 255) === t.OBJECT;
|
|
}
|
|
isArray() {
|
|
return this._type === (t.OBJECT | t.ARRAY);
|
|
}
|
|
isArguments() {
|
|
return this._type === (t.OBJECT | t.ARGUMENTS);
|
|
}
|
|
isDate() {
|
|
return this._type === (t.OBJECT | t.DATE);
|
|
}
|
|
isRegExp() {
|
|
return this._type === (t.OBJECT | t.REGEXP);
|
|
}
|
|
isError() {
|
|
return this._type === (t.OBJECT | t.ERROR);
|
|
}
|
|
isPromise() {
|
|
return this._type === (t.OBJECT | t.PROMISE);
|
|
}
|
|
isProxy() {
|
|
return this._type === (t.OBJECT | t.PROXY);
|
|
}
|
|
isGenerator() {
|
|
return this._type === (t.OBJECT | t.GENERATOR);
|
|
}
|
|
isMap() {
|
|
return this._type === (t.OBJECT | t.MAP);
|
|
}
|
|
isSet() {
|
|
return this._type === (t.OBJECT | t.SET);
|
|
}
|
|
isWeakMap() {
|
|
return this._type === (t.OBJECT | t.WEAK_MAP);
|
|
}
|
|
isWeakSet() {
|
|
return this._type === (t.OBJECT | t.WEAK_SET);
|
|
}
|
|
isWeakRef() {
|
|
return this._type === (t.OBJECT | t.WEAK_REF);
|
|
}
|
|
isArrayBuffer() {
|
|
return this._type === (t.OBJECT | t.ARRAYBUFFER);
|
|
}
|
|
isSharedArrayBuffer() {
|
|
return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER);
|
|
}
|
|
isTypedArray() {
|
|
return (this._type & 65535) === (t.OBJECT | t.TYPEDARRAY);
|
|
}
|
|
isInt8Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY);
|
|
}
|
|
isUint8Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY);
|
|
}
|
|
isUint8ClampedArray() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY);
|
|
}
|
|
isInt16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY);
|
|
}
|
|
isUint16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY);
|
|
}
|
|
isInt32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY);
|
|
}
|
|
isUint32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY);
|
|
}
|
|
isFloat16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY);
|
|
}
|
|
isFloat32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY);
|
|
}
|
|
isFloat64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY);
|
|
}
|
|
isBigInt64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY);
|
|
}
|
|
isBigUint64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY);
|
|
}
|
|
isDataView() {
|
|
return this._type === (t.OBJECT | t.DATAVIEW);
|
|
}
|
|
isModuleNamespace() {
|
|
return this._type === (t.OBJECT | t.MODULE_NAMESPACE);
|
|
}
|
|
isFunction() {
|
|
return (this._type & 255) === t.FUNCTION;
|
|
}
|
|
isAsyncFunction() {
|
|
return (this._type & (255 | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION);
|
|
}
|
|
isGeneratorFunction() {
|
|
return (this._type & (255 | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION);
|
|
}
|
|
isExternal() {
|
|
return this._type === t.EXTERNAL;
|
|
}
|
|
isBigInt() {
|
|
return this._type === t.BIGINT;
|
|
}
|
|
};
|
|
module.exports = exports = function type(value) {
|
|
switch (typeof value) {
|
|
case "undefined":
|
|
return new Type(t.UNDEFINED);
|
|
case "boolean":
|
|
return new Type(t.BOOLEAN);
|
|
case "number":
|
|
return new Type(
|
|
Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER
|
|
);
|
|
case "string":
|
|
return new Type(t.STRING);
|
|
case "symbol":
|
|
return new Type(t.SYMBOL);
|
|
case "object":
|
|
return new Type(value === null ? t.NULL : binding.type(value));
|
|
case "function":
|
|
return new Type(binding.type(value));
|
|
case "bigint":
|
|
return new Type(t.BIGINT);
|
|
}
|
|
};
|
|
exports.createTag = function createTag(...components) {
|
|
const tag = new Uint32Array(4);
|
|
for (let i = 0; i < 4; i++) tag[i] = components[i] || 0;
|
|
return tag;
|
|
};
|
|
exports.addTag = function addTag(object, tag) {
|
|
binding.addTag(object, tag);
|
|
};
|
|
exports.checkTag = function checkTag(object, tag) {
|
|
return binding.checkTag(object, tag);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-inspect/binding.js
|
|
var require_binding3 = __commonJS({
|
|
"../../node_modules/bare-inspect/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-inspect/index.js
|
|
var require_bare_inspect = __commonJS({
|
|
"../../node_modules/bare-inspect/index.js"(exports, module) {
|
|
var ansiEscapes = require_bare_ansi_escapes();
|
|
var getType = require_bare_type();
|
|
var binding = require_binding3();
|
|
var PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
|
|
var defaultDepth = 2;
|
|
var defaultBreakLength = 80;
|
|
var defaultMaxArrayLength = 40;
|
|
module.exports = exports = function inspect(value, opts = {}) {
|
|
const {
|
|
colors = false,
|
|
depth = defaultDepth,
|
|
breakLength = defaultBreakLength,
|
|
stylize = defaultStylize(colors)
|
|
} = opts;
|
|
const references = new InspectRefMap();
|
|
const tree = inspectValue(value, 0, {
|
|
colors,
|
|
depth,
|
|
breakLength,
|
|
stylize,
|
|
references
|
|
});
|
|
return tree.toString();
|
|
};
|
|
exports.styles = {
|
|
bigint: ansiEscapes.colorYellow,
|
|
boolean: ansiEscapes.colorYellow,
|
|
date: ansiEscapes.colorMagenta,
|
|
module: ansiEscapes.modifierUnderline,
|
|
name: ansiEscapes.modifierReset,
|
|
null: ansiEscapes.modifierBold,
|
|
number: ansiEscapes.colorYellow,
|
|
regexp: ansiEscapes.colorRed,
|
|
special: ansiEscapes.colorCyan,
|
|
string: ansiEscapes.colorGreen,
|
|
symbol: ansiEscapes.colorGreen,
|
|
undefined: ansiEscapes.colorBrightBlack
|
|
};
|
|
var styles = exports.styles;
|
|
function defaultStylize(colors) {
|
|
return function stylize(value, style) {
|
|
const color = colors && styles[style];
|
|
if (color) return color + value + ansiEscapes.modifierReset;
|
|
return value;
|
|
};
|
|
}
|
|
var InspectRefMap = class {
|
|
constructor() {
|
|
this.refs = /* @__PURE__ */ new WeakMap();
|
|
this.ids = /* @__PURE__ */ new WeakMap();
|
|
this.nextId = 1;
|
|
}
|
|
has(object) {
|
|
return this.refs.has(object);
|
|
}
|
|
get(object) {
|
|
return this.refs.get(object) || null;
|
|
}
|
|
set(object, ref) {
|
|
this.refs.set(object, ref);
|
|
}
|
|
id(object) {
|
|
let id = this.ids.get(object);
|
|
if (id) return id;
|
|
id = this.nextId++;
|
|
this.ids.set(object, id);
|
|
return id;
|
|
}
|
|
};
|
|
var InspectNode = class {
|
|
constructor(depth, length, opts) {
|
|
const { breakLength = defaultBreakLength, breakAlways = false } = opts;
|
|
this.depth = depth;
|
|
this.length = length;
|
|
this.breakLength = breakLength;
|
|
this.breakAlways = breakAlways;
|
|
}
|
|
pad(n, string) {
|
|
return string.padStart(n, " ");
|
|
}
|
|
indent(n, string) {
|
|
return " ".repeat(n) + string;
|
|
}
|
|
};
|
|
var InspectRef = class extends InspectNode {
|
|
constructor(depth, opts) {
|
|
super(depth, "[circular *]".length, opts);
|
|
this.refs = opts.references;
|
|
this.count = 0;
|
|
this.circular = false;
|
|
this.color = opts.colors && styles.special;
|
|
}
|
|
get id() {
|
|
return this.refs.id(this);
|
|
}
|
|
increment() {
|
|
return ++this.count;
|
|
}
|
|
decrement() {
|
|
return --this.count;
|
|
}
|
|
toString(opts = {}) {
|
|
const { offset = 0, pad = 0, indent = 0 } = opts;
|
|
let value = this.pad(pad, "[circular *" + this.id + "]");
|
|
if (this.color) value = this.color + value + ansiEscapes.modifierReset;
|
|
return offset ? value : this.indent(indent, value);
|
|
}
|
|
};
|
|
var InspectLeaf = class extends InspectNode {
|
|
constructor(value, color, depth, opts) {
|
|
const length = value.length;
|
|
if (value.includes("\n")) {
|
|
value = value.replaceAll("\n", "\n" + " ".repeat(depth));
|
|
opts = { ...opts, breakAlways: true };
|
|
}
|
|
super(depth, length, opts);
|
|
this.value = value;
|
|
this.color = opts.colors && color;
|
|
}
|
|
toString(opts = {}) {
|
|
const { offset = 0, pad = 0, indent = 0 } = opts;
|
|
let value = this.pad(pad, this.value);
|
|
if (this.color) value = this.color + value + ansiEscapes.modifierReset;
|
|
return offset ? value : this.indent(indent, value);
|
|
}
|
|
};
|
|
var InspectPair = class extends InspectNode {
|
|
constructor(delim, left, right, depth, opts) {
|
|
const length = left.length + delim.length + right.length;
|
|
if (left.breakAlways || right.breakAlways) {
|
|
opts = { ...opts, breakAlways: true };
|
|
}
|
|
super(depth, length, opts);
|
|
this.delim = delim;
|
|
this.left = left;
|
|
this.right = right;
|
|
}
|
|
toString(opts = {}) {
|
|
const { indent = 0 } = opts;
|
|
return this.indent(
|
|
indent,
|
|
this.left + this.delim + this.right.toString({
|
|
indent,
|
|
offset: this.left.length + this.delim.length
|
|
})
|
|
);
|
|
}
|
|
};
|
|
var InspectSuspension = class extends InspectNode {
|
|
constructor(overflow, depth, opts) {
|
|
const label = `... ${overflow} more`;
|
|
super(depth, label.length, opts);
|
|
this.label = label;
|
|
}
|
|
toString(opts = {}) {
|
|
const { indent = 0 } = opts;
|
|
return this.indent(indent, this.label);
|
|
}
|
|
};
|
|
var InspectSequence = class extends InspectNode {
|
|
constructor(header, footer, delim, values, ref, depth, opts) {
|
|
const { tabulate = false } = opts;
|
|
const length = (ref.circular ? "<ref *>".length + 1 : 0) + header.length + values.reduce(
|
|
(length2, value, i) => length2 + value.length + (i === 0 ? 0 : delim.length),
|
|
0
|
|
) + footer.length;
|
|
if (values.some((value) => value.breakAlways)) {
|
|
opts = { ...opts, breakAlways: true };
|
|
}
|
|
super(depth, length, opts);
|
|
this.header = header;
|
|
this.footer = footer;
|
|
this.delim = delim;
|
|
this.values = values;
|
|
this.ref = ref;
|
|
this.tabulate = tabulate;
|
|
}
|
|
toString(opts = {}) {
|
|
const { offset = 0, indent = 0 } = opts;
|
|
const split = this.breakAlways || this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength);
|
|
let header = this.header;
|
|
if (this.ref.circular) {
|
|
header = "<ref *" + this.ref.id + "> " + header;
|
|
}
|
|
if (this.values.length === 0) {
|
|
header = header.trimEnd();
|
|
}
|
|
if (offset === 0) {
|
|
header = this.indent(indent, header);
|
|
}
|
|
if (split) {
|
|
header = header.trimEnd() + "\n";
|
|
}
|
|
let string = header;
|
|
let columns = 1;
|
|
let pad = 0;
|
|
if (this.tabulate) {
|
|
const widest = this.values.reduce(
|
|
(length, value) => value.breakAlways ? length : Math.max(length, value.length),
|
|
0
|
|
);
|
|
if (widest) {
|
|
columns = Math.max(
|
|
columns,
|
|
Math.floor(
|
|
(this.breakLength - indent * 2) / (widest + this.delim.length)
|
|
)
|
|
);
|
|
if (columns > 1) pad = widest;
|
|
}
|
|
}
|
|
for (let i = 0, n = this.values.length, offset2 = 0; i < n; i++) {
|
|
const value = this.values[i];
|
|
if (split) {
|
|
let part;
|
|
if (i % columns === 0 || value.breakAlways) {
|
|
part = value.toString({ indent: indent + 1, pad });
|
|
} else {
|
|
part = value.toString({ pad });
|
|
}
|
|
string += part;
|
|
if (i < n - 1) {
|
|
if (i % columns === columns - 1 || this.values[i + 1].breakAlways) {
|
|
string += this.delim.trimEnd() + "\n";
|
|
} else {
|
|
string += this.delim;
|
|
}
|
|
}
|
|
} else {
|
|
if (i > 0) string += this.delim;
|
|
string += value.toString({ offset: offset2 });
|
|
offset2 += value.length;
|
|
}
|
|
}
|
|
let footer = this.footer;
|
|
if (this.values.length === 0) {
|
|
footer = footer.trimStart();
|
|
}
|
|
if (split) {
|
|
string += "\n" + this.indent(indent, footer.trimStart());
|
|
} else {
|
|
string += footer;
|
|
}
|
|
return string;
|
|
}
|
|
};
|
|
function inspectValue(value, depth, opts) {
|
|
const type = getType(value);
|
|
if (type.isUndefined()) return inspectUndefined(depth, opts);
|
|
if (type.isNull()) return inspectNull(depth, opts);
|
|
if (type.isBoolean()) return inspectBoolean(value, depth, opts);
|
|
if (type.isNumber()) return inspectNumber(value, depth, opts);
|
|
if (type.isBigInt()) return inspectBigInt(value, depth, opts);
|
|
if (type.isString()) return inspectString(value, depth, opts);
|
|
if (type.isSymbol()) return inspectSymbol(value, depth, opts);
|
|
if (type.isObject()) return inspectObject(type, value, depth, opts);
|
|
if (type.isFunction()) return inspectFunction(type, value, depth, opts);
|
|
if (type.isExternal()) return inspectExternal(value, opts, opts);
|
|
}
|
|
function inspectUndefined(depth, opts) {
|
|
return new InspectLeaf("undefined", styles.undefined, depth, opts);
|
|
}
|
|
function inspectNull(depth, opts) {
|
|
return new InspectLeaf("null", styles.null, depth, opts);
|
|
}
|
|
function inspectBoolean(value, depth, opts) {
|
|
return new InspectLeaf(value.toString(), styles.boolean, depth, opts);
|
|
}
|
|
function inspectNumber(value, depth, opts) {
|
|
let string;
|
|
if (Object.is(value, -0)) {
|
|
string = "-0";
|
|
} else {
|
|
string = value.toString(10);
|
|
}
|
|
return new InspectLeaf(string, styles.number, depth, opts);
|
|
}
|
|
function inspectBigInt(value, depth, opts) {
|
|
return new InspectLeaf(value.toString(10) + "n", styles.bigint, depth, opts);
|
|
}
|
|
var STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g;
|
|
function inspectString(value, depth, opts) {
|
|
const string = value.replace(STRING_ESCAPES, (match) => {
|
|
if (match.length === 2) return match;
|
|
switch (match) {
|
|
case "'":
|
|
return "\\'";
|
|
case "\\":
|
|
return "\\\\";
|
|
case "\b":
|
|
return "\\b";
|
|
case " ":
|
|
return "\\t";
|
|
case "\n":
|
|
return "\\n";
|
|
case "\f":
|
|
return "\\f";
|
|
case "\r":
|
|
return "\\r";
|
|
default:
|
|
return "\\u" + match.charCodeAt(0).toString(16).padStart(4, "0");
|
|
}
|
|
});
|
|
return new InspectLeaf("'" + string + "'", styles.string, depth, opts);
|
|
}
|
|
function inspectSymbol(value, depth, opts) {
|
|
return new InspectLeaf(value.toString(), styles.symbol, depth, opts);
|
|
}
|
|
function inspectKey(value, depth, opts) {
|
|
if (PLAIN_KEY.test(value)) {
|
|
return new InspectLeaf(value, null, depth, opts);
|
|
} else {
|
|
return inspectValue(value, depth, opts);
|
|
}
|
|
}
|
|
function inspectObject(type, object, depth, opts) {
|
|
const refs = opts.references;
|
|
let ref = refs.get(object);
|
|
if (ref === null) {
|
|
ref = new InspectRef(depth, opts);
|
|
refs.set(object, ref);
|
|
} else if (ref.count) {
|
|
ref.circular = true;
|
|
return ref;
|
|
}
|
|
const maxDepth = typeof opts.depth === "number" ? opts.depth : Infinity;
|
|
if (maxDepth < depth) {
|
|
const constructor = object.constructor;
|
|
return new InspectLeaf(
|
|
"[" + (constructor && constructor.name ? constructor.name : "Object") + "]",
|
|
styles.special,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
const inspect = object[Symbol.for("bare.inspect")] || object[Symbol.for("nodejs.util.inspect.custom")];
|
|
if (typeof inspect === "function") {
|
|
const value = inspect.call(
|
|
object,
|
|
typeof opts.depth === "number" ? opts.depth - depth : null,
|
|
{
|
|
colors: opts.colors,
|
|
breakLength: opts.breakLength,
|
|
stylize: opts.stylize
|
|
},
|
|
exports
|
|
);
|
|
if (typeof value === "object" && value !== null) {
|
|
refs.set(value, ref);
|
|
}
|
|
if (typeof value !== "string") {
|
|
return inspectValue(value, depth, opts);
|
|
}
|
|
return new InspectLeaf(value, null, depth, opts);
|
|
}
|
|
if (type.isArray()) return inspectArray(object, ref, depth, opts);
|
|
if (type.isDate()) return inspectDate(object, ref, depth, opts);
|
|
if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts);
|
|
if (type.isError()) return inspectError(object, ref, depth, opts);
|
|
if (type.isPromise()) return inspectPromise(object, ref, depth, opts);
|
|
if (type.isMap()) return inspectMap(object, ref, depth, opts);
|
|
if (type.isSet()) return inspectSet(object, ref, depth, opts);
|
|
if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts);
|
|
if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts);
|
|
if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts);
|
|
if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts);
|
|
if (type.isSharedArrayBuffer())
|
|
return inspectSharedArrayBuffer(object, ref, depth, opts);
|
|
if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts);
|
|
if (type.isDataView()) return inspectDataView(object, ref, depth, opts);
|
|
ref.increment();
|
|
const values = [];
|
|
for (const key in object) {
|
|
if (key === "constructor") continue;
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(object[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
let header = "{ ";
|
|
const tag = object[Symbol.toStringTag];
|
|
if (tag) header = "[" + tag + "] " + header;
|
|
if (object.constructor) {
|
|
const name = object.constructor.name;
|
|
if (name && name !== "Object") {
|
|
header = object.constructor.name + " " + header;
|
|
}
|
|
}
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
|
|
}
|
|
function inspectArray(array, ref, depth, opts) {
|
|
const { maxArrayLength = defaultMaxArrayLength } = opts;
|
|
ref.increment();
|
|
const values = [];
|
|
let remaining = Math.max(maxArrayLength, 0);
|
|
for (let i = 0, n = array.length; i < n; i++) {
|
|
if (remaining-- === 0) {
|
|
values.push(
|
|
new InspectSuspension(array.length - values.length, depth + 1, {
|
|
...opts,
|
|
breakAlways: true
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
values.push(inspectValue(array[i], depth + 1, opts));
|
|
}
|
|
for (const key of binding.getOwnNonIndexPropertyNames(array)) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(array[key], depth + 1, opts),
|
|
depth + 1,
|
|
{ ...opts, breakAlways: remaining < 0 }
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
let header = "[ ";
|
|
if (array.constructor.name !== "Array") {
|
|
header = array.constructor.name + "(" + array.length + ") " + header;
|
|
}
|
|
return new InspectSequence(header, " ]", ", ", values, ref, depth, {
|
|
...opts,
|
|
tabulate: true
|
|
});
|
|
}
|
|
function inspectDate(date, ref, depth, opts) {
|
|
return new InspectLeaf(date.toISOString(), styles.date, depth, opts);
|
|
}
|
|
function inspectRegExp(regExp, ref, depth, opts) {
|
|
return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts);
|
|
}
|
|
function inspectError(error, ref, depth, opts) {
|
|
let header;
|
|
if ("stack" in error) {
|
|
header = error.stack;
|
|
if (depth > 0) {
|
|
header = header.replaceAll("\n", "\n" + " ".repeat(depth));
|
|
}
|
|
} else {
|
|
header = error.toString();
|
|
}
|
|
const builtins = ["cause"];
|
|
if (error.name === "AggregateError") {
|
|
builtins.push("errors");
|
|
} else if (error.name === "SuppressedError") {
|
|
builtins.push("error", "suppressed");
|
|
}
|
|
const values = [];
|
|
for (const key of builtins) {
|
|
if (key in error === false) continue;
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
new InspectLeaf("[" + key + "]", null, depth + 1, opts),
|
|
inspectValue(error[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
for (const key in error) {
|
|
if (key === "constructor" || builtins.includes(key)) continue;
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(error[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
if (values.length === 0) return new InspectLeaf(header, null, depth, opts);
|
|
return new InspectSequence(
|
|
header + " {",
|
|
" }",
|
|
", ",
|
|
values,
|
|
ref,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
function inspectPromise(promise, ref, depth, opts) {
|
|
ref.increment();
|
|
const state = binding.getPromiseState(promise);
|
|
const values = [];
|
|
switch (state) {
|
|
case 0:
|
|
values.push(new InspectLeaf("<pending>", styles.special, depth, opts));
|
|
break;
|
|
case 1:
|
|
values.push(inspectValue(binding.getPromiseResult(promise), depth, opts));
|
|
break;
|
|
case 2:
|
|
values.push(
|
|
new InspectLeaf("<rejected>", styles.special, depth, opts),
|
|
inspectValue(binding.getPromiseResult(promise), depth, opts)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = promise.constructor.name + " { ";
|
|
return new InspectSequence(header, " }", " ", values, ref, depth, opts);
|
|
}
|
|
function inspectMap(map, ref, depth, opts) {
|
|
const {
|
|
maxArrayLength = defaultMaxArrayLength,
|
|
maxMapLength = maxArrayLength
|
|
} = opts;
|
|
ref.increment();
|
|
const values = [];
|
|
let remaining = maxMapLength;
|
|
for (const entry of map) {
|
|
if (remaining-- === 0) {
|
|
values.push(
|
|
new InspectSuspension(map.size - values.length, depth + 1, {
|
|
...opts,
|
|
breakAlways: true
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
values.push(
|
|
new InspectPair(
|
|
" => ",
|
|
inspectValue(entry[0], depth + 1, opts),
|
|
inspectValue(entry[1], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
for (const key in map) {
|
|
if (key === "constructor") continue;
|
|
const value = inspectValue(map[key], depth + 1, opts);
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
value,
|
|
depth + 1,
|
|
{ ...opts, breakAlways: remaining < 0 }
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = map.constructor.name + "(" + map.size + ") { ";
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, {
|
|
...opts,
|
|
tabulate: true
|
|
});
|
|
}
|
|
function inspectSet(set, ref, depth, opts) {
|
|
const {
|
|
maxArrayLength = defaultMaxArrayLength,
|
|
maxSetLength = maxArrayLength
|
|
} = opts;
|
|
ref.increment();
|
|
const values = [];
|
|
let remaining = maxSetLength;
|
|
for (const entry of set) {
|
|
if (remaining-- === 0) {
|
|
values.push(
|
|
new InspectSuspension(set.size - values.length, depth + 1, {
|
|
...opts,
|
|
breakAlways: true
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
values.push(inspectValue(entry, depth + 1, opts));
|
|
}
|
|
for (const key in set) {
|
|
if (key === "constructor") continue;
|
|
const value = inspectValue(set[key], depth + 1, opts);
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
value,
|
|
depth + 1,
|
|
{ ...opts, breakAlways: remaining < 0 }
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = set.constructor.name + "(" + set.size + ") { ";
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, {
|
|
...opts,
|
|
tabulate: true
|
|
});
|
|
}
|
|
function inspectWeakMap(weakMap, ref, depth, opts) {
|
|
const header = weakMap.constructor.name + " { ";
|
|
return new InspectSequence(
|
|
header,
|
|
" }",
|
|
" ",
|
|
[new InspectLeaf("<items unknown>", styles.special, depth + 1, opts)],
|
|
ref,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
function inspectWeakSet(weakSet, ref, depth, opts) {
|
|
const header = weakSet.constructor.name + " { ";
|
|
return new InspectSequence(
|
|
header,
|
|
" }",
|
|
" ",
|
|
[new InspectLeaf("<items unknown>", styles.special, depth + 1, opts)],
|
|
ref,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
function inspectWeakRef(weakRef, ref, depth, opts) {
|
|
const target = weakRef.deref();
|
|
let value;
|
|
if (target === void 0) {
|
|
value = new InspectLeaf("<cleared>", styles.special, depth + 1, opts);
|
|
} else {
|
|
value = inspectValue(target, depth + 1, opts);
|
|
}
|
|
const header = weakRef.constructor.name + " { ";
|
|
return new InspectSequence(header, " }", " ", [value], ref, depth, opts);
|
|
}
|
|
function inspectArrayBuffer(arrayBuffer, ref, depth, opts) {
|
|
ref.increment();
|
|
const values = [];
|
|
for (const key of ["byteLength"]) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(arrayBuffer[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = arrayBuffer.constructor.name + " { ";
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
|
|
}
|
|
function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) {
|
|
ref.increment();
|
|
const values = [];
|
|
for (const key of ["byteLength"]) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(sharedArrayBuffer[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = sharedArrayBuffer.constructor.name + " { ";
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
|
|
}
|
|
function inspectTypedArray(typedArray, ref, depth, opts) {
|
|
if (Buffer.isBuffer(typedArray)) {
|
|
return inspectBuffer(typedArray, ref, depth, opts);
|
|
}
|
|
const {
|
|
maxArrayLength = defaultMaxArrayLength,
|
|
maxTypedArrayLength = maxArrayLength
|
|
} = opts;
|
|
ref.increment();
|
|
const values = [];
|
|
let remaining = Math.max(maxTypedArrayLength, 0);
|
|
for (let i = 0, n = typedArray.length; i < n; i++) {
|
|
if (remaining-- === 0) {
|
|
values.push(
|
|
new InspectSuspension(typedArray.length - values.length, depth + 1, {
|
|
...opts,
|
|
breakAlways: true
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
values.push(inspectValue(typedArray[i], depth + 1, opts));
|
|
}
|
|
for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(typedArray[key], depth + 1, opts),
|
|
depth + 1,
|
|
{ ...opts, breakAlways: remaining < 0 }
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = typedArray.constructor.name + "(" + typedArray.length + ") [ ";
|
|
return new InspectSequence(header, " ]", ", ", values, ref, depth, {
|
|
...opts,
|
|
tabulate: true
|
|
});
|
|
}
|
|
function inspectBuffer(buffer, ref, depth, opts) {
|
|
const {
|
|
maxArrayLength = defaultMaxArrayLength,
|
|
maxBufferLength = maxArrayLength
|
|
} = opts;
|
|
ref.increment();
|
|
const values = [];
|
|
let remaining = Math.max(maxBufferLength, 0);
|
|
for (let i = 0, n = buffer.byteLength; i < n; i++) {
|
|
if (remaining-- === 0) {
|
|
values.push(
|
|
new InspectSuspension(buffer.length - values.length, depth + 1, {
|
|
...opts,
|
|
breakAlways: true
|
|
})
|
|
);
|
|
break;
|
|
}
|
|
values.push(
|
|
new InspectLeaf(
|
|
buffer[i].toString(16).padStart(2, "0"),
|
|
null,
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
for (const key of binding.getOwnNonIndexPropertyNames(buffer)) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(buffer[key], depth + 1, opts),
|
|
depth + 1,
|
|
{ ...opts, breakAlways: remaining < 0 }
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
return new InspectSequence("<Buffer ", ">", " ", values, ref, depth, {
|
|
...opts,
|
|
tabulate: true
|
|
});
|
|
}
|
|
function inspectDataView(dataView, ref, depth, opts) {
|
|
ref.increment();
|
|
const values = [];
|
|
for (const key of ["byteLength", "byteOffset", "buffer"]) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(dataView[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
for (const key of binding.getOwnNonIndexPropertyNames(dataView)) {
|
|
values.push(
|
|
new InspectPair(
|
|
": ",
|
|
inspectKey(key, depth + 1, opts),
|
|
inspectValue(dataView[key], depth + 1, opts),
|
|
depth + 1,
|
|
opts
|
|
)
|
|
);
|
|
}
|
|
ref.decrement();
|
|
const header = dataView.constructor.name + " { ";
|
|
return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
|
|
}
|
|
function inspectFunction(type, fn, depth, opts) {
|
|
if (fn.toString().startsWith("class")) return inspectClass(fn, depth, opts);
|
|
let tag = "function";
|
|
if (type.isGeneratorFunction()) tag = "generator " + tag;
|
|
if (type.isAsyncFunction()) tag = "async " + tag;
|
|
return new InspectLeaf(
|
|
"[" + tag + " " + (fn.name ? fn.name : "(anonymous)") + "]",
|
|
styles.special,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
function inspectClass(ctor, depth, opts) {
|
|
return new InspectLeaf(
|
|
"[class " + (ctor.name ? ctor.name : "(anonymous)") + "]",
|
|
styles.special,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
function inspectExternal(external, depth, opts) {
|
|
return new InspectLeaf(
|
|
"[external 0x" + binding.getExternal(external).toString(16) + "]",
|
|
styles.special,
|
|
depth,
|
|
opts
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-format/index.js
|
|
var require_bare_format = __commonJS({
|
|
"../../node_modules/bare-format/index.js"(exports, module) {
|
|
var inspect = require_bare_inspect();
|
|
module.exports = exports = function format(...args) {
|
|
return exports.formatWithOptions({}, ...args);
|
|
};
|
|
exports.format = exports;
|
|
exports.formatWithOptions = function formatWithOptions(opts, ...args) {
|
|
const format = args[0];
|
|
let result = "";
|
|
let join = "";
|
|
let i = 0;
|
|
if (typeof format === "string") {
|
|
if (args.length === 1) return format;
|
|
let tmp;
|
|
let j = 0;
|
|
let c;
|
|
for (let k = 0, n = format.length; k < n; k++) {
|
|
c = format.charCodeAt(k);
|
|
if (c === 37) {
|
|
c = format.charCodeAt(++k);
|
|
if (i < args.length) {
|
|
switch (c) {
|
|
case 115: {
|
|
const value = args[++i];
|
|
switch (typeof value) {
|
|
case "string":
|
|
tmp = value;
|
|
break;
|
|
case "bigint":
|
|
tmp = inspect(value, { ...opts, colors: false });
|
|
break;
|
|
default:
|
|
tmp = String(value);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 100: {
|
|
const value = args[++i];
|
|
switch (typeof value) {
|
|
case "symbol":
|
|
tmp = NaN;
|
|
break;
|
|
case "bigint":
|
|
tmp = inspect(value, { ...opts, colors: false });
|
|
break;
|
|
default:
|
|
tmp = inspect(Number(value), { ...opts, colors: false });
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 105: {
|
|
const value = args[++i];
|
|
switch (typeof value) {
|
|
case "symbol":
|
|
tmp = NaN;
|
|
break;
|
|
case "bigint":
|
|
tmp = inspect(value, { ...opts, colors: false });
|
|
break;
|
|
default:
|
|
tmp = inspect(parseInt(value, 10), { ...opts, colors: false });
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 102: {
|
|
const value = args[++i];
|
|
switch (typeof value) {
|
|
case "symbol":
|
|
tmp = NaN;
|
|
break;
|
|
default:
|
|
tmp = inspect(parseFloat(value), { ...opts, colors: false });
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 79:
|
|
case 111:
|
|
tmp = inspect(args[++i], opts);
|
|
break;
|
|
case 106:
|
|
tmp = JSON.stringify(args[++i]);
|
|
break;
|
|
case 99:
|
|
i++;
|
|
tmp = "";
|
|
break;
|
|
case 37:
|
|
result += format.substring(j, k);
|
|
j = k + 1;
|
|
continue;
|
|
default:
|
|
continue;
|
|
}
|
|
if (j !== k - 1) result += format.substring(j, k - 1);
|
|
result += tmp;
|
|
j = k + 1;
|
|
} else if (c === 37) {
|
|
result += format.substring(j, k);
|
|
j = k + 1;
|
|
}
|
|
}
|
|
}
|
|
if (j !== 0) {
|
|
i++;
|
|
join = " ";
|
|
if (j < format.length) {
|
|
result += format.substring(j);
|
|
}
|
|
}
|
|
}
|
|
while (i < args.length) {
|
|
const value = args[i++];
|
|
result += join;
|
|
result += typeof value === "string" ? value : inspect(value, opts);
|
|
join = " ";
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-abort/binding.js
|
|
var require_binding4 = __commonJS({
|
|
"../../node_modules/bare-abort/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-abort/index.js
|
|
var require_bare_abort = __commonJS({
|
|
"../../node_modules/bare-abort/index.js"(exports, module) {
|
|
var binding = require_binding4();
|
|
module.exports = binding.abort;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-events/lib/errors.js
|
|
var require_errors3 = __commonJS({
|
|
"../../node_modules/bare-events/lib/errors.js"(exports, module) {
|
|
module.exports = class EventEmitterError extends Error {
|
|
constructor(msg, code, fn = EventEmitterError, opts) {
|
|
super(`${code}: ${msg}`, opts);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "EventEmitterError";
|
|
}
|
|
static OPERATION_ABORTED(cause, msg = "Operation aborted") {
|
|
return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
|
|
cause
|
|
});
|
|
}
|
|
static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
|
|
return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
|
|
cause
|
|
});
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-events/index.js
|
|
var require_bare_events = __commonJS({
|
|
"../../node_modules/bare-events/index.js"(exports, module) {
|
|
var errors = require_errors3();
|
|
var EventListener = class {
|
|
constructor() {
|
|
this.list = [];
|
|
this.count = 0;
|
|
}
|
|
append(ctx, name, fn, once) {
|
|
this.count++;
|
|
ctx.emit("newListener", name, fn);
|
|
this.list.push([fn, once]);
|
|
}
|
|
prepend(ctx, name, fn, once) {
|
|
this.count++;
|
|
ctx.emit("newListener", name, fn);
|
|
this.list.unshift([fn, once]);
|
|
}
|
|
remove(ctx, name, fn) {
|
|
for (let i = 0, n = this.list.length; i < n; i++) {
|
|
const l = this.list[i];
|
|
if (l[0] === fn) {
|
|
this.list.splice(i, 1);
|
|
if (this.count === 1) delete ctx._events[name];
|
|
ctx.emit("removeListener", name, fn);
|
|
this.count--;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
removeAll(ctx, name) {
|
|
const list = [...this.list];
|
|
this.list = [];
|
|
if (this.count === list.length) delete ctx._events[name];
|
|
for (let i = list.length - 1; i >= 0; i--) {
|
|
ctx.emit("removeListener", name, list[i][0]);
|
|
}
|
|
this.count -= list.length;
|
|
}
|
|
emit(ctx, name, ...args) {
|
|
const list = [...this.list];
|
|
for (let i = 0, n = list.length; i < n; i++) {
|
|
const l = list[i];
|
|
if (l[1] === true) this.remove(ctx, name, l[0]);
|
|
Reflect.apply(l[0], ctx, args);
|
|
}
|
|
return list.length > 0;
|
|
}
|
|
};
|
|
function appendListener(ctx, name, fn, once) {
|
|
if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
|
|
const e = ctx._events[name] || (ctx._events[name] = new EventListener());
|
|
e.append(ctx, name, fn, once);
|
|
return ctx;
|
|
}
|
|
function prependListener(ctx, name, fn, once) {
|
|
if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
|
|
const e = ctx._events[name] || (ctx._events[name] = new EventListener());
|
|
e.prepend(ctx, name, fn, once);
|
|
return ctx;
|
|
}
|
|
function removeListener(ctx, name, fn) {
|
|
if (ctx._events === void 0) return ctx;
|
|
const e = ctx._events[name];
|
|
if (e !== void 0) e.remove(ctx, name, fn);
|
|
return ctx;
|
|
}
|
|
function throwUnhandledError(...args) {
|
|
let err;
|
|
if (args.length > 0) err = args[0];
|
|
if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(err, exports.prototype.emit);
|
|
}
|
|
queueMicrotask(() => {
|
|
throw err;
|
|
});
|
|
}
|
|
module.exports = exports = class EventEmitter {
|
|
constructor() {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
}
|
|
addListener(name, fn) {
|
|
return appendListener(this, name, fn, false);
|
|
}
|
|
addOnceListener(name, fn) {
|
|
return appendListener(this, name, fn, true);
|
|
}
|
|
prependListener(name, fn) {
|
|
return prependListener(this, name, fn, false);
|
|
}
|
|
prependOnceListener(name, fn) {
|
|
return prependListener(this, name, fn, true);
|
|
}
|
|
removeListener(name, fn) {
|
|
return removeListener(this, name, fn);
|
|
}
|
|
on(name, fn) {
|
|
return appendListener(this, name, fn, false);
|
|
}
|
|
once(name, fn) {
|
|
return appendListener(this, name, fn, true);
|
|
}
|
|
off(name, fn) {
|
|
return removeListener(this, name, fn);
|
|
}
|
|
emit(name, ...args) {
|
|
if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
|
|
throwUnhandledError(...args);
|
|
}
|
|
if (this._events === void 0) return false;
|
|
const e = this._events[name];
|
|
return e === void 0 ? false : e.emit(this, name, ...args);
|
|
}
|
|
listeners(name) {
|
|
if (this._events === void 0) return [];
|
|
const e = this._events[name];
|
|
return e === void 0 ? [] : [...e.list];
|
|
}
|
|
listenerCount(name) {
|
|
if (this._events === void 0) return 0;
|
|
const e = this._events[name];
|
|
return e === void 0 ? 0 : e.list.length;
|
|
}
|
|
getMaxListeners() {
|
|
return EventEmitter.defaultMaxListeners;
|
|
}
|
|
setMaxListeners(n) {
|
|
}
|
|
removeAllListeners(name) {
|
|
if (arguments.length === 0) {
|
|
for (const key of Reflect.ownKeys(this._events)) {
|
|
if (key === "removeListener") continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners("removeListener");
|
|
} else {
|
|
const e = this._events[name];
|
|
if (e !== void 0) e.removeAll(this, name);
|
|
}
|
|
return this;
|
|
}
|
|
};
|
|
exports.EventEmitter = exports;
|
|
exports.errors = errors;
|
|
exports.defaultMaxListeners = 10;
|
|
exports.on = function on(emitter, name, opts = {}) {
|
|
const { signal } = opts;
|
|
if (signal && signal.aborted) {
|
|
throw errors.OPERATION_ABORTED(signal.reason);
|
|
}
|
|
let error = null;
|
|
let done = false;
|
|
const events = [];
|
|
const promises = [];
|
|
if (name !== "error") emitter.on("error", onerror);
|
|
if (signal) signal.addEventListener("abort", onabort);
|
|
emitter.on(name, onevent);
|
|
return {
|
|
next() {
|
|
if (events.length) {
|
|
return Promise.resolve({ value: events.shift(), done: false });
|
|
}
|
|
if (error) {
|
|
const err = error;
|
|
error = null;
|
|
return Promise.reject(err);
|
|
}
|
|
if (done) return onclose();
|
|
return new Promise((resolve, reject) => promises.push({ resolve, reject }));
|
|
},
|
|
return() {
|
|
return onclose();
|
|
},
|
|
throw(err) {
|
|
return onerror(err);
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
}
|
|
};
|
|
function onevent(...args) {
|
|
if (promises.length) {
|
|
promises.shift().resolve({ value: args, done: false });
|
|
} else {
|
|
events.push(args);
|
|
}
|
|
}
|
|
function onerror(err) {
|
|
emitter.off(name, onevent).off("error", onerror);
|
|
if (promises.length) {
|
|
promises.shift().reject(err);
|
|
} else {
|
|
error = err;
|
|
}
|
|
return Promise.resolve({ done: true });
|
|
}
|
|
function onabort() {
|
|
signal.removeEventListener("abort", onabort);
|
|
onerror(errors.OPERATION_ABORTED(signal.reason));
|
|
}
|
|
function onclose() {
|
|
emitter.off(name, onevent);
|
|
if (name !== "error") emitter.off("error", onerror);
|
|
if (signal) signal.removeEventListener("abort", onabort);
|
|
done = true;
|
|
if (promises.length) promises.shift().resolve({ done: true });
|
|
return Promise.resolve({ done: true });
|
|
}
|
|
};
|
|
exports.once = function once(emitter, name, opts = {}) {
|
|
const { signal } = opts;
|
|
if (signal && signal.aborted) {
|
|
return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
if (name !== "error") emitter.on("error", onerror);
|
|
if (signal) signal.addEventListener("abort", onabort);
|
|
emitter.once(name, onevent);
|
|
function onevent(...args) {
|
|
if (name !== "error") emitter.off("error", onerror);
|
|
if (signal) signal.removeEventListener("abort", onabort);
|
|
resolve(args);
|
|
}
|
|
function onerror(err) {
|
|
emitter.off(name, onevent);
|
|
if (name !== "error") emitter.off("error", onerror);
|
|
reject(err);
|
|
}
|
|
function onabort() {
|
|
signal.removeEventListener("abort", onabort);
|
|
onerror(errors.OPERATION_ABORTED(signal.reason));
|
|
}
|
|
});
|
|
};
|
|
exports.forward = function forward(from, to, names, opts = {}) {
|
|
if (typeof names === "string") names = [names];
|
|
const { emit = to.emit.bind(to) } = opts;
|
|
const listeners = names.map(
|
|
(name) => function onevent(...args) {
|
|
emit(name, ...args);
|
|
}
|
|
);
|
|
to.on("newListener", (name) => {
|
|
const i = names.indexOf(name);
|
|
if (i !== -1 && to.listenerCount(name) === 0) {
|
|
from.on(name, listeners[i]);
|
|
}
|
|
}).on("removeListener", (name) => {
|
|
const i = names.indexOf(name);
|
|
if (i !== -1 && to.listenerCount(name) === 0) {
|
|
from.off(name, listeners[i]);
|
|
}
|
|
});
|
|
};
|
|
exports.listenerCount = function listenerCount(emitter, name) {
|
|
return emitter.listenerCount(name);
|
|
};
|
|
exports.getMaxListeners = function getMaxListeners(emitter) {
|
|
if (typeof emitter.getMaxListeners === "function") {
|
|
return emitter.getMaxListeners();
|
|
}
|
|
return exports.defaultMaxListeners;
|
|
};
|
|
exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
|
|
if (emitters.length === 0) exports.defaultMaxListeners = n;
|
|
else {
|
|
for (const emitter of emitters) {
|
|
if (typeof emitter.setMaxListeners === "function") {
|
|
emitter.setMaxListeners(n);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-signals/binding.js
|
|
var require_binding5 = __commonJS({
|
|
"../../node_modules/bare-signals/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-signals/lib/errors.js
|
|
var require_errors4 = __commonJS({
|
|
"../../node_modules/bare-signals/lib/errors.js"(exports, module) {
|
|
module.exports = class SignalError extends Error {
|
|
constructor(msg, fn = SignalError, code = fn.name) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "SignalError";
|
|
}
|
|
static UNKNOWN_SIGNAL(msg) {
|
|
return new SignalError(msg, SignalError.UNKNOWN_SIGNAL);
|
|
}
|
|
static SIGNAL_CLOSED(msg) {
|
|
return new SignalError(msg, SignalError.SIGNAL_CLOSED);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-signals/lib/emitter.js
|
|
var require_emitter = __commonJS({
|
|
"../../node_modules/bare-signals/lib/emitter.js"(exports, module) {
|
|
var EventEmitter = require_bare_events();
|
|
var Signal = require_bare_signals();
|
|
module.exports = class SignalEmitter extends EventEmitter {
|
|
constructor() {
|
|
super();
|
|
this._signals = /* @__PURE__ */ new Map();
|
|
this._unrefed = false;
|
|
this.on("newListener", this._onnewlistener).on(
|
|
"removeListener",
|
|
this._onremovelistener
|
|
);
|
|
}
|
|
ref() {
|
|
this._unrefed = false;
|
|
for (const signal of this._signals.values()) signal.ref();
|
|
return this;
|
|
}
|
|
unref() {
|
|
this._unrefed = true;
|
|
for (const signal of this._signals.values()) signal.unref();
|
|
return this;
|
|
}
|
|
_onnewlistener(name) {
|
|
if (name === "newListener" || name === "removeListener") return;
|
|
if (this.listenerCount(name) === 0) {
|
|
const signal = new Signal(name);
|
|
signal.on("signal", this._onsignal.bind(this, name)).start();
|
|
if (this._unrefed) signal.unref();
|
|
this._signals.set(name, signal);
|
|
}
|
|
}
|
|
_onremovelistener(name) {
|
|
if (name === "newListener" || name === "removeListener") return;
|
|
if (this.listenerCount(name) === 0) {
|
|
const signal = this._signals.get(name);
|
|
if (this._unrefed) signal.ref();
|
|
signal.close();
|
|
this._signals.delete(name);
|
|
}
|
|
}
|
|
_onsignal(name) {
|
|
this.emit(name, name, Signal.constants[name]);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-signals/index.js
|
|
var require_bare_signals = __commonJS({
|
|
"../../node_modules/bare-signals/index.js"(exports, module) {
|
|
var EventEmitter = require_bare_events();
|
|
var os = require_bare_os();
|
|
var binding = require_binding5();
|
|
var errors = require_errors4();
|
|
var signals = os.constants.signals;
|
|
module.exports = exports = class Signal extends EventEmitter {
|
|
constructor(signum) {
|
|
super();
|
|
if (typeof signum === "string") {
|
|
if (signum in signals === false) {
|
|
throw errors.UNKNOWN_SIGNAL(`Unknown signal '${signum}'`);
|
|
}
|
|
signum = signals[signum];
|
|
}
|
|
this._signum = signum;
|
|
this._closing = null;
|
|
this._handle = binding.init(this, this._onsignal, this._onclose);
|
|
}
|
|
start() {
|
|
if (this._closing) throw errors.SIGNAL_CLOSED("Signal is closed");
|
|
binding.start(this._handle, this._signum);
|
|
return this;
|
|
}
|
|
stop() {
|
|
if (this._closing) return this;
|
|
binding.stop(this._handle);
|
|
return this;
|
|
}
|
|
ref() {
|
|
if (this._closing) return this;
|
|
binding.ref(this._handle);
|
|
return this;
|
|
}
|
|
unref() {
|
|
if (this._closing) return this;
|
|
binding.unref(this._handle);
|
|
return this;
|
|
}
|
|
close() {
|
|
if (this._closing) return this._closing;
|
|
this._closing = EventEmitter.once(this, "close");
|
|
binding.close(this._handle);
|
|
return this._closing;
|
|
}
|
|
_onsignal() {
|
|
this.emit("signal", this._signum);
|
|
}
|
|
_onclose() {
|
|
this._handle = null;
|
|
this.emit("close");
|
|
}
|
|
static send(signum, pid = os.pid()) {
|
|
os.kill(pid, signum);
|
|
}
|
|
};
|
|
exports.Emitter = require_emitter();
|
|
exports.constants = signals;
|
|
exports.errors = errors;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-env/index.js
|
|
var require_bare_env = __commonJS({
|
|
"../../node_modules/bare-env/index.js"(exports, module) {
|
|
var os = require_bare_os();
|
|
module.exports = new Proxy(/* @__PURE__ */ Object.create(null), {
|
|
ownKeys(target) {
|
|
return os.getEnvKeys();
|
|
},
|
|
get(target, property) {
|
|
if (typeof property !== "string") return;
|
|
return os.getEnv(property);
|
|
},
|
|
has(target, property) {
|
|
if (typeof property !== "string") return false;
|
|
return os.hasEnv(property);
|
|
},
|
|
set(target, property, value) {
|
|
if (typeof property !== "string") return;
|
|
const type = typeof value;
|
|
if (type !== "string" && type !== "number" && type !== "boolean") {
|
|
throw new Error("Environment variable must be of type string, number, or boolean");
|
|
}
|
|
value = String(value);
|
|
os.setEnv(property, value);
|
|
return true;
|
|
},
|
|
deleteProperty(target, property) {
|
|
if (typeof property !== "string") return;
|
|
os.unsetEnv(property);
|
|
},
|
|
getOwnPropertyDescriptor(target, property) {
|
|
return {
|
|
value: this.get(target, property),
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
};
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-hrtime/binding.js
|
|
var require_binding6 = __commonJS({
|
|
"../../node_modules/bare-hrtime/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-hrtime/index.js
|
|
var require_bare_hrtime = __commonJS({
|
|
"../../node_modules/bare-hrtime/index.js"(exports, module) {
|
|
var binding = require_binding6();
|
|
module.exports = exports = function hrtime(past) {
|
|
let now = binding.hrtime();
|
|
if (past) now -= BigInt(past[0]) * 1000000000n + BigInt(past[1]);
|
|
return [Number(now / 1000000000n), Number(now % 1000000000n)];
|
|
};
|
|
exports.bigint = function hrtime() {
|
|
return binding.hrtime();
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/fast-fifo/fixed-size.js
|
|
var require_fixed_size = __commonJS({
|
|
"../../node_modules/fast-fifo/fixed-size.js"(exports, module) {
|
|
module.exports = class FixedFIFO {
|
|
constructor(hwm) {
|
|
if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
|
|
this.buffer = new Array(hwm);
|
|
this.mask = hwm - 1;
|
|
this.top = 0;
|
|
this.btm = 0;
|
|
this.next = null;
|
|
}
|
|
clear() {
|
|
this.top = this.btm = 0;
|
|
this.next = null;
|
|
this.buffer.fill(void 0);
|
|
}
|
|
push(data) {
|
|
if (this.buffer[this.top] !== void 0) return false;
|
|
this.buffer[this.top] = data;
|
|
this.top = this.top + 1 & this.mask;
|
|
return true;
|
|
}
|
|
shift() {
|
|
const last = this.buffer[this.btm];
|
|
if (last === void 0) return void 0;
|
|
this.buffer[this.btm] = void 0;
|
|
this.btm = this.btm + 1 & this.mask;
|
|
return last;
|
|
}
|
|
peek() {
|
|
return this.buffer[this.btm];
|
|
}
|
|
isEmpty() {
|
|
return this.buffer[this.btm] === void 0;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/fast-fifo/index.js
|
|
var require_fast_fifo = __commonJS({
|
|
"../../node_modules/fast-fifo/index.js"(exports, module) {
|
|
var FixedFIFO = require_fixed_size();
|
|
module.exports = class FastFIFO {
|
|
constructor(hwm) {
|
|
this.hwm = hwm || 16;
|
|
this.head = new FixedFIFO(this.hwm);
|
|
this.tail = this.head;
|
|
this.length = 0;
|
|
}
|
|
clear() {
|
|
this.head = this.tail;
|
|
this.head.clear();
|
|
this.length = 0;
|
|
}
|
|
push(val) {
|
|
this.length++;
|
|
if (!this.head.push(val)) {
|
|
const prev = this.head;
|
|
this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
|
|
this.head.push(val);
|
|
}
|
|
}
|
|
shift() {
|
|
if (this.length !== 0) this.length--;
|
|
const val = this.tail.shift();
|
|
if (val === void 0 && this.tail.next) {
|
|
const next = this.tail.next;
|
|
this.tail.next = null;
|
|
this.tail = next;
|
|
return this.tail.shift();
|
|
}
|
|
return val;
|
|
}
|
|
peek() {
|
|
const val = this.tail.peek();
|
|
if (val === void 0 && this.tail.next) return this.tail.next.peek();
|
|
return val;
|
|
}
|
|
isEmpty() {
|
|
return this.length === 0;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/constants.js
|
|
var require_constants2 = __commonJS({
|
|
"../../node_modules/bare-path/lib/constants.js"(exports, module) {
|
|
module.exports = {
|
|
CHAR_UPPERCASE_A: 65,
|
|
CHAR_LOWERCASE_A: 97,
|
|
CHAR_UPPERCASE_Z: 90,
|
|
CHAR_LOWERCASE_Z: 122,
|
|
CHAR_DOT: 46,
|
|
CHAR_FORWARD_SLASH: 47,
|
|
CHAR_BACKWARD_SLASH: 92,
|
|
CHAR_COLON: 58,
|
|
CHAR_QUESTION_MARK: 63
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/shared.js
|
|
var require_shared = __commonJS({
|
|
"../../node_modules/bare-path/lib/shared.js"(exports) {
|
|
var {
|
|
CHAR_DOT,
|
|
CHAR_FORWARD_SLASH
|
|
} = require_constants2();
|
|
exports.normalizeString = function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
|
|
let res = "";
|
|
let lastSegmentLength = 0;
|
|
let lastSlash = -1;
|
|
let dots = 0;
|
|
let code = 0;
|
|
for (let i = 0; i <= path.length; ++i) {
|
|
if (i < path.length) {
|
|
code = path.charCodeAt(i);
|
|
} else if (isPathSeparator(code)) {
|
|
break;
|
|
} else {
|
|
code = CHAR_FORWARD_SLASH;
|
|
}
|
|
if (isPathSeparator(code)) {
|
|
if (lastSlash === i - 1 || dots === 1) ;
|
|
else if (dots === 2) {
|
|
if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
|
|
if (res.length > 2) {
|
|
const lastSlashIndex = res.lastIndexOf(separator);
|
|
if (lastSlashIndex === -1) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
} else {
|
|
res = res.substring(0, lastSlashIndex);
|
|
lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
} else if (res.length !== 0) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
}
|
|
}
|
|
if (allowAboveRoot) {
|
|
res += res.length > 0 ? `${separator}..` : "..";
|
|
lastSegmentLength = 2;
|
|
}
|
|
} else {
|
|
if (res.length > 0) {
|
|
res += `${separator}${path.substring(lastSlash + 1, i)}`;
|
|
} else {
|
|
res = path.substring(lastSlash + 1, i);
|
|
}
|
|
lastSegmentLength = i - lastSlash - 1;
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
} else if (code === CHAR_DOT && dots !== -1) {
|
|
++dots;
|
|
} else {
|
|
dots = -1;
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/posix.js
|
|
var require_posix = __commonJS({
|
|
"../../node_modules/bare-path/lib/posix.js"(exports) {
|
|
var os = require_bare_os();
|
|
var { normalizeString } = require_shared();
|
|
var {
|
|
CHAR_DOT,
|
|
CHAR_FORWARD_SLASH
|
|
} = require_constants2();
|
|
function isPosixPathSeparator(code) {
|
|
return code === CHAR_FORWARD_SLASH;
|
|
}
|
|
exports.win32 = require_win32();
|
|
exports.posix = exports;
|
|
exports.sep = "/";
|
|
exports.delimiter = ":";
|
|
exports.resolve = function resolve(...args) {
|
|
let resolvedPath = "";
|
|
let resolvedAbsolute = false;
|
|
for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
const path = i >= 0 ? args[i] : os.cwd();
|
|
if (path.length === 0) {
|
|
continue;
|
|
}
|
|
resolvedPath = `${path}/${resolvedPath}`;
|
|
resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
}
|
|
resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
|
|
if (resolvedAbsolute) {
|
|
return `/${resolvedPath}`;
|
|
}
|
|
return resolvedPath.length > 0 ? resolvedPath : ".";
|
|
};
|
|
exports.normalize = function normalize(path) {
|
|
if (path.length === 0) return ".";
|
|
const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
|
|
path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
|
|
if (path.length === 0) {
|
|
if (isAbsolute) return "/";
|
|
return trailingSeparator ? "./" : ".";
|
|
}
|
|
if (trailingSeparator) path += "/";
|
|
return isAbsolute ? `/${path}` : path;
|
|
};
|
|
exports.isAbsolute = function isAbsolute(path) {
|
|
return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
};
|
|
exports.join = function join(...args) {
|
|
if (args.length === 0) return ".";
|
|
let joined;
|
|
for (let i = 0; i < args.length; ++i) {
|
|
const arg = args[i];
|
|
if (arg.length > 0) {
|
|
if (joined === void 0) joined = arg;
|
|
else joined += `/${arg}`;
|
|
}
|
|
}
|
|
if (joined === void 0) return ".";
|
|
return exports.normalize(joined);
|
|
};
|
|
exports.relative = function relative(from, to) {
|
|
if (from === to) return "";
|
|
from = exports.resolve(from);
|
|
to = exports.resolve(to);
|
|
if (from === to) return "";
|
|
const fromStart = 1;
|
|
const fromEnd = from.length;
|
|
const fromLen = fromEnd - fromStart;
|
|
const toStart = 1;
|
|
const toLen = to.length - toStart;
|
|
const length = fromLen < toLen ? fromLen : toLen;
|
|
let lastCommonSep = -1;
|
|
let i = 0;
|
|
for (; i < length; i++) {
|
|
const fromCode = from.charCodeAt(fromStart + i);
|
|
if (fromCode !== to.charCodeAt(toStart + i)) {
|
|
break;
|
|
} else if (fromCode === CHAR_FORWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
}
|
|
}
|
|
if (i === length) {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
|
|
return to.substring(toStart + i + 1);
|
|
}
|
|
if (i === 0) {
|
|
return to.substring(toStart + i);
|
|
}
|
|
} else if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
} else if (i === 0) {
|
|
lastCommonSep = 0;
|
|
}
|
|
}
|
|
}
|
|
let out = "";
|
|
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
|
|
if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
out += out.length === 0 ? ".." : "/..";
|
|
}
|
|
}
|
|
return `${out}${to.substring(toStart + lastCommonSep)}`;
|
|
};
|
|
exports.toNamespacedPath = function toNamespacedPath(path) {
|
|
return path;
|
|
};
|
|
exports.dirname = function dirname(path) {
|
|
if (path.length === 0) return ".";
|
|
const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
for (let i = path.length - 1; i >= 1; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
if (end === -1) return hasRoot ? "/" : ".";
|
|
if (hasRoot && end === 1) return "//";
|
|
return path.substring(0, end);
|
|
};
|
|
exports.basename = function basename(path, suffix) {
|
|
let start = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
|
|
if (suffix === path) {
|
|
return "";
|
|
}
|
|
let extIdx = suffix.length - 1;
|
|
let firstNonSlashEnd = -1;
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
if (code === suffix.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) {
|
|
end = i;
|
|
}
|
|
} else {
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.substring(start, end);
|
|
}
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
if (end === -1) return "";
|
|
return path.substring(start, end);
|
|
};
|
|
exports.extname = function extname(path) {
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let preDotState = 0;
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
return "";
|
|
}
|
|
return path.substring(startDot, end);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/win32.js
|
|
var require_win32 = __commonJS({
|
|
"../../node_modules/bare-path/lib/win32.js"(exports) {
|
|
var os = require_bare_os();
|
|
var { normalizeString } = require_shared();
|
|
var {
|
|
CHAR_UPPERCASE_A,
|
|
CHAR_LOWERCASE_A,
|
|
CHAR_UPPERCASE_Z,
|
|
CHAR_LOWERCASE_Z,
|
|
CHAR_DOT,
|
|
CHAR_FORWARD_SLASH,
|
|
CHAR_BACKWARD_SLASH,
|
|
CHAR_COLON,
|
|
CHAR_QUESTION_MARK
|
|
} = require_constants2();
|
|
function isWindowsPathSeparator(code) {
|
|
return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
|
|
}
|
|
function isWindowsDeviceRoot(code) {
|
|
return code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z || code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z;
|
|
}
|
|
exports.posix = require_posix();
|
|
exports.win32 = exports;
|
|
exports.sep = "\\";
|
|
exports.delimiter = ";";
|
|
exports.resolve = function resolve(...args) {
|
|
let resolvedDevice = "";
|
|
let resolvedTail = "";
|
|
let resolvedAbsolute = false;
|
|
for (let i = args.length - 1; i >= -1; i--) {
|
|
let path;
|
|
if (i >= 0) {
|
|
path = args[i];
|
|
if (path.length === 0) continue;
|
|
} else if (resolvedDevice.length === 0) {
|
|
path = os.cwd();
|
|
} else {
|
|
path = os.getEnv(`=${resolvedDevice}`) || os.cwd();
|
|
if (path === void 0 || path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
|
|
path = `${resolvedDevice}\\`;
|
|
}
|
|
}
|
|
const len = path.length;
|
|
let rootEnd = 0;
|
|
let device = "";
|
|
let isAbsolute = false;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
if (isWindowsPathSeparator(code)) {
|
|
rootEnd = 1;
|
|
isAbsolute = true;
|
|
}
|
|
} else if (isWindowsPathSeparator(code)) {
|
|
isAbsolute = true;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
const firstPart = path.substring(last, j);
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len || j !== last) {
|
|
device = `\\\\${firstPart}\\${path.substring(last, j)}`;
|
|
rootEnd = j;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
rootEnd = 1;
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
device = path.substring(0, 2);
|
|
rootEnd = 2;
|
|
if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
|
|
isAbsolute = true;
|
|
rootEnd = 3;
|
|
}
|
|
}
|
|
if (device.length > 0) {
|
|
if (resolvedDevice.length > 0) {
|
|
if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
|
|
continue;
|
|
}
|
|
} else {
|
|
resolvedDevice = device;
|
|
}
|
|
}
|
|
if (resolvedAbsolute) {
|
|
if (resolvedDevice.length > 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}`;
|
|
resolvedAbsolute = isAbsolute;
|
|
if (isAbsolute && resolvedDevice.length > 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isWindowsPathSeparator);
|
|
return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || ".";
|
|
};
|
|
exports.normalize = function normalize(path) {
|
|
const len = path.length;
|
|
if (len === 0) return ".";
|
|
let rootEnd = 0;
|
|
let device;
|
|
let isAbsolute = false;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
return code === CHAR_FORWARD_SLASH ? "\\" : path;
|
|
}
|
|
if (isWindowsPathSeparator(code)) {
|
|
isAbsolute = true;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
const firstPart = path.substring(last, j);
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len) {
|
|
return `\\\\${firstPart}\\${path.substring(last)}\\`;
|
|
}
|
|
if (j !== last) {
|
|
device = `\\\\${firstPart}\\${path.substring(last, j)}`;
|
|
rootEnd = j;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
rootEnd = 1;
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
device = path.substring(0, 2);
|
|
rootEnd = 2;
|
|
if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
|
|
isAbsolute = true;
|
|
rootEnd = 3;
|
|
}
|
|
}
|
|
let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, "\\", isWindowsPathSeparator) : "";
|
|
if (tail.length === 0 && !isAbsolute) {
|
|
tail = ".";
|
|
}
|
|
if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) {
|
|
tail += "\\";
|
|
}
|
|
if (device === void 0) {
|
|
return isAbsolute ? `\\${tail}` : tail;
|
|
}
|
|
return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
|
|
};
|
|
exports.isAbsolute = function isAbsolute(path) {
|
|
const len = path.length;
|
|
if (len === 0) return false;
|
|
const code = path.charCodeAt(0);
|
|
return isWindowsPathSeparator(code) || len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2));
|
|
};
|
|
exports.join = function join(...args) {
|
|
if (args.length === 0) return ".";
|
|
let joined;
|
|
let firstPart;
|
|
for (let i = 0; i < args.length; ++i) {
|
|
const arg = args[i];
|
|
if (arg.length > 0) {
|
|
if (joined === void 0) joined = firstPart = arg;
|
|
else joined += `\\${arg}`;
|
|
}
|
|
}
|
|
if (joined === void 0) return ".";
|
|
let needsReplace = true;
|
|
let slashCount = 0;
|
|
if (isWindowsPathSeparator(firstPart.charCodeAt(0))) {
|
|
++slashCount;
|
|
const firstLen = firstPart.length;
|
|
if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) {
|
|
++slashCount;
|
|
if (firstLen > 2) {
|
|
if (isWindowsPathSeparator(firstPart.charCodeAt(2))) {
|
|
++slashCount;
|
|
} else {
|
|
needsReplace = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (needsReplace) {
|
|
while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) {
|
|
slashCount++;
|
|
}
|
|
if (slashCount >= 2) {
|
|
joined = `\\${joined.substring(slashCount)}`;
|
|
}
|
|
}
|
|
return exports.normalize(joined);
|
|
};
|
|
exports.relative = function relative(from, to) {
|
|
if (from === to) return "";
|
|
const fromOrig = exports.resolve(from);
|
|
const toOrig = exports.resolve(to);
|
|
if (fromOrig === toOrig) return "";
|
|
from = fromOrig.toLowerCase();
|
|
to = toOrig.toLowerCase();
|
|
if (from === to) return "";
|
|
let fromStart = 0;
|
|
while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
|
|
fromStart++;
|
|
}
|
|
let fromEnd = from.length;
|
|
while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
|
|
fromEnd--;
|
|
}
|
|
const fromLen = fromEnd - fromStart;
|
|
let toStart = 0;
|
|
while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
|
|
toStart++;
|
|
}
|
|
let toEnd = to.length;
|
|
while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
|
|
toEnd--;
|
|
}
|
|
const toLen = toEnd - toStart;
|
|
const length = fromLen < toLen ? fromLen : toLen;
|
|
let lastCommonSep = -1;
|
|
let i = 0;
|
|
for (; i < length; i++) {
|
|
const fromCode = from.charCodeAt(fromStart + i);
|
|
if (fromCode !== to.charCodeAt(toStart + i)) {
|
|
break;
|
|
} else if (fromCode === CHAR_BACKWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
}
|
|
}
|
|
if (i !== length) {
|
|
if (lastCommonSep === -1) return toOrig;
|
|
} else {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
|
|
return toOrig.substring(toStart + i + 1);
|
|
}
|
|
if (i === 2) {
|
|
return toOrig.substring(toStart + i);
|
|
}
|
|
}
|
|
if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
} else if (i === 2) {
|
|
lastCommonSep = 3;
|
|
}
|
|
}
|
|
if (lastCommonSep === -1) lastCommonSep = 0;
|
|
}
|
|
let out = "";
|
|
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
|
|
if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
|
|
out += out.length === 0 ? ".." : "\\..";
|
|
}
|
|
}
|
|
toStart += lastCommonSep;
|
|
if (out.length > 0) {
|
|
return `${out}${toOrig.substring(toStart, toEnd)}`;
|
|
}
|
|
if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
|
|
++toStart;
|
|
}
|
|
return toOrig.substring(toStart, toEnd);
|
|
};
|
|
exports.toNamespacedPath = function toNamespacedPath(path) {
|
|
if (path.length === 0) return path;
|
|
const resolvedPath = exports.resolve(path);
|
|
if (resolvedPath.length <= 2) return path;
|
|
if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
|
|
if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
|
|
const code = resolvedPath.charCodeAt(2);
|
|
if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
|
|
return `\\\\?\\UNC\\${resolvedPath.substring(2)}`;
|
|
}
|
|
}
|
|
} else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
|
|
return `\\\\?\\${resolvedPath}`;
|
|
}
|
|
return path;
|
|
};
|
|
exports.dirname = function dirname(path) {
|
|
const len = path.length;
|
|
if (len === 0) return ".";
|
|
let rootEnd = -1;
|
|
let offset = 0;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
return isWindowsPathSeparator(code) ? path : ".";
|
|
}
|
|
if (isWindowsPathSeparator(code)) {
|
|
rootEnd = offset = 1;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len) {
|
|
return path;
|
|
}
|
|
if (j !== last) {
|
|
rootEnd = offset = j + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2;
|
|
offset = rootEnd;
|
|
}
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
for (let i = len - 1; i >= offset; --i) {
|
|
if (isWindowsPathSeparator(path.charCodeAt(i))) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
if (end === -1) {
|
|
if (rootEnd === -1) return ".";
|
|
end = rootEnd;
|
|
}
|
|
return path.substring(0, end);
|
|
};
|
|
exports.basename = function basename(path, suffix) {
|
|
let start = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) {
|
|
start = 2;
|
|
}
|
|
if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
|
|
if (suffix === path) return "";
|
|
let extIdx = suffix.length - 1;
|
|
let firstNonSlashEnd = -1;
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (isWindowsPathSeparator(code)) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
if (code === suffix.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) {
|
|
end = i;
|
|
}
|
|
} else {
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.substring(start, end);
|
|
}
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
if (isWindowsPathSeparator(path.charCodeAt(i))) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
if (end === -1) return "";
|
|
return path.substring(start, end);
|
|
};
|
|
exports.extname = function extname(path) {
|
|
let start = 0;
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let preDotState = 0;
|
|
if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) {
|
|
start = startPart = 2;
|
|
}
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (isWindowsPathSeparator(code)) {
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
return "";
|
|
}
|
|
return path.substring(startDot, end);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/index.js
|
|
var require_bare_path = __commonJS({
|
|
"../../node_modules/bare-path/index.js"(exports, module) {
|
|
if (Bare.platform === "win32") {
|
|
module.exports = require_win32();
|
|
} else {
|
|
module.exports = require_posix();
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/binding.js
|
|
var require_binding7 = __commonJS({
|
|
"../../node_modules/bare-url/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/lib/errors.js
|
|
var require_errors5 = __commonJS({
|
|
"../../node_modules/bare-url/lib/errors.js"(exports, module) {
|
|
module.exports = class URLError extends Error {
|
|
constructor(msg, fn = URLError, code = fn.name) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) Error.captureStackTrace(this, fn);
|
|
}
|
|
get name() {
|
|
return "URLError";
|
|
}
|
|
static INVALID_URL(msg, input) {
|
|
const err = new URLError(msg, URLError.INVALID_URL);
|
|
err.input = input;
|
|
return err;
|
|
}
|
|
static INVALID_URL_SCHEME(msg = "Invalid URL") {
|
|
return new URLError(msg, URLError.INVALID_URL_SCHEME);
|
|
}
|
|
static INVALID_FILE_URL_HOST(msg = "Invalid file: URL host") {
|
|
return new URLError(msg, URLError.INVALID_FILE_URL_HOST);
|
|
}
|
|
static INVALID_FILE_URL_PATH(msg = "Invalid file: URL path") {
|
|
return new URLError(msg, URLError.INVALID_FILE_URL_PATH);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/lib/url-search-params.js
|
|
var require_url_search_params = __commonJS({
|
|
"../../node_modules/bare-url/lib/url-search-params.js"(exports, module) {
|
|
var kind = Symbol.for("bare.url.search-params.kind");
|
|
var URLSearchParams = class _URLSearchParams {
|
|
static _urls = /* @__PURE__ */ new WeakMap();
|
|
static get [kind]() {
|
|
return 0;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams
|
|
constructor(init, url = null) {
|
|
this._params = /* @__PURE__ */ new Map();
|
|
if (url) _URLSearchParams._urls.set(this, url);
|
|
if (typeof init === "string") {
|
|
this._parse(init);
|
|
} else if (init) {
|
|
for (const [name, value] of typeof init[Symbol.iterator] === "function" ? init : Object.entries(init)) {
|
|
this.append(name, value);
|
|
}
|
|
}
|
|
}
|
|
get [kind]() {
|
|
return _URLSearchParams[kind];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-size
|
|
get size() {
|
|
return this._params.length;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
|
|
append(name, value = null) {
|
|
if (value === null) return;
|
|
let list = this._params.get(name);
|
|
if (list === void 0) {
|
|
list = [];
|
|
this._params.set(name, list);
|
|
}
|
|
list.push(value);
|
|
this._update();
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
|
|
delete(name, value = null) {
|
|
if (value === null) this._params.delete(name);
|
|
else {
|
|
let list = this._params.get(name);
|
|
if (list === void 0) return;
|
|
list = list.filter((found) => found !== value);
|
|
if (list.length === 0) this._params.delete(name);
|
|
else this._params.set(name, list);
|
|
}
|
|
this._update();
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
|
|
get(name) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return null;
|
|
return list[0];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
|
|
getAll(name) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return [];
|
|
return Array.from(list);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
|
|
has(name, value = null) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return false;
|
|
if (value === null) return true;
|
|
return list.includes(value);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
|
|
set(name, value = null) {
|
|
if (value === null) this._params.delete(name);
|
|
else this._params.set(name, [value]);
|
|
this._update();
|
|
}
|
|
toString() {
|
|
return this._serialize();
|
|
}
|
|
toJSON() {
|
|
return [...this];
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (const [name, values] of this._params) {
|
|
for (const value of values) yield [name, value];
|
|
}
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
const object = {
|
|
__proto__: { constructor: _URLSearchParams }
|
|
};
|
|
for (const [name, values] of this._params) {
|
|
if (values.length === 1) object[name] = values[0];
|
|
else object[name] = values;
|
|
}
|
|
return object;
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlsearchparams-update
|
|
_update() {
|
|
const url = _URLSearchParams._urls.get(this);
|
|
if (url === void 0) return;
|
|
url.search = this._serialize();
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlencoded-parser
|
|
_parse(input) {
|
|
if (input[0] === "?") input = input.substring(1);
|
|
this._params = /* @__PURE__ */ new Map();
|
|
for (const sequence of input.split("&")) {
|
|
if (sequence.length === 0) continue;
|
|
let i = sequence.indexOf("=");
|
|
if (i === -1) i = sequence.length;
|
|
const name = decodeURIComponent(sequence.substring(0, i));
|
|
const value = decodeURIComponent(sequence.substring(i + 1, sequence.length));
|
|
let list = this._params.get(name);
|
|
if (list === void 0) {
|
|
list = [];
|
|
this._params.set(name, list);
|
|
}
|
|
list.push(value);
|
|
}
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlencoded-serializer
|
|
_serialize() {
|
|
let output = "";
|
|
for (let [name, values] of this._params) {
|
|
name = encodeURIComponent(name);
|
|
for (const value of values) {
|
|
if (output) output += "&";
|
|
output += name + "=" + encodeURIComponent(value);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
};
|
|
module.exports = exports = URLSearchParams;
|
|
exports.isURLSearchParams = function isURLSearchParams(value) {
|
|
if (value instanceof URLSearchParams) return true;
|
|
return typeof value === "object" && value !== null && value[kind] === URLSearchParams[kind];
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/index.js
|
|
var require_bare_url = __commonJS({
|
|
"../../node_modules/bare-url/index.js"(exports, module) {
|
|
var path = require_bare_path();
|
|
var binding = require_binding7();
|
|
var errors = require_errors5();
|
|
var URLSearchParams = require_url_search_params();
|
|
var kind = Symbol.for("bare.url.kind");
|
|
var isWindows = Bare.platform === "win32";
|
|
var URL = class _URL {
|
|
static get [kind]() {
|
|
return 0;
|
|
}
|
|
constructor(input, base, opts = {}) {
|
|
if (arguments.length === 0) throw errors.INVALID_URL();
|
|
input = String(input);
|
|
if (base !== void 0) base = String(base);
|
|
this._components = new Uint32Array(8);
|
|
this._parse(input, base, opts.throw !== false);
|
|
if (this._href) this._params = new URLSearchParams(this.search, this);
|
|
}
|
|
get [kind]() {
|
|
return _URL[kind];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-href
|
|
get href() {
|
|
return this._href;
|
|
}
|
|
set href(value) {
|
|
this._update(value);
|
|
this._params._parse(this.search);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-protocol
|
|
get protocol() {
|
|
return this._slice(0, this._components[0]) + ":";
|
|
}
|
|
set protocol(value) {
|
|
this._update(this._replace(value.replace(/:+$/, ""), 0, this._components[0]));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-username
|
|
get username() {
|
|
return this._slice(this._components[0] + 3, this._components[1]);
|
|
}
|
|
set username(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
if (this.username === "") value += "@";
|
|
this._update(this._replace(value, this._components[0] + 3, this._components[1]));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-password
|
|
get password() {
|
|
return this._href.slice(
|
|
this._components[1] + 1,
|
|
this._components[2] - 1
|
|
/* @ */
|
|
);
|
|
}
|
|
set password(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
let start = this._components[1] + 1;
|
|
let end = this._components[2] - 1;
|
|
if (this.password === "") {
|
|
value = ":" + value;
|
|
start--;
|
|
}
|
|
if (this.username === "") {
|
|
value += "@";
|
|
end++;
|
|
}
|
|
this._update(this._replace(value, start, end));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-host
|
|
get host() {
|
|
return this._slice(this._components[2], this._components[5]);
|
|
}
|
|
set host(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
this._update(
|
|
this._replace(value, this._components[2], this._components[value.includes(":") ? 5 : 3])
|
|
);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-hostname
|
|
get hostname() {
|
|
return this._slice(this._components[2], this._components[3]);
|
|
}
|
|
set hostname(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
this._update(this._replace(value, this._components[2], this._components[3]));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-port
|
|
get port() {
|
|
return this._slice(this._components[3] + 1, this._components[5]);
|
|
}
|
|
set port(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
let start = this._components[3] + 1;
|
|
if (this.port === "") {
|
|
value = ":" + value;
|
|
start--;
|
|
}
|
|
this._update(this._replace(value, start, this._components[5]));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-pathname
|
|
get pathname() {
|
|
return this._slice(
|
|
this._components[5],
|
|
this._components[6] - 1
|
|
/* ? */
|
|
);
|
|
}
|
|
set pathname(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
if (value[0] !== "/" && value[0] !== "\\") {
|
|
value = "/" + value;
|
|
}
|
|
this._update(this._replace(
|
|
value,
|
|
this._components[5],
|
|
this._components[6] - 1
|
|
/* ? */
|
|
));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-search
|
|
get search() {
|
|
return this._slice(
|
|
this._components[6] - 1,
|
|
this._components[7] - 1
|
|
/* # */
|
|
);
|
|
}
|
|
set search(value) {
|
|
if (value && value[0] !== "?") value = "?" + value;
|
|
this._update(
|
|
this._replace(
|
|
value,
|
|
this._components[6] - 1,
|
|
this._components[7] - 1
|
|
/* # */
|
|
)
|
|
);
|
|
this._params._parse(this.search);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-searchparams
|
|
get searchParams() {
|
|
return this._params;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-hash
|
|
get hash() {
|
|
return this._slice(
|
|
this._components[7] - 1
|
|
/* # */
|
|
);
|
|
}
|
|
set hash(value) {
|
|
if (value && value[0] !== "#") value = "#" + value;
|
|
this._update(this._replace(
|
|
value,
|
|
this._components[7] - 1
|
|
/* # */
|
|
));
|
|
}
|
|
toString() {
|
|
return this._href;
|
|
}
|
|
toJSON() {
|
|
return this._href;
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _URL },
|
|
href: this.href,
|
|
protocol: this.protocol,
|
|
username: this.username,
|
|
password: this.password,
|
|
host: this.host,
|
|
hostname: this.hostname,
|
|
port: this.port,
|
|
pathname: this.pathname,
|
|
search: this.search,
|
|
searchParams: this.searchParams,
|
|
hash: this.hash
|
|
};
|
|
}
|
|
_slice(start, end = this._href.length) {
|
|
return this._href.slice(start, end);
|
|
}
|
|
_replace(replacement, start, end = this._href.length) {
|
|
return this._slice(0, start) + replacement + this._slice(end);
|
|
}
|
|
_parse(input, base, shouldThrow) {
|
|
try {
|
|
this._href = binding.parse(
|
|
String(input),
|
|
base ? String(base) : null,
|
|
this._components,
|
|
shouldThrow
|
|
);
|
|
} catch (err) {
|
|
if (err instanceof TypeError) throw err;
|
|
throw errors.INVALID_URL(`Invalid URL '${input}'`, input);
|
|
}
|
|
}
|
|
_update(input) {
|
|
try {
|
|
this._parse(input, null, true);
|
|
} catch (err) {
|
|
if (err instanceof TypeError) throw err;
|
|
}
|
|
}
|
|
};
|
|
module.exports = exports = URL;
|
|
function hasOpaquePath(url) {
|
|
return url.pathname[0] !== "/";
|
|
}
|
|
function cannotHaveCredentialsOrPort(url) {
|
|
return url.hostname === "" || url.protocol === "file:";
|
|
}
|
|
exports.URL = URL;
|
|
exports.URLSearchParams = URLSearchParams;
|
|
exports.errors = errors;
|
|
exports.isURL = function isURL(value) {
|
|
if (value instanceof URL) return true;
|
|
return typeof value === "object" && value !== null && value[kind] === URL[kind];
|
|
};
|
|
exports.isURLSearchParams = URLSearchParams.isURLSearchParams;
|
|
exports.parse = function parse(input, base) {
|
|
const url = new URL(input, base, { throw: false });
|
|
return url._href ? url : null;
|
|
};
|
|
exports.canParse = function canParse(input, base) {
|
|
return binding.canParse(String(input), base ? String(base) : null);
|
|
};
|
|
exports.fileURLToPath = function fileURLToPath(url) {
|
|
if (typeof url === "string") {
|
|
url = new URL(url);
|
|
}
|
|
if (url.protocol !== "file:") {
|
|
throw errors.INVALID_URL_SCHEME("The URL must use the file: protocol");
|
|
}
|
|
if (isWindows) {
|
|
if (/%2f|%5c/i.test(url.pathname)) {
|
|
throw errors.INVALID_FILE_URL_PATH(
|
|
"The file: URL path must not include encoded \\ or / characters"
|
|
);
|
|
}
|
|
} else {
|
|
if (url.hostname) {
|
|
throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty");
|
|
}
|
|
if (/%2f/i.test(url.pathname)) {
|
|
throw errors.INVALID_FILE_URL_PATH("The file: URL path must not include encoded / characters");
|
|
}
|
|
}
|
|
const pathname = path.normalize(decodeURIComponent(url.pathname));
|
|
if (isWindows) {
|
|
if (url.hostname) return "\\\\" + url.hostname + pathname;
|
|
const letter = pathname.charCodeAt(1) | 32;
|
|
if (letter < 97 || letter > 122 || pathname.charCodeAt(2) !== 58) {
|
|
throw errors.INVALID_FILE_URL_PATH("The file: URL path must be absolute");
|
|
}
|
|
return pathname.slice(1);
|
|
}
|
|
return pathname;
|
|
};
|
|
exports.pathToFileURL = function pathToFileURL(pathname) {
|
|
let resolved = path.resolve(pathname);
|
|
if (pathname[pathname.length - 1] === "/") {
|
|
resolved += "/";
|
|
} else if (isWindows && pathname[pathname.length - 1] === "\\") {
|
|
resolved += "\\";
|
|
}
|
|
resolved = resolved.replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("?", "%3f").replaceAll("\n", "%0a").replaceAll("\r", "%0d").replaceAll(" ", "%09");
|
|
if (!isWindows) {
|
|
resolved = resolved.replaceAll("\\", "%5c");
|
|
}
|
|
return new URL("file:" + resolved);
|
|
};
|
|
exports.format = function format(parts) {
|
|
const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts;
|
|
let result = "";
|
|
if (typeof protocol === "string") {
|
|
result += protocol;
|
|
if (protocol[protocol.length - 1] !== ":") {
|
|
result += ":";
|
|
}
|
|
if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) {
|
|
result += "//";
|
|
}
|
|
}
|
|
if (typeof auth === "string") {
|
|
if (host || hostname) result += auth + "@";
|
|
}
|
|
if (typeof host === "string") result += host;
|
|
else {
|
|
result += hostname;
|
|
if (port) result += ":" + port;
|
|
}
|
|
if (typeof pathname === "string" && pathname !== "") {
|
|
if (pathname[0] !== "/") result += "/";
|
|
result += pathname;
|
|
}
|
|
if (typeof search === "string") {
|
|
if (search[0] !== "?") result += "?";
|
|
result += search;
|
|
} else if (typeof query === "object" && query !== null) {
|
|
result += "?" + new URLSearchParams(query);
|
|
}
|
|
if (typeof hash === "string") {
|
|
if (hash[0] !== "#") result += "#";
|
|
result += hash;
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/events-universal/default.js
|
|
var require_default = __commonJS({
|
|
"../../node_modules/events-universal/default.js"(exports, module) {
|
|
module.exports = __require("events");
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/b4a/index.js
|
|
var require_b4a = __commonJS({
|
|
"../../node_modules/b4a/index.js"(exports, module) {
|
|
function isBuffer(value) {
|
|
return Buffer.isBuffer(value) || value instanceof Uint8Array;
|
|
}
|
|
function isEncoding(encoding) {
|
|
return Buffer.isEncoding(encoding);
|
|
}
|
|
function alloc(size, fill2, encoding) {
|
|
return Buffer.alloc(size, fill2, encoding);
|
|
}
|
|
function allocUnsafe(size) {
|
|
return Buffer.allocUnsafe(size);
|
|
}
|
|
function allocUnsafeSlow(size) {
|
|
return Buffer.allocUnsafeSlow(size);
|
|
}
|
|
function byteLength(string, encoding) {
|
|
return Buffer.byteLength(string, encoding);
|
|
}
|
|
function compare(a, b) {
|
|
return Buffer.compare(a, b);
|
|
}
|
|
function concat(buffers, totalLength) {
|
|
return Buffer.concat(buffers, totalLength);
|
|
}
|
|
function copy(source, target, targetStart, start, end) {
|
|
return toBuffer(source).copy(target, targetStart, start, end);
|
|
}
|
|
function equals(a, b) {
|
|
return toBuffer(a).equals(b);
|
|
}
|
|
function fill(buffer, value, offset, end, encoding) {
|
|
return toBuffer(buffer).fill(value, offset, end, encoding);
|
|
}
|
|
function from(value, encodingOrOffset, length) {
|
|
return Buffer.from(value, encodingOrOffset, length);
|
|
}
|
|
function includes(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).includes(value, byteOffset, encoding);
|
|
}
|
|
function indexOf(buffer, value, byfeOffset, encoding) {
|
|
return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
|
|
}
|
|
function lastIndexOf(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
|
|
}
|
|
function swap16(buffer) {
|
|
return toBuffer(buffer).swap16();
|
|
}
|
|
function swap32(buffer) {
|
|
return toBuffer(buffer).swap32();
|
|
}
|
|
function swap64(buffer) {
|
|
return toBuffer(buffer).swap64();
|
|
}
|
|
function toBuffer(buffer) {
|
|
if (Buffer.isBuffer(buffer)) return buffer;
|
|
return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
}
|
|
function toString(buffer, encoding, start, end) {
|
|
return toBuffer(buffer).toString(encoding, start, end);
|
|
}
|
|
function write(buffer, string, offset, length, encoding) {
|
|
return toBuffer(buffer).write(string, offset, length, encoding);
|
|
}
|
|
function readDoubleBE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleBE(offset);
|
|
}
|
|
function readDoubleLE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleLE(offset);
|
|
}
|
|
function readFloatBE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatBE(offset);
|
|
}
|
|
function readFloatLE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatLE(offset);
|
|
}
|
|
function readInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32BE(offset);
|
|
}
|
|
function readInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32LE(offset);
|
|
}
|
|
function readUInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32BE(offset);
|
|
}
|
|
function readUInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32LE(offset);
|
|
}
|
|
function writeDoubleBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleBE(value, offset);
|
|
}
|
|
function writeDoubleLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleLE(value, offset);
|
|
}
|
|
function writeFloatBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatBE(value, offset);
|
|
}
|
|
function writeFloatLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatLE(value, offset);
|
|
}
|
|
function writeInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32BE(value, offset);
|
|
}
|
|
function writeInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32LE(value, offset);
|
|
}
|
|
function writeUInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32BE(value, offset);
|
|
}
|
|
function writeUInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32LE(value, offset);
|
|
}
|
|
module.exports = {
|
|
isBuffer,
|
|
isEncoding,
|
|
alloc,
|
|
allocUnsafe,
|
|
allocUnsafeSlow,
|
|
byteLength,
|
|
compare,
|
|
concat,
|
|
copy,
|
|
equals,
|
|
fill,
|
|
from,
|
|
includes,
|
|
indexOf,
|
|
lastIndexOf,
|
|
swap16,
|
|
swap32,
|
|
swap64,
|
|
toBuffer,
|
|
toString,
|
|
write,
|
|
readDoubleBE,
|
|
readDoubleLE,
|
|
readFloatBE,
|
|
readFloatLE,
|
|
readInt32BE,
|
|
readInt32LE,
|
|
readUInt32BE,
|
|
readUInt32LE,
|
|
writeDoubleBE,
|
|
writeDoubleLE,
|
|
writeFloatBE,
|
|
writeFloatLE,
|
|
writeInt32BE,
|
|
writeInt32LE,
|
|
writeUInt32BE,
|
|
writeUInt32LE
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/text-decoder/lib/pass-through-decoder.js
|
|
var require_pass_through_decoder2 = __commonJS({
|
|
"../../node_modules/text-decoder/lib/pass-through-decoder.js"(exports, module) {
|
|
var b4a = require_b4a();
|
|
module.exports = class PassThroughDecoder {
|
|
constructor(encoding) {
|
|
this.encoding = encoding;
|
|
}
|
|
get remaining() {
|
|
return 0;
|
|
}
|
|
decode(data) {
|
|
return b4a.toString(data, this.encoding);
|
|
}
|
|
flush() {
|
|
return "";
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/text-decoder/lib/utf8-decoder.js
|
|
var require_utf8_decoder2 = __commonJS({
|
|
"../../node_modules/text-decoder/lib/utf8-decoder.js"(exports, module) {
|
|
var b4a = require_b4a();
|
|
module.exports = class UTF8Decoder {
|
|
constructor() {
|
|
this._reset();
|
|
}
|
|
get remaining() {
|
|
return this.bytesSeen;
|
|
}
|
|
decode(data) {
|
|
if (data.byteLength === 0) return "";
|
|
if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) {
|
|
this.bytesSeen = trailingBytesSeen(data);
|
|
return b4a.toString(data, "utf8");
|
|
}
|
|
let result = "";
|
|
let start = 0;
|
|
if (this.bytesNeeded > 0) {
|
|
while (start < data.byteLength) {
|
|
const byte = data[start];
|
|
if (byte < this.lowerBoundary || byte > this.upperBoundary) {
|
|
result += "\uFFFD";
|
|
this._reset();
|
|
break;
|
|
}
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
this.codePoint = this.codePoint << 6 | byte & 63;
|
|
this.bytesSeen++;
|
|
start++;
|
|
if (this.bytesSeen === this.bytesNeeded) {
|
|
result += String.fromCodePoint(this.codePoint);
|
|
this._reset();
|
|
break;
|
|
}
|
|
}
|
|
if (this.bytesNeeded > 0) return result;
|
|
}
|
|
const trailing = trailingIncomplete(data, start);
|
|
const end = data.byteLength - trailing;
|
|
if (end > start) result += b4a.toString(data, "utf8", start, end);
|
|
for (let i = end; i < data.byteLength; i++) {
|
|
const byte = data[i];
|
|
if (this.bytesNeeded === 0) {
|
|
if (byte <= 127) {
|
|
this.bytesSeen = 0;
|
|
result += String.fromCharCode(byte);
|
|
} else if (byte >= 194 && byte <= 223) {
|
|
this.bytesNeeded = 2;
|
|
this.bytesSeen = 1;
|
|
this.codePoint = byte & 31;
|
|
} else if (byte >= 224 && byte <= 239) {
|
|
if (byte === 224) this.lowerBoundary = 160;
|
|
else if (byte === 237) this.upperBoundary = 159;
|
|
this.bytesNeeded = 3;
|
|
this.bytesSeen = 1;
|
|
this.codePoint = byte & 15;
|
|
} else if (byte >= 240 && byte <= 244) {
|
|
if (byte === 240) this.lowerBoundary = 144;
|
|
else if (byte === 244) this.upperBoundary = 143;
|
|
this.bytesNeeded = 4;
|
|
this.bytesSeen = 1;
|
|
this.codePoint = byte & 7;
|
|
} else {
|
|
this.bytesSeen = 1;
|
|
result += "\uFFFD";
|
|
}
|
|
continue;
|
|
}
|
|
if (byte < this.lowerBoundary || byte > this.upperBoundary) {
|
|
result += "\uFFFD";
|
|
i--;
|
|
this._reset();
|
|
continue;
|
|
}
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
this.codePoint = this.codePoint << 6 | byte & 63;
|
|
this.bytesSeen++;
|
|
if (this.bytesSeen === this.bytesNeeded) {
|
|
result += String.fromCodePoint(this.codePoint);
|
|
this._reset();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
flush() {
|
|
const result = this.bytesNeeded > 0 ? "\uFFFD" : "";
|
|
this._reset();
|
|
return result;
|
|
}
|
|
_reset() {
|
|
this.codePoint = 0;
|
|
this.bytesNeeded = 0;
|
|
this.bytesSeen = 0;
|
|
this.lowerBoundary = 128;
|
|
this.upperBoundary = 191;
|
|
}
|
|
};
|
|
function trailingIncomplete(data, start) {
|
|
const len = data.byteLength;
|
|
if (len <= start) return 0;
|
|
const limit = Math.max(start, len - 4);
|
|
let i = len - 1;
|
|
while (i > limit && (data[i] & 192) === 128) i--;
|
|
if (i < start) return 0;
|
|
const byte = data[i];
|
|
let needed;
|
|
if (byte <= 127) return 0;
|
|
if (byte >= 194 && byte <= 223) needed = 2;
|
|
else if (byte >= 224 && byte <= 239) needed = 3;
|
|
else if (byte >= 240 && byte <= 244) needed = 4;
|
|
else return 0;
|
|
const available = len - i;
|
|
return available < needed ? available : 0;
|
|
}
|
|
function trailingBytesSeen(data) {
|
|
const len = data.byteLength;
|
|
if (len === 0) return 0;
|
|
const last = data[len - 1];
|
|
if (last <= 127) return 0;
|
|
if ((last & 192) !== 128) return 1;
|
|
const limit = Math.max(0, len - 4);
|
|
let i = len - 2;
|
|
while (i >= limit && (data[i] & 192) === 128) i--;
|
|
if (i < 0) return 1;
|
|
const first = data[i];
|
|
let needed;
|
|
if (first >= 194 && first <= 223) needed = 2;
|
|
else if (first >= 224 && first <= 239) needed = 3;
|
|
else if (first >= 240 && first <= 244) needed = 4;
|
|
else return 1;
|
|
if (len - i !== needed) return 1;
|
|
if (needed >= 3) {
|
|
const second = data[i + 1];
|
|
if (first === 224 && second < 160) return 1;
|
|
if (first === 237 && second > 159) return 1;
|
|
if (first === 240 && second < 144) return 1;
|
|
if (first === 244 && second > 143) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/text-decoder/index.js
|
|
var require_text_decoder = __commonJS({
|
|
"../../node_modules/text-decoder/index.js"(exports, module) {
|
|
var PassThroughDecoder = require_pass_through_decoder2();
|
|
var UTF8Decoder = require_utf8_decoder2();
|
|
module.exports = class TextDecoder {
|
|
constructor(encoding = "utf8") {
|
|
this.encoding = normalizeEncoding(encoding);
|
|
switch (this.encoding) {
|
|
case "utf8":
|
|
this.decoder = new UTF8Decoder();
|
|
break;
|
|
case "utf16le":
|
|
case "base64":
|
|
throw new Error("Unsupported encoding: " + this.encoding);
|
|
default:
|
|
this.decoder = new PassThroughDecoder(this.encoding);
|
|
}
|
|
}
|
|
get remaining() {
|
|
return this.decoder.remaining;
|
|
}
|
|
push(data) {
|
|
if (typeof data === "string") return data;
|
|
return this.decoder.decode(data);
|
|
}
|
|
// For Node.js compatibility
|
|
write(data) {
|
|
return this.push(data);
|
|
}
|
|
end(data) {
|
|
let result = "";
|
|
if (data) result = this.push(data);
|
|
result += this.decoder.flush();
|
|
return result;
|
|
}
|
|
};
|
|
function normalizeEncoding(encoding) {
|
|
encoding = encoding.toLowerCase();
|
|
switch (encoding) {
|
|
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 encoding;
|
|
default:
|
|
throw new Error("Unknown encoding: " + encoding);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/streamx/index.js
|
|
var require_streamx = __commonJS({
|
|
"../../node_modules/streamx/index.js"(exports, module) {
|
|
var { EventEmitter } = require_default();
|
|
var STREAM_DESTROYED = new Error("Stream was destroyed");
|
|
var PREMATURE_CLOSE = new Error("Premature close");
|
|
var FIFO = require_fast_fifo();
|
|
var TextDecoder = require_text_decoder();
|
|
var qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask;
|
|
var MAX = (1 << 29) - 1;
|
|
var OPENING = 1;
|
|
var PREDESTROYING = 2;
|
|
var DESTROYING = 4;
|
|
var DESTROYED = 8;
|
|
var NOT_OPENING = MAX ^ OPENING;
|
|
var NOT_PREDESTROYING = MAX ^ PREDESTROYING;
|
|
var READ_ACTIVE = 1 << 4;
|
|
var READ_UPDATING = 2 << 4;
|
|
var READ_PRIMARY = 4 << 4;
|
|
var READ_QUEUED = 8 << 4;
|
|
var READ_RESUMED = 16 << 4;
|
|
var READ_PIPE_DRAINED = 32 << 4;
|
|
var READ_ENDING = 64 << 4;
|
|
var READ_EMIT_DATA = 128 << 4;
|
|
var READ_EMIT_READABLE = 256 << 4;
|
|
var READ_EMITTED_READABLE = 512 << 4;
|
|
var READ_DONE = 1024 << 4;
|
|
var READ_NEXT_TICK = 2048 << 4;
|
|
var READ_NEEDS_PUSH = 4096 << 4;
|
|
var READ_READ_AHEAD = 8192 << 4;
|
|
var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
|
|
var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH;
|
|
var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
|
|
var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
|
|
var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD;
|
|
var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
|
|
var READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
|
|
var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
|
|
var READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
|
|
var READ_PAUSED = MAX ^ READ_RESUMED;
|
|
var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
|
|
var READ_NOT_ENDING = MAX ^ READ_ENDING;
|
|
var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
|
|
var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
|
|
var READ_NOT_UPDATING = MAX ^ READ_UPDATING;
|
|
var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD;
|
|
var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD;
|
|
var WRITE_ACTIVE = 1 << 18;
|
|
var WRITE_UPDATING = 2 << 18;
|
|
var WRITE_PRIMARY = 4 << 18;
|
|
var WRITE_QUEUED = 8 << 18;
|
|
var WRITE_UNDRAINED = 16 << 18;
|
|
var WRITE_DONE = 32 << 18;
|
|
var WRITE_EMIT_DRAIN = 64 << 18;
|
|
var WRITE_NEXT_TICK = 128 << 18;
|
|
var WRITE_WRITING = 256 << 18;
|
|
var WRITE_FINISHING = 512 << 18;
|
|
var WRITE_CORKED = 1024 << 18;
|
|
var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING);
|
|
var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
|
|
var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING);
|
|
var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
|
|
var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
|
|
var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
|
|
var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING;
|
|
var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED;
|
|
var ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
|
|
var NOT_ACTIVE = MAX ^ ACTIVE;
|
|
var DONE = READ_DONE | WRITE_DONE;
|
|
var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
|
|
var OPEN_STATUS = DESTROY_STATUS | OPENING;
|
|
var AUTO_DESTROY = DESTROY_STATUS | DONE;
|
|
var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
|
|
var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
|
|
var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
|
|
var IS_OPENING = OPEN_STATUS | TICKING;
|
|
var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
|
|
var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
|
|
var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
|
|
var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
|
|
var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD;
|
|
var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
|
|
var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY;
|
|
var READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING;
|
|
var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
|
|
var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
|
|
var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
|
|
var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
|
|
var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED;
|
|
var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
|
|
var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING;
|
|
var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
|
|
var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
|
|
var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
|
|
var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS;
|
|
var asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
|
|
var WritableState = class {
|
|
constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
|
|
this.stream = stream;
|
|
this.queue = new FIFO();
|
|
this.highWaterMark = highWaterMark;
|
|
this.buffered = 0;
|
|
this.error = null;
|
|
this.pipeline = null;
|
|
this.drains = null;
|
|
this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
|
|
this.map = mapWritable || map;
|
|
this.afterWrite = afterWrite.bind(this);
|
|
this.afterUpdateNextTick = updateWriteNT.bind(this);
|
|
}
|
|
get ending() {
|
|
return (this.stream._duplexState & WRITE_FINISHING) !== 0;
|
|
}
|
|
get ended() {
|
|
return (this.stream._duplexState & WRITE_DONE) !== 0;
|
|
}
|
|
push(data) {
|
|
if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false;
|
|
if (this.map !== null) data = this.map(data);
|
|
this.buffered += this.byteLength(data);
|
|
this.queue.push(data);
|
|
if (this.buffered < this.highWaterMark) {
|
|
this.stream._duplexState |= WRITE_QUEUED;
|
|
return true;
|
|
}
|
|
this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
|
|
return false;
|
|
}
|
|
shift() {
|
|
const data = this.queue.shift();
|
|
this.buffered -= this.byteLength(data);
|
|
if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED;
|
|
return data;
|
|
}
|
|
end(data) {
|
|
if (typeof data === "function") this.stream.once("finish", data);
|
|
else if (data !== void 0 && data !== null) this.push(data);
|
|
this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
|
|
}
|
|
autoBatch(data, cb) {
|
|
const buffer = [];
|
|
const stream = this.stream;
|
|
buffer.push(data);
|
|
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
|
|
buffer.push(stream._writableState.shift());
|
|
}
|
|
if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null);
|
|
stream._writev(buffer, cb);
|
|
}
|
|
update() {
|
|
const stream = this.stream;
|
|
stream._duplexState |= WRITE_UPDATING;
|
|
do {
|
|
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
|
|
const data = this.shift();
|
|
stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
|
|
stream._write(data, this.afterWrite);
|
|
}
|
|
if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
|
|
} while (this.continueUpdate() === true);
|
|
stream._duplexState &= WRITE_NOT_UPDATING;
|
|
}
|
|
updateNonPrimary() {
|
|
const stream = this.stream;
|
|
if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
|
|
stream._duplexState = stream._duplexState | WRITE_ACTIVE;
|
|
stream._final(afterFinal.bind(this));
|
|
return;
|
|
}
|
|
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
|
|
if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
|
|
stream._duplexState |= ACTIVE;
|
|
stream._destroy(afterDestroy.bind(this));
|
|
}
|
|
return;
|
|
}
|
|
if ((stream._duplexState & IS_OPENING) === OPENING) {
|
|
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
|
|
stream._open(afterOpen.bind(this));
|
|
}
|
|
}
|
|
continueUpdate() {
|
|
if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false;
|
|
this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
|
|
return true;
|
|
}
|
|
updateCallback() {
|
|
if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update();
|
|
else this.updateNextTick();
|
|
}
|
|
updateNextTick() {
|
|
if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
|
|
this.stream._duplexState |= WRITE_NEXT_TICK;
|
|
if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick);
|
|
}
|
|
};
|
|
var ReadableState = class {
|
|
constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
|
|
this.stream = stream;
|
|
this.queue = new FIFO();
|
|
this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
|
|
this.buffered = 0;
|
|
this.readAhead = highWaterMark > 0;
|
|
this.error = null;
|
|
this.pipeline = null;
|
|
this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
|
|
this.map = mapReadable || map;
|
|
this.pipeTo = null;
|
|
this.afterRead = afterRead.bind(this);
|
|
this.afterUpdateNextTick = updateReadNT.bind(this);
|
|
}
|
|
get ending() {
|
|
return (this.stream._duplexState & READ_ENDING) !== 0;
|
|
}
|
|
get ended() {
|
|
return (this.stream._duplexState & READ_DONE) !== 0;
|
|
}
|
|
pipe(pipeTo, cb) {
|
|
if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
|
|
if (typeof cb !== "function") cb = null;
|
|
this.stream._duplexState |= READ_PIPE_DRAINED;
|
|
this.pipeTo = pipeTo;
|
|
this.pipeline = new Pipeline(this.stream, pipeTo, cb);
|
|
if (cb) this.stream.on("error", noop);
|
|
if (isStreamx(pipeTo)) {
|
|
pipeTo._writableState.pipeline = this.pipeline;
|
|
if (cb) pipeTo.on("error", noop);
|
|
pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
|
|
} else {
|
|
const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
|
|
const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
|
|
pipeTo.on("error", onerror);
|
|
pipeTo.on("close", onclose);
|
|
pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
|
|
}
|
|
pipeTo.on("drain", afterDrain.bind(this));
|
|
this.stream.emit("piping", pipeTo);
|
|
pipeTo.emit("pipe", this.stream);
|
|
}
|
|
push(data) {
|
|
const stream = this.stream;
|
|
if (data === null) {
|
|
this.highWaterMark = 0;
|
|
stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
|
|
return false;
|
|
}
|
|
if (this.map !== null) {
|
|
data = this.map(data);
|
|
if (data === null) {
|
|
stream._duplexState &= READ_PUSHED;
|
|
return this.buffered < this.highWaterMark;
|
|
}
|
|
}
|
|
this.buffered += this.byteLength(data);
|
|
this.queue.push(data);
|
|
stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
|
|
return this.buffered < this.highWaterMark;
|
|
}
|
|
shift() {
|
|
const data = this.queue.shift();
|
|
this.buffered -= this.byteLength(data);
|
|
if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
|
|
return data;
|
|
}
|
|
unshift(data) {
|
|
const pending = [this.map !== null ? this.map(data) : data];
|
|
while (this.buffered > 0) pending.push(this.shift());
|
|
for (let i = 0; i < pending.length - 1; i++) {
|
|
const data2 = pending[i];
|
|
this.buffered += this.byteLength(data2);
|
|
this.queue.push(data2);
|
|
}
|
|
this.push(pending[pending.length - 1]);
|
|
}
|
|
read() {
|
|
const stream = this.stream;
|
|
if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
|
|
const data = this.shift();
|
|
if (this.pipeTo !== null && this.pipeTo.write(data) === false)
|
|
stream._duplexState &= READ_PIPE_NOT_DRAINED;
|
|
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
|
|
return data;
|
|
}
|
|
if (this.readAhead === false) {
|
|
stream._duplexState |= READ_READ_AHEAD;
|
|
this.updateNextTick();
|
|
}
|
|
return null;
|
|
}
|
|
drain() {
|
|
const stream = this.stream;
|
|
while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
|
|
const data = this.shift();
|
|
if (this.pipeTo !== null && this.pipeTo.write(data) === false)
|
|
stream._duplexState &= READ_PIPE_NOT_DRAINED;
|
|
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
|
|
}
|
|
}
|
|
update() {
|
|
const stream = this.stream;
|
|
stream._duplexState |= READ_UPDATING;
|
|
do {
|
|
this.drain();
|
|
while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {
|
|
stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
|
|
stream._read(this.afterRead);
|
|
this.drain();
|
|
}
|
|
if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
|
|
stream._duplexState |= READ_EMITTED_READABLE;
|
|
stream.emit("readable");
|
|
}
|
|
if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
|
|
} while (this.continueUpdate() === true);
|
|
stream._duplexState &= READ_NOT_UPDATING;
|
|
}
|
|
updateNonPrimary() {
|
|
const stream = this.stream;
|
|
if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
|
|
stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
|
|
stream.emit("end");
|
|
if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
|
|
if (this.pipeTo !== null) this.pipeTo.end();
|
|
}
|
|
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
|
|
if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
|
|
stream._duplexState |= ACTIVE;
|
|
stream._destroy(afterDestroy.bind(this));
|
|
}
|
|
return;
|
|
}
|
|
if ((stream._duplexState & IS_OPENING) === OPENING) {
|
|
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
|
|
stream._open(afterOpen.bind(this));
|
|
}
|
|
}
|
|
continueUpdate() {
|
|
if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false;
|
|
this.stream._duplexState &= READ_NOT_NEXT_TICK;
|
|
return true;
|
|
}
|
|
updateCallback() {
|
|
if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update();
|
|
else this.updateNextTick();
|
|
}
|
|
updateNextTickIfOpen() {
|
|
if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return;
|
|
this.stream._duplexState |= READ_NEXT_TICK;
|
|
if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
|
|
}
|
|
updateNextTick() {
|
|
if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return;
|
|
this.stream._duplexState |= READ_NEXT_TICK;
|
|
if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
|
|
}
|
|
};
|
|
var TransformState = class {
|
|
constructor(stream) {
|
|
this.data = null;
|
|
this.afterTransform = afterTransform.bind(stream);
|
|
this.afterFinal = null;
|
|
}
|
|
};
|
|
var Pipeline = class {
|
|
constructor(src, dst, cb) {
|
|
this.from = src;
|
|
this.to = dst;
|
|
this.afterPipe = cb;
|
|
this.error = null;
|
|
this.pipeToFinished = false;
|
|
}
|
|
finished() {
|
|
this.pipeToFinished = true;
|
|
}
|
|
done(stream, err) {
|
|
if (err) this.error = err;
|
|
if (stream === this.to) {
|
|
this.to = null;
|
|
if (this.from !== null) {
|
|
if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
|
|
this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (stream === this.from) {
|
|
this.from = null;
|
|
if (this.to !== null) {
|
|
if ((stream._duplexState & READ_DONE) === 0) {
|
|
this.to.destroy(this.error || new Error("Readable stream closed before ending"));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (this.afterPipe !== null) this.afterPipe(this.error);
|
|
this.to = this.from = this.afterPipe = null;
|
|
}
|
|
};
|
|
function afterDrain() {
|
|
this.stream._duplexState |= READ_PIPE_DRAINED;
|
|
this.updateCallback();
|
|
}
|
|
function afterFinal(err) {
|
|
const stream = this.stream;
|
|
if (err) stream.destroy(err);
|
|
if ((stream._duplexState & DESTROY_STATUS) === 0) {
|
|
stream._duplexState |= WRITE_DONE;
|
|
stream.emit("finish");
|
|
}
|
|
if ((stream._duplexState & AUTO_DESTROY) === DONE) {
|
|
stream._duplexState |= DESTROYING;
|
|
}
|
|
stream._duplexState &= WRITE_NOT_FINISHING;
|
|
if ((stream._duplexState & WRITE_UPDATING) === 0) this.update();
|
|
else this.updateNextTick();
|
|
}
|
|
function afterDestroy(err) {
|
|
const stream = this.stream;
|
|
if (!err && this.error !== STREAM_DESTROYED) err = this.error;
|
|
if (err) stream.emit("error", err);
|
|
stream._duplexState |= DESTROYED;
|
|
stream.emit("close");
|
|
const rs = stream._readableState;
|
|
const ws = stream._writableState;
|
|
if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
|
|
if (ws !== null) {
|
|
while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false);
|
|
if (ws.pipeline !== null) ws.pipeline.done(stream, err);
|
|
}
|
|
}
|
|
function afterWrite(err) {
|
|
const stream = this.stream;
|
|
if (err) stream.destroy(err);
|
|
stream._duplexState &= WRITE_NOT_ACTIVE;
|
|
if (this.drains !== null) tickDrains(this.drains);
|
|
if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
|
|
stream._duplexState &= WRITE_DRAINED;
|
|
if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
|
|
stream.emit("drain");
|
|
}
|
|
}
|
|
this.updateCallback();
|
|
}
|
|
function afterRead(err) {
|
|
if (err) this.stream.destroy(err);
|
|
this.stream._duplexState &= READ_NOT_ACTIVE;
|
|
if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0)
|
|
this.stream._duplexState &= READ_NO_READ_AHEAD;
|
|
this.updateCallback();
|
|
}
|
|
function updateReadNT() {
|
|
if ((this.stream._duplexState & READ_UPDATING) === 0) {
|
|
this.stream._duplexState &= READ_NOT_NEXT_TICK;
|
|
this.update();
|
|
}
|
|
}
|
|
function updateWriteNT() {
|
|
if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
|
|
this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
|
|
this.update();
|
|
}
|
|
}
|
|
function tickDrains(drains) {
|
|
for (let i = 0; i < drains.length; i++) {
|
|
if (--drains[i].writes === 0) {
|
|
drains.shift().resolve(true);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
function afterOpen(err) {
|
|
const stream = this.stream;
|
|
if (err) stream.destroy(err);
|
|
if ((stream._duplexState & DESTROYING) === 0) {
|
|
if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
|
|
if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
|
|
stream.emit("open");
|
|
}
|
|
stream._duplexState &= NOT_ACTIVE;
|
|
if (stream._writableState !== null) {
|
|
stream._writableState.updateCallback();
|
|
}
|
|
if (stream._readableState !== null) {
|
|
stream._readableState.updateCallback();
|
|
}
|
|
}
|
|
function afterTransform(err, data) {
|
|
if (data !== void 0 && data !== null) this.push(data);
|
|
this._writableState.afterWrite(err);
|
|
}
|
|
function newListener(name) {
|
|
if (this._readableState !== null) {
|
|
if (name === "data") {
|
|
this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD;
|
|
this._readableState.updateNextTick();
|
|
}
|
|
if (name === "readable") {
|
|
this._duplexState |= READ_EMIT_READABLE;
|
|
this._readableState.updateNextTick();
|
|
}
|
|
}
|
|
if (this._writableState !== null) {
|
|
if (name === "drain") {
|
|
this._duplexState |= WRITE_EMIT_DRAIN;
|
|
this._writableState.updateNextTick();
|
|
}
|
|
}
|
|
}
|
|
var Stream = class extends EventEmitter {
|
|
constructor(opts) {
|
|
super();
|
|
this._duplexState = 0;
|
|
this._readableState = null;
|
|
this._writableState = null;
|
|
if (opts) {
|
|
if (opts.open) this._open = opts.open;
|
|
if (opts.destroy) this._destroy = opts.destroy;
|
|
if (opts.predestroy) this._predestroy = opts.predestroy;
|
|
if (opts.signal) {
|
|
opts.signal.addEventListener("abort", abort.bind(this));
|
|
}
|
|
}
|
|
this.on("newListener", newListener);
|
|
}
|
|
_open(cb) {
|
|
cb(null);
|
|
}
|
|
_destroy(cb) {
|
|
cb(null);
|
|
}
|
|
_predestroy() {
|
|
}
|
|
get readable() {
|
|
return this._readableState !== null ? true : void 0;
|
|
}
|
|
get writable() {
|
|
return this._writableState !== null ? true : void 0;
|
|
}
|
|
get destroyed() {
|
|
return (this._duplexState & DESTROYED) !== 0;
|
|
}
|
|
get destroying() {
|
|
return (this._duplexState & DESTROY_STATUS) !== 0;
|
|
}
|
|
destroy(err) {
|
|
if ((this._duplexState & DESTROY_STATUS) === 0) {
|
|
if (!err) err = STREAM_DESTROYED;
|
|
this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
|
|
if (this._readableState !== null) {
|
|
this._readableState.highWaterMark = 0;
|
|
this._readableState.error = err;
|
|
}
|
|
if (this._writableState !== null) {
|
|
this._writableState.highWaterMark = 0;
|
|
this._writableState.error = err;
|
|
}
|
|
this._duplexState |= PREDESTROYING;
|
|
this._predestroy();
|
|
this._duplexState &= NOT_PREDESTROYING;
|
|
if (this._readableState !== null) this._readableState.updateNextTick();
|
|
if (this._writableState !== null) this._writableState.updateNextTick();
|
|
}
|
|
}
|
|
};
|
|
var Readable = class _Readable extends Stream {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD;
|
|
this._readableState = new ReadableState(this, opts);
|
|
if (opts) {
|
|
if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD;
|
|
if (opts.read) this._read = opts.read;
|
|
if (opts.eagerOpen) this._readableState.updateNextTick();
|
|
if (opts.encoding) this.setEncoding(opts.encoding);
|
|
}
|
|
}
|
|
setEncoding(encoding) {
|
|
const dec = new TextDecoder(encoding);
|
|
const map = this._readableState.map || echo;
|
|
this._readableState.map = mapOrSkip;
|
|
return this;
|
|
function mapOrSkip(data) {
|
|
const next = dec.push(data);
|
|
return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
|
|
}
|
|
}
|
|
_read(cb) {
|
|
cb(null);
|
|
}
|
|
pipe(dest, cb) {
|
|
this._readableState.updateNextTick();
|
|
this._readableState.pipe(dest, cb);
|
|
return dest;
|
|
}
|
|
read() {
|
|
this._readableState.updateNextTick();
|
|
return this._readableState.read();
|
|
}
|
|
push(data) {
|
|
this._readableState.updateNextTickIfOpen();
|
|
return this._readableState.push(data);
|
|
}
|
|
unshift(data) {
|
|
this._readableState.updateNextTickIfOpen();
|
|
return this._readableState.unshift(data);
|
|
}
|
|
resume() {
|
|
this._duplexState |= READ_RESUMED_READ_AHEAD;
|
|
this._readableState.updateNextTick();
|
|
return this;
|
|
}
|
|
pause() {
|
|
this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED;
|
|
return this;
|
|
}
|
|
static _fromAsyncIterator(ite, opts) {
|
|
let destroy;
|
|
const rs = new _Readable({
|
|
...opts,
|
|
read(cb) {
|
|
ite.next().then(push).then(cb.bind(null, null)).catch(cb);
|
|
},
|
|
predestroy() {
|
|
destroy = ite.return();
|
|
},
|
|
destroy(cb) {
|
|
if (!destroy) return cb(null);
|
|
destroy.then(cb.bind(null, null)).catch(cb);
|
|
}
|
|
});
|
|
return rs;
|
|
function push(data) {
|
|
if (data.done) rs.push(null);
|
|
else rs.push(data.value);
|
|
}
|
|
}
|
|
static from(data, opts) {
|
|
if (isReadStreamx(data)) return data;
|
|
if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts);
|
|
if (!Array.isArray(data)) data = data === void 0 ? [] : [data];
|
|
let i = 0;
|
|
return new _Readable({
|
|
...opts,
|
|
read(cb) {
|
|
this.push(i === data.length ? null : data[i++]);
|
|
cb(null);
|
|
}
|
|
});
|
|
}
|
|
static isBackpressured(rs) {
|
|
return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
|
|
}
|
|
static isPaused(rs) {
|
|
return (rs._duplexState & READ_RESUMED) === 0;
|
|
}
|
|
[asyncIterator]() {
|
|
const stream = this;
|
|
let error = null;
|
|
let promiseResolve = null;
|
|
let promiseReject = null;
|
|
this.on("error", (err) => {
|
|
error = err;
|
|
});
|
|
this.on("readable", onreadable);
|
|
this.on("close", onclose);
|
|
return {
|
|
[asyncIterator]() {
|
|
return this;
|
|
},
|
|
next() {
|
|
return new Promise(function(resolve, reject) {
|
|
promiseResolve = resolve;
|
|
promiseReject = reject;
|
|
const data = stream.read();
|
|
if (data !== null) ondata(data);
|
|
else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
|
|
});
|
|
},
|
|
return() {
|
|
return destroy(null);
|
|
},
|
|
throw(err) {
|
|
return destroy(err);
|
|
}
|
|
};
|
|
function onreadable() {
|
|
if (promiseResolve !== null) ondata(stream.read());
|
|
}
|
|
function onclose() {
|
|
if (promiseResolve !== null) ondata(null);
|
|
}
|
|
function ondata(data) {
|
|
if (promiseReject === null) return;
|
|
if (error) promiseReject(error);
|
|
else if (data === null && (stream._duplexState & READ_DONE) === 0)
|
|
promiseReject(STREAM_DESTROYED);
|
|
else promiseResolve({ value: data, done: data === null });
|
|
promiseReject = promiseResolve = null;
|
|
}
|
|
function destroy(err) {
|
|
stream.destroy(err);
|
|
return new Promise((resolve, reject) => {
|
|
if (stream._duplexState & DESTROYED) return resolve({ value: void 0, done: true });
|
|
stream.once("close", function() {
|
|
if (err) reject(err);
|
|
else resolve({ value: void 0, done: true });
|
|
});
|
|
});
|
|
}
|
|
}
|
|
};
|
|
var Writable = class extends Stream {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._duplexState |= OPENING | READ_DONE;
|
|
this._writableState = new WritableState(this, opts);
|
|
if (opts) {
|
|
if (opts.writev) this._writev = opts.writev;
|
|
if (opts.write) this._write = opts.write;
|
|
if (opts.final) this._final = opts.final;
|
|
if (opts.eagerOpen) this._writableState.updateNextTick();
|
|
}
|
|
}
|
|
cork() {
|
|
this._duplexState |= WRITE_CORKED;
|
|
}
|
|
uncork() {
|
|
this._duplexState &= WRITE_NOT_CORKED;
|
|
this._writableState.updateNextTick();
|
|
}
|
|
_writev(batch, cb) {
|
|
cb(null);
|
|
}
|
|
_write(data, cb) {
|
|
this._writableState.autoBatch(data, cb);
|
|
}
|
|
_final(cb) {
|
|
cb(null);
|
|
}
|
|
static isBackpressured(ws) {
|
|
return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
|
|
}
|
|
static drained(ws) {
|
|
if (ws.destroyed) return Promise.resolve(false);
|
|
const state = ws._writableState;
|
|
const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length;
|
|
const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
|
|
if (writes === 0) return Promise.resolve(true);
|
|
if (state.drains === null) state.drains = [];
|
|
return new Promise((resolve) => {
|
|
state.drains.push({ writes, resolve });
|
|
});
|
|
}
|
|
write(data) {
|
|
this._writableState.updateNextTick();
|
|
return this._writableState.push(data);
|
|
}
|
|
end(data) {
|
|
this._writableState.updateNextTick();
|
|
this._writableState.end(data);
|
|
return this;
|
|
}
|
|
};
|
|
var Duplex = class extends Readable {
|
|
// and Writable
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD;
|
|
this._writableState = new WritableState(this, opts);
|
|
if (opts) {
|
|
if (opts.writev) this._writev = opts.writev;
|
|
if (opts.write) this._write = opts.write;
|
|
if (opts.final) this._final = opts.final;
|
|
}
|
|
}
|
|
cork() {
|
|
this._duplexState |= WRITE_CORKED;
|
|
}
|
|
uncork() {
|
|
this._duplexState &= WRITE_NOT_CORKED;
|
|
this._writableState.updateNextTick();
|
|
}
|
|
_writev(batch, cb) {
|
|
cb(null);
|
|
}
|
|
_write(data, cb) {
|
|
this._writableState.autoBatch(data, cb);
|
|
}
|
|
_final(cb) {
|
|
cb(null);
|
|
}
|
|
write(data) {
|
|
this._writableState.updateNextTick();
|
|
return this._writableState.push(data);
|
|
}
|
|
end(data) {
|
|
this._writableState.updateNextTick();
|
|
this._writableState.end(data);
|
|
return this;
|
|
}
|
|
};
|
|
var Transform = class extends Duplex {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._transformState = new TransformState(this);
|
|
if (opts) {
|
|
if (opts.transform) this._transform = opts.transform;
|
|
if (opts.flush) this._flush = opts.flush;
|
|
}
|
|
}
|
|
_write(data, cb) {
|
|
if (this._readableState.buffered >= this._readableState.highWaterMark) {
|
|
this._transformState.data = data;
|
|
} else {
|
|
this._transform(data, this._transformState.afterTransform);
|
|
}
|
|
}
|
|
_read(cb) {
|
|
if (this._transformState.data !== null) {
|
|
const data = this._transformState.data;
|
|
this._transformState.data = null;
|
|
cb(null);
|
|
this._transform(data, this._transformState.afterTransform);
|
|
} else {
|
|
cb(null);
|
|
}
|
|
}
|
|
destroy(err) {
|
|
super.destroy(err);
|
|
if (this._transformState.data !== null) {
|
|
this._transformState.data = null;
|
|
this._transformState.afterTransform();
|
|
}
|
|
}
|
|
_transform(data, cb) {
|
|
cb(null, data);
|
|
}
|
|
_flush(cb) {
|
|
cb(null);
|
|
}
|
|
_final(cb) {
|
|
this._transformState.afterFinal = cb;
|
|
this._flush(transformAfterFlush.bind(this));
|
|
}
|
|
};
|
|
var PassThrough = class extends Transform {
|
|
};
|
|
function transformAfterFlush(err, data) {
|
|
const cb = this._transformState.afterFinal;
|
|
if (err) return cb(err);
|
|
if (data !== null && data !== void 0) this.push(data);
|
|
this.push(null);
|
|
cb(null);
|
|
}
|
|
function pipelinePromise(...streams) {
|
|
return new Promise((resolve, reject) => {
|
|
return pipeline(...streams, (err) => {
|
|
if (err) return reject(err);
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
function pipeline(stream, ...streams) {
|
|
const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
|
|
const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
|
|
if (all.length < 2) throw new Error("Pipeline requires at least 2 streams");
|
|
let src = all[0];
|
|
let dest = null;
|
|
let error = null;
|
|
for (let i = 1; i < all.length; i++) {
|
|
dest = all[i];
|
|
if (isStreamx(src)) {
|
|
src.pipe(dest, onerror);
|
|
} else {
|
|
errorHandle(src, true, i > 1, onerror);
|
|
src.pipe(dest);
|
|
}
|
|
src = dest;
|
|
}
|
|
if (done) {
|
|
let fin = false;
|
|
const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
|
|
dest.on("error", (err) => {
|
|
if (error === null) error = err;
|
|
});
|
|
dest.on("finish", () => {
|
|
fin = true;
|
|
if (!autoDestroy) done(error);
|
|
});
|
|
if (autoDestroy) {
|
|
dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE)));
|
|
}
|
|
}
|
|
return dest;
|
|
function errorHandle(s, rd, wr, onerror2) {
|
|
s.on("error", onerror2);
|
|
s.on("close", onclose);
|
|
function onclose() {
|
|
if (rd && s._readableState && !s._readableState.ended) return onerror2(PREMATURE_CLOSE);
|
|
if (wr && s._writableState && !s._writableState.ended) return onerror2(PREMATURE_CLOSE);
|
|
}
|
|
}
|
|
function onerror(err) {
|
|
if (!err || error) return;
|
|
error = err;
|
|
for (const s of all) {
|
|
s.destroy(err);
|
|
}
|
|
}
|
|
}
|
|
function echo(s) {
|
|
return s;
|
|
}
|
|
function isStream(stream) {
|
|
return !!stream._readableState || !!stream._writableState;
|
|
}
|
|
function isStreamx(stream) {
|
|
return typeof stream._duplexState === "number" && isStream(stream);
|
|
}
|
|
function isEnding(stream) {
|
|
return !!stream._readableState && stream._readableState.ending;
|
|
}
|
|
function isEnded(stream) {
|
|
return !!stream._readableState && stream._readableState.ended;
|
|
}
|
|
function isFinishing(stream) {
|
|
return !!stream._writableState && stream._writableState.ending;
|
|
}
|
|
function isFinished(stream) {
|
|
return !!stream._writableState && stream._writableState.ended;
|
|
}
|
|
function getStreamError(stream, opts = {}) {
|
|
const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
|
|
return !opts.all && err === STREAM_DESTROYED ? null : err;
|
|
}
|
|
function isReadStreamx(stream) {
|
|
return isStreamx(stream) && stream.readable;
|
|
}
|
|
function isDisturbed(stream) {
|
|
return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
|
|
}
|
|
function isTypedArray(data) {
|
|
return typeof data === "object" && data !== null && typeof data.byteLength === "number";
|
|
}
|
|
function defaultByteLength(data) {
|
|
return isTypedArray(data) ? data.byteLength : 1024;
|
|
}
|
|
function noop() {
|
|
}
|
|
function abort() {
|
|
this.destroy(new Error("Stream aborted."));
|
|
}
|
|
function isWritev(s) {
|
|
return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
|
|
}
|
|
module.exports = {
|
|
pipeline,
|
|
pipelinePromise,
|
|
isStream,
|
|
isStreamx,
|
|
isEnding,
|
|
isEnded,
|
|
isFinishing,
|
|
isFinished,
|
|
isDisturbed,
|
|
getStreamError,
|
|
Stream,
|
|
Writable,
|
|
Readable,
|
|
Duplex,
|
|
Transform,
|
|
// Export PassThrough for compatibility with Node.js core's stream module
|
|
PassThrough
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/teex/index.js
|
|
var require_teex = __commonJS({
|
|
"../../node_modules/teex/index.js"(exports, module) {
|
|
var { Readable } = require_streamx();
|
|
module.exports = function(s, forks = 2) {
|
|
const streams = new Array(forks);
|
|
const status = new Array(forks).fill(true);
|
|
let ended = false;
|
|
for (let i = 0; i < forks; i++) {
|
|
streams[i] = new Readable({
|
|
read(cb) {
|
|
const check = !status[i];
|
|
status[i] = true;
|
|
if (check && allReadable()) s.resume();
|
|
cb(null);
|
|
}
|
|
});
|
|
}
|
|
s.on("end", function() {
|
|
ended = true;
|
|
for (const stream of streams) stream.push(null);
|
|
});
|
|
s.on("error", function(err) {
|
|
for (const stream of streams) stream.destroy(err);
|
|
});
|
|
s.on("close", function() {
|
|
if (ended) return;
|
|
for (const stream of streams) stream.destroy();
|
|
});
|
|
s.on("data", function(data) {
|
|
let needsPause = false;
|
|
for (let i = 0; i < streams.length; i++) {
|
|
if (!(status[i] = streams[i].push(data))) {
|
|
needsPause = true;
|
|
}
|
|
}
|
|
if (needsPause) s.pause();
|
|
});
|
|
return streams;
|
|
function allReadable() {
|
|
for (let j = 0; j < status.length; j++) {
|
|
if (!status[j]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-stream/web.js
|
|
var require_web = __commonJS({
|
|
"../../node_modules/bare-stream/web.js"(exports) {
|
|
var { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require_streamx();
|
|
var tee = require_teex();
|
|
var readableKind = Symbol.for("bare.stream.readable.kind");
|
|
var writableKind = Symbol.for("bare.stream.writable.kind");
|
|
var transformKind = Symbol.for("bare.stream.transform.kind");
|
|
exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader {
|
|
constructor(stream) {
|
|
this._stream = stream;
|
|
this._stream._stream.once("close", onclose).once("error", onerror);
|
|
const closed = Promise.withResolvers();
|
|
closed.promise.catch(noop);
|
|
this._closed = closed;
|
|
function onclose() {
|
|
closed.resolve();
|
|
}
|
|
function onerror(err) {
|
|
closed.reject(err);
|
|
}
|
|
}
|
|
get closed() {
|
|
return this._closed.promise;
|
|
}
|
|
read() {
|
|
const stream = this._stream._stream;
|
|
return new Promise((resolve, reject) => {
|
|
const err = getStreamError(stream);
|
|
if (err) return reject(err);
|
|
if (stream.destroyed) {
|
|
return resolve({ value: void 0, done: true });
|
|
}
|
|
const value = stream.read();
|
|
if (value !== null) {
|
|
return resolve({ value, done: false });
|
|
}
|
|
stream.once("readable", onreadable).once("close", onclose).once("error", onerror);
|
|
function onreadable() {
|
|
const value2 = stream.read();
|
|
ondone(null, value2 === null ? { value: void 0, done: true } : { value: value2, done: false });
|
|
}
|
|
function onclose() {
|
|
ondone(null, { value: void 0, done: true });
|
|
}
|
|
function onerror(err2) {
|
|
ondone(err2, null);
|
|
}
|
|
function ondone(err2, value2) {
|
|
stream.off("readable", onreadable).off("close", onclose).off("error", onerror);
|
|
if (err2) reject(err2);
|
|
else resolve(value2);
|
|
}
|
|
});
|
|
}
|
|
releaseLock() {
|
|
this._closed.reject(new TypeError("Reader was released"));
|
|
this._stream._releaseLock();
|
|
this._stream = null;
|
|
}
|
|
cancel(reason = new TypeError("Stream was cancelled")) {
|
|
const stream = this._stream._stream;
|
|
if (stream.destroyed) return Promise.resolve();
|
|
return new Promise(
|
|
(resolve) => stream.once("close", resolve).once("error", noop).destroy(reason)
|
|
);
|
|
}
|
|
};
|
|
exports.ReadableStreamDefaultController = class ReadableStreamDefaultController {
|
|
constructor(stream) {
|
|
this._stream = stream;
|
|
}
|
|
get desiredSize() {
|
|
const stream = this._stream._stream;
|
|
return stream._readableState.highWaterMark - stream._readableState.buffered;
|
|
}
|
|
enqueue(data) {
|
|
this._stream._stream.push(data);
|
|
}
|
|
close() {
|
|
this._stream._stream.push(null);
|
|
}
|
|
error(err) {
|
|
this._stream._stream.destroy(err);
|
|
}
|
|
};
|
|
var ReadableStream = class _ReadableStream {
|
|
static get [readableKind]() {
|
|
return 0;
|
|
}
|
|
static from(iterable) {
|
|
return new _ReadableStream(Readable.from(iterable));
|
|
}
|
|
constructor(underlyingSource = {}, queuingStrategy) {
|
|
if (isStreamx(underlyingSource)) {
|
|
this._stream = underlyingSource;
|
|
} else {
|
|
if (queuingStrategy === void 0) {
|
|
queuingStrategy = new exports.CountQueuingStrategy();
|
|
}
|
|
const { start, pull, cancel } = underlyingSource;
|
|
const { highWaterMark = 1, size = defaultSize } = queuingStrategy;
|
|
this._stream = new Readable({ highWaterMark, byteLength: size });
|
|
const controller = new exports.ReadableStreamDefaultController(this);
|
|
if (start) {
|
|
this._stream._open = this._open.bind(this, start.call(this, controller));
|
|
}
|
|
if (pull) {
|
|
this._stream._read = this._read.bind(this, pull.bind(this, controller));
|
|
}
|
|
if (cancel) {
|
|
this._stream.once("error", cancel);
|
|
}
|
|
}
|
|
this._reader = null;
|
|
}
|
|
get [readableKind]() {
|
|
return _ReadableStream[readableKind];
|
|
}
|
|
get locked() {
|
|
return this._reader !== null;
|
|
}
|
|
getReader() {
|
|
if (this.locked) throw new TypeError("Stream is locked");
|
|
this._reader = new exports.ReadableStreamDefaultReader(this);
|
|
return this._reader;
|
|
}
|
|
cancel(reason = new TypeError("Stream was cancelled")) {
|
|
const stream = this._stream;
|
|
if (stream.destroyed) return Promise.resolve();
|
|
if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
|
|
return new Promise(
|
|
(resolve) => stream.once("close", resolve).once("error", noop).destroy(reason)
|
|
);
|
|
}
|
|
tee() {
|
|
const [a, b] = tee(this._stream);
|
|
return [new _ReadableStream(a), new _ReadableStream(b)];
|
|
}
|
|
pipeTo(destination) {
|
|
return new Promise(
|
|
(resolve, reject) => this._stream.pipe(destination._stream, (err) => {
|
|
err ? reject(err) : resolve();
|
|
})
|
|
);
|
|
}
|
|
[Symbol.asyncIterator]() {
|
|
return this._stream[Symbol.asyncIterator]();
|
|
}
|
|
_releaseLock() {
|
|
this._reader = null;
|
|
}
|
|
async _open(starting, cb) {
|
|
let err = null;
|
|
try {
|
|
await starting;
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _read(pull, cb) {
|
|
let err = null;
|
|
try {
|
|
await pull();
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
};
|
|
function defaultSize() {
|
|
return 1;
|
|
}
|
|
exports.ReadableStream = ReadableStream;
|
|
exports.CountQueuingStrategy = class CountQueuingStrategy {
|
|
constructor(opts = {}) {
|
|
const { highWaterMark = 1 } = opts;
|
|
this.highWaterMark = highWaterMark;
|
|
}
|
|
size(chunk) {
|
|
return 1;
|
|
}
|
|
};
|
|
exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy {
|
|
constructor(opts = {}) {
|
|
const { highWaterMark = 16384 } = opts;
|
|
this.highWaterMark = highWaterMark;
|
|
}
|
|
size(chunk) {
|
|
return chunk.byteLength;
|
|
}
|
|
};
|
|
exports.isReadableStream = function isReadableStream(value) {
|
|
if (value instanceof ReadableStream) return true;
|
|
return typeof value === "object" && value !== null && value[readableKind] === ReadableStream[readableKind];
|
|
};
|
|
exports.isReadableStreamErrored = function isReadableStreamErrored(stream) {
|
|
return getStreamError(stream._stream) !== null;
|
|
};
|
|
exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) {
|
|
return isDisturbed(stream._stream);
|
|
};
|
|
exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter {
|
|
constructor(stream) {
|
|
this._stream = stream;
|
|
this._stream._stream.once("close", onclose).once("error", onerror);
|
|
const closed = Promise.withResolvers();
|
|
closed.promise.catch(noop);
|
|
this._closed = closed;
|
|
function onclose() {
|
|
closed.resolve();
|
|
}
|
|
function onerror(err) {
|
|
closed.reject(err);
|
|
}
|
|
}
|
|
get desiredSize() {
|
|
const stream = this._stream._stream;
|
|
return stream._writableState.highWaterMark - stream._writableState.buffered;
|
|
}
|
|
get closed() {
|
|
return this._closed.promise;
|
|
}
|
|
get ready() {
|
|
const stream = this._stream._stream;
|
|
if (getStreamError(stream)) return Promise.reject();
|
|
return Writable.drained(stream).then();
|
|
}
|
|
async write(chunk) {
|
|
const stream = this._stream._stream;
|
|
let err = getStreamError(stream);
|
|
if (err) return Promise.reject(err);
|
|
stream.write(chunk);
|
|
await Writable.drained(stream);
|
|
err = getStreamError(stream);
|
|
if (err) return Promise.reject(err);
|
|
}
|
|
releaseLock() {
|
|
this._closed.reject(new TypeError("Writer was released"));
|
|
this._stream._releaseLock();
|
|
this._stream = null;
|
|
}
|
|
close() {
|
|
const stream = this._stream._stream;
|
|
if (stream.destroyed) return Promise.resolve();
|
|
return new Promise((resolve) => stream.once("close", resolve).end());
|
|
}
|
|
abort(reason = new TypeError("Stream was aborted")) {
|
|
const stream = this._stream._stream;
|
|
if (stream.destroyed) return Promise.resolve();
|
|
return new Promise((resolve) => stream.once("close", resolve).destroy(reason));
|
|
}
|
|
};
|
|
exports.WritableStreamDefaultController = class WritableStreamDefaultController {
|
|
constructor(stream) {
|
|
this._stream = stream;
|
|
}
|
|
error(err) {
|
|
this._stream._stream.destroy(err);
|
|
}
|
|
};
|
|
var WritableStream = class _WritableStream {
|
|
static get [writableKind]() {
|
|
return 0;
|
|
}
|
|
constructor(underlyingSink = {}, queuingStrategy = {}) {
|
|
if (isStreamx(underlyingSink)) {
|
|
this._stream = underlyingSink;
|
|
} else {
|
|
if (queuingStrategy === void 0) {
|
|
queuingStrategy = new exports.CountQueuingStrategy();
|
|
}
|
|
const { start, write, close, abort } = underlyingSink;
|
|
const { highWaterMark = 1, size = defaultSize } = queuingStrategy;
|
|
this._stream = new Writable({ highWaterMark, byteLength: size });
|
|
this._controller = new exports.WritableStreamDefaultController(this);
|
|
if (start) {
|
|
this._stream._open = this._open.bind(this, start.call(this, this._controller));
|
|
}
|
|
if (write) {
|
|
this._stream._write = this._write.bind(this, write);
|
|
}
|
|
if (close) {
|
|
this._stream._destroy = this._destroy.bind(this, close.call(this));
|
|
}
|
|
if (abort) {
|
|
this._stream.once("error", abort);
|
|
}
|
|
}
|
|
this._writer = null;
|
|
}
|
|
get [writableKind]() {
|
|
return _WritableStream[writableKind];
|
|
}
|
|
get locked() {
|
|
return this._writer !== null;
|
|
}
|
|
getWriter() {
|
|
if (this.locked) throw new TypeError("Stream is locked");
|
|
this._writer = new exports.WritableStreamDefaultWriter(this);
|
|
return this._writer;
|
|
}
|
|
abort(reason = new TypeError("Stream was aborted")) {
|
|
if (this._stream.destroyed) return Promise.resolve();
|
|
if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
|
|
return new Promise((resolve) => this._stream.once("close", resolve).destroy(reason));
|
|
}
|
|
close() {
|
|
if (this._stream.destroyed) return Promise.resolve();
|
|
if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
|
|
return new Promise((resolve) => this._stream.once("close", resolve).end());
|
|
}
|
|
_releaseLock() {
|
|
this._writer = null;
|
|
}
|
|
async _open(starting, cb) {
|
|
let err = null;
|
|
try {
|
|
await starting;
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _write(write, data, cb) {
|
|
let err = null;
|
|
try {
|
|
await write(data, this._controller);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _destroy(closing, cb) {
|
|
let err = null;
|
|
try {
|
|
await closing;
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
};
|
|
exports.WritableStream = WritableStream;
|
|
exports.isWritableStream = function isWritableStream(value) {
|
|
if (value instanceof WritableStream) return true;
|
|
return typeof value === "object" && value !== null && value[writableKind] === WritableStream[writableKind];
|
|
};
|
|
exports.TransformStreamDefaultController = class TransformStreamDefaultController {
|
|
constructor(stream) {
|
|
this._stream = stream;
|
|
}
|
|
get desiredSize() {
|
|
const stream = this._stream._stream;
|
|
return stream._readableState.highWaterMark - stream._readableState.buffered;
|
|
}
|
|
enqueue(data) {
|
|
this._stream._stream.push(data);
|
|
}
|
|
error(err) {
|
|
this._stream._stream.destroy(err);
|
|
}
|
|
terminate() {
|
|
const stream = this._stream._stream;
|
|
stream.push(null);
|
|
stream.destroy(new TypeError("Stream has been terminated"));
|
|
}
|
|
};
|
|
var TransformStream = class _TransformStream {
|
|
static get [transformKind]() {
|
|
return 0;
|
|
}
|
|
constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) {
|
|
const { start, transform, flush } = transformer;
|
|
this._stream = new Transform({ ...writableStrategy, ...readableStrategy });
|
|
this._writable = new WritableStream(this._stream);
|
|
this._readable = new ReadableStream(this._stream);
|
|
this._controller = new exports.TransformStreamDefaultController(this);
|
|
if (start) {
|
|
this._stream._open = this._open.bind(this, start.call(this, this._controller));
|
|
}
|
|
if (transform) {
|
|
this._stream._write = this._transform.bind(this, transform);
|
|
}
|
|
if (flush) {
|
|
this._stream._flush = this._flush.bind(this, flush.call(this, this._controller));
|
|
}
|
|
}
|
|
get [transformKind]() {
|
|
return _TransformStream[transformKind];
|
|
}
|
|
get writable() {
|
|
return this._writable;
|
|
}
|
|
get readable() {
|
|
return this._readable;
|
|
}
|
|
async _open(starting, cb) {
|
|
let err = null;
|
|
try {
|
|
await starting;
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _transform(transform, data, cb) {
|
|
let err = null;
|
|
try {
|
|
await transform(data, this._controller);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _flush(flush, cb) {
|
|
let err = null;
|
|
try {
|
|
await flush;
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
};
|
|
exports.TransformStream = TransformStream;
|
|
exports.isTransformStream = function isTransformStream(value) {
|
|
if (value instanceof TransformStream) return true;
|
|
return typeof value === "object" && value !== null && value[transformKind] === TransformStream[transformKind];
|
|
};
|
|
function noop() {
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-stream/index.js
|
|
var require_bare_stream = __commonJS({
|
|
"../../node_modules/bare-stream/index.js"(exports, module) {
|
|
var stream = require_streamx();
|
|
var { ReadableStream, WritableStream } = require_web();
|
|
var defaultEncoding = "utf8";
|
|
module.exports = exports = stream.Stream;
|
|
exports.pipeline = stream.pipeline;
|
|
exports.isStream = stream.isStream;
|
|
exports.isEnding = stream.isEnding;
|
|
exports.isEnded = stream.isEnded;
|
|
exports.isFinishing = stream.isFinishing;
|
|
exports.isFinished = stream.isFinished;
|
|
exports.isDisturbed = stream.isDisturbed;
|
|
exports.isErrored = function isErrored(stream2) {
|
|
return exports.getStreamError(stream2) !== null;
|
|
};
|
|
exports.isReadable = function isReadable(stream2) {
|
|
return stream2.readable && !stream2.destroying && !exports.isEnded(stream2);
|
|
};
|
|
exports.isWritable = function isWritable(stream2) {
|
|
return stream2.writable && !stream2.destroying && !exports.isFinishing(stream2);
|
|
};
|
|
exports.getStreamError = stream.getStreamError;
|
|
exports.addAbortSignal = function addAbortSignal(signal, stream2) {
|
|
function onAbort() {
|
|
stream2.destroy(signal.reason);
|
|
}
|
|
if (signal.aborted) onAbort();
|
|
else signal.addEventListener("abort", onAbort);
|
|
return stream2;
|
|
};
|
|
exports.Stream = exports;
|
|
exports.Readable = class Readable extends stream.Readable {
|
|
constructor(opts = {}) {
|
|
super({
|
|
...opts,
|
|
byteLength: null,
|
|
byteLengthReadable: null,
|
|
map: null,
|
|
mapReadable: null
|
|
});
|
|
if (this._construct) this._open = this._construct;
|
|
if (this._read !== stream.Readable.prototype._read) {
|
|
this._read = read.bind(this, this._read);
|
|
}
|
|
if (this._destroy !== stream.Stream.prototype._destroy) {
|
|
this._destroy = destroy.bind(this, this._destroy);
|
|
}
|
|
}
|
|
get closed() {
|
|
return !exports.isReadable(this);
|
|
}
|
|
get errored() {
|
|
return stream.getStreamError(this);
|
|
}
|
|
push(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
return super.push(chunk);
|
|
}
|
|
unshift(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
super.unshift(chunk);
|
|
}
|
|
static fromWeb(readableStream, opts = {}) {
|
|
const stream2 = readableStream._stream;
|
|
if (opts.encoding) stream2.setEncoding(opts.encoding);
|
|
if (opts.signal) exports.addAbortSignal(opts.signal, stream2);
|
|
return stream2;
|
|
}
|
|
static toWeb(readable, opts = {}) {
|
|
return new ReadableStream(readable, opts.strategy);
|
|
}
|
|
async [Symbol.asyncDispose]() {
|
|
if (!this.destroyed) this.destroy();
|
|
await new Promise((resolve) => exports.finished(this, resolve));
|
|
}
|
|
};
|
|
exports.Writable = class Writable extends stream.Writable {
|
|
constructor(opts = {}) {
|
|
super({
|
|
...opts,
|
|
byteLength: null,
|
|
byteLengthWritable,
|
|
map: null,
|
|
mapWritable: null
|
|
});
|
|
if (this._construct) this._open = this._construct;
|
|
if (this._write !== stream.Writable.prototype._write) {
|
|
this._write = write.bind(this, this._write);
|
|
}
|
|
if (this._destroy !== stream.Stream.prototype._destroy) {
|
|
this._destroy = destroy.bind(this, this._destroy);
|
|
}
|
|
}
|
|
get closed() {
|
|
return !exports.isWritable(this);
|
|
}
|
|
get errored() {
|
|
return stream.getStreamError(this);
|
|
}
|
|
write(chunk, encoding, cb) {
|
|
if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = super.write({ chunk, encoding });
|
|
if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
|
|
return result;
|
|
}
|
|
end(chunk, encoding, cb) {
|
|
if (typeof chunk === "function") {
|
|
cb = chunk;
|
|
chunk = null;
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
|
|
if (cb) this.once("finish", () => cb(null));
|
|
return result;
|
|
}
|
|
static fromWeb(writableStream, opts = {}) {
|
|
const stream2 = writableStream._stream;
|
|
if (opts.signal) exports.addAbortSignal(opts.signal, stream2);
|
|
return stream2;
|
|
}
|
|
static toWeb(writable) {
|
|
return new WritableStream(writable);
|
|
}
|
|
async [Symbol.asyncDispose]() {
|
|
if (!this.destroyed) this.destroy();
|
|
await new Promise((resolve) => exports.finished(this, resolve));
|
|
}
|
|
};
|
|
exports.Duplex = class Duplex extends stream.Duplex {
|
|
constructor(opts = {}) {
|
|
super({
|
|
...opts,
|
|
byteLength: null,
|
|
byteLengthReadable: null,
|
|
byteLengthWritable,
|
|
map: null,
|
|
mapReadable: null,
|
|
mapWritable: null
|
|
});
|
|
if (this._construct) this._open = this._construct;
|
|
if (this._read !== stream.Readable.prototype._read) {
|
|
this._read = read.bind(this, this._read);
|
|
}
|
|
if (this._write !== stream.Duplex.prototype._write) {
|
|
this._write = write.bind(this, this._write);
|
|
}
|
|
if (this._destroy !== stream.Stream.prototype._destroy) {
|
|
this._destroy = destroy.bind(this, this._destroy);
|
|
}
|
|
}
|
|
push(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
return super.push(chunk);
|
|
}
|
|
unshift(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
super.unshift(chunk);
|
|
}
|
|
write(chunk, encoding, cb) {
|
|
if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = super.write({ chunk, encoding });
|
|
if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
|
|
return result;
|
|
}
|
|
end(chunk, encoding, cb) {
|
|
if (typeof chunk === "function") {
|
|
cb = chunk;
|
|
chunk = null;
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
|
|
if (cb) this.once("finish", () => cb(null));
|
|
return result;
|
|
}
|
|
static fromWeb({ readable: readableStream, writable: writableStream }, opts) {
|
|
const readable = exports.Readable.fromWeb(readableStream, opts);
|
|
const writable = exports.Readable.fromWeb(writableStream, opts);
|
|
const duplex = new exports.Duplex({
|
|
write(data, encoding, cb) {
|
|
writable.write(data, encoding, cb);
|
|
}
|
|
});
|
|
readable.on("data", (data) => duplex.push(data)).on("end", () => duplex.push(null)).on("error", (err) => duplex.destroy(err));
|
|
writable.on("finish", () => duplex.end()).on("error", (err) => duplex.destroy(err));
|
|
return duplex;
|
|
}
|
|
static toWeb(duplex) {
|
|
const readableStream = exports.Readable.toWeb(duplex);
|
|
const writableStream = exports.Writable.toWeb(duplex);
|
|
return { readable: readableStream, writable: writableStream };
|
|
}
|
|
};
|
|
var DuplexSide = class extends exports.Duplex {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._otherSide = null;
|
|
this._cb = null;
|
|
}
|
|
_read() {
|
|
const cb = this._cb;
|
|
if (!cb) return;
|
|
this._cb = null;
|
|
cb();
|
|
}
|
|
_write(chunk, encoding, cb) {
|
|
this._otherSide.push(chunk, encoding);
|
|
this._otherSide._cb = cb;
|
|
}
|
|
_final(cb) {
|
|
this._otherSide.on("end", cb);
|
|
this._otherSide.push(null);
|
|
}
|
|
};
|
|
exports.duplexPair = function duplexPair(opts) {
|
|
const sideA = new DuplexSide(opts);
|
|
const sideB = new DuplexSide(opts);
|
|
sideA._otherSide = sideB;
|
|
sideB._otherSide = sideA;
|
|
return [sideA, sideB];
|
|
};
|
|
exports.Transform = class Transform extends stream.Transform {
|
|
constructor(opts = {}) {
|
|
super({
|
|
...opts,
|
|
byteLength: null,
|
|
byteLengthReadable: null,
|
|
byteLengthWritable,
|
|
map: null,
|
|
mapReadable: null,
|
|
mapWritable: null
|
|
});
|
|
if (this._transform !== stream.Transform.prototype._transform) {
|
|
this._transform = transform.bind(this, this._transform);
|
|
} else {
|
|
this._transform = passthrough;
|
|
}
|
|
}
|
|
push(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
return super.push(chunk);
|
|
}
|
|
unshift(chunk, encoding) {
|
|
if (typeof chunk === "string") {
|
|
chunk = Buffer.from(chunk, encoding || defaultEncoding);
|
|
}
|
|
super.unshift(chunk);
|
|
}
|
|
write(chunk, encoding, cb) {
|
|
if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = super.write({ chunk, encoding });
|
|
if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
|
|
return result;
|
|
}
|
|
end(chunk, encoding, cb) {
|
|
if (typeof chunk === "function") {
|
|
cb = chunk;
|
|
chunk = null;
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || defaultEncoding;
|
|
chunk = Buffer.from(chunk, encoding);
|
|
} else {
|
|
encoding = "buffer";
|
|
}
|
|
const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
|
|
if (cb) this.once("finish", () => cb(null));
|
|
return result;
|
|
}
|
|
};
|
|
exports.PassThrough = class PassThrough extends exports.Transform {
|
|
};
|
|
exports.finished = function finished(stream2, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (!opts) opts = {};
|
|
const { cleanup = false } = opts;
|
|
const done = () => {
|
|
cb(exports.getStreamError(stream2, { all: true }));
|
|
if (cleanup) detach();
|
|
};
|
|
const detach = () => {
|
|
stream2.off("close", done);
|
|
stream2.off("error", noop);
|
|
};
|
|
if (stream2.destroyed) {
|
|
done();
|
|
} else {
|
|
stream2.on("close", done);
|
|
stream2.on("error", noop);
|
|
}
|
|
return detach;
|
|
};
|
|
function read(read2, cb) {
|
|
read2.call(this, 65536);
|
|
cb(null);
|
|
}
|
|
function write(write2, data, cb) {
|
|
write2.call(this, data.chunk, data.encoding, cb);
|
|
}
|
|
function transform(transform2, data, cb) {
|
|
transform2.call(this, data.chunk, data.encoding, cb);
|
|
}
|
|
function destroy(destroy2, cb) {
|
|
destroy2.call(this, exports.getStreamError(this), cb);
|
|
}
|
|
function passthrough(data, cb) {
|
|
cb(null, data.chunk);
|
|
}
|
|
function byteLengthWritable(data) {
|
|
return data.chunk.byteLength;
|
|
}
|
|
function noop() {
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-fs/binding.js
|
|
var require_binding8 = __commonJS({
|
|
"../../node_modules/bare-fs/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-fs/lib/constants.js
|
|
var require_constants3 = __commonJS({
|
|
"../../node_modules/bare-fs/lib/constants.js"(exports, module) {
|
|
var binding = require_binding8();
|
|
module.exports = {
|
|
O_RDWR: binding.O_RDWR,
|
|
O_RDONLY: binding.O_RDONLY,
|
|
O_WRONLY: binding.O_WRONLY,
|
|
O_CREAT: binding.O_CREAT,
|
|
O_TRUNC: binding.O_TRUNC,
|
|
O_APPEND: binding.O_APPEND,
|
|
F_OK: binding.F_OK || 0,
|
|
R_OK: binding.R_OK || 0,
|
|
W_OK: binding.W_OK || 0,
|
|
X_OK: binding.X_OK || 0,
|
|
S_IFMT: binding.S_IFMT,
|
|
S_IFREG: binding.S_IFREG,
|
|
S_IFDIR: binding.S_IFDIR,
|
|
S_IFCHR: binding.S_IFCHR,
|
|
S_IFLNK: binding.S_IFLNK,
|
|
S_IFBLK: binding.S_IFBLK || 0,
|
|
S_IFIFO: binding.S_IFIFO || 0,
|
|
S_IFSOCK: binding.S_IFSOCK || 0,
|
|
S_IRUSR: binding.S_IRUSR || 0,
|
|
S_IWUSR: binding.S_IWUSR || 0,
|
|
S_IXUSR: binding.S_IXUSR || 0,
|
|
S_IRGRP: binding.S_IRGRP || 0,
|
|
S_IWGRP: binding.S_IWGRP || 0,
|
|
S_IXGRP: binding.S_IXGRP || 0,
|
|
S_IROTH: binding.S_IROTH || 0,
|
|
S_IWOTH: binding.S_IWOTH || 0,
|
|
S_IXOTH: binding.S_IXOTH || 0,
|
|
UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN,
|
|
UV_DIRENT_FILE: binding.UV_DIRENT_FILE,
|
|
UV_DIRENT_DIR: binding.UV_DIRENT_DIR,
|
|
UV_DIRENT_LINK: binding.UV_DIRENT_LINK,
|
|
UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO,
|
|
UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET,
|
|
UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR,
|
|
UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK,
|
|
COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL,
|
|
COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE,
|
|
COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE,
|
|
UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR,
|
|
UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-fs/lib/errors.js
|
|
var require_errors6 = __commonJS({
|
|
"../../node_modules/bare-fs/lib/errors.js"(exports, module) {
|
|
var os = require_bare_os();
|
|
module.exports = class FileError extends Error {
|
|
constructor(msg, opts = {}) {
|
|
const { code, operation = null, path = null, destination = null, fd = -1 } = opts;
|
|
if (operation !== null) msg += describe(operation, opts);
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (operation !== null) this.operation = operation;
|
|
if (path !== null) this.path = path;
|
|
if (destination !== null) this.destination = destination;
|
|
if (fd !== -1) this.fd = fd;
|
|
}
|
|
get name() {
|
|
return "FileError";
|
|
}
|
|
// For Node.js compatibility
|
|
get errno() {
|
|
return os.constants.errnos[this.code];
|
|
}
|
|
// For Node.js compatibility
|
|
get syscall() {
|
|
return this.operation;
|
|
}
|
|
// For Node.js compatibility
|
|
get dest() {
|
|
return this.destination;
|
|
}
|
|
};
|
|
function describe(operation, opts) {
|
|
const { path = null, destination = null, fd = -1 } = opts;
|
|
let result = `, ${operation}`;
|
|
if (path !== null) {
|
|
result += ` ${JSON.stringify(path)}`;
|
|
if (destination !== null) {
|
|
result += ` -> ${JSON.stringify(destination)}`;
|
|
}
|
|
} else if (fd !== -1) {
|
|
result += ` ${fd}`;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-fs/promises.js
|
|
var require_promises = __commonJS({
|
|
"../../node_modules/bare-fs/promises.js"(exports) {
|
|
var EventEmitter = require_bare_events();
|
|
var fs = require_bare_fs();
|
|
var FileHandle = class extends EventEmitter {
|
|
constructor(fd) {
|
|
super();
|
|
this.fd = fd;
|
|
}
|
|
async close() {
|
|
await fs.close(this.fd);
|
|
this.fd = -1;
|
|
this.emit("close");
|
|
}
|
|
async read(buffer, ...args) {
|
|
return {
|
|
bytesRead: await fs.read(this.fd, buffer, ...args),
|
|
buffer
|
|
};
|
|
}
|
|
async readv(buffers, ...args) {
|
|
return {
|
|
bytesRead: await fs.readv(this.fd, buffers, ...args),
|
|
buffers
|
|
};
|
|
}
|
|
async write(buffer, ...args) {
|
|
return {
|
|
bytesWritten: await fs.write(this.fd, buffer, ...args),
|
|
buffer
|
|
};
|
|
}
|
|
async writev(buffers, ...args) {
|
|
return {
|
|
bytesWritten: await fs.writev(this.fd, buffers, ...args),
|
|
buffers
|
|
};
|
|
}
|
|
async stat() {
|
|
return fs.fstat(this.fd);
|
|
}
|
|
async chmod(mode) {
|
|
await fs.fchmod(this.fd, mode);
|
|
}
|
|
createReadStream(opts) {
|
|
return fs.createReadStream(null, { ...opts, fd: this.fd });
|
|
}
|
|
createWriteStream(opts) {
|
|
return fs.createWriteStream(null, { ...opts, fd: this.fd });
|
|
}
|
|
async [Symbol.asyncDispose]() {
|
|
await this.close();
|
|
}
|
|
};
|
|
exports.open = async function open(filepath, flags, mode) {
|
|
return new FileHandle(await fs.open(filepath, flags, mode));
|
|
};
|
|
exports.access = fs.access;
|
|
exports.appendFile = fs.appendFile;
|
|
exports.chmod = fs.chmod;
|
|
exports.constants = fs.constants;
|
|
exports.copyFile = fs.copyFile;
|
|
exports.cp = fs.cp;
|
|
exports.lstat = fs.lstat;
|
|
exports.mkdir = fs.mkdir;
|
|
exports.opendir = fs.opendir;
|
|
exports.readFile = fs.readFile;
|
|
exports.readdir = fs.readdir;
|
|
exports.readlink = fs.readlink;
|
|
exports.realpath = fs.realpath;
|
|
exports.rename = fs.rename;
|
|
exports.rm = fs.rm;
|
|
exports.rmdir = fs.rmdir;
|
|
exports.stat = fs.stat;
|
|
exports.symlink = fs.symlink;
|
|
exports.unlink = fs.unlink;
|
|
exports.utimes = fs.utimes;
|
|
exports.watch = fs.watch;
|
|
exports.writeFile = fs.writeFile;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-fs/index.js
|
|
var require_bare_fs = __commonJS({
|
|
"../../node_modules/bare-fs/index.js"(exports) {
|
|
var FIFO = require_fast_fifo();
|
|
var EventEmitter = require_bare_events();
|
|
var path = require_bare_path();
|
|
var { isURL, fileURLToPath } = require_bare_url();
|
|
var { Readable, Writable } = require_bare_stream();
|
|
var binding = require_binding8();
|
|
var constants = require_constants3();
|
|
var FileError = require_errors6();
|
|
var isWindows = Bare.platform === "win32";
|
|
exports.constants = constants;
|
|
var FileRequest = class _FileRequest {
|
|
static borrow() {
|
|
if (this._free.length > 0) return this._free.pop();
|
|
return new _FileRequest();
|
|
}
|
|
static return(req) {
|
|
if (this._free.length < 32) this._free.push(req.reset());
|
|
else req.destroy();
|
|
}
|
|
constructor() {
|
|
this._reset();
|
|
this._handle = binding.requestInit(this, this._onresult);
|
|
}
|
|
get handle() {
|
|
return this._handle;
|
|
}
|
|
retain(value) {
|
|
this._retain = value;
|
|
}
|
|
reset() {
|
|
if (this._handle === null) return this;
|
|
binding.requestReset(this._handle);
|
|
this._reset();
|
|
return this;
|
|
}
|
|
destroy() {
|
|
if (this._handle === null) return this;
|
|
binding.requestDestroy(this._handle);
|
|
this._reset();
|
|
this._handle = null;
|
|
return this;
|
|
}
|
|
then(resolve, reject) {
|
|
return this._promise.then(resolve, reject);
|
|
}
|
|
return() {
|
|
if (this._handle === null) return this;
|
|
_FileRequest.return(this);
|
|
return this;
|
|
}
|
|
_reset() {
|
|
this._promise = new Promise((resolve, reject) => {
|
|
this._resolve = resolve;
|
|
this._reject = reject;
|
|
});
|
|
this._retain = null;
|
|
}
|
|
_onresult(err, status) {
|
|
if (err) this._reject(err);
|
|
else this._resolve(status);
|
|
}
|
|
};
|
|
FileRequest._free = [];
|
|
function ok(result, cb) {
|
|
if (typeof result === "function") {
|
|
cb = result;
|
|
result = void 0;
|
|
}
|
|
if (cb) cb(null, result);
|
|
else return result;
|
|
}
|
|
function fail(err, cb) {
|
|
if (cb) cb(err);
|
|
else throw err;
|
|
}
|
|
function done(err, result, cb) {
|
|
if (typeof result === "function") {
|
|
cb = result;
|
|
result = void 0;
|
|
}
|
|
if (err) fail(err, cb);
|
|
else return ok(result, cb);
|
|
}
|
|
async function open(filepath, flags = "r", mode = 438, cb) {
|
|
if (typeof flags === "function") {
|
|
cb = flags;
|
|
flags = "r";
|
|
mode = 438;
|
|
} else if (typeof mode === "function") {
|
|
cb = mode;
|
|
mode = 438;
|
|
}
|
|
if (typeof flags === "string") flags = toFlags(flags);
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let fd;
|
|
let err = null;
|
|
try {
|
|
binding.open(req.handle, filepath, flags, mode);
|
|
fd = await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "open",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, fd, cb);
|
|
}
|
|
function openSync(filepath, flags = "r", mode = 438) {
|
|
if (typeof flags === "string") flags = toFlags(flags);
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
return binding.openSync(req.handle, filepath, flags, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "open",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function close(fd, cb) {
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.close(req.handle, fd);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "close", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function closeSync(fd) {
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.closeSync(req.handle, fd);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "close", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function access(filepath, mode = constants.F_OK, cb) {
|
|
if (typeof mode === "function") {
|
|
cb = mode;
|
|
mode = constants.F_OK;
|
|
}
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.access(req.handle, filepath, mode);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "access",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function accessSync(filepath, mode = constants.F_OK) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.accessSync(req.handle, filepath, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "access",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function exists(filepath, cb) {
|
|
let ok2 = true;
|
|
try {
|
|
await access(filepath);
|
|
} catch {
|
|
ok2 = false;
|
|
}
|
|
return done(null, ok2, cb);
|
|
}
|
|
function existsSync(filepath) {
|
|
try {
|
|
accessSync(filepath);
|
|
} catch {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) {
|
|
if (typeof offset === "function") {
|
|
cb = offset;
|
|
offset = 0;
|
|
len = buffer.byteLength;
|
|
pos = -1;
|
|
} else if (typeof len === "function") {
|
|
cb = len;
|
|
len = buffer.byteLength - offset;
|
|
pos = -1;
|
|
} else if (typeof pos === "function") {
|
|
cb = pos;
|
|
pos = -1;
|
|
}
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
let bytes;
|
|
let err = null;
|
|
try {
|
|
binding.read(req.handle, fd, buffer, offset, len, pos);
|
|
bytes = await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "read", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, bytes, cb);
|
|
}
|
|
function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) {
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
return binding.readSync(req.handle, fd, buffer, offset, len, pos);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "read", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function readv(fd, buffers, pos = -1, cb) {
|
|
if (typeof pos === "function") {
|
|
cb = pos;
|
|
pos = -1;
|
|
}
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
let bytes;
|
|
let err = null;
|
|
try {
|
|
binding.readv(req.handle, fd, buffers, pos);
|
|
bytes = await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "readv", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, bytes, cb);
|
|
}
|
|
function readvSync(fd, buffers, pos = -1) {
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
return binding.readvSync(req.handle, fd, buffers, pos);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "readv", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function write(fd, data, offset, len, pos = -1, cb) {
|
|
if (typeof data === "string") {
|
|
let encoding = len;
|
|
cb = pos;
|
|
pos = offset;
|
|
if (typeof pos === "function") {
|
|
cb = pos;
|
|
pos = -1;
|
|
encoding = "utf8";
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = "utf8";
|
|
}
|
|
if (typeof pos === "string") {
|
|
encoding = pos;
|
|
pos = -1;
|
|
}
|
|
data = Buffer.from(data, encoding);
|
|
offset = 0;
|
|
len = data.byteLength;
|
|
} else if (typeof offset === "function") {
|
|
cb = offset;
|
|
offset = 0;
|
|
len = data.byteLength;
|
|
pos = -1;
|
|
} else if (typeof len === "function") {
|
|
cb = len;
|
|
len = data.byteLength - offset;
|
|
pos = -1;
|
|
} else if (typeof pos === "function") {
|
|
cb = pos;
|
|
pos = -1;
|
|
}
|
|
if (typeof offset !== "number") offset = 0;
|
|
if (typeof len !== "number") len = data.byteLength - offset;
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
let bytes;
|
|
let err = null;
|
|
try {
|
|
binding.write(req.handle, fd, data, offset, len, pos);
|
|
bytes = await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "write", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, bytes, cb);
|
|
}
|
|
function writeSync(fd, data, offset, len, pos = -1) {
|
|
if (typeof data === "string") {
|
|
let encoding = len;
|
|
pos = offset;
|
|
if (typeof pos === "string") {
|
|
encoding = pos;
|
|
pos = -1;
|
|
}
|
|
data = Buffer.from(data, encoding);
|
|
offset = 0;
|
|
len = data.byteLength;
|
|
}
|
|
if (typeof offset !== "number") offset = 0;
|
|
if (typeof len !== "number") len = data.byteLength - offset;
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
return binding.writeSync(req.handle, fd, data, offset, len, pos);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "write", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function writev(fd, buffers, pos = -1, cb) {
|
|
if (typeof pos === "function") {
|
|
cb = pos;
|
|
pos = -1;
|
|
}
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
let bytes;
|
|
let err = null;
|
|
try {
|
|
binding.writev(req.handle, fd, buffers, pos);
|
|
bytes = await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "writev", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, bytes, cb);
|
|
}
|
|
function writevSync(fd, buffers, pos = -1) {
|
|
if (typeof pos !== "number") pos = -1;
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
return binding.writevSync(req.handle, fd, buffers, pos);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "writev", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function stat(filepath, cb) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let st;
|
|
let err = null;
|
|
try {
|
|
binding.stat(req.handle, filepath);
|
|
await req;
|
|
st = new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "stat",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, st, cb);
|
|
}
|
|
function statSync(filepath) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.statSync(req.handle, filepath);
|
|
return new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "stat",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function lstat(filepath, cb) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let st;
|
|
let err = null;
|
|
try {
|
|
binding.lstat(req.handle, filepath);
|
|
await req;
|
|
st = new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "lstat",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, st, cb);
|
|
}
|
|
function lstatSync(filepath) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.lstatSync(req.handle, filepath);
|
|
return new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "lstat",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function fstat(fd, cb) {
|
|
const req = FileRequest.borrow();
|
|
let st;
|
|
let err = null;
|
|
try {
|
|
binding.fstat(req.handle, fd);
|
|
await req;
|
|
st = new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "fstat", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, st, cb);
|
|
}
|
|
function fstatSync(fd) {
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.fstatSync(req.handle, fd);
|
|
return new Stats(...binding.requestResultStat(req.handle));
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "fstat", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function ftruncate(fd, len = 0, cb) {
|
|
if (typeof len === "function") {
|
|
cb = len;
|
|
len = 0;
|
|
}
|
|
if (typeof len !== "number") len = 0;
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.ftruncate(req.handle, fd, len);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "ftruncate", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function ftruncateSync(fd, len = 0) {
|
|
if (typeof len !== "number") len = 0;
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.ftruncateSync(req.handle, fd, len);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "ftruncate", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function chmod(filepath, mode, cb) {
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.chmod(req.handle, filepath, mode);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "chmod",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function chmodSync(filepath, mode) {
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.chmodSync(req.handle, filepath, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "chmod",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function fchmod(fd, mode, cb) {
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.fchmod(req.handle, fd, mode);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, { operation: "fchmod", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function fchmodSync(fd, mode) {
|
|
if (typeof mode === "string") mode = toMode(mode);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.fchmodSync(req.handle, fd, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, { operation: "fchmod", code: e.code, fd });
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function utimes(filepath, atime, mtime, cb) {
|
|
if (typeof atime !== "number") atime = atime.getTime() / 1e3;
|
|
if (typeof mtime !== "number") mtime = mtime.getTime() / 1e3;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.utimes(req.handle, filepath, atime, mtime);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "utimes",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function utimesSync(filepath, atime, mtime) {
|
|
if (typeof atime !== "number") atime = atime.getTime() / 1e3;
|
|
if (typeof mtime !== "number") mtime = mtime.getTime() / 1e3;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.utimesSync(req.handle, filepath, atime, mtime);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "utimes",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function mkdir(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = { mode: 511 };
|
|
}
|
|
if (typeof opts === "number") opts = { mode: opts };
|
|
else if (!opts) opts = {};
|
|
const mode = typeof opts.mode === "number" ? opts.mode : 511;
|
|
filepath = toNamespacedPath(filepath);
|
|
if (opts.recursive) {
|
|
let err2 = null;
|
|
try {
|
|
try {
|
|
await mkdir(filepath, { mode });
|
|
} catch (err3) {
|
|
if (err3.code !== "ENOENT") {
|
|
if (!(await stat(filepath)).isDirectory()) throw err3;
|
|
} else {
|
|
while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1);
|
|
const i = filepath.lastIndexOf(path.sep);
|
|
if (i <= 0) throw err3;
|
|
await mkdir(filepath.slice(0, i), { mode, recursive: true });
|
|
try {
|
|
await mkdir(filepath, { mode });
|
|
} catch (err4) {
|
|
if (!(await stat(filepath)).isDirectory()) throw err4;
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
err2 = e;
|
|
}
|
|
return done(err2, cb);
|
|
}
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.mkdir(req.handle, filepath, mode);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "mkdir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function mkdirSync(filepath, opts) {
|
|
if (typeof opts === "number") opts = { mode: opts };
|
|
else if (!opts) opts = {};
|
|
const mode = typeof opts.mode === "number" ? opts.mode : 511;
|
|
filepath = toNamespacedPath(filepath);
|
|
if (opts.recursive) {
|
|
try {
|
|
mkdirSync(filepath, { mode });
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT") {
|
|
if (!statSync(filepath).isDirectory()) throw err;
|
|
} else {
|
|
while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1);
|
|
const i = filepath.lastIndexOf(path.sep);
|
|
if (i <= 0) throw err;
|
|
mkdirSync(filepath.slice(0, i), { mode, recursive: true });
|
|
try {
|
|
mkdirSync(filepath, { mode });
|
|
} catch (err2) {
|
|
if (!statSync(filepath).isDirectory()) throw err2;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.mkdirSync(req.handle, filepath, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "mkdir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function rmdir(filepath, cb) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.rmdir(req.handle, filepath);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "rmdir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function rmdirSync(filepath) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.rmdirSync(req.handle, filepath);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "rmdir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function rm(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (!opts) opts = {};
|
|
filepath = toNamespacedPath(filepath);
|
|
let err = null;
|
|
try {
|
|
const st = await lstat(filepath);
|
|
if (st.isDirectory()) {
|
|
if (opts.recursive) {
|
|
try {
|
|
await rmdir(filepath);
|
|
} catch (err2) {
|
|
if (err2.code !== "ENOTEMPTY") throw err2;
|
|
const files = await readdir(filepath);
|
|
for (const file of files) {
|
|
await rm(filepath + path.sep + file, opts);
|
|
}
|
|
await rmdir(filepath);
|
|
}
|
|
} else {
|
|
throw new FileError("is a directory", {
|
|
operation: "rm",
|
|
code: "EISDIR",
|
|
path: filepath
|
|
});
|
|
}
|
|
} else {
|
|
await unlink(filepath);
|
|
}
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT" || !opts.force) err = e;
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function rmSync(filepath, opts) {
|
|
if (!opts) opts = {};
|
|
filepath = toNamespacedPath(filepath);
|
|
try {
|
|
const st = lstatSync(filepath);
|
|
if (st.isDirectory()) {
|
|
if (opts.recursive) {
|
|
try {
|
|
rmdirSync(filepath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOTEMPTY") throw err;
|
|
const files = readdirSync(filepath);
|
|
for (const file of files) {
|
|
rmSync(filepath + path.sep + file, opts);
|
|
}
|
|
rmdirSync(filepath);
|
|
}
|
|
} else {
|
|
throw new FileError("is a directory", {
|
|
operation: "rm",
|
|
code: "EISDIR",
|
|
path: filepath
|
|
});
|
|
}
|
|
} else {
|
|
unlinkSync(filepath);
|
|
}
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT" || !opts.force) throw err;
|
|
}
|
|
}
|
|
async function unlink(filepath, cb) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.unlink(req.handle, filepath);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "unlink",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function unlinkSync(filepath) {
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.unlinkSync(req.handle, filepath);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "unlink",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function rename(src, dst, cb) {
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.rename(req.handle, src, dst);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "rename",
|
|
code: e.code,
|
|
path: src,
|
|
destination: dst
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function renameSync(src, dst) {
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.renameSync(req.handle, src, dst);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "rename",
|
|
code: e.code,
|
|
path: src,
|
|
destination: dst
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function copyFile(src, dst, mode = 0, cb) {
|
|
if (typeof mode === "function") {
|
|
cb = mode;
|
|
mode = 0;
|
|
}
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.copyfile(req.handle, src, dst, mode);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "copyfile",
|
|
code: e.code,
|
|
path: src,
|
|
destination: dst
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function copyFileSync(src, dst, mode = 0) {
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.copyfileSync(req.handle, src, dst, mode);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "copyfile",
|
|
code: e.code,
|
|
path: src,
|
|
destination: dst
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function cp(src, dst, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (!opts) opts = {};
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
let err = null;
|
|
try {
|
|
const st = await lstat(src);
|
|
if (st.isDirectory()) {
|
|
if (opts.recursive !== true) {
|
|
throw new FileError("is a directory", { operation: "cp", code: "EISDIR", path: src });
|
|
}
|
|
try {
|
|
await lstat(dst);
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT") throw e;
|
|
await mkdir(dst, { mode: st.mode, recursive: true });
|
|
}
|
|
const dir = await opendir(src);
|
|
for await (const { name } of dir) {
|
|
await cp(path.join(src, name), path.join(dst, name), opts);
|
|
}
|
|
} else if (st.isFile()) {
|
|
await copyFile(src, dst);
|
|
await chmod(dst, st.mode);
|
|
}
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function cpSync(src, dst, opts = {}) {
|
|
src = toNamespacedPath(src);
|
|
dst = toNamespacedPath(dst);
|
|
const st = lstatSync(src);
|
|
if (st.isDirectory()) {
|
|
if (opts.recursive !== true) {
|
|
throw new FileError("is a directory", { operation: "cp", code: "EISDIR", path: src });
|
|
}
|
|
try {
|
|
lstatSync(dst);
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT") throw e;
|
|
mkdirSync(dst, { mode: st.mode, recursive: true });
|
|
}
|
|
const dir = opendirSync(src);
|
|
for (const { name } of dir) {
|
|
cpSync(path.join(src, name), path.join(dst, name), opts);
|
|
}
|
|
} else if (st.isFile()) {
|
|
copyFileSync(src, dst);
|
|
chmodSync(dst, st.mode);
|
|
}
|
|
}
|
|
async function realpath(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "utf8" } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let res;
|
|
let err = null;
|
|
try {
|
|
binding.realpath(req.handle, filepath);
|
|
await req;
|
|
res = Buffer.from(binding.requestResultString(req.handle));
|
|
if (encoding !== "buffer") res = res.toString(encoding);
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "realpath",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, res, cb);
|
|
}
|
|
function realpathSync(filepath, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "utf8" } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.realpathSync(req.handle, filepath);
|
|
let res = Buffer.from(binding.requestResultString(req.handle));
|
|
if (encoding !== "buffer") res = res.toString(encoding);
|
|
return res;
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "realpath",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function readlink(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "utf8" } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let res;
|
|
let err = null;
|
|
try {
|
|
binding.readlink(req.handle, filepath);
|
|
await req;
|
|
res = Buffer.from(binding.requestResultString(req.handle));
|
|
if (encoding !== "buffer") res = res.toString(encoding);
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "readlink",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, res, cb);
|
|
}
|
|
function readlinkSync(filepath, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "utf8" } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.readlinkSync(req.handle, filepath);
|
|
let res = Buffer.from(binding.requestResultString(req.handle));
|
|
if (encoding !== "buffer") res = res.toString(encoding);
|
|
return res;
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "readlink",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
function normalizeSymlinkTarget(target, type, filepath) {
|
|
if (isWindows) {
|
|
if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, "..", target);
|
|
if (path.isAbsolute(target)) return path.toNamespacedPath(target);
|
|
return target.replace(/\//g, path.sep);
|
|
}
|
|
return target;
|
|
}
|
|
async function symlink(target, filepath, type, cb) {
|
|
if (typeof type === "function") {
|
|
cb = type;
|
|
type = null;
|
|
}
|
|
filepath = toNamespacedPath(filepath);
|
|
if (typeof type === "string") {
|
|
switch (type) {
|
|
case "dir":
|
|
type = constants.UV_FS_SYMLINK_DIR;
|
|
break;
|
|
case "junction":
|
|
type = constants.UV_FS_SYMLINK_JUNCTION;
|
|
break;
|
|
case "file":
|
|
default:
|
|
type = 0;
|
|
break;
|
|
}
|
|
} else if (typeof type !== "number") {
|
|
if (isWindows) {
|
|
target = path.resolve(filepath, "..", target);
|
|
try {
|
|
type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION;
|
|
} catch {
|
|
type = 0;
|
|
}
|
|
} else {
|
|
type = 0;
|
|
}
|
|
}
|
|
target = normalizeSymlinkTarget(target, type, filepath);
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.symlink(req.handle, target, filepath, type);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "symlink",
|
|
code: e.code,
|
|
path: target,
|
|
destination: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, cb);
|
|
}
|
|
function symlinkSync(target, filepath, type) {
|
|
filepath = toNamespacedPath(filepath);
|
|
if (typeof type === "string") {
|
|
switch (type) {
|
|
case "dir":
|
|
type = constants.UV_FS_SYMLINK_DIR;
|
|
break;
|
|
case "junction":
|
|
type = constants.UV_FS_SYMLINK_JUNCTION;
|
|
break;
|
|
case "file":
|
|
default:
|
|
type = 0;
|
|
break;
|
|
}
|
|
} else if (typeof type !== "number") {
|
|
if (isWindows) {
|
|
target = path.resolve(filepath, "..", target);
|
|
try {
|
|
type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION;
|
|
} catch {
|
|
type = 0;
|
|
}
|
|
} else {
|
|
type = 0;
|
|
}
|
|
}
|
|
target = normalizeSymlinkTarget(target, type, filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.symlinkSync(req.handle, target, filepath, type);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "symlink",
|
|
code: e.code,
|
|
path: target,
|
|
destination: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function opendir(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
let dir;
|
|
let err = null;
|
|
try {
|
|
binding.opendir(req.handle, filepath);
|
|
await req;
|
|
dir = new Dir(filepath, binding.requestResultDir(req.handle), opts);
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "opendir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
return done(err, dir, cb);
|
|
}
|
|
function opendirSync(filepath, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
filepath = toNamespacedPath(filepath);
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.opendirSync(req.handle, filepath);
|
|
return new Dir(filepath, binding.requestResultDir(req.handle), opts);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "opendir",
|
|
code: e.code,
|
|
path: filepath
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
}
|
|
async function readdir(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { withFileTypes = false } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
let result = [];
|
|
let err = null;
|
|
try {
|
|
const dir = await opendir(filepath);
|
|
for await (const entry of dir) {
|
|
result.push(withFileTypes ? entry : entry.name);
|
|
}
|
|
} catch (e) {
|
|
result = [];
|
|
err = e;
|
|
}
|
|
return done(err, result, cb);
|
|
}
|
|
function readdirSync(filepath, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { withFileTypes = false } = opts;
|
|
filepath = toNamespacedPath(filepath);
|
|
const dir = opendirSync(filepath, opts);
|
|
const result = [];
|
|
for (const entry of dir) {
|
|
result.push(withFileTypes ? entry : entry.name);
|
|
}
|
|
return result;
|
|
}
|
|
async function readFile(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "buffer" } = opts;
|
|
let fd = -1;
|
|
let buffer = null;
|
|
let err = null;
|
|
try {
|
|
fd = await open(filepath, opts.flag || "r");
|
|
const st = await fstat(fd);
|
|
let len = 0;
|
|
if (st.size === 0) {
|
|
const buffers = [];
|
|
while (true) {
|
|
buffer = Buffer.allocUnsafe(8192);
|
|
const r = await read(fd, buffer);
|
|
len += r;
|
|
if (r === 0) break;
|
|
buffers.push(buffer.subarray(0, r));
|
|
}
|
|
buffer = Buffer.concat(buffers);
|
|
} else {
|
|
buffer = Buffer.allocUnsafe(st.size);
|
|
while (true) {
|
|
const r = await read(fd, len ? buffer.subarray(len) : buffer);
|
|
len += r;
|
|
if (r === 0 || len === buffer.byteLength) break;
|
|
}
|
|
if (len !== buffer.byteLength) buffer = buffer.subarray(0, len);
|
|
}
|
|
if (encoding !== "buffer") buffer = buffer.toString(encoding);
|
|
} catch (e) {
|
|
err = e;
|
|
} finally {
|
|
if (fd !== -1) await close(fd);
|
|
}
|
|
return done(err, buffer, cb);
|
|
}
|
|
function readFileSync(filepath, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
const { encoding = "buffer" } = opts;
|
|
let fd = -1;
|
|
try {
|
|
fd = openSync(filepath, opts.flag || "r");
|
|
const st = fstatSync(fd);
|
|
let buffer;
|
|
let len = 0;
|
|
if (st.size === 0) {
|
|
const buffers = [];
|
|
while (true) {
|
|
buffer = Buffer.allocUnsafe(8192);
|
|
const r = readSync(fd, buffer);
|
|
len += r;
|
|
if (r === 0) break;
|
|
buffers.push(buffer.subarray(0, r));
|
|
}
|
|
buffer = Buffer.concat(buffers);
|
|
} else {
|
|
buffer = Buffer.allocUnsafe(st.size);
|
|
while (true) {
|
|
const r = readSync(fd, len ? buffer.subarray(len) : buffer);
|
|
len += r;
|
|
if (r === 0 || len === buffer.byteLength) break;
|
|
}
|
|
if (len !== buffer.byteLength) buffer = buffer.subarray(0, len);
|
|
}
|
|
if (encoding !== "buffer") buffer = buffer.toString(encoding);
|
|
return buffer;
|
|
} finally {
|
|
if (fd !== -1) closeSync(fd);
|
|
}
|
|
}
|
|
async function writeFile(filepath, data, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
if (typeof data === "string") data = Buffer.from(data, opts.encoding);
|
|
let fd = -1;
|
|
let len = 0;
|
|
let err = null;
|
|
try {
|
|
fd = await open(filepath, opts.flag || "w", opts.mode || 438);
|
|
while (true) {
|
|
len += await write(fd, len ? data.subarray(len) : data);
|
|
if (len === data.byteLength) break;
|
|
}
|
|
} catch (e) {
|
|
err = e;
|
|
} finally {
|
|
if (fd !== -1) await close(fd);
|
|
}
|
|
return done(err, len, cb);
|
|
}
|
|
function writeFileSync(filepath, data, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
if (typeof data === "string") data = Buffer.from(data, opts.encoding);
|
|
let fd = -1;
|
|
try {
|
|
fd = openSync(filepath, opts.flag || "w", opts.mode || 438);
|
|
let len = 0;
|
|
while (true) {
|
|
len += writeSync(fd, len ? data.subarray(len) : data);
|
|
if (len === data.byteLength) break;
|
|
}
|
|
} finally {
|
|
if (fd !== -1) closeSync(fd);
|
|
}
|
|
}
|
|
function appendFile(filepath, data, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
if (!opts.flag) opts = { ...opts, flag: "a" };
|
|
return writeFile(filepath, data, opts, cb);
|
|
}
|
|
function appendFileSync(filepath, data, opts) {
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
if (!opts.flag) opts = { ...opts, flag: "a" };
|
|
return writeFileSync(filepath, data, opts);
|
|
}
|
|
function watch(filepath, opts, cb) {
|
|
if (typeof opts === "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof opts === "string") opts = { encoding: opts };
|
|
else if (!opts) opts = {};
|
|
filepath = toNamespacedPath(filepath);
|
|
return new Watcher(filepath, opts, cb);
|
|
}
|
|
var Stats = class {
|
|
constructor(dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs) {
|
|
this.dev = dev;
|
|
this.mode = mode;
|
|
this.nlink = nlink;
|
|
this.uid = uid;
|
|
this.gid = gid;
|
|
this.rdev = rdev;
|
|
this.blksize = blksize;
|
|
this.ino = ino;
|
|
this.size = size;
|
|
this.blocks = blocks;
|
|
this.atimeMs = atimeMs;
|
|
this.mtimeMs = mtimeMs;
|
|
this.ctimeMs = ctimeMs;
|
|
this.birthtimeMs = birthtimeMs;
|
|
this.atime = new Date(atimeMs);
|
|
this.mtime = new Date(mtimeMs);
|
|
this.ctime = new Date(ctimeMs);
|
|
this.birthtime = new Date(birthtimeMs);
|
|
}
|
|
isDirectory() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFDIR;
|
|
}
|
|
isFile() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFREG;
|
|
}
|
|
isBlockDevice() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFBLK;
|
|
}
|
|
isCharacterDevice() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFCHR;
|
|
}
|
|
isFIFO() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFIFO;
|
|
}
|
|
isSymbolicLink() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFLNK;
|
|
}
|
|
isSocket() {
|
|
return (this.mode & constants.S_IFMT) === constants.S_IFSOCK;
|
|
}
|
|
};
|
|
var Dir = class {
|
|
constructor(path2, handle, opts = {}) {
|
|
const { encoding = "utf8", bufferSize = 32 } = opts;
|
|
this.path = path2;
|
|
this._encoding = encoding;
|
|
this._capacity = bufferSize;
|
|
this._buffer = new FIFO();
|
|
this._ended = false;
|
|
this._handle = handle;
|
|
}
|
|
async read(cb) {
|
|
if (this._buffer.length) return ok(this._buffer.shift(), cb);
|
|
if (this._ended) return ok(null, cb);
|
|
const req = FileRequest.borrow();
|
|
let entries;
|
|
let err = null;
|
|
try {
|
|
req.retain(binding.readdir(req.handle, this._handle, this._capacity));
|
|
await req;
|
|
entries = binding.requestResultDirents(req.handle);
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "readdir",
|
|
code: e.code,
|
|
path: this.path
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
if (err) return fail(err, cb);
|
|
if (entries.length === 0) {
|
|
this._ended = true;
|
|
return ok(null, cb);
|
|
}
|
|
for (const entry of entries) {
|
|
let name = Buffer.from(entry.name);
|
|
if (this._encoding !== "buffer") name = name.toString(this._encoding);
|
|
this._buffer.push(new Dirent(this.path, name, entry.type));
|
|
}
|
|
return ok(this._buffer.shift(), cb);
|
|
}
|
|
readSync() {
|
|
if (this._buffer.length) return this._buffer.shift();
|
|
if (this._ended) return null;
|
|
const req = FileRequest.borrow();
|
|
let entries;
|
|
try {
|
|
req.retain(binding.readdirSync(req.handle, this._handle, this._capacity));
|
|
entries = binding.requestResultDirents(req.handle);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "readdir",
|
|
code: e.code,
|
|
path: this.path
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
if (entries.length === 0) {
|
|
this._ended = true;
|
|
return null;
|
|
}
|
|
for (const entry of entries) {
|
|
let name = Buffer.from(entry.name);
|
|
if (this._encoding !== "buffer") name = name.toString(this._encoding);
|
|
this._buffer.push(new Dirent(this.path, name, entry.type));
|
|
}
|
|
return this._buffer.shift();
|
|
}
|
|
async close(cb) {
|
|
const req = FileRequest.borrow();
|
|
let err = null;
|
|
try {
|
|
binding.closedir(req.handle, this._handle);
|
|
await req;
|
|
} catch (e) {
|
|
err = new FileError(e.message, {
|
|
operation: "closedir",
|
|
code: e.code,
|
|
path: this.path
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
this._handle = null;
|
|
return done(err, cb);
|
|
}
|
|
closeSync() {
|
|
const req = FileRequest.borrow();
|
|
try {
|
|
binding.closedirSync(req.handle, this._handle);
|
|
} catch (e) {
|
|
throw new FileError(e.message, {
|
|
operation: "closedir",
|
|
code: e.code,
|
|
path: this.path
|
|
});
|
|
} finally {
|
|
req.return();
|
|
}
|
|
this._handle = null;
|
|
}
|
|
[Symbol.dispose]() {
|
|
this.closeSync();
|
|
}
|
|
async [Symbol.asyncDispose]() {
|
|
await this.close();
|
|
}
|
|
*[Symbol.iterator]() {
|
|
while (true) {
|
|
const entry = this.readSync();
|
|
if (entry === null) break;
|
|
yield entry;
|
|
}
|
|
this.closeSync();
|
|
}
|
|
async *[Symbol.asyncIterator]() {
|
|
while (true) {
|
|
const entry = await this.read();
|
|
if (entry === null) break;
|
|
yield entry;
|
|
}
|
|
await this.close();
|
|
}
|
|
};
|
|
var Dirent = class {
|
|
constructor(parentPath, name, type) {
|
|
this.parentPath = parentPath;
|
|
this.name = name;
|
|
this.type = type;
|
|
}
|
|
isFile() {
|
|
return this.type === constants.UV_DIRENT_FILE;
|
|
}
|
|
isDirectory() {
|
|
return this.type === constants.UV_DIRENT_DIR;
|
|
}
|
|
isSymbolicLink() {
|
|
return this.type === constants.UV_DIRENT_LINK;
|
|
}
|
|
isFIFO() {
|
|
return this.type === constants.UV_DIRENT_FIFO;
|
|
}
|
|
isSocket() {
|
|
return this.type === constants.UV_DIRENT_SOCKET;
|
|
}
|
|
isCharacterDevice() {
|
|
return this.type === constants.UV_DIRENT_CHAR;
|
|
}
|
|
isBlockDevice() {
|
|
return this.type === constants.UV_DIRENT_BLOCK;
|
|
}
|
|
};
|
|
var FileReadStream = class extends Readable {
|
|
constructor(path2, opts = {}) {
|
|
const { eagerOpen = true } = opts;
|
|
super({ eagerOpen, ...opts });
|
|
this.path = path2;
|
|
this.fd = typeof opts.fd === "number" ? opts.fd : -1;
|
|
this.flags = opts.flags || "r";
|
|
this.mode = opts.mode || 438;
|
|
this._offset = opts.start || 0;
|
|
this._missing = 0;
|
|
if (opts.length) {
|
|
this._missing = opts.length;
|
|
} else if (typeof opts.end === "number") {
|
|
this._missing = opts.end - this._offset + 1;
|
|
} else {
|
|
this._missing = -1;
|
|
}
|
|
}
|
|
async _open(cb) {
|
|
let err;
|
|
if (this.fd === -1) {
|
|
err = null;
|
|
try {
|
|
this.fd = await open(this.path, this.flags, this.mode);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
if (err) return cb(err);
|
|
}
|
|
let st;
|
|
err = null;
|
|
try {
|
|
st = await fstat(this.fd);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
if (err) return cb(err);
|
|
if (this._missing === -1) this._missing = st.size;
|
|
if (st.size < this._offset) {
|
|
this._offset = st.size;
|
|
this._missing = 0;
|
|
} else if (st.size < this._offset + this._missing) {
|
|
this._missing = st.size - this._offset;
|
|
}
|
|
cb(null);
|
|
}
|
|
async _read(size) {
|
|
if (this._missing <= 0) return this.push(null);
|
|
const data = Buffer.allocUnsafe(Math.min(this._missing, size));
|
|
let len;
|
|
let err = null;
|
|
try {
|
|
len = await read(this.fd, data, 0, data.byteLength, this._offset);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
if (err) return this.destroy(err);
|
|
if (len === 0) return this.push(null);
|
|
if (this._missing < len) len = this._missing;
|
|
this._missing -= len;
|
|
this._offset += len;
|
|
this.push(data.subarray(0, len));
|
|
}
|
|
async _destroy(err, cb) {
|
|
if (this.fd === -1) return cb(err);
|
|
try {
|
|
await close(this.fd);
|
|
} catch (e) {
|
|
err = err || e;
|
|
}
|
|
cb(err);
|
|
}
|
|
};
|
|
var FileWriteStream = class extends Writable {
|
|
constructor(path2, opts = {}) {
|
|
const { eagerOpen = true } = opts;
|
|
super({ eagerOpen, ...opts });
|
|
this.path = path2;
|
|
this.fd = typeof opts.fd === "number" ? opts.fd : -1;
|
|
this.flags = opts.flags || "w";
|
|
this.mode = opts.mode || 438;
|
|
}
|
|
async _open(cb) {
|
|
if (this.fd !== -1) return cb(null);
|
|
let err = null;
|
|
try {
|
|
this.fd = await open(this.path, this.flags, this.mode);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _writev(batch, cb) {
|
|
let err = null;
|
|
try {
|
|
await writev(
|
|
this.fd,
|
|
batch.map(({ chunk }) => chunk)
|
|
);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
cb(err);
|
|
}
|
|
async _destroy(err, cb) {
|
|
if (this.fd === -1) return cb(err);
|
|
try {
|
|
await close(this.fd);
|
|
} catch (e) {
|
|
err = err || e;
|
|
}
|
|
cb(err);
|
|
}
|
|
};
|
|
var Watcher = class extends EventEmitter {
|
|
constructor(path2, opts, onchange) {
|
|
if (typeof opts === "function") {
|
|
onchange = opts;
|
|
opts = {};
|
|
}
|
|
if (!opts) opts = {};
|
|
const { persistent = true, recursive = false, encoding = "utf8" } = opts;
|
|
super();
|
|
this._closed = false;
|
|
this._encoding = encoding;
|
|
this._handle = binding.watcherInit(path2, recursive, this, this._onevent, this._onclose);
|
|
if (!persistent) this.unref();
|
|
if (onchange) this.on("change", onchange);
|
|
}
|
|
close() {
|
|
if (this._closed) return;
|
|
this._closed = true;
|
|
binding.watcherClose(this._handle);
|
|
}
|
|
ref() {
|
|
if (this._handle) binding.watcherRef(this._handle);
|
|
return this;
|
|
}
|
|
unref() {
|
|
if (this._handle) binding.watcherUnref(this._handle);
|
|
return this;
|
|
}
|
|
[Symbol.asyncIterator]() {
|
|
const buffer = [];
|
|
let done2 = false;
|
|
let error = null;
|
|
let next = null;
|
|
this.on("change", (eventType, filename) => {
|
|
if (next) {
|
|
next.resolve({ done: false, value: { eventType, filename } });
|
|
next = null;
|
|
} else {
|
|
buffer.push({ eventType, filename });
|
|
}
|
|
}).on("error", (err) => {
|
|
done2 = true;
|
|
error = err;
|
|
if (next) {
|
|
next.reject(error);
|
|
next = null;
|
|
}
|
|
}).on("close", () => {
|
|
done2 = true;
|
|
if (next) {
|
|
next.resolve({ done: done2 });
|
|
next = null;
|
|
}
|
|
});
|
|
return {
|
|
next: () => new Promise((resolve, reject) => {
|
|
if (error) return reject(error);
|
|
if (buffer.length) return resolve({ done: false, value: buffer.shift() });
|
|
if (done2) return resolve({ done: done2 });
|
|
next = { resolve, reject };
|
|
})
|
|
};
|
|
}
|
|
_onevent(err, events, filename) {
|
|
if (err) {
|
|
this.close();
|
|
this.emit("error", err);
|
|
} else {
|
|
const path2 = this._encoding === "buffer" ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding);
|
|
if (events & binding.UV_RENAME) {
|
|
this.emit("change", "rename", path2);
|
|
}
|
|
if (events & binding.UV_CHANGE) {
|
|
this.emit("change", "change", path2);
|
|
}
|
|
}
|
|
}
|
|
_onclose() {
|
|
this._handle = null;
|
|
this.emit("close");
|
|
}
|
|
};
|
|
exports.access = access;
|
|
exports.appendFile = appendFile;
|
|
exports.chmod = chmod;
|
|
exports.close = close;
|
|
exports.copyFile = copyFile;
|
|
exports.cp = cp;
|
|
exports.exists = exists;
|
|
exports.fchmod = fchmod;
|
|
exports.fstat = fstat;
|
|
exports.ftruncate = ftruncate;
|
|
exports.lstat = lstat;
|
|
exports.mkdir = mkdir;
|
|
exports.open = open;
|
|
exports.opendir = opendir;
|
|
exports.read = read;
|
|
exports.readFile = readFile;
|
|
exports.readdir = readdir;
|
|
exports.readlink = readlink;
|
|
exports.readv = readv;
|
|
exports.realpath = realpath;
|
|
exports.rename = rename;
|
|
exports.rm = rm;
|
|
exports.rmdir = rmdir;
|
|
exports.stat = stat;
|
|
exports.symlink = symlink;
|
|
exports.unlink = unlink;
|
|
exports.utimes = utimes;
|
|
exports.watch = watch;
|
|
exports.write = write;
|
|
exports.writeFile = writeFile;
|
|
exports.writev = writev;
|
|
exports.accessSync = accessSync;
|
|
exports.appendFileSync = appendFileSync;
|
|
exports.chmodSync = chmodSync;
|
|
exports.closeSync = closeSync;
|
|
exports.copyFileSync = copyFileSync;
|
|
exports.cpSync = cpSync;
|
|
exports.existsSync = existsSync;
|
|
exports.fchmodSync = fchmodSync;
|
|
exports.fstatSync = fstatSync;
|
|
exports.ftruncateSync = ftruncateSync;
|
|
exports.lstatSync = lstatSync;
|
|
exports.mkdirSync = mkdirSync;
|
|
exports.openSync = openSync;
|
|
exports.opendirSync = opendirSync;
|
|
exports.readFileSync = readFileSync;
|
|
exports.readSync = readSync;
|
|
exports.readdirSync = readdirSync;
|
|
exports.readlinkSync = readlinkSync;
|
|
exports.readvSync = readvSync;
|
|
exports.realpathSync = realpathSync;
|
|
exports.renameSync = renameSync;
|
|
exports.rmSync = rmSync;
|
|
exports.rmdirSync = rmdirSync;
|
|
exports.statSync = statSync;
|
|
exports.symlinkSync = symlinkSync;
|
|
exports.unlinkSync = unlinkSync;
|
|
exports.utimesSync = utimesSync;
|
|
exports.writeFileSync = writeFileSync;
|
|
exports.writeSync = writeSync;
|
|
exports.writevSync = writevSync;
|
|
exports.promises = require_promises();
|
|
exports.Stats = Stats;
|
|
exports.Dir = Dir;
|
|
exports.Dirent = Dirent;
|
|
exports.Watcher = Watcher;
|
|
exports.ReadStream = FileReadStream;
|
|
exports.createReadStream = function createReadStream(path2, opts) {
|
|
return new FileReadStream(path2, opts);
|
|
};
|
|
exports.WriteStream = FileWriteStream;
|
|
exports.createWriteStream = function createWriteStream(path2, opts) {
|
|
return new FileWriteStream(path2, opts);
|
|
};
|
|
function toNamespacedPath(filepath) {
|
|
if (typeof filepath !== "string") {
|
|
if (isURL(filepath)) filepath = fileURLToPath(filepath);
|
|
else filepath = filepath.toString();
|
|
}
|
|
return path.toNamespacedPath(filepath);
|
|
}
|
|
function toFlags(flags) {
|
|
switch (flags) {
|
|
case "r":
|
|
return constants.O_RDONLY;
|
|
case "rs":
|
|
// Fall through.
|
|
case "sr":
|
|
return constants.O_RDONLY | constants.O_SYNC;
|
|
case "r+":
|
|
return constants.O_RDWR;
|
|
case "rs+":
|
|
// Fall through.
|
|
case "sr+":
|
|
return constants.O_RDWR | constants.O_SYNC;
|
|
case "w":
|
|
return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY;
|
|
case "wx":
|
|
// Fall through.
|
|
case "xw":
|
|
return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL;
|
|
case "w+":
|
|
return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR;
|
|
case "wx+":
|
|
// Fall through.
|
|
case "xw+":
|
|
return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL;
|
|
case "a":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY;
|
|
case "ax":
|
|
// Fall through.
|
|
case "xa":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL;
|
|
case "as":
|
|
// Fall through.
|
|
case "sa":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC;
|
|
case "a+":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR;
|
|
case "ax+":
|
|
// Fall through.
|
|
case "xa+":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL;
|
|
case "as+":
|
|
// Fall through.
|
|
case "sa+":
|
|
return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
function toMode(mode) {
|
|
return parseInt(mode, 8);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-tty/binding.js
|
|
var require_binding9 = __commonJS({
|
|
"../../node_modules/bare-tty/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-tty/lib/constants.js
|
|
var require_constants4 = __commonJS({
|
|
"../../node_modules/bare-tty/lib/constants.js"(exports, module) {
|
|
var binding = require_binding9();
|
|
module.exports = exports = {
|
|
mode: {
|
|
NORMAL: binding.MODE_NORMAL,
|
|
RAW: binding.MODE_RAW,
|
|
IO: binding.MODE_IO || 0
|
|
},
|
|
state: {
|
|
READING: 1,
|
|
CLOSING: 2
|
|
}
|
|
};
|
|
exports.MODE_NORMAL = exports.mode.NORMAL;
|
|
exports.MODE_RAW = exports.mode.RAW;
|
|
exports.MODE_IO = exports.mode.IO;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-tty/index.js
|
|
var require_bare_tty = __commonJS({
|
|
"../../node_modules/bare-tty/index.js"(exports) {
|
|
var { Readable, Writable } = require_bare_stream();
|
|
var Signal = require_bare_signals();
|
|
var binding = require_binding9();
|
|
var constants = require_constants4();
|
|
var defaultReadBufferSize = 65536;
|
|
var empty = Buffer.alloc(0);
|
|
exports.ReadStream = class TTYReadStream extends Readable {
|
|
constructor(fd, opts = {}) {
|
|
super();
|
|
const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true } = opts;
|
|
this._fd = fd;
|
|
this._state = 0;
|
|
this._allowHalfOpen = allowHalfOpen;
|
|
this._buffer = Buffer.alloc(readBufferSize);
|
|
this._pendingDestroy = null;
|
|
this._handle = binding.init(fd, this._buffer, this, noop, this._onread, this._onclose);
|
|
}
|
|
get fd() {
|
|
return this._fd;
|
|
}
|
|
get isTTY() {
|
|
return true;
|
|
}
|
|
setMode(mode) {
|
|
binding.setMode(this._handle, mode);
|
|
return this;
|
|
}
|
|
setRawMode(enabled) {
|
|
return this.setMode(enabled ? constants.mode.RAW : constants.mode.NORMAL);
|
|
}
|
|
_read() {
|
|
if ((this._state & constants.state.READING) === 0) {
|
|
this._state |= constants.state.READING;
|
|
binding.resume(this._handle);
|
|
}
|
|
}
|
|
_predestroy() {
|
|
if (this._state & constants.state.CLOSING) return;
|
|
this._state |= constants.state.CLOSING;
|
|
binding.close(this._handle);
|
|
}
|
|
_destroy(err, cb) {
|
|
if (this._state & constants.state.CLOSING) return cb(err);
|
|
this._state |= constants.state.CLOSING;
|
|
this._pendingDestroy = cb;
|
|
binding.close(this._handle);
|
|
}
|
|
_continueDestroy() {
|
|
if (this._pendingDestroy === null) return;
|
|
const cb = this._pendingDestroy;
|
|
this._pendingDestroy = null;
|
|
cb(null);
|
|
}
|
|
_onread(err, read) {
|
|
if (err) {
|
|
this.destroy(err);
|
|
return;
|
|
}
|
|
if (read === 0) {
|
|
this.push(null);
|
|
if (this._allowHalfOpen === false) this.end();
|
|
return;
|
|
}
|
|
const copy = Buffer.allocUnsafe(read);
|
|
copy.set(this._buffer.subarray(0, read));
|
|
if (this.push(copy) === false && this.destroying === false) {
|
|
this._state &= ~constants.state.READING;
|
|
binding.pause(this._handle);
|
|
}
|
|
}
|
|
_onclose() {
|
|
this._handle = null;
|
|
this._continueDestroy();
|
|
}
|
|
};
|
|
exports.WriteStream = class TTYWriteStream extends Writable {
|
|
constructor(fd, opts = {}) {
|
|
super();
|
|
this._fd = fd;
|
|
this._state = 0;
|
|
this._size = null;
|
|
this._pendingWrite = null;
|
|
this._pendingDestroy = null;
|
|
this._handle = binding.init(fd, empty, this, this._onwrite, noop, this._onclose);
|
|
this._size = this.getWindowSize();
|
|
if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.start();
|
|
TTYWriteStream._streams.add(this);
|
|
}
|
|
get fd() {
|
|
return this._fd;
|
|
}
|
|
get isTTY() {
|
|
return true;
|
|
}
|
|
get columns() {
|
|
return this._size[0];
|
|
}
|
|
get rows() {
|
|
return this._size[1];
|
|
}
|
|
getWindowSize() {
|
|
return binding.getWindowSize(this._handle);
|
|
}
|
|
_writev(batch, cb) {
|
|
this._pendingWrite = [cb, batch];
|
|
binding.writev(
|
|
this._handle,
|
|
batch.map(({ chunk }) => chunk)
|
|
);
|
|
}
|
|
_predestroy() {
|
|
if (this._state & constants.state.CLOSING) return;
|
|
this._state |= constants.state.CLOSING;
|
|
binding.close(this._handle);
|
|
TTYWriteStream._streams.delete(this);
|
|
if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.stop();
|
|
}
|
|
_destroy(err, cb) {
|
|
if (this._state & constants.state.CLOSING) return cb(err);
|
|
this._state |= constants.state.CLOSING;
|
|
this._pendingDestroy = cb;
|
|
binding.close(this._handle);
|
|
TTYWriteStream._streams.delete(this);
|
|
if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.stop();
|
|
}
|
|
_continueWrite(err) {
|
|
if (this._pendingWrite === null) return;
|
|
const cb = this._pendingWrite[0];
|
|
this._pendingWrite = null;
|
|
cb(err);
|
|
}
|
|
_continueDestroy() {
|
|
if (this._pendingDestroy === null) return;
|
|
const cb = this._pendingDestroy;
|
|
this._pendingDestroy = null;
|
|
cb(null);
|
|
}
|
|
_onwrite(err) {
|
|
this._continueWrite(err);
|
|
}
|
|
_onclose() {
|
|
this._handle = null;
|
|
this._continueDestroy();
|
|
}
|
|
_onresize() {
|
|
this._size = this.getWindowSize();
|
|
this.emit("resize");
|
|
}
|
|
static _streams = /* @__PURE__ */ new Set();
|
|
static _resize = new Signal("SIGWINCH");
|
|
};
|
|
exports.constants = constants;
|
|
exports.isTTY = binding.isTTY;
|
|
exports.isatty = exports.isTTY;
|
|
exports.WriteStream._resize.on("signal", () => {
|
|
for (const stream of exports.WriteStream._streams) {
|
|
stream._onresize();
|
|
}
|
|
}).unref();
|
|
function noop() {
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-pipe/binding.js
|
|
var require_binding10 = __commonJS({
|
|
"../../node_modules/bare-pipe/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-pipe/lib/constants.js
|
|
var require_constants5 = __commonJS({
|
|
"../../node_modules/bare-pipe/lib/constants.js"(exports, module) {
|
|
module.exports = {
|
|
state: {
|
|
CONNECTING: 1,
|
|
CONNECTED: 2,
|
|
BINDING: 4,
|
|
BOUND: 8,
|
|
READING: 16,
|
|
CLOSING: 32,
|
|
READABLE: 64,
|
|
WRITABLE: 128,
|
|
UNREFED: 256
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-pipe/lib/errors.js
|
|
var require_errors7 = __commonJS({
|
|
"../../node_modules/bare-pipe/lib/errors.js"(exports, module) {
|
|
module.exports = class PipeError extends Error {
|
|
constructor(msg, fn = PipeError, code = fn.name) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "PipeError";
|
|
}
|
|
static PIPE_ALREADY_CONNECTED(msg) {
|
|
return new PipeError(msg, PipeError.PIPE_ALREADY_CONNECTED);
|
|
}
|
|
static SERVER_ALREADY_LISTENING(msg) {
|
|
return new PipeError(msg, PipeError.SERVER_ALREADY_LISTENING);
|
|
}
|
|
static SERVER_IS_CLOSED(msg) {
|
|
return new PipeError(msg, PipeError.SERVER_IS_CLOSED);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-pipe/index.js
|
|
var require_bare_pipe = __commonJS({
|
|
"../../node_modules/bare-pipe/index.js"(exports, module) {
|
|
var EventEmitter = require_bare_events();
|
|
var { Duplex } = require_bare_stream();
|
|
var binding = require_binding10();
|
|
var constants = require_constants5();
|
|
var errors = require_errors7();
|
|
var defaultReadBufferSize = 65536;
|
|
var empty = Buffer.alloc(0);
|
|
module.exports = exports = class Pipe extends Duplex {
|
|
constructor(path, opts = {}) {
|
|
if (typeof path === "object" && path !== null) {
|
|
opts = path;
|
|
path = null;
|
|
}
|
|
const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true, eagerOpen = true } = opts;
|
|
super({ eagerOpen });
|
|
this._state = 0;
|
|
this._allowHalfOpen = allowHalfOpen;
|
|
this._fd = -1;
|
|
this._path = null;
|
|
this._pendingOpen = null;
|
|
this._pendingWrite = null;
|
|
this._pendingFinal = null;
|
|
this._pendingDestroy = null;
|
|
this._buffer = Buffer.alloc(readBufferSize);
|
|
this._handle = binding.init(
|
|
this._buffer,
|
|
this,
|
|
noop,
|
|
this._onconnect,
|
|
this._onwrite,
|
|
this._onfinal,
|
|
this._onread,
|
|
this._onclose
|
|
);
|
|
if (typeof path === "number") {
|
|
this.open(path);
|
|
} else if (typeof path === "string") {
|
|
this.connect(path);
|
|
}
|
|
}
|
|
get connecting() {
|
|
return (this._state & constants.state.CONNECTING) !== 0;
|
|
}
|
|
get pending() {
|
|
return (this._state & constants.state.CONNECTED) === 0;
|
|
}
|
|
get readyState() {
|
|
if (this._state & constants.state.READABLE && this._state & constants.state.WRITABLE) {
|
|
return "open";
|
|
}
|
|
if (this._state & constants.state.READABLE) {
|
|
return "readOnly";
|
|
}
|
|
if (this._state & constants.state.WRITABLE) {
|
|
return "writeOnly";
|
|
}
|
|
return "opening";
|
|
}
|
|
open(fd, opts = {}, onconnect) {
|
|
if (typeof opts === "function") {
|
|
onconnect = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof fd === "object" && fd !== null) {
|
|
opts = fd || {};
|
|
fd = opts.fd;
|
|
}
|
|
try {
|
|
const status = binding.open(this._handle, fd);
|
|
this._state |= constants.state.CONNECTED;
|
|
this._fd = fd;
|
|
if (status & binding.READABLE) {
|
|
this._state |= constants.state.READABLE;
|
|
} else {
|
|
this.push(null);
|
|
}
|
|
if (status & binding.WRITABLE) {
|
|
this._state |= constants.state.WRITABLE;
|
|
} else {
|
|
this.end();
|
|
}
|
|
if (onconnect) this.once("connect", onconnect);
|
|
queueMicrotask(() => this.emit("connect"));
|
|
} catch (err) {
|
|
queueMicrotask(() => {
|
|
if (this._pendingOpen) this._pendingOpen(err);
|
|
else this.destroy(err);
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
connect(path, opts = {}, onconnect) {
|
|
if (this._state & constants.state.CONNECTING || this._state & constants.state.CONNECTED) {
|
|
throw errors.PIPE_ALREADY_CONNECTED("Pipe is already connected");
|
|
}
|
|
this._state |= constants.state.CONNECTING;
|
|
if (typeof opts === "function") {
|
|
onconnect = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof path === "object" && path !== null) {
|
|
opts = path || {};
|
|
path = opts.path;
|
|
}
|
|
try {
|
|
binding.connect(this._handle, path);
|
|
this._path = path;
|
|
if (onconnect) this.once("connect", onconnect);
|
|
} catch (err) {
|
|
queueMicrotask(() => {
|
|
if (this._pendingOpen) this._pendingOpen(err);
|
|
else this.destroy(err);
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
ref() {
|
|
binding.ref(this._handle);
|
|
return this;
|
|
}
|
|
unref() {
|
|
binding.unref(this._handle);
|
|
return this;
|
|
}
|
|
_open(cb) {
|
|
if (this._state & constants.state.CONNECTED) return cb(null);
|
|
this._pendingOpen = cb;
|
|
}
|
|
_read() {
|
|
if ((this._state & constants.state.READING) === 0) {
|
|
this._state |= constants.state.READING;
|
|
binding.resume(this._handle);
|
|
}
|
|
}
|
|
_writev(batch, cb) {
|
|
this._pendingWrite = [cb, batch];
|
|
binding.writev(
|
|
this._handle,
|
|
batch.map(({ chunk }) => chunk)
|
|
);
|
|
}
|
|
_final(cb) {
|
|
if (this._state & constants.state.READABLE && this._state & constants.state.WRITABLE) {
|
|
this._pendingFinal = cb;
|
|
binding.end(this._handle);
|
|
} else {
|
|
cb(null);
|
|
}
|
|
}
|
|
_predestroy() {
|
|
if (this._state & constants.state.CLOSING) return;
|
|
this._state |= constants.state.CLOSING;
|
|
binding.close(this._handle);
|
|
}
|
|
_destroy(err, cb) {
|
|
if (this._state & constants.state.CLOSING) return cb(err);
|
|
this._state |= constants.state.CLOSING;
|
|
this._pendingDestroy = cb;
|
|
binding.close(this._handle);
|
|
}
|
|
_continueOpen(err) {
|
|
if (this._pendingOpen === null) return;
|
|
const cb = this._pendingOpen;
|
|
this._pendingOpen = null;
|
|
cb(err);
|
|
}
|
|
_continueWrite(err) {
|
|
if (this._pendingWrite === null) return;
|
|
const cb = this._pendingWrite[0];
|
|
this._pendingWrite = null;
|
|
cb(err);
|
|
}
|
|
_continueFinal(err) {
|
|
if (this._pendingFinal === null) return;
|
|
const cb = this._pendingFinal;
|
|
this._pendingFinal = null;
|
|
cb(err);
|
|
}
|
|
_continueDestroy() {
|
|
if (this._pendingDestroy === null) return;
|
|
const cb = this._pendingDestroy;
|
|
this._pendingDestroy = null;
|
|
cb(null);
|
|
}
|
|
_onconnect(err) {
|
|
if (err) {
|
|
if (this._pendingOpen) this._continueOpen(err);
|
|
else this.destroy(err);
|
|
return;
|
|
}
|
|
this._state |= constants.state.CONNECTED | constants.state.READABLE | constants.state.WRITABLE;
|
|
this._state &= ~constants.state.CONNECTING;
|
|
this._continueOpen();
|
|
this.emit("connect");
|
|
}
|
|
_onread(err, read) {
|
|
if (err) {
|
|
this.destroy(err);
|
|
return;
|
|
}
|
|
if (read === 0) {
|
|
this.push(null);
|
|
if (this._allowHalfOpen === false) this.end();
|
|
return;
|
|
}
|
|
const copy = Buffer.allocUnsafe(read);
|
|
copy.set(this._buffer.subarray(0, read));
|
|
if (this.push(copy) === false && this.destroying === false) {
|
|
this._state &= ~constants.state.READING;
|
|
binding.pause(this._handle);
|
|
}
|
|
}
|
|
_onwrite(err) {
|
|
this._continueWrite(err);
|
|
}
|
|
_onfinal(err) {
|
|
this._continueFinal(err === null || err.code === "ENOTCONN" ? null : err);
|
|
}
|
|
_onclose() {
|
|
this._continueDestroy();
|
|
}
|
|
_onspawn(readable, writable) {
|
|
this._state |= constants.state.CONNECTED;
|
|
if (readable) {
|
|
this._state |= constants.state.READABLE;
|
|
} else {
|
|
this.push(null);
|
|
}
|
|
if (writable) {
|
|
this._state |= constants.state.WRITABLE;
|
|
} else {
|
|
this.end();
|
|
}
|
|
this._continueOpen();
|
|
}
|
|
};
|
|
exports.Pipe = exports;
|
|
exports.pipe = function pipe() {
|
|
return binding.pipe();
|
|
};
|
|
exports.Server = class PipeServer extends EventEmitter {
|
|
constructor(opts = {}, onconnection) {
|
|
if (typeof opts === "function") {
|
|
onconnection = opts;
|
|
opts = {};
|
|
}
|
|
super();
|
|
const {
|
|
readBufferSize = defaultReadBufferSize,
|
|
allowHalfOpen = true,
|
|
pauseOnConnect = false
|
|
} = opts;
|
|
this._state = 0;
|
|
this._readBufferSize = readBufferSize;
|
|
this._allowHalfOpen = allowHalfOpen;
|
|
this._pauseOnConnect = pauseOnConnect;
|
|
this._path = null;
|
|
this._connections = /* @__PURE__ */ new Set();
|
|
this._error = null;
|
|
this._handle = null;
|
|
if (onconnection) this.on("connection", onconnection);
|
|
}
|
|
get listening() {
|
|
return (this._state & constants.state.BOUND) !== 0;
|
|
}
|
|
address() {
|
|
if ((this._state & constants.state.BOUND) === 0) {
|
|
return null;
|
|
}
|
|
return this._path;
|
|
}
|
|
listen(path, backlog = 511, opts = {}, onlistening) {
|
|
if (this._state & constants.state.BINDING || this._state & constants.state.BOUND) {
|
|
throw errors.SERVER_ALREADY_LISTENING("Server is already listening");
|
|
}
|
|
if (this._state & constants.state.CLOSING) {
|
|
throw errors.SERVER_IS_CLOSED("Server is closed");
|
|
}
|
|
this._state |= constants.state.BINDING;
|
|
if (typeof backlog === "function") {
|
|
onlistening = backlog;
|
|
backlog = 511;
|
|
} else if (typeof opts === "function") {
|
|
onlistening = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof path === "object" && path !== null) {
|
|
opts = path || {};
|
|
path = opts.path;
|
|
backlog = opts.backlog || 511;
|
|
}
|
|
this._handle = binding.init(
|
|
empty,
|
|
this,
|
|
this._onconnection,
|
|
noop,
|
|
noop,
|
|
noop,
|
|
noop,
|
|
this._onclose
|
|
);
|
|
if (this._state & constants.state.UNREFED) binding.unref(this._handle);
|
|
try {
|
|
binding.bind(this._handle, path, backlog);
|
|
this._path = path;
|
|
this._state |= constants.state.BOUND;
|
|
this._state &= ~constants.state.BINDING;
|
|
if (onlistening) this.once("listening", onlistening);
|
|
queueMicrotask(() => this.emit("listening"));
|
|
} catch (err) {
|
|
this._error = err;
|
|
binding.close(this._handle);
|
|
}
|
|
return this;
|
|
}
|
|
close(onclose) {
|
|
if (onclose) this.once("close", onclose);
|
|
if (this._state & constants.state.CLOSING) return;
|
|
this._state |= constants.state.CLOSING;
|
|
this._closeMaybe();
|
|
return this;
|
|
}
|
|
ref() {
|
|
this._state &= ~constants.state.UNREFED;
|
|
if (this._handle !== null) binding.ref(this._handle);
|
|
return this;
|
|
}
|
|
unref() {
|
|
this._state |= constants.state.UNREFED;
|
|
if (this._handle !== null) binding.unref(this._handle);
|
|
return this;
|
|
}
|
|
_closeMaybe() {
|
|
if (this._state & constants.state.CLOSING && this._connections.size === 0) {
|
|
if (this._handle !== null) binding.close(this._handle);
|
|
else queueMicrotask(() => this.emit("close"));
|
|
}
|
|
}
|
|
_onconnection(err) {
|
|
if (err) {
|
|
this.emit("error", err);
|
|
return;
|
|
}
|
|
if (this._state & constants.state.CLOSING) return;
|
|
const pipe = new exports.Pipe({
|
|
readBufferSize: this._readBufferSize,
|
|
allowHalfOpen: this._allowHalfOpen,
|
|
eagerOpen: !this._pauseOnConnect
|
|
});
|
|
try {
|
|
binding.accept(this._handle, pipe._handle);
|
|
pipe._path = this._path;
|
|
pipe._state |= constants.state.CONNECTED | constants.state.READABLE | constants.state.WRITABLE;
|
|
this._connections.add(pipe);
|
|
pipe.on("close", () => {
|
|
this._connections.delete(pipe);
|
|
this._closeMaybe();
|
|
});
|
|
this.emit("connection", pipe);
|
|
} catch (err2) {
|
|
pipe.destroy();
|
|
throw err2;
|
|
}
|
|
}
|
|
_onclose() {
|
|
const err = this._error;
|
|
this._state &= ~constants.state.BINDING;
|
|
this._error = null;
|
|
this._handle = null;
|
|
if (err) this.emit("error", err);
|
|
else this.emit("close");
|
|
}
|
|
};
|
|
exports.constants = constants;
|
|
exports.errors = errors;
|
|
exports.createConnection = function createConnection(path, opts, onconnect) {
|
|
if (typeof opts === "function") {
|
|
onconnect = opts;
|
|
opts = {};
|
|
}
|
|
if (typeof path === "object" && path !== null) {
|
|
opts = path || {};
|
|
path = opts.path;
|
|
}
|
|
return new exports.Pipe(opts).connect(path, opts, onconnect);
|
|
};
|
|
exports.createServer = function createServer(opts, onconnection) {
|
|
return new exports.Server(opts, onconnection);
|
|
};
|
|
function noop() {
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-stdio/binding.js
|
|
var require_binding11 = __commonJS({
|
|
"../../node_modules/bare-stdio/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-stdio/index.js
|
|
var require_bare_stdio = __commonJS({
|
|
"../../node_modules/bare-stdio/index.js"(exports, module) {
|
|
var fs = require_bare_fs();
|
|
var tty = require_bare_tty();
|
|
var Pipe = require_bare_pipe();
|
|
var binding = require_binding11();
|
|
var { TTY, NAMED_PIPE } = binding;
|
|
var IO = class {
|
|
constructor() {
|
|
this._in = null;
|
|
this._out = null;
|
|
this._err = null;
|
|
}
|
|
get in() {
|
|
if (this._in === null) {
|
|
switch (binding.guessType(0)) {
|
|
case TTY:
|
|
this._in = new tty.ReadStream(0);
|
|
break;
|
|
case NAMED_PIPE:
|
|
this._in = new Pipe(0, { eagerOpen: false });
|
|
break;
|
|
default:
|
|
this._in = fs.createReadStream(null, { fd: 0, eagerOpen: false });
|
|
}
|
|
}
|
|
return this._in;
|
|
}
|
|
get out() {
|
|
if (this._out === null) {
|
|
switch (binding.guessType(1)) {
|
|
case TTY:
|
|
this._out = new tty.WriteStream(1);
|
|
break;
|
|
case NAMED_PIPE:
|
|
this._out = new Pipe(1, { eagerOpen: false });
|
|
this._out.unref();
|
|
break;
|
|
default:
|
|
this._out = fs.createWriteStream(null, { fd: 1, eagerOpen: false });
|
|
}
|
|
}
|
|
return this._out;
|
|
}
|
|
get err() {
|
|
if (this._err === null) {
|
|
switch (binding.guessType(2)) {
|
|
case TTY:
|
|
this._err = new tty.WriteStream(2);
|
|
break;
|
|
case NAMED_PIPE:
|
|
this._err = new Pipe(2, { eagerOpen: false });
|
|
this._err.unref();
|
|
break;
|
|
default:
|
|
this._err = fs.createWriteStream(null, { fd: 2, eagerOpen: false });
|
|
}
|
|
}
|
|
return this._err;
|
|
}
|
|
};
|
|
module.exports = new IO();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-process/index.js
|
|
var require_bare_process = __commonJS({
|
|
"../../node_modules/bare-process/index.js"(exports, module) {
|
|
var abort = require_bare_abort();
|
|
var EventEmitter = require_bare_events();
|
|
var Signal = require_bare_signals();
|
|
var os = require_bare_os();
|
|
var env = require_bare_env();
|
|
var hrtime = require_bare_hrtime();
|
|
var stdio = require_bare_stdio();
|
|
var Process = class _Process extends EventEmitter {
|
|
constructor() {
|
|
super();
|
|
this._startTime = hrtime.bigint();
|
|
EventEmitter.forward(Bare, this, [
|
|
"uncaughtException",
|
|
"unhandledRejection",
|
|
"beforeExit",
|
|
"exit",
|
|
"suspend",
|
|
"wakeup",
|
|
"idle",
|
|
"resume"
|
|
]);
|
|
const signals = new Signal.Emitter();
|
|
signals.unref();
|
|
EventEmitter.forward(signals, this, Object.keys(os.constants.signals));
|
|
}
|
|
get stdin() {
|
|
return stdio.in;
|
|
}
|
|
get stdout() {
|
|
return stdio.out;
|
|
}
|
|
get stderr() {
|
|
return stdio.err;
|
|
}
|
|
get platform() {
|
|
return os.platform();
|
|
}
|
|
get arch() {
|
|
return os.arch();
|
|
}
|
|
get title() {
|
|
return os.getProcessTitle();
|
|
}
|
|
set title(title) {
|
|
os.setProcessTitle(title);
|
|
}
|
|
get pid() {
|
|
return os.pid();
|
|
}
|
|
get ppid() {
|
|
return os.ppid();
|
|
}
|
|
get argv() {
|
|
return Bare.argv;
|
|
}
|
|
get execPath() {
|
|
return os.execPath();
|
|
}
|
|
get exitCode() {
|
|
return Bare.exitCode;
|
|
}
|
|
set exitCode(code) {
|
|
Bare.exitCode = code;
|
|
}
|
|
get version() {
|
|
return Bare.version;
|
|
}
|
|
get versions() {
|
|
return Bare.versions;
|
|
}
|
|
get env() {
|
|
return env;
|
|
}
|
|
get hrtime() {
|
|
return hrtime;
|
|
}
|
|
abort() {
|
|
abort();
|
|
}
|
|
exit(code) {
|
|
Bare.exit(code);
|
|
}
|
|
suspend() {
|
|
Bare.suspend();
|
|
}
|
|
resume() {
|
|
Bare.resume();
|
|
}
|
|
cwd() {
|
|
return os.cwd();
|
|
}
|
|
chdir(directory) {
|
|
os.chdir(directory);
|
|
}
|
|
kill(pid, signal) {
|
|
os.kill(pid, signal);
|
|
}
|
|
uptime() {
|
|
return Number(hrtime.bigint() - this._startTime) / 1e9;
|
|
}
|
|
cpuUsage(previous) {
|
|
return os.cpuUsage(previous);
|
|
}
|
|
threadCpuUsage(previous) {
|
|
return os.threadCpuUsage(previous);
|
|
}
|
|
resourceUsage() {
|
|
return os.resourceUsage();
|
|
}
|
|
availableMemory() {
|
|
return os.availableMemory();
|
|
}
|
|
constrainedMemory() {
|
|
return os.constrainedMemory();
|
|
}
|
|
memoryUsage() {
|
|
return os.memoryUsage();
|
|
}
|
|
nextTick(cb, ...args) {
|
|
queueMicrotask(cb.bind(null, ...args));
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _Process },
|
|
platform: this.platform,
|
|
arch: this.arch,
|
|
title: this.title,
|
|
pid: this.pid,
|
|
ppid: this.ppid,
|
|
argv: this.argv,
|
|
execPath: this.execPath,
|
|
exitCode: this.exitCode,
|
|
version: this.version,
|
|
versions: this.versions,
|
|
env: this.env
|
|
};
|
|
}
|
|
};
|
|
module.exports = new Process();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-stylize/index.js
|
|
var require_bare_stylize = __commonJS({
|
|
"../../node_modules/bare-stylize/index.js"(exports, module) {
|
|
var escapes = require_bare_ansi_escapes();
|
|
var process = require_bare_process();
|
|
function getStylesMap() {
|
|
const stylesMap2 = {};
|
|
let style;
|
|
for (const escape of Object.getOwnPropertyNames(escapes)) {
|
|
if (escape.startsWith("color")) {
|
|
style = escape[5].toLowerCase() + escape.slice(6);
|
|
} else if (escape.startsWith("modifier")) {
|
|
style = escape[8].toLowerCase() + escape.slice(9);
|
|
} else {
|
|
continue;
|
|
}
|
|
stylesMap2[style] = escapes[escape];
|
|
}
|
|
return stylesMap2;
|
|
}
|
|
var stylesMap = getStylesMap();
|
|
module.exports = function stylize(styles, text, opts = {}) {
|
|
const validateStream = opts.validateStream ?? true;
|
|
const stream = opts.stream ?? process.stdout;
|
|
if (!validateStream || !stream.isTTY) return text;
|
|
if (typeof styles === "string") styles = [styles];
|
|
const code = styles.map((style) => stylesMap[style]).join("");
|
|
return code + text + escapes.modifierReset;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-utils/lib/deprecate.js
|
|
var require_deprecate = __commonJS({
|
|
"../../node_modules/bare-utils/lib/deprecate.js"(exports, module) {
|
|
module.exports = function deprecate(fn, msg, code) {
|
|
let warned = false;
|
|
return function(...args) {
|
|
if (!warned) {
|
|
warned = true;
|
|
if (code) {
|
|
console.warn(`[${code}]`, "DeprecationWarning:", msg);
|
|
} else {
|
|
console.warn("DeprecationWarning:", msg);
|
|
}
|
|
}
|
|
if (new.target) return Reflect.construct(fn, args, new.target);
|
|
return Reflect.apply(fn, this, args);
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-utils/lib/inherits.js
|
|
var require_inherits = __commonJS({
|
|
"../../node_modules/bare-utils/lib/inherits.js"(exports, module) {
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-utils/lib/promisify.js
|
|
var require_promisify = __commonJS({
|
|
"../../node_modules/bare-utils/lib/promisify.js"(exports, module) {
|
|
module.exports = function promisify(fn) {
|
|
return function(...args) {
|
|
return new Promise((resolve, reject) => {
|
|
args.push((err, ...result) => {
|
|
if (err) reject(err);
|
|
else resolve(...result);
|
|
});
|
|
Reflect.apply(fn, this, args);
|
|
});
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-utils/lib/types.js
|
|
var require_types = __commonJS({
|
|
"../../node_modules/bare-utils/lib/types.js"(exports) {
|
|
var type = require_bare_type();
|
|
exports.isAnyArrayBuffer = (value) => {
|
|
const t = type(value);
|
|
return t.isArrayBuffer() || t.isSharedArrayBuffer();
|
|
};
|
|
exports.isArrayBufferView = (value) => ArrayBuffer.isView(value);
|
|
exports.isArgumentsObject = (value) => type(value).isArguments();
|
|
exports.isArrayBuffer = (value) => type(value).isArrayBuffer();
|
|
exports.isAsyncFunction = (value) => type(value).isAsyncFunction();
|
|
exports.isBigInt64Array = (value) => type(value).isBigInt64Array();
|
|
exports.isBigIntObject = (value) => value instanceof BigInt;
|
|
exports.isBigUint64Array = (value) => type(value).isBigUint64Array();
|
|
exports.isBooleanObject = (value) => value instanceof Boolean;
|
|
exports.isBoxedPrimitive = (value) => exports.isBigIntObject(value) || exports.isBooleanObject(value) || exports.isNumberObject(value) || exports.isStringObject(value) || exports.isSymbolObject(value);
|
|
exports.isCryptoKey = () => {
|
|
return false;
|
|
};
|
|
exports.isDataView = (value) => type(value).isDataView();
|
|
exports.isDate = (value) => type(value).isDate();
|
|
exports.isExternal = (value) => type(value).isExternal();
|
|
exports.isFloat16Array = () => {
|
|
return false;
|
|
};
|
|
exports.isFloat32Array = (value) => type(value).isFloat32Array();
|
|
exports.isFloat64Array = (value) => type(value).isFloat64Array();
|
|
exports.isGeneratorFunction = (value) => type(value).isGeneratorFunction();
|
|
exports.isGeneratorObject = (value) => type(value).isGenerator();
|
|
exports.isInt8Array = (value) => type(value).isInt8Array();
|
|
exports.isInt16Array = (value) => type(value).isInt16Array();
|
|
exports.isInt32Array = (value) => type(value).isInt32Array();
|
|
exports.isKeyObject = () => {
|
|
return false;
|
|
};
|
|
exports.isMap = (value) => type(value).isMap();
|
|
exports.isMapIterator = () => {
|
|
return false;
|
|
};
|
|
exports.isModuleNamespaceObject = (value) => type(value).isModuleNamespace();
|
|
exports.isNativeError = (value) => {
|
|
return value instanceof Error;
|
|
};
|
|
exports.isNumberObject = (value) => value instanceof Number;
|
|
exports.isPromise = (value) => type(value).isPromise();
|
|
exports.isProxy = (value) => type(value).isProxy();
|
|
exports.isRegExp = (value) => type(value).isRegExp();
|
|
exports.isSet = (value) => type(value).isSet();
|
|
exports.isSetIterator = () => {
|
|
return false;
|
|
};
|
|
exports.isSharedArrayBuffer = (value) => type(value).isSharedArrayBuffer();
|
|
exports.isStringObject = (value) => value instanceof String;
|
|
exports.isSymbolObject = (value) => value instanceof Symbol;
|
|
exports.isTypedArray = (value) => type(value).isTypedArray();
|
|
exports.isUint8Array = (value) => type(value).isUint8Array();
|
|
exports.isUint8ClampedArray = (value) => type(value).isUint8ClampedArray();
|
|
exports.isUint16Array = (value) => type(value).isUint16Array();
|
|
exports.isUint32Array = (value) => type(value).isUint32Array();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-utils/index.js
|
|
var require_bare_utils = __commonJS({
|
|
"../../node_modules/bare-utils/index.js"(exports) {
|
|
var { TextEncoder, TextDecoder } = require_bare_encoding();
|
|
exports.TextEncoder = TextEncoder;
|
|
exports.TextDecoder = TextDecoder;
|
|
exports.debuglog = require_bare_debug_log();
|
|
exports.format = require_bare_format();
|
|
exports.formatWithOptions = exports.format.formatWithOptions;
|
|
exports.inspect = require_bare_inspect();
|
|
exports.styleText = require_bare_stylize();
|
|
exports.deprecate = require_deprecate();
|
|
exports.inherits = require_inherits();
|
|
exports.promisify = require_promisify();
|
|
exports.types = require_types();
|
|
}
|
|
});
|
|
|
|
// ../../bare-lib-entry-bareUtils.js
|
|
var bare_lib_entry_bareUtils_exports = {};
|
|
__export(bare_lib_entry_bareUtils_exports, {
|
|
default: () => bare_lib_entry_bareUtils_default
|
|
});
|
|
var import_bare_utils = __toESM(require_bare_utils());
|
|
var bare_lib_entry_bareUtils_default = import_bare_utils.default;
|
|
return __toCommonJS(bare_lib_entry_bareUtils_exports);
|
|
})();
|
|
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareUtils"]=v;})();
|