snxraven/bare-operating-system
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
35ac6633ea1eecb909a171994c0c7f1641d86787
bare-operating-system/packages/bare-os-seeder/kernel/lib/bare/bundles/bareFormData.js
T
Raven Scott 57b1296981 themes
2026-04-03 21:39:36 -04:00

3201 lines
117 KiB
JavaScript
Raw Blame History

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/events-universal/default.js
var require_default = __commonJS({
"../../node_modules/events-universal/default.js"(exports, module) {
module.exports = __require("events");
}
});
// ../../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/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_decoder = __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_decoder = __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_decoder();
var UTF8Decoder = require_utf8_decoder();
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-buffer/binding.js
var require_binding = __commonJS({
"../../node_modules/bare-buffer/binding.js"(exports, module) {
module.exports = __require.addon();
}
});
// ../../node_modules/bare-buffer/lib/constants.js
var require_constants = __commonJS({
"../../node_modules/bare-buffer/lib/constants.js"(exports, module) {
var binding = require_binding();
module.exports = binding.constants;
}
});
// ../../node_modules/bare-buffer/lib/ascii.js
var require_ascii = __commonJS({
"../../node_modules/bare-buffer/lib/ascii.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length;
};
exports.toString = function toString(buffer) {
const len = buffer.byteLength;
let result = "";
for (let i = 0; i < len; i++) {
result += String.fromCharCode(buffer[i] & 127);
}
return result;
};
exports.write = function write(buffer, string) {
const len = buffer.byteLength;
for (let i = 0; i < len; i++) {
buffer[i] = string.charCodeAt(i);
}
return len;
};
exports.validate = function validate(buffer) {
return binding.validateAscii(buffer.buffer, buffer.byteLength);
};
}
});
// ../../node_modules/bare-buffer/lib/base64.js
var require_base64 = __commonJS({
"../../node_modules/bare-buffer/lib/base64.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
let len = string.length;
if (string.charCodeAt(len - 1) === 61) len--;
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
return len * 3 >>> 2;
};
exports.toString = function toString(buffer) {
return binding.toStringBase64(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeBase64(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
}
});
// ../../node_modules/bare-buffer/lib/base64url.js
var require_base64url = __commonJS({
"../../node_modules/bare-buffer/lib/base64url.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
let len = string.length;
if (string.charCodeAt(len - 1) === 61) len--;
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
return len * 3 >>> 2;
};
exports.toString = function toString(buffer) {
return binding.toStringBase64URL(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeBase64(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
}
});
// ../../node_modules/bare-buffer/lib/hex.js
var require_hex = __commonJS({
"../../node_modules/bare-buffer/lib/hex.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length >>> 1;
};
exports.toString = function toString(buffer) {
return binding.toStringHex(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeHex(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
}
});
// ../../node_modules/bare-buffer/lib/utf8.js
var require_utf8 = __commonJS({
"../../node_modules/bare-buffer/lib/utf8.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return binding.byteLengthUTF8(string);
};
exports.toString = function toString(buffer) {
return binding.toStringUTF8(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeUTF8(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
exports.validate = function validate(buffer) {
return binding.validateUTF8(buffer.buffer, buffer.byteLength);
};
}
});
// ../../node_modules/bare-buffer/lib/utf16le.js
var require_utf16le = __commonJS({
"../../node_modules/bare-buffer/lib/utf16le.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length * 2;
};
exports.toString = function toString(buffer) {
return binding.toStringUTF16LE(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeUTF16LE(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
}
});
// ../../node_modules/bare-buffer/lib/latin1.js
var require_latin1 = __commonJS({
"../../node_modules/bare-buffer/lib/latin1.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length;
};
exports.toString = function toString(buffer) {
return binding.toStringLatin1(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.write = function write(buffer, string) {
return binding.writeLatin1(buffer.buffer, buffer.byteOffset, buffer.byteLength, string);
};
}
});
// ../../node_modules/bare-buffer/index.js
var require_bare_buffer = __commonJS({
"../../node_modules/bare-buffer/index.js"(exports, module) {
var constants = require_constants();
var ascii = require_ascii();
var base64 = require_base64();
var base64url = require_base64url();
var hex = require_hex();
var utf8 = require_utf8();
var utf16le = require_utf16le();
var latin1 = require_latin1();
var binding = require_binding();
var kind = Symbol.for("bare.buffer.kind");
var poolSize = 0;
module.exports = exports = class Buffer3 extends Uint8Array {
static get [kind]() {
return 0;
}
static get poolSize() {
return poolSize;
}
static set poolSize(value) {
poolSize = Math.max(0, value);
}
constructor(arrayBuffer, offset, length, opts = {}) {
if (typeof arrayBuffer === "number") {
opts = offset || {};
const { uninitialized = false } = opts;
offset = 0;
length = arrayBuffer;
if (length > constants.MAX_LENGTH) {
throw new RangeError(`Buffer length must be at most ${constants.MAX_LENGTH}`);
}
arrayBuffer = uninitialized ? binding.allocUnsafe(length) : binding.alloc(length);
} else {
if (length > constants.MAX_LENGTH) {
throw new RangeError(`Buffer length must be at most ${constants.MAX_LENGTH}`);
}
if (typeof offset === "object" && offset !== null) {
opts = offset;
offset = 0;
length = arrayBuffer.byteLength;
} else if (typeof length === "length" && length !== null) {
opts = length;
length = arrayBuffer.byteLength - offset;
}
}
super(arrayBuffer, offset, length);
}
get [kind]() {
return Buffer3[kind];
}
copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
let source = this;
if (targetStart < 0) targetStart = 0;
if (targetStart >= target.byteLength) return 0;
const targetLength = target.byteLength - targetStart;
if (sourceStart < 0) sourceStart = 0;
if (sourceStart >= source.byteLength) return 0;
if (sourceEnd <= sourceStart) return 0;
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
if (sourceEnd - sourceStart > targetLength) {
sourceEnd = sourceStart + targetLength;
}
const sourceLength = sourceEnd - sourceStart;
if (source === target) {
target.copyWithin(targetStart, sourceStart, sourceEnd);
} else {
if (sourceStart !== 0 || sourceEnd !== source.byteLength) {
source = source.subarray(sourceStart, sourceEnd);
}
target.set(source, targetStart);
}
return sourceLength;
}
equals(target) {
const source = this;
if (source === target) return true;
if (source.byteLength !== target.byteLength) return false;
return binding.compare(
source.buffer,
source.byteOffset,
source.byteLength,
target.buffer,
target.byteOffset,
target.byteLength
) === 0;
}
compare(target, targetStart = 0, targetEnd = target.byteLength, sourceStart = 0, sourceEnd = this.byteLength) {
let source = this;
if (source === target) return 0;
if (arguments.length > 1) {
if (targetStart < 0) targetStart = 0;
if (targetStart > target.byteLength) targetStart = target.byteLength;
if (targetEnd < targetStart) targetEnd = targetStart;
if (targetEnd > target.byteLength) targetEnd = target.byteLength;
if (sourceStart < 0) sourceStart = 0;
if (sourceStart > source.byteLength) sourceStart = source.byteLength;
if (sourceEnd < sourceStart) sourceEnd = sourceStart;
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
if (sourceStart !== 0 || sourceEnd !== source.byteLength) {
source = source.subarray(sourceStart, sourceEnd);
}
if (targetStart !== 0 || targetEnd !== target.byteLength) {
target = target.subarray(targetStart, targetEnd);
}
}
return binding.compare(
source.buffer,
source.byteOffset,
source.byteLength,
target.buffer,
target.byteOffset,
target.byteLength
);
}
fill(value, offset = 0, end = this.byteLength, encoding = "utf8") {
if (typeof value === "string") {
if (typeof offset === "string") {
encoding = offset;
offset = 0;
end = this.byteLength;
} else if (typeof end === "string") {
encoding = end;
end = this.byteLength;
}
} else if (typeof value === "number") {
value = value & 255;
} else if (typeof value === "boolean") {
value = +value;
}
if (offset < 0) offset = 0;
if (offset >= this.byteLength) return this;
if (end <= offset) return this;
if (end > this.byteLength) end = this.byteLength;
if (typeof value === "number") return super.fill(value, offset, end);
if (typeof value === "string") value = exports.from(value, encoding);
const length = value.byteLength;
for (let i = 0, n = end - offset; i < n; ++i) {
this[i + offset] = value[i % length];
}
return this;
}
includes(value, offset, encoding) {
return this.indexOf(value, offset, encoding) !== -1;
}
indexOf(value, offset = 0, encoding) {
if (typeof value === "boolean") value = +value;
if (typeof value === "number") {
return super.indexOf(value & 255, offset);
}
return bidirectionalIndexOf(
this,
value,
offset,
encoding,
true
/* first */
);
}
lastIndexOf(value, offset = this.byteLength - 1, encoding) {
if (typeof value === "boolean") value = +value;
if (typeof value === "number") {
return super.lastIndexOf(value & 255, offset);
}
return bidirectionalIndexOf(
this,
value,
offset,
encoding,
false
/* last */
);
}
swap16() {
const length = this.byteLength;
if (length % 2 !== 0) {
throw new RangeError("Buffer size must be a multiple of 16-bits");
}
for (let i = 0; i < length; i += 2) swap(this, i, i + 1);
return this;
}
swap32() {
const length = this.byteLength;
if (length % 4 !== 0) {
throw new RangeError("Buffer size must be a multiple of 32-bits");
}
for (let i = 0; i < length; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this;
}
swap64() {
const length = this.byteLength;
if (length % 8 !== 0) {
throw new RangeError("Buffer size must be a multiple of 64-bits");
}
for (let i = 0; i < length; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this;
}
toString(encoding = "utf8", start = 0, end = this.byteLength) {
if (arguments.length === 0) return utf8.toString(this);
if (arguments.length === 1) return codecFor(encoding).toString(this);
if (start < 0) start = 0;
if (start >= this.byteLength) return "";
if (end <= start) return "";
if (end > this.byteLength) end = this.byteLength;
let buffer = this;
if (start !== 0 || end !== this.byteLength) {
buffer = buffer.subarray(start, end);
}
return codecFor(encoding).toString(buffer);
}
toJSON() {
return Array.from(this);
}
write(string, offset = 0, length = this.byteLength - offset, encoding = "utf8") {
if (arguments.length === 1) return utf8.write(this, string);
if (typeof offset === "string") {
encoding = offset;
offset = 0;
length = this.byteLength;
} else if (typeof length === "string") {
encoding = length;
length = this.byteLength - offset;
}
length = Math.min(length, exports.byteLength(string, encoding));
let start = offset;
if (start < 0) start = 0;
if (start >= this.byteLength) return 0;
let end = offset + length;
if (end <= start) return 0;
if (end > this.byteLength) end = this.byteLength;
let buffer = this;
if (start !== 0 || end !== this.byteLength) {
buffer = buffer.subarray(start, end);
}
return codecFor(encoding).write(buffer, string);
}
readBigInt64BE(offset = 0) {
return viewOf(this).getBigInt64(offset, false);
}
readBigInt64LE(offset = 0) {
return viewOf(this).getBigInt64(offset, true);
}
readBigUint64BE(offset = 0) {
return viewOf(this).getBigUint64(offset, false);
}
readBigUint64LE(offset = 0) {
return viewOf(this).getBigUint64(offset, true);
}
readDoubleBE(offset = 0) {
return viewOf(this).getFloat64(offset, false);
}
readDoubleLE(offset = 0) {
return viewOf(this).getFloat64(offset, true);
}
readFloatBE(offset = 0) {
return viewOf(this).getFloat32(offset, false);
}
readFloatLE(offset = 0) {
return viewOf(this).getFloat32(offset, true);
}
readInt8(offset = 0) {
return viewOf(this).getInt8(offset);
}
readInt16BE(offset = 0) {
return viewOf(this).getInt16(offset, false);
}
readInt16LE(offset = 0) {
return viewOf(this).getInt16(offset, true);
}
readInt32BE(offset = 0) {
return viewOf(this).getInt32(offset, false);
}
readInt32LE(offset = 0) {
return viewOf(this).getInt32(offset, true);
}
readIntBE(offset, byteLength) {
if (byteLength === 6) return readInt48BE(viewOf(this), offset);
if (byteLength === 5) return readInt40BE(viewOf(this), offset);
if (byteLength === 3) return readInt24BE(viewOf(this), offset);
if (byteLength === 4) return this.readInt32BE(offset);
if (byteLength === 2) return this.readInt16BE(offset);
if (byteLength === 1) return this.readInt8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readIntLE(offset, byteLength) {
if (byteLength === 6) return readInt48LE(viewOf(this), offset);
if (byteLength === 5) return readInt40LE(viewOf(this), offset);
if (byteLength === 3) return readInt24LE(viewOf(this), offset);
if (byteLength === 4) return this.readInt32LE(offset);
if (byteLength === 2) return this.readInt16LE(offset);
if (byteLength === 1) return this.readInt8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readUint8(offset = 0) {
return viewOf(this).getUint8(offset);
}
readUint16BE(offset = 0) {
return viewOf(this).getUint16(offset, false);
}
readUint16LE(offset = 0) {
return viewOf(this).getUint16(offset, true);
}
readUint32BE(offset = 0) {
return viewOf(this).getUint32(offset, false);
}
readUint32LE(offset = 0) {
return viewOf(this).getUint32(offset, true);
}
readUintBE(offset, byteLength) {
if (byteLength === 6) return readUint48BE(viewOf(this), offset);
if (byteLength === 5) return readUint40BE(viewOf(this), offset);
if (byteLength === 3) return readUint24BE(viewOf(this), offset);
if (byteLength === 4) return this.readUint32BE(offset);
if (byteLength === 2) return this.readUint16BE(offset);
if (byteLength === 1) return this.readUint8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readUintLE(offset, byteLength) {
if (byteLength === 6) return readUint48LE(viewOf(this), offset);
if (byteLength === 5) return readUint40LE(viewOf(this), offset);
if (byteLength === 3) return readUint24LE(viewOf(this), offset);
if (byteLength === 4) return this.readUint32LE(offset);
if (byteLength === 2) return this.readUint16LE(offset);
if (byteLength === 1) return this.readUint8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readBigUInt64BE(...args) {
return this.readBigUint64BE(...args);
}
readBigUInt64LE(...args) {
return this.readBigUint64LE(...args);
}
readUInt8(...args) {
return this.readUint8(...args);
}
readUInt16BE(...args) {
return this.readUint16BE(...args);
}
readUInt16LE(...args) {
return this.readUint16LE(...args);
}
readUInt32BE(...args) {
return this.readUint32BE(...args);
}
readUInt32LE(...args) {
return this.readUint32LE(...args);
}
readUIntBE(...args) {
return this.readUintBE(...args);
}
readUIntLE(...args) {
return this.readUintLE(...args);
}
writeBigInt64BE(value, offset = 0) {
viewOf(this).setBigInt64(offset, value, false);
return offset + 8;
}
writeBigInt64LE(value, offset = 0) {
viewOf(this).setBigInt64(offset, value, true);
return offset + 8;
}
writeBigUint64BE(value, offset = 0) {
viewOf(this).setBigUint64(offset, value, false);
return offset + 8;
}
writeBigUint64LE(value, offset = 0) {
viewOf(this).setBigUint64(offset, value, true);
return offset + 8;
}
writeDoubleBE(value, offset = 0) {
viewOf(this).setFloat64(offset, value, false);
return offset + 8;
}
writeDoubleLE(value, offset = 0) {
viewOf(this).setFloat64(offset, value, true);
return offset + 8;
}
writeFloatBE(value, offset = 0) {
viewOf(this).setFloat32(offset, value, false);
return offset + 4;
}
writeFloatLE(value, offset = 0) {
viewOf(this).setFloat32(offset, value, true);
return offset + 4;
}
writeInt8(value, offset = 0) {
viewOf(this).setInt8(offset, value);
return offset + 1;
}
writeInt16BE(value, offset = 0) {
viewOf(this).setInt16(offset, value, false);
return offset + 2;
}
writeInt16LE(value, offset = 0) {
viewOf(this).setInt16(offset, value, true);
return offset + 2;
}
writeInt32BE(value, offset = 0) {
viewOf(this).setInt32(offset, value, false);
return offset + 4;
}
writeInt32LE(value, offset = 0) {
viewOf(this).setInt32(offset, value, true);
return offset + 4;
}
writeIntBE(value, offset, byteLength) {
if (byteLength === 6) return writeInt48BE(value, viewOf(this), offset);
if (byteLength === 5) return writeInt40BE(value, viewOf(this), offset);
if (byteLength === 3) return writeInt24BE(value, viewOf(this), offset);
if (byteLength === 4) return this.writeInt32BE(value, offset);
if (byteLength === 2) return this.writeInt16BE(value, offset);
if (byteLength === 1) return this.writeInt8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeIntLE(value, offset, byteLength) {
if (byteLength === 6) return writeInt48LE(value, viewOf(this), offset);
if (byteLength === 5) return writeInt40LE(value, viewOf(this), offset);
if (byteLength === 3) return writeInt24LE(value, viewOf(this), offset);
if (byteLength === 4) return this.writeInt32LE(value, offset);
if (byteLength === 2) return this.writeInt16LE(value, offset);
if (byteLength === 1) return this.writeInt8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeUint8(value, offset = 0) {
viewOf(this).setUint8(offset, value, true);
return offset + 1;
}
writeUint16BE(value, offset = 0) {
viewOf(this).setUint16(offset, value, false);
return offset + 2;
}
writeUint16LE(value, offset = 0) {
viewOf(this).setUint16(offset, value, true);
return offset + 2;
}
writeUint32LE(value, offset = 0) {
viewOf(this).setUint32(offset, value, true);
return offset + 4;
}
writeUint32BE(value, offset = 0) {
viewOf(this).setUint32(offset, value, false);
return offset + 4;
}
writeUintBE(value, offset, byteLength) {
if (byteLength === 6) return writeUint48BE(value, viewOf(this), offset);
if (byteLength === 5) return writeUint40BE(value, viewOf(this), offset);
if (byteLength === 3) return writeUint24BE(value, viewOf(this), offset);
if (byteLength === 4) return this.writeUint32BE(value, offset);
if (byteLength === 2) return this.writeUint16BE(value, offset);
if (byteLength === 1) return this.writeUint8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeUintLE(value, offset, byteLength) {
if (byteLength === 6) return writeUint48LE(value, viewOf(this), offset);
if (byteLength === 5) return writeUint40LE(value, viewOf(this), offset);
if (byteLength === 3) return writeUint24LE(value, viewOf(this), offset);
if (byteLength === 4) return this.writeUint32LE(value, offset);
if (byteLength === 2) return this.writeUint16LE(value, offset);
if (byteLength === 1) return this.writeUint8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeBigUInt64BE(...args) {
return this.writeBigUint64BE(...args);
}
writeBigUInt64LE(...args) {
return this.writeBigUint64LE(...args);
}
writeUInt8(...args) {
return this.writeUint8(...args);
}
writeUInt16BE(...args) {
return this.writeUint16BE(...args);
}
writeUInt16LE(...args) {
return this.writeUint16LE(...args);
}
writeUInt32BE(...args) {
return this.writeUint32BE(...args);
}
writeUInt32LE(...args) {
return this.writeUint32LE(...args);
}
writeUIntBE(...args) {
return this.writeUintBE(...args);
}
writeUIntLE(...args) {
return this.writeUintLE(...args);
}
};
var Buffer2 = exports;
exports.Buffer = Buffer2;
exports.constants = constants;
var codecs = /* @__PURE__ */ Object.create(null);
codecs.ascii = ascii;
codecs.base64 = base64;
codecs.base64url = base64url;
codecs.hex = hex;
codecs.utf8 = codecs["utf-8"] = utf8;
codecs.utf16le = codecs.ucs2 = codecs["utf-16le"] = codecs["ucs-2"] = utf16le;
codecs.latin1 = codecs.binary = latin1;
function codecFor(encoding = "utf8") {
if (encoding in codecs) return codecs[encoding];
encoding = encoding.toLowerCase();
if (encoding in codecs) return codecs[encoding];
throw new Error(`Unknown encoding '${encoding}'`);
}
var views = /* @__PURE__ */ new WeakMap();
function viewOf(buffer) {
let view = views.get(buffer);
if (view === void 0) {
view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
views.set(buffer, view);
}
return view;
}
exports.isBuffer = function isBuffer(value) {
if (value instanceof Buffer2) return true;
return typeof value === "object" && value !== null && value[kind] === Buffer2[kind];
};
exports.isEncoding = function isEncoding(encoding) {
try {
codecFor(encoding);
return true;
} catch {
return false;
}
};
exports.isASCII = function isASCII(buffer) {
return ascii.validate(buffer);
};
exports.isAscii = exports.isASCII;
exports.isUTF8 = function isUTF8(buffer) {
return utf8.validate(buffer);
};
exports.isUtf8 = exports.isUTF8;
exports.alloc = function alloc(size, fill, encoding) {
const buffer = new Buffer2(size);
if (fill !== void 0) buffer.fill(fill, 0, buffer.byteLength, encoding);
return buffer;
};
exports.allocUnsafe = function allocUnsafe(size) {
return new Buffer2(size, { uninitialized: true });
};
exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
return exports.allocUnsafe(size);
};
exports.byteLength = function byteLength(string, encoding) {
if (typeof string === "string") {
return codecFor(encoding).byteLength(string);
}
return string.byteLength;
};
exports.compare = function compare(a, b) {
return binding.compare(a.buffer, a.byteOffset, a.byteLength, b.buffer, b.byteOffset, b.byteLength);
};
exports.concat = function concat(buffers, length) {
if (length === void 0) {
length = buffers.reduce((length2, buffer) => length2 + buffer.byteLength, 0);
}
const result = new Buffer2(length);
for (let i = 0, n = buffers.length, offset = 0; i < n; i++) {
const buffer = buffers[i];
if (offset + buffer.byteLength > result.byteLength) {
result.set(buffer.subarray(0, result.byteLength - offset), offset);
return result;
}
result.set(buffer, offset);
offset += buffer.byteLength;
}
return result;
};
exports.coerce = function coerce(buffer) {
if (exports.isBuffer(buffer)) return buffer;
return new Buffer2(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.copyBytesFrom = function copyBytesFrom(view, offset = 0, length = view.length - offset) {
if (offset + length > view.length) {
throw new RangeError("View length is out of range");
}
if (offset !== 0 || length !== view.length) {
view = view.subarray(offset, offset + length);
}
return new Buffer2(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
};
exports.from = function from(value, encodingOrOffset, length) {
if (typeof value === "string") return fromString(value, encodingOrOffset);
if (Array.isArray(value)) return fromArray(value);
if (ArrayBuffer.isView(value)) return fromBuffer(value);
return fromArrayBuffer(value, encodingOrOffset, length);
};
function fromString(string, encoding) {
const codec = codecFor(encoding);
const buffer = new Buffer2(codec.byteLength(string));
codec.write(buffer, string);
return buffer;
}
function fromArray(array) {
const buffer = new Buffer2(array.length);
buffer.set(array);
return buffer;
}
function fromBuffer(buffer) {
const copy = new Buffer2(buffer.byteLength);
copy.set(buffer);
return copy;
}
function fromArrayBuffer(arrayBuffer, offset, length) {
return new Buffer2(arrayBuffer, offset, length);
}
function bidirectionalIndexOf(buffer, value, offset, encoding, first) {
if (buffer.byteLength === 0) return -1;
if (typeof offset === "string") {
encoding = offset;
offset = 0;
} else if (offset === void 0) {
offset = first ? 0 : buffer.byteLength - 1;
} else if (offset < 0) {
offset += buffer.byteLength;
}
if (offset >= buffer.byteLength) {
if (first) return -1;
else offset = buffer.byteLength - 1;
} else if (offset < 0) {
if (first) offset = 0;
else return -1;
}
if (typeof value === "string") value = exports.from(value, encoding);
if (value.byteLength === 0) return -1;
if (first) {
let foundIndex = -1;
for (let i = offset; i < buffer.byteLength; i++) {
if (buffer[i] === value[foundIndex === -1 ? 0 : i - foundIndex]) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === value.byteLength) return foundIndex;
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
}
} else {
if (offset + value.byteLength > buffer.byteLength) {
offset = buffer.byteLength - value.byteLength;
}
for (let i = offset; i >= 0; i--) {
let found = true;
for (let j = 0; j < value.byteLength; j++) {
if (buffer[i + j] !== value[j]) {
found = false;
break;
}
}
if (found) return i;
}
}
return -1;
}
function swap(buffer, n, m) {
const i = buffer[n];
buffer[n] = buffer[m];
buffer[m] = i;
}
exports.atob = function atob(data) {
return Buffer2.from(data, "base64").toString("latin1");
};
exports.btoa = function btoa(data) {
if (typeof data !== "string") data = String(data);
return Buffer2.from(data, "latin1").toString("base64");
};
exports.transcode = function transcode(buffer, from, to) {
return Buffer2.from(buffer.toString(from), to);
};
function readInt48BE(view, offset) {
const hi = view.getUint16(offset, false);
const lo = view.getUint32(offset + 2, false);
let value = lo + hi * 4294967296;
if (hi & 32768) value -= 281474976710656;
return value;
}
function readInt48LE(view, offset) {
const lo = view.getUint32(offset, true);
const hi = view.getUint16(offset + 4, true);
let value = lo + hi * 4294967296;
if (hi & 32768) value -= 281474976710656;
return value;
}
function readInt40BE(view, offset) {
const hi = view.getUint8(offset);
const lo = view.getUint32(offset + 1, false);
let value = lo + hi * 4294967296;
if (hi & 128) value -= 1099511627776;
return value;
}
function readInt40LE(view, offset) {
const lo = view.getUint32(offset, true);
const hi = view.getUint8(offset + 4);
let value = lo + hi * 4294967296;
if (hi & 128) value -= 1099511627776;
return value;
}
function readInt24BE(view, offset) {
const value = view.getUint8(offset) << 16 | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2);
return value & 8388608 ? value - 16777216 : value;
}
function readInt24LE(view, offset) {
const value = view.getUint8(offset) | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2) << 16;
return value & 8388608 ? value - 16777216 : value;
}
function readUint48BE(view, offset) {
const hi = view.getUint16(offset, false);
const lo = view.getUint32(offset + 2, false);
return lo + hi * 4294967296;
}
function readUint48LE(view, offset) {
const lo = view.getUint32(offset, true);
const hi = view.getUint16(offset + 4, true);
return lo + hi * 4294967296;
}
function readUint40BE(view, offset) {
const hi = view.getUint8(offset);
const lo = view.getUint32(offset + 1, false);
return lo + hi * 4294967296;
}
function readUint40LE(view, offset) {
const lo = view.getUint32(offset, true);
const hi = view.getUint8(offset + 4);
return lo + hi * 4294967296;
}
function readUint24BE(view, offset) {
return view.getUint8(offset) << 16 | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2);
}
function readUint24LE(view, offset) {
return view.getUint8(offset) | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2) << 16;
}
function writeInt48BE(value, view, offset) {
if (value < 0) value += 281474976710656;
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint16(offset, hi, false);
view.setUint32(offset + 2, lo, false);
return offset + 6;
}
function writeInt48LE(value, view, offset) {
if (value < 0) value += 281474976710656;
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint32(offset, lo, true);
view.setUint16(offset + 4, hi, true);
return offset + 6;
}
function writeInt40BE(value, view, offset) {
if (value < 0) value += 1099511627776;
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint8(offset, hi);
view.setUint32(offset + 1, lo, false);
return offset + 5;
}
function writeInt40LE(value, view, offset) {
if (value < 0) value += 1099511627776;
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint32(offset, lo, true);
view.setUint8(offset + 4, hi);
return offset + 5;
}
function writeInt24BE(value, view, offset) {
if (value < 0) value += 16777216;
view.setUint8(offset, value >> 16 & 255);
view.setUint8(offset + 1, value >> 8 & 255);
view.setUint8(offset + 2, value & 255);
return offset + 3;
}
function writeInt24LE(value, view, offset) {
if (value < 0) value += 16777216;
view.setUint8(offset, value & 255);
view.setUint8(offset + 1, value >> 8 & 255);
view.setUint8(offset + 2, value >> 16 & 255);
return offset + 3;
}
function writeUint48BE(value, view, offset) {
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint16(offset, hi, false);
view.setUint32(offset + 2, lo, false);
return offset + 6;
}
function writeUint48LE(value, view, offset) {
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint32(offset, lo, true);
view.setUint16(offset + 4, hi, true);
return offset + 6;
}
function writeUint40BE(value, view, offset) {
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint8(offset, hi);
view.setUint32(offset + 1, lo, false);
return offset + 5;
}
function writeUint40LE(value, view, offset) {
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
view.setUint32(offset, lo, true);
view.setUint8(offset + 4, hi);
return offset + 5;
}
function writeUint24BE(value, view, offset) {
view.setUint8(offset, value >> 16 & 255);
view.setUint8(offset + 1, value >> 8 & 255);
view.setUint8(offset + 2, value & 255);
return offset + 3;
}
function writeUint24LE(value, view, offset) {
view.setUint8(offset, value & 255);
view.setUint8(offset + 1, value >> 8 & 255);
view.setUint8(offset + 2, value >> 16 & 255);
return offset + 3;
}
}
});
// ../../node_modules/bare-form-data/lib/errors.js
var require_errors = __commonJS({
"../../node_modules/bare-form-data/lib/errors.js"(exports, module) {
module.exports = class FormDataError extends Error {
constructor(msg, code, fn = FormDataError) {
super(`${code}: ${msg}`);
this.code = code;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, fn);
}
}
get name() {
return "FormDataError";
}
static INVALID_MIME_TYPE(msg) {
return new FormDataError(msg, "INVALID_MIME_TYPE", FormDataError.INVALID_MIME_TYPE);
}
};
}
});
// ../../node_modules/bare-form-data/index.js
var require_bare_form_data = __commonJS({
"../../node_modules/bare-form-data/index.js"(exports, module) {
var { ReadableStream } = require_web();
var { isBuffer } = require_bare_buffer();
var errors = require_errors();
var FormData = class _FormData {
constructor() {
this._entries = [];
}
append(name, value, filename) {
if (typeof value !== "string") {
if (!isFile(value) || filename) {
value = new File([value], filename || "blob", { type: value.type });
}
}
this._entries.push([name, value]);
}
delete(name) {
this._entries = this._entries.filter((entry) => entry[0] !== name);
}
get(name) {
const entry = this._entries.find((entry2) => entry2[0] === name);
return entry ? entry[1] : null;
}
getAll(name) {
const entries = [];
for (const entry of this._entries) {
if (entry[0] === name) entries.push(entry[1]);
}
return entries;
}
has(name) {
return this._entries.findIndex((entry) => entry[0] === name) !== -1;
}
set(name, value, filename) {
this.delete(name);
this.append(name, value, filename);
}
[Symbol.iterator]() {
return this._entries[Symbol.iterator]();
}
[Symbol.for("bare.inspect")]() {
return {
__proto__: { constructor: _FormData },
entries: this._entries
};
}
};
module.exports = exports = FormData;
exports.FormData = FormData;
function isFormData(value) {
return value instanceof FormData;
}
exports.isFormData = isFormData;
var Blob = class _Blob {
// https://w3c.github.io/FileAPI/#dom-blob-blob
constructor(parts, options = {}) {
const { type = "" } = options;
this._bytes = processBlobParts(parts);
this._type = type;
}
// https://w3c.github.io/FileAPI/#dfn-size
get size() {
return this._bytes.byteLength;
}
// https://w3c.github.io/FileAPI/#dfn-type
get type() {
return this._type;
}
// https://w3c.github.io/FileAPI/#stream-method-algo
stream() {
const bytes = this._bytes;
return new ReadableStream({
start(controller) {
controller.enqueue(bytes);
controller.close();
}
});
}
async buffer() {
return Buffer.from(this._bytes);
}
// https://w3c.github.io/FileAPI/#bytes-method-algo
async bytes() {
return this.buffer();
}
// https://w3c.github.io/FileAPI/#arraybuffer-method-algo
async arrayBuffer() {
const buffer = new ArrayBuffer(this._bytes.byteLength);
buffer.set(this._bytes);
return buffer;
}
// https://w3c.github.io/FileAPI/#text-method-algo
async text() {
return this._bytes.toString();
}
[Symbol.for("bare.inspect")]() {
return {
__proto__: { constructor: _Blob },
size: this.size,
type: this.type
};
}
};
exports.Blob = Blob;
function isBlob(value) {
return value instanceof Blob;
}
exports.isBlob = Blob.isBlob = isBlob;
var File = class _File extends Blob {
// https://w3c.github.io/FileAPI/#dom-file-file
constructor(parts, name, options = {}) {
const { lastModified = Date.now() } = options;
super(parts, options);
this._name = name;
this._lastModified = lastModified;
}
// https://w3c.github.io/FileAPI/#dfn-name
get name() {
return this._name;
}
// https://w3c.github.io/FileAPI/#dfn-lastModified
get lastModified() {
return this._lastModified;
}
[Symbol.for("bare.inspect")]() {
return {
__proto__: { constructor: _File },
size: this.size,
type: this.type,
name: this.name,
lastModified: this.lastModified
};
}
};
exports.File = File;
function isFile(value) {
return value instanceof File;
}
exports.isFile = File.isFile = isFile;
function processBlobParts(parts) {
const chunks = [];
for (const part of parts) {
if (typeof part === "string") {
const buffer = Buffer.from(part);
if (parts.length === 1) return buffer;
chunks.push(buffer);
} else if (isBlob(part)) {
chunks.push(part._bytes);
} else if (isBuffer(part)) {
chunks.push(part);
} else if (ArrayBuffer.isView(part)) {
chunks.push(Buffer.from(part.buffer, part.byteOffset, part.byteLength));
} else {
chunks.push(Buffer.from(part));
}
}
return Buffer.concat(chunks);
}
function toBlob(formData, mimeType = "multipart/form-data") {
switch (mimeType) {
case "multipart/form-data":
return toMultipartBlob(formData);
default:
throw errors.INVALID_MIME_TYPE(`Invalid MIME type '${mimeType}'`);
}
}
exports.toBlob = toBlob;
function escape(value) {
return value.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
}
function normalizeLinefeeds(value) {
return value.replace(/\r?\n|\r/g, "\r\n");
}
var linefeed = Buffer.from("\r\n");
function toMultipartBlob(formData) {
const boundary = Math.random().toString(16).slice(2, 18).padStart(16, "0");
const prefix = `--${boundary}\r
Content-Disposition: form-data`;
const parts = [];
for (const [name, value] of formData) {
if (typeof value === "string") {
const chunk = Buffer.from(
prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`
);
parts.push(chunk);
} else {
const chunk = Buffer.from(
prefix + `; name="${escape(normalizeLinefeeds(name))}"; filename="${escape(value.name)}"\r
Content-Type: ${value.type || "application/octet-stream"}\r
\r
`
);
parts.push(chunk, value, linefeed);
}
}
parts.push(Buffer.from(`--${boundary}--\r
`));
return new Blob(parts, {
type: "multipart/form-data; boundary=" + boundary
});
}
}
});
// ../../bare-lib-entry-bareFormData.js
var bare_lib_entry_bareFormData_exports = {};
__export(bare_lib_entry_bareFormData_exports, {
default: () => bare_lib_entry_bareFormData_default
});
var import_bare_form_data = __toESM(require_bare_form_data());
var bare_lib_entry_bareFormData_default = import_bare_form_data.default;
return __toCommonJS(bare_lib_entry_bareFormData_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};g[s]["bareFormData"]=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;})();
Reference in New Issue View Git Blame Copy Permalink