@storm-software/linting-tools
Version:
⚡ A package containing various linting tools used to validate syntax, enforce design standards, and format code in a Storm workspace.
1,472 lines (1,467 loc) • 843 kB
JavaScript
import {
basename,
defu,
dirname,
join,
normalize,
relative,
resolve,
ve
} from "./chunk-2SFETDSP.js";
import "./chunk-QMM2FP2O.js";
import "./chunk-MJALI6JA.js";
import "./chunk-K7JPZUFQ.js";
import "./chunk-2YAFQKU5.js";
import "./chunk-2F6YEABW.js";
import {
G,
Mi,
Mn,
Sl,
_l,
_r,
br,
dt,
gl,
init_node,
init_node_fetch_native_DfbY2q_x,
jn,
le,
qn,
ut,
ye,
yl
} from "./chunk-IFYC4ICN.js";
import {
__commonJS,
__esm,
__export,
__require,
__toESM,
init_esm_shims
} from "./chunk-LXPMPMVD.js";
// ../../node_modules/.pnpm/tar@6.2.1/node_modules/tar/lib/high-level-opt.js
var require_high_level_opt = __commonJS({
"../../node_modules/.pnpm/tar@6.2.1/node_modules/tar/lib/high-level-opt.js"(exports, module) {
"use strict";
init_esm_shims();
var argmap = /* @__PURE__ */ new Map([
["C", "cwd"],
["f", "file"],
["z", "gzip"],
["P", "preservePaths"],
["U", "unlink"],
["strip-components", "strip"],
["stripComponents", "strip"],
["keep-newer", "newer"],
["keepNewer", "newer"],
["keep-newer-files", "newer"],
["keepNewerFiles", "newer"],
["k", "keep"],
["keep-existing", "keep"],
["keepExisting", "keep"],
["m", "noMtime"],
["no-mtime", "noMtime"],
["p", "preserveOwner"],
["L", "follow"],
["h", "follow"]
]);
module.exports = (opt) => opt ? Object.keys(opt).map((k) => [
argmap.has(k) ? argmap.get(k) : k,
opt[k]
]).reduce((set, kv) => (set[kv[0]] = kv[1], set), /* @__PURE__ */ Object.create(null)) : {};
}
});
// ../../node_modules/.pnpm/minipass@5.0.0/node_modules/minipass/index.mjs
var minipass_exports = {};
__export(minipass_exports, {
Minipass: () => Minipass
});
import EE from "events";
import Stream from "stream";
import stringdecoder from "string_decoder";
var proc, SD, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, defer, doIter, ASYNCITERATOR, ITERATOR, isEndish, isArrayBuffer, isArrayBufferView, Pipe, PipeProxyErrors, Minipass;
var init_minipass = __esm({
"../../node_modules/.pnpm/minipass@5.0.0/node_modules/minipass/index.mjs"() {
"use strict";
init_esm_shims();
proc = typeof process === "object" && process ? process : {
stdout: null,
stderr: null
};
SD = stringdecoder.StringDecoder;
EOF = Symbol("EOF");
MAYBE_EMIT_END = Symbol("maybeEmitEnd");
EMITTED_END = Symbol("emittedEnd");
EMITTING_END = Symbol("emittingEnd");
EMITTED_ERROR = Symbol("emittedError");
CLOSED = Symbol("closed");
READ = Symbol("read");
FLUSH = Symbol("flush");
FLUSHCHUNK = Symbol("flushChunk");
ENCODING = Symbol("encoding");
DECODER = Symbol("decoder");
FLOWING = Symbol("flowing");
PAUSED = Symbol("paused");
RESUME = Symbol("resume");
BUFFER = Symbol("buffer");
PIPES = Symbol("pipes");
BUFFERLENGTH = Symbol("bufferLength");
BUFFERPUSH = Symbol("bufferPush");
BUFFERSHIFT = Symbol("bufferShift");
OBJECTMODE = Symbol("objectMode");
DESTROYED = Symbol("destroyed");
ERROR = Symbol("error");
EMITDATA = Symbol("emitData");
EMITEND = Symbol("emitEnd");
EMITEND2 = Symbol("emitEnd2");
ASYNC = Symbol("async");
ABORT = Symbol("abort");
ABORTED = Symbol("aborted");
SIGNAL = Symbol("signal");
defer = (fn) => Promise.resolve().then(fn);
doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1";
ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented");
ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented");
isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
isArrayBuffer = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
Pipe = class {
constructor(src, dest, opts) {
this.src = src;
this.dest = dest;
this.opts = opts;
this.ondrain = () => src[RESUME]();
dest.on("drain", this.ondrain);
}
unpipe() {
this.dest.removeListener("drain", this.ondrain);
}
// istanbul ignore next - only here for the prototype
proxyErrors() {
}
end() {
this.unpipe();
if (this.opts.end) this.dest.end();
}
};
PipeProxyErrors = class extends Pipe {
unpipe() {
this.src.removeListener("error", this.proxyErrors);
super.unpipe();
}
constructor(src, dest, opts) {
super(src, dest, opts);
this.proxyErrors = (er) => dest.emit("error", er);
src.on("error", this.proxyErrors);
}
};
Minipass = class _Minipass extends Stream {
constructor(options) {
super();
this[FLOWING] = false;
this[PAUSED] = false;
this[PIPES] = [];
this[BUFFER] = [];
this[OBJECTMODE] = options && options.objectMode || false;
if (this[OBJECTMODE]) this[ENCODING] = null;
else this[ENCODING] = options && options.encoding || null;
if (this[ENCODING] === "buffer") this[ENCODING] = null;
this[ASYNC] = options && !!options.async || false;
this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null;
this[EOF] = false;
this[EMITTED_END] = false;
this[EMITTING_END] = false;
this[CLOSED] = false;
this[EMITTED_ERROR] = null;
this.writable = true;
this.readable = true;
this[BUFFERLENGTH] = 0;
this[DESTROYED] = false;
if (options && options.debugExposeBuffer === true) {
Object.defineProperty(this, "buffer", { get: () => this[BUFFER] });
}
if (options && options.debugExposePipes === true) {
Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
}
this[SIGNAL] = options && options.signal;
this[ABORTED] = false;
if (this[SIGNAL]) {
this[SIGNAL].addEventListener("abort", () => this[ABORT]());
if (this[SIGNAL].aborted) {
this[ABORT]();
}
}
}
get bufferLength() {
return this[BUFFERLENGTH];
}
get encoding() {
return this[ENCODING];
}
set encoding(enc) {
if (this[OBJECTMODE]) throw new Error("cannot set encoding in objectMode");
if (this[ENCODING] && enc !== this[ENCODING] && (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
throw new Error("cannot change encoding");
if (this[ENCODING] !== enc) {
this[DECODER] = enc ? new SD(enc) : null;
if (this[BUFFER].length)
this[BUFFER] = this[BUFFER].map((chunk) => this[DECODER].write(chunk));
}
this[ENCODING] = enc;
}
setEncoding(enc) {
this.encoding = enc;
}
get objectMode() {
return this[OBJECTMODE];
}
set objectMode(om) {
this[OBJECTMODE] = this[OBJECTMODE] || !!om;
}
get ["async"]() {
return this[ASYNC];
}
set ["async"](a) {
this[ASYNC] = this[ASYNC] || !!a;
}
// drop everything and get out of the flow completely
[ABORT]() {
this[ABORTED] = true;
this.emit("abort", this[SIGNAL].reason);
this.destroy(this[SIGNAL].reason);
}
get aborted() {
return this[ABORTED];
}
set aborted(_) {
}
write(chunk, encoding, cb) {
if (this[ABORTED]) return false;
if (this[EOF]) throw new Error("write after end");
if (this[DESTROYED]) {
this.emit(
"error",
Object.assign(
new Error("Cannot call write after a stream was destroyed"),
{ code: "ERR_STREAM_DESTROYED" }
)
);
return true;
}
if (typeof encoding === "function") cb = encoding, encoding = "utf8";
if (!encoding) encoding = "utf8";
const fn = this[ASYNC] ? defer : (f) => f();
if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
if (isArrayBufferView(chunk))
chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
else if (isArrayBuffer(chunk)) chunk = Buffer.from(chunk);
else if (typeof chunk !== "string")
this.objectMode = true;
}
if (this[OBJECTMODE]) {
if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
if (this.flowing) this.emit("data", chunk);
else this[BUFFERPUSH](chunk);
if (this[BUFFERLENGTH] !== 0) this.emit("readable");
if (cb) fn(cb);
return this.flowing;
}
if (!chunk.length) {
if (this[BUFFERLENGTH] !== 0) this.emit("readable");
if (cb) fn(cb);
return this.flowing;
}
if (typeof chunk === "string" && // unless it is a string already ready for us to use
!(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
chunk = Buffer.from(chunk, encoding);
}
if (Buffer.isBuffer(chunk) && this[ENCODING])
chunk = this[DECODER].write(chunk);
if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
if (this.flowing) this.emit("data", chunk);
else this[BUFFERPUSH](chunk);
if (this[BUFFERLENGTH] !== 0) this.emit("readable");
if (cb) fn(cb);
return this.flowing;
}
read(n2) {
if (this[DESTROYED]) return null;
if (this[BUFFERLENGTH] === 0 || n2 === 0 || n2 > this[BUFFERLENGTH]) {
this[MAYBE_EMIT_END]();
return null;
}
if (this[OBJECTMODE]) n2 = null;
if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
if (this.encoding) this[BUFFER] = [this[BUFFER].join("")];
else this[BUFFER] = [Buffer.concat(this[BUFFER], this[BUFFERLENGTH])];
}
const ret = this[READ](n2 || null, this[BUFFER][0]);
this[MAYBE_EMIT_END]();
return ret;
}
[READ](n2, chunk) {
if (n2 === chunk.length || n2 === null) this[BUFFERSHIFT]();
else {
this[BUFFER][0] = chunk.slice(n2);
chunk = chunk.slice(0, n2);
this[BUFFERLENGTH] -= n2;
}
this.emit("data", chunk);
if (!this[BUFFER].length && !this[EOF]) this.emit("drain");
return chunk;
}
end(chunk, encoding, cb) {
if (typeof chunk === "function") cb = chunk, chunk = null;
if (typeof encoding === "function") cb = encoding, encoding = "utf8";
if (chunk) this.write(chunk, encoding);
if (cb) this.once("end", cb);
this[EOF] = true;
this.writable = false;
if (this.flowing || !this[PAUSED]) this[MAYBE_EMIT_END]();
return this;
}
// don't let the internal resume be overwritten
[RESUME]() {
if (this[DESTROYED]) return;
this[PAUSED] = false;
this[FLOWING] = true;
this.emit("resume");
if (this[BUFFER].length) this[FLUSH]();
else if (this[EOF]) this[MAYBE_EMIT_END]();
else this.emit("drain");
}
resume() {
return this[RESUME]();
}
pause() {
this[FLOWING] = false;
this[PAUSED] = true;
}
get destroyed() {
return this[DESTROYED];
}
get flowing() {
return this[FLOWING];
}
get paused() {
return this[PAUSED];
}
[BUFFERPUSH](chunk) {
if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1;
else this[BUFFERLENGTH] += chunk.length;
this[BUFFER].push(chunk);
}
[BUFFERSHIFT]() {
if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1;
else this[BUFFERLENGTH] -= this[BUFFER][0].length;
return this[BUFFER].shift();
}
[FLUSH](noDrain) {
do {
} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit("drain");
}
[FLUSHCHUNK](chunk) {
this.emit("data", chunk);
return this.flowing;
}
pipe(dest, opts) {
if (this[DESTROYED]) return;
const ended = this[EMITTED_END];
opts = opts || {};
if (dest === proc.stdout || dest === proc.stderr) opts.end = false;
else opts.end = opts.end !== false;
opts.proxyErrors = !!opts.proxyErrors;
if (ended) {
if (opts.end) dest.end();
} else {
this[PIPES].push(
!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts)
);
if (this[ASYNC]) defer(() => this[RESUME]());
else this[RESUME]();
}
return dest;
}
unpipe(dest) {
const p2 = this[PIPES].find((p3) => p3.dest === dest);
if (p2) {
this[PIPES].splice(this[PIPES].indexOf(p2), 1);
p2.unpipe();
}
}
addListener(ev, fn) {
return this.on(ev, fn);
}
on(ev, fn) {
const ret = super.on(ev, fn);
if (ev === "data" && !this[PIPES].length && !this.flowing) this[RESUME]();
else if (ev === "readable" && this[BUFFERLENGTH] !== 0)
super.emit("readable");
else if (isEndish(ev) && this[EMITTED_END]) {
super.emit(ev);
this.removeAllListeners(ev);
} else if (ev === "error" && this[EMITTED_ERROR]) {
if (this[ASYNC]) defer(() => fn.call(this, this[EMITTED_ERROR]));
else fn.call(this, this[EMITTED_ERROR]);
}
return ret;
}
get emittedEnd() {
return this[EMITTED_END];
}
[MAYBE_EMIT_END]() {
if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF]) {
this[EMITTING_END] = true;
this.emit("end");
this.emit("prefinish");
this.emit("finish");
if (this[CLOSED]) this.emit("close");
this[EMITTING_END] = false;
}
}
emit(ev, data, ...extra) {
if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED])
return;
else if (ev === "data") {
return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? defer(() => this[EMITDATA](data)) : this[EMITDATA](data);
} else if (ev === "end") {
return this[EMITEND]();
} else if (ev === "close") {
this[CLOSED] = true;
if (!this[EMITTED_END] && !this[DESTROYED]) return;
const ret2 = super.emit("close");
this.removeAllListeners("close");
return ret2;
} else if (ev === "error") {
this[EMITTED_ERROR] = data;
super.emit(ERROR, data);
const ret2 = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
this[MAYBE_EMIT_END]();
return ret2;
} else if (ev === "resume") {
const ret2 = super.emit("resume");
this[MAYBE_EMIT_END]();
return ret2;
} else if (ev === "finish" || ev === "prefinish") {
const ret2 = super.emit(ev);
this.removeAllListeners(ev);
return ret2;
}
const ret = super.emit(ev, data, ...extra);
this[MAYBE_EMIT_END]();
return ret;
}
[EMITDATA](data) {
for (const p2 of this[PIPES]) {
if (p2.dest.write(data) === false) this.pause();
}
const ret = super.emit("data", data);
this[MAYBE_EMIT_END]();
return ret;
}
[EMITEND]() {
if (this[EMITTED_END]) return;
this[EMITTED_END] = true;
this.readable = false;
if (this[ASYNC]) defer(() => this[EMITEND2]());
else this[EMITEND2]();
}
[EMITEND2]() {
if (this[DECODER]) {
const data = this[DECODER].end();
if (data) {
for (const p2 of this[PIPES]) {
p2.dest.write(data);
}
super.emit("data", data);
}
}
for (const p2 of this[PIPES]) {
p2.end();
}
const ret = super.emit("end");
this.removeAllListeners("end");
return ret;
}
// const all = await stream.collect()
collect() {
const buf = [];
if (!this[OBJECTMODE]) buf.dataLength = 0;
const p2 = this.promise();
this.on("data", (c2) => {
buf.push(c2);
if (!this[OBJECTMODE]) buf.dataLength += c2.length;
});
return p2.then(() => buf);
}
// const data = await stream.concat()
concat() {
return this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this.collect().then(
(buf) => this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength)
);
}
// stream.promise().then(() => done, er => emitted error)
promise() {
return new Promise((resolve2, reject) => {
this.on(DESTROYED, () => reject(new Error("stream destroyed")));
this.on("error", (er) => reject(er));
this.on("end", () => resolve2());
});
}
// for await (let chunk of stream)
[ASYNCITERATOR]() {
let stopped = false;
const stop = () => {
this.pause();
stopped = true;
return Promise.resolve({ done: true });
};
const next = () => {
if (stopped) return stop();
const res = this.read();
if (res !== null) return Promise.resolve({ done: false, value: res });
if (this[EOF]) return stop();
let resolve2 = null;
let reject = null;
const onerr = (er) => {
this.removeListener("data", ondata);
this.removeListener("end", onend);
this.removeListener(DESTROYED, ondestroy);
stop();
reject(er);
};
const ondata = (value) => {
this.removeListener("error", onerr);
this.removeListener("end", onend);
this.removeListener(DESTROYED, ondestroy);
this.pause();
resolve2({ value, done: !!this[EOF] });
};
const onend = () => {
this.removeListener("error", onerr);
this.removeListener("data", ondata);
this.removeListener(DESTROYED, ondestroy);
stop();
resolve2({ done: true });
};
const ondestroy = () => onerr(new Error("stream destroyed"));
return new Promise((res2, rej) => {
reject = rej;
resolve2 = res2;
this.once(DESTROYED, ondestroy);
this.once("error", onerr);
this.once("end", onend);
this.once("data", ondata);
});
};
return {
next,
throw: stop,
return: stop,
[ASYNCITERATOR]() {
return this;
}
};
}
// for (let chunk of stream)
[ITERATOR]() {
let stopped = false;
const stop = () => {
this.pause();
this.removeListener(ERROR, stop);
this.removeListener(DESTROYED, stop);
this.removeListener("end", stop);
stopped = true;
return { done: true };
};
const next = () => {
if (stopped) return stop();
const value = this.read();
return value === null ? stop() : { value };
};
this.once("end", stop);
this.once(ERROR, stop);
this.once(DESTROYED, stop);
return {
next,
throw: stop,
return: stop,
[ITERATOR]() {
return this;
}
};
}
destroy(er) {
if (this[DESTROYED]) {
if (er) this.emit("error", er);
else this.emit(DESTROYED);
return this;
}
this[DESTROYED] = true;
this[BUFFER].length = 0;
this[BUFFERLENGTH] = 0;
if (typeof this.close === "function" && !this[CLOSED]) this.close();
if (er) this.emit("error", er);
else this.emit(DESTROYED);
return this;
}
static isStream(s) {
return !!s && (s instanceof _Minipass || s instanceof Stream || s instanceof EE && // readable
(typeof s.pipe === "function" || // writable
typeof s.write === "function" && typeof s.end === "function"));
}
};
}
});
// ../../node_modules/.pnpm/minizlib@2.1.2/node_modules/minizlib/constants.js
import * as __import_zlib from "zlib";
var require_constants = __commonJS({
"../../node_modules/.pnpm/minizlib@2.1.2/node_modules/minizlib/constants.js"(exports, module) {
init_esm_shims();
var realZlibConstants = __import_zlib.constants || /* istanbul ignore next */
{ ZLIB_VERNUM: 4736 };
module.exports = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
Z_NO_FLUSH: 0,
Z_PARTIAL_FLUSH: 1,
Z_SYNC_FLUSH: 2,
Z_FULL_FLUSH: 3,
Z_FINISH: 4,
Z_BLOCK: 5,
Z_OK: 0,
Z_STREAM_END: 1,
Z_NEED_DICT: 2,
Z_ERRNO: -1,
Z_STREAM_ERROR: -2,
Z_DATA_ERROR: -3,
Z_MEM_ERROR: -4,
Z_BUF_ERROR: -5,
Z_VERSION_ERROR: -6,
Z_NO_COMPRESSION: 0,
Z_BEST_SPEED: 1,
Z_BEST_COMPRESSION: 9,
Z_DEFAULT_COMPRESSION: -1,
Z_FILTERED: 1,
Z_HUFFMAN_ONLY: 2,
Z_RLE: 3,
Z_FIXED: 4,
Z_DEFAULT_STRATEGY: 0,
DEFLATE: 1,
INFLATE: 2,
GZIP: 3,
GUNZIP: 4,
DEFLATERAW: 5,
INFLATERAW: 6,
UNZIP: 7,
BROTLI_DECODE: 8,
BROTLI_ENCODE: 9,
Z_MIN_WINDOWBITS: 8,
Z_MAX_WINDOWBITS: 15,
Z_DEFAULT_WINDOWBITS: 15,
Z_MIN_CHUNK: 64,
Z_MAX_CHUNK: Infinity,
Z_DEFAULT_CHUNK: 16384,
Z_MIN_MEMLEVEL: 1,
Z_MAX_MEMLEVEL: 9,
Z_DEFAULT_MEMLEVEL: 8,
Z_MIN_LEVEL: -1,
Z_MAX_LEVEL: 9,
Z_DEFAULT_LEVEL: -1,
BROTLI_OPERATION_PROCESS: 0,
BROTLI_OPERATION_FLUSH: 1,
BROTLI_OPERATION_FINISH: 2,
BROTLI_OPERATION_EMIT_METADATA: 3,
BROTLI_MODE_GENERIC: 0,
BROTLI_MODE_TEXT: 1,
BROTLI_MODE_FONT: 2,
BROTLI_DEFAULT_MODE: 0,
BROTLI_MIN_QUALITY: 0,
BROTLI_MAX_QUALITY: 11,
BROTLI_DEFAULT_QUALITY: 11,
BROTLI_MIN_WINDOW_BITS: 10,
BROTLI_MAX_WINDOW_BITS: 24,
BROTLI_LARGE_MAX_WINDOW_BITS: 30,
BROTLI_DEFAULT_WINDOW: 22,
BROTLI_MIN_INPUT_BLOCK_BITS: 16,
BROTLI_MAX_INPUT_BLOCK_BITS: 24,
BROTLI_PARAM_MODE: 0,
BROTLI_PARAM_QUALITY: 1,
BROTLI_PARAM_LGWIN: 2,
BROTLI_PARAM_LGBLOCK: 3,
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
BROTLI_PARAM_SIZE_HINT: 5,
BROTLI_PARAM_LARGE_WINDOW: 6,
BROTLI_PARAM_NPOSTFIX: 7,
BROTLI_PARAM_NDIRECT: 8,
BROTLI_DECODER_RESULT_ERROR: 0,
BROTLI_DECODER_RESULT_SUCCESS: 1,
BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
BROTLI_DECODER_NO_ERROR: 0,
BROTLI_DECODER_SUCCESS: 1,
BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
BROTLI_DECODER_ERROR_UNREACHABLE: -31
}, realZlibConstants));
}
});
// ../../node_modules/.pnpm/minipass@3.3.6/node_modules/minipass/index.js
import * as __import_events from "events";
import * as __import_stream from "stream";
import * as __import_string_decoder from "string_decoder";
var require_minipass = __commonJS({
"../../node_modules/.pnpm/minipass@3.3.6/node_modules/minipass/index.js"(exports, module) {
init_esm_shims();
var proc2 = typeof process === "object" && process ? process : {
stdout: null,
stderr: null
};
var EE2 = __import_events;
var Stream2 = __import_stream;
var SD2 = __import_string_decoder.StringDecoder;
var EOF2 = Symbol("EOF");
var MAYBE_EMIT_END2 = Symbol("maybeEmitEnd");
var EMITTED_END2 = Symbol("emittedEnd");
var EMITTING_END2 = Symbol("emittingEnd");
var EMITTED_ERROR2 = Symbol("emittedError");
var CLOSED2 = Symbol("closed");
var READ2 = Symbol("read");
var FLUSH2 = Symbol("flush");
var FLUSHCHUNK2 = Symbol("flushChunk");
var ENCODING2 = Symbol("encoding");
var DECODER2 = Symbol("decoder");
var FLOWING2 = Symbol("flowing");
var PAUSED2 = Symbol("paused");
var RESUME2 = Symbol("resume");
var BUFFERLENGTH2 = Symbol("bufferLength");
var BUFFERPUSH2 = Symbol("bufferPush");
var BUFFERSHIFT2 = Symbol("bufferShift");
var OBJECTMODE2 = Symbol("objectMode");
var DESTROYED2 = Symbol("destroyed");
var EMITDATA2 = Symbol("emitData");
var EMITEND3 = Symbol("emitEnd");
var EMITEND22 = Symbol("emitEnd2");
var ASYNC2 = Symbol("async");
var defer2 = (fn) => Promise.resolve().then(fn);
var doIter2 = global._MP_NO_ITERATOR_SYMBOLS_ !== "1";
var ASYNCITERATOR2 = doIter2 && Symbol.asyncIterator || Symbol("asyncIterator not implemented");
var ITERATOR2 = doIter2 && Symbol.iterator || Symbol("iterator not implemented");
var isEndish2 = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
var isArrayBuffer2 = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
var isArrayBufferView2 = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
var Pipe2 = class {
constructor(src, dest, opts) {
this.src = src;
this.dest = dest;
this.opts = opts;
this.ondrain = () => src[RESUME2]();
dest.on("drain", this.ondrain);
}
unpipe() {
this.dest.removeListener("drain", this.ondrain);
}
// istanbul ignore next - only here for the prototype
proxyErrors() {
}
end() {
this.unpipe();
if (this.opts.end)
this.dest.end();
}
};
var PipeProxyErrors2 = class extends Pipe2 {
unpipe() {
this.src.removeListener("error", this.proxyErrors);
super.unpipe();
}
constructor(src, dest, opts) {
super(src, dest, opts);
this.proxyErrors = (er) => dest.emit("error", er);
src.on("error", this.proxyErrors);
}
};
module.exports = class Minipass2 extends Stream2 {
constructor(options) {
super();
this[FLOWING2] = false;
this[PAUSED2] = false;
this.pipes = [];
this.buffer = [];
this[OBJECTMODE2] = options && options.objectMode || false;
if (this[OBJECTMODE2])
this[ENCODING2] = null;
else
this[ENCODING2] = options && options.encoding || null;
if (this[ENCODING2] === "buffer")
this[ENCODING2] = null;
this[ASYNC2] = options && !!options.async || false;
this[DECODER2] = this[ENCODING2] ? new SD2(this[ENCODING2]) : null;
this[EOF2] = false;
this[EMITTED_END2] = false;
this[EMITTING_END2] = false;
this[CLOSED2] = false;
this[EMITTED_ERROR2] = null;
this.writable = true;
this.readable = true;
this[BUFFERLENGTH2] = 0;
this[DESTROYED2] = false;
}
get bufferLength() {
return this[BUFFERLENGTH2];
}
get encoding() {
return this[ENCODING2];
}
set encoding(enc) {
if (this[OBJECTMODE2])
throw new Error("cannot set encoding in objectMode");
if (this[ENCODING2] && enc !== this[ENCODING2] && (this[DECODER2] && this[DECODER2].lastNeed || this[BUFFERLENGTH2]))
throw new Error("cannot change encoding");
if (this[ENCODING2] !== enc) {
this[DECODER2] = enc ? new SD2(enc) : null;
if (this.buffer.length)
this.buffer = this.buffer.map((chunk) => this[DECODER2].write(chunk));
}
this[ENCODING2] = enc;
}
setEncoding(enc) {
this.encoding = enc;
}
get objectMode() {
return this[OBJECTMODE2];
}
set objectMode(om) {
this[OBJECTMODE2] = this[OBJECTMODE2] || !!om;
}
get ["async"]() {
return this[ASYNC2];
}
set ["async"](a) {
this[ASYNC2] = this[ASYNC2] || !!a;
}
write(chunk, encoding, cb) {
if (this[EOF2])
throw new Error("write after end");
if (this[DESTROYED2]) {
this.emit("error", Object.assign(
new Error("Cannot call write after a stream was destroyed"),
{ code: "ERR_STREAM_DESTROYED" }
));
return true;
}
if (typeof encoding === "function")
cb = encoding, encoding = "utf8";
if (!encoding)
encoding = "utf8";
const fn = this[ASYNC2] ? defer2 : (f) => f();
if (!this[OBJECTMODE2] && !Buffer.isBuffer(chunk)) {
if (isArrayBufferView2(chunk))
chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
else if (isArrayBuffer2(chunk))
chunk = Buffer.from(chunk);
else if (typeof chunk !== "string")
this.objectMode = true;
}
if (this[OBJECTMODE2]) {
if (this.flowing && this[BUFFERLENGTH2] !== 0)
this[FLUSH2](true);
if (this.flowing)
this.emit("data", chunk);
else
this[BUFFERPUSH2](chunk);
if (this[BUFFERLENGTH2] !== 0)
this.emit("readable");
if (cb)
fn(cb);
return this.flowing;
}
if (!chunk.length) {
if (this[BUFFERLENGTH2] !== 0)
this.emit("readable");
if (cb)
fn(cb);
return this.flowing;
}
if (typeof chunk === "string" && // unless it is a string already ready for us to use
!(encoding === this[ENCODING2] && !this[DECODER2].lastNeed)) {
chunk = Buffer.from(chunk, encoding);
}
if (Buffer.isBuffer(chunk) && this[ENCODING2])
chunk = this[DECODER2].write(chunk);
if (this.flowing && this[BUFFERLENGTH2] !== 0)
this[FLUSH2](true);
if (this.flowing)
this.emit("data", chunk);
else
this[BUFFERPUSH2](chunk);
if (this[BUFFERLENGTH2] !== 0)
this.emit("readable");
if (cb)
fn(cb);
return this.flowing;
}
read(n2) {
if (this[DESTROYED2])
return null;
if (this[BUFFERLENGTH2] === 0 || n2 === 0 || n2 > this[BUFFERLENGTH2]) {
this[MAYBE_EMIT_END2]();
return null;
}
if (this[OBJECTMODE2])
n2 = null;
if (this.buffer.length > 1 && !this[OBJECTMODE2]) {
if (this.encoding)
this.buffer = [this.buffer.join("")];
else
this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH2])];
}
const ret = this[READ2](n2 || null, this.buffer[0]);
this[MAYBE_EMIT_END2]();
return ret;
}
[READ2](n2, chunk) {
if (n2 === chunk.length || n2 === null)
this[BUFFERSHIFT2]();
else {
this.buffer[0] = chunk.slice(n2);
chunk = chunk.slice(0, n2);
this[BUFFERLENGTH2] -= n2;
}
this.emit("data", chunk);
if (!this.buffer.length && !this[EOF2])
this.emit("drain");
return chunk;
}
end(chunk, encoding, cb) {
if (typeof chunk === "function")
cb = chunk, chunk = null;
if (typeof encoding === "function")
cb = encoding, encoding = "utf8";
if (chunk)
this.write(chunk, encoding);
if (cb)
this.once("end", cb);
this[EOF2] = true;
this.writable = false;
if (this.flowing || !this[PAUSED2])
this[MAYBE_EMIT_END2]();
return this;
}
// don't let the internal resume be overwritten
[RESUME2]() {
if (this[DESTROYED2])
return;
this[PAUSED2] = false;
this[FLOWING2] = true;
this.emit("resume");
if (this.buffer.length)
this[FLUSH2]();
else if (this[EOF2])
this[MAYBE_EMIT_END2]();
else
this.emit("drain");
}
resume() {
return this[RESUME2]();
}
pause() {
this[FLOWING2] = false;
this[PAUSED2] = true;
}
get destroyed() {
return this[DESTROYED2];
}
get flowing() {
return this[FLOWING2];
}
get paused() {
return this[PAUSED2];
}
[BUFFERPUSH2](chunk) {
if (this[OBJECTMODE2])
this[BUFFERLENGTH2] += 1;
else
this[BUFFERLENGTH2] += chunk.length;
this.buffer.push(chunk);
}
[BUFFERSHIFT2]() {
if (this.buffer.length) {
if (this[OBJECTMODE2])
this[BUFFERLENGTH2] -= 1;
else
this[BUFFERLENGTH2] -= this.buffer[0].length;
}
return this.buffer.shift();
}
[FLUSH2](noDrain) {
do {
} while (this[FLUSHCHUNK2](this[BUFFERSHIFT2]()));
if (!noDrain && !this.buffer.length && !this[EOF2])
this.emit("drain");
}
[FLUSHCHUNK2](chunk) {
return chunk ? (this.emit("data", chunk), this.flowing) : false;
}
pipe(dest, opts) {
if (this[DESTROYED2])
return;
const ended = this[EMITTED_END2];
opts = opts || {};
if (dest === proc2.stdout || dest === proc2.stderr)
opts.end = false;
else
opts.end = opts.end !== false;
opts.proxyErrors = !!opts.proxyErrors;
if (ended) {
if (opts.end)
dest.end();
} else {
this.pipes.push(!opts.proxyErrors ? new Pipe2(this, dest, opts) : new PipeProxyErrors2(this, dest, opts));
if (this[ASYNC2])
defer2(() => this[RESUME2]());
else
this[RESUME2]();
}
return dest;
}
unpipe(dest) {
const p2 = this.pipes.find((p3) => p3.dest === dest);
if (p2) {
this.pipes.splice(this.pipes.indexOf(p2), 1);
p2.unpipe();
}
}
addListener(ev, fn) {
return this.on(ev, fn);
}
on(ev, fn) {
const ret = super.on(ev, fn);
if (ev === "data" && !this.pipes.length && !this.flowing)
this[RESUME2]();
else if (ev === "readable" && this[BUFFERLENGTH2] !== 0)
super.emit("readable");
else if (isEndish2(ev) && this[EMITTED_END2]) {
super.emit(ev);
this.removeAllListeners(ev);
} else if (ev === "error" && this[EMITTED_ERROR2]) {
if (this[ASYNC2])
defer2(() => fn.call(this, this[EMITTED_ERROR2]));
else
fn.call(this, this[EMITTED_ERROR2]);
}
return ret;
}
get emittedEnd() {
return this[EMITTED_END2];
}
[MAYBE_EMIT_END2]() {
if (!this[EMITTING_END2] && !this[EMITTED_END2] && !this[DESTROYED2] && this.buffer.length === 0 && this[EOF2]) {
this[EMITTING_END2] = true;
this.emit("end");
this.emit("prefinish");
this.emit("finish");
if (this[CLOSED2])
this.emit("close");
this[EMITTING_END2] = false;
}
}
emit(ev, data, ...extra) {
if (ev !== "error" && ev !== "close" && ev !== DESTROYED2 && this[DESTROYED2])
return;
else if (ev === "data") {
return !data ? false : this[ASYNC2] ? defer2(() => this[EMITDATA2](data)) : this[EMITDATA2](data);
} else if (ev === "end") {
return this[EMITEND3]();
} else if (ev === "close") {
this[CLOSED2] = true;
if (!this[EMITTED_END2] && !this[DESTROYED2])
return;
const ret2 = super.emit("close");
this.removeAllListeners("close");
return ret2;
} else if (ev === "error") {
this[EMITTED_ERROR2] = data;
const ret2 = super.emit("error", data);
this[MAYBE_EMIT_END2]();
return ret2;
} else if (ev === "resume") {
const ret2 = super.emit("resume");
this[MAYBE_EMIT_END2]();
return ret2;
} else if (ev === "finish" || ev === "prefinish") {
const ret2 = super.emit(ev);
this.removeAllListeners(ev);
return ret2;
}
const ret = super.emit(ev, data, ...extra);
this[MAYBE_EMIT_END2]();
return ret;
}
[EMITDATA2](data) {
for (const p2 of this.pipes) {
if (p2.dest.write(data) === false)
this.pause();
}
const ret = super.emit("data", data);
this[MAYBE_EMIT_END2]();
return ret;
}
[EMITEND3]() {
if (this[EMITTED_END2])
return;
this[EMITTED_END2] = true;
this.readable = false;
if (this[ASYNC2])
defer2(() => this[EMITEND22]());
else
this[EMITEND22]();
}
[EMITEND22]() {
if (this[DECODER2]) {
const data = this[DECODER2].end();
if (data) {
for (const p2 of this.pipes) {
p2.dest.write(data);
}
super.emit("data", data);
}
}
for (const p2 of this.pipes) {
p2.end();
}
const ret = super.emit("end");
this.removeAllListeners("end");
return ret;
}
// const all = await stream.collect()
collect() {
const buf = [];
if (!this[OBJECTMODE2])
buf.dataLength = 0;
const p2 = this.promise();
this.on("data", (c2) => {
buf.push(c2);
if (!this[OBJECTMODE2])
buf.dataLength += c2.length;
});
return p2.then(() => buf);
}
// const data = await stream.concat()
concat() {
return this[OBJECTMODE2] ? Promise.reject(new Error("cannot concat in objectMode")) : this.collect().then((buf) => this[OBJECTMODE2] ? Promise.reject(new Error("cannot concat in objectMode")) : this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength));
}
// stream.promise().then(() => done, er => emitted error)
promise() {
return new Promise((resolve2, reject) => {
this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
this.on("error", (er) => reject(er));
this.on("end", () => resolve2());
});
}
// for await (let chunk of stream)
[ASYNCITERATOR2]() {
const next = () => {
const res = this.read();
if (res !== null)
return Promise.resolve({ done: false, value: res });
if (this[EOF2])
return Promise.resolve({ done: true });
let resolve2 = null;
let reject = null;
const onerr = (er) => {
this.removeListener("data", ondata);
this.removeListener("end", onend);
reject(er);
};
const ondata = (value) => {
this.removeListener("error", onerr);
this.removeListener("end", onend);
this.pause();
resolve2({ value, done: !!this[EOF2] });
};
const onend = () => {
this.removeListener("error", onerr);
this.removeListener("data", ondata);
resolve2({ done: true });
};
const ondestroy = () => onerr(new Error("stream destroyed"));
return new Promise((res2, rej) => {
reject = rej;
resolve2 = res2;
this.once(DESTROYED2, ondestroy);
this.once("error", onerr);
this.once("end", onend);
this.once("data", ondata);
});
};
return { next };
}
// for (let chunk of stream)
[ITERATOR2]() {
const next = () => {
const value = this.read();
const done = value === null;
return { value, done };
};
return { next };
}
destroy(er) {
if (this[DESTROYED2]) {
if (er)
this.emit("error", er);
else
this.emit(DESTROYED2);
return this;
}
this[DESTROYED2] = true;
this.buffer.length = 0;
this[BUFFERLENGTH2] = 0;
if (typeof this.close === "function" && !this[CLOSED2])
this.close();
if (er)
this.emit("error", er);
else
this.emit(DESTROYED2);
return this;
}
static isStream(s) {
return !!s && (s instanceof Minipass2 || s instanceof Stream2 || s instanceof EE2 && (typeof s.pipe === "function" || // readable
typeof s.write === "function" && typeof s.end === "function"));
}
};
}
});
// ../../node_modules/.pnpm/minizlib@2.1.2/node_modules/minizlib/index.js
import * as __import_assert from "assert";
import * as __import_buffer from "buffer";
import * as __import_zlib2 from "zlib";
var require_minizlib = __commonJS({
"../../node_modules/.pnpm/minizlib@2.1.2/node_modules/minizlib/index.js"(exports) {
init_esm_shims();
var __import___constants_js = __toESM(require_constants());
var __import_minipass = __toESM(require_minipass());
var assert = __import_assert;
var Buffer2 = __import_buffer.Buffer;
var realZlib = __import_zlib2;
var constants = exports.constants = __import___constants_js;
var Minipass2 = __import_minipass;
var OriginalBufferConcat = Buffer2.concat;
var _superWrite = Symbol("_superWrite");
var ZlibError = class extends Error {
constructor(err) {
super("zlib: " + err.message);
this.code = err.code;
this.errno = err.errno;
if (!this.code)
this.code = "ZLIB_ERROR";
this.message = "zlib: " + err.message;
Error.captureStackTrace(this, this.constructor);
}
get name() {
return "ZlibError";
}
};
var _opts = Symbol("opts");
var _flushFlag = Symbol("flushFlag");
var _finishFlushFlag = Symbol("finishFlushFlag");
var _fullFlushFlag = Symbol("fullFlushFlag");
var _handle = Symbol("handle");
var _onError = Symbol("onError");
var _sawError = Symbol("sawError");
var _level = Symbol("level");
var _strategy = Symbol("strategy");
var _ended = Symbol("ended");
var _defaultFullFlush = Symbol("_defaultFullFlush");
var ZlibBase = class extends Minipass2 {
constructor(opts, mode) {
if (!opts || typeof opts !== "object")
throw new TypeError("invalid options for ZlibBase constructor");
super(opts);
this[_sawError] = false;
this[_ended] = false;
this[_opts] = opts;
this[_flushFlag] = opts.flush;
this[_finishFlushFlag] = opts.finishFlush;
try {
this[_handle] = new realZlib[mode](opts);
} catch (er) {
throw new ZlibError(er);
}
this[_onError] = (err) => {
if (this[_sawError])
return;
this[_sawError] = true;
this.close();
this.emit("error", err);
};
this[_handle].on("error", (er) => this[_onError](new ZlibError(er)));
this.once("end", () => this.close);
}
close() {
if (this[_handle]) {
this[_handle].close();
this[_handle] = null;
this.emit("close");
}
}
reset() {
if (!this[_sawError]) {
assert(this[_handle], "zlib binding closed");
return this[_handle].reset();
}
}
flush(flushFlag) {
if (this.ended)
return;
if (typeof flushFlag !== "number")
flushFlag = this[_fullFlushFlag];
this.write(Object.assign(Buffer2.alloc(0), { [_flushFlag]: flushFlag }));
}
end(chunk, encoding, cb) {
if (chunk)
this.write(chunk, encoding);
this.flush(this[_finishFlushFlag]);
this[_ended] = true;
return super.end(null, null, cb);
}
get ended() {
return this[_ended];
}
write(chunk, encoding, cb) {
if (typeof encoding === "function")
cb = encoding, encoding = "utf8";
if (typeof chunk === "string")
chunk = Buffer2.from(chunk, encoding);
if (this[_sawError])
return;
assert(this[_handle], "zlib binding closed");
const nativeHandle = this[_handle]._handle;
const originalNativeClose = nativeHandle.close;
nativeHandle.close = () => {
};
const originalClose = this[_handle].close;
this[_handle].close = () => {
};
Buffer2.concat = (args) => args;
let result;
try {
const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this[_flushFlag];
result = this[_handle]._processChunk(chunk, flushFlag);
Buffer2.concat = OriginalBufferConcat;
} catch (err) {
Buffer2.concat = OriginalBufferConcat;
this[_onError](new ZlibError(err));
} finally {
if (this[_handle]) {
this[_handle]._handle = nativeHandle;
nativeHandle.close = originalNativeClose;
this[_handle].close = originalClose;
this[_handle].removeAllListeners("error");
}
}
if (this[_handle])
this[_handle].on("error", (er) => this[_onError](new ZlibError(er)));
let writeReturn;
if (result) {
if (Array.isArray(result) && result.length > 0) {
writeReturn = this[_superWrite](Buffer2.from(result[0]));
for (let i = 1; i < result.length; i++) {
writeReturn = this[_superWrite](result[i]);
}
} else {
writeReturn = this[_superWrite](Buffer2.from(result));
}
}
if (cb)
cb();
return writeReturn;
}
[_superWrite](data) {
return super.write(data);
}
};
var Zlib = class extends ZlibBase {
constructor(opts, mode) {
opts = opts || {};
opts.flush = opts.flush || constants.Z_NO_FLUSH;
opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
super(opts, mode);
this[_fullFlushFlag] = constants.Z_FULL_FLUSH;
this[_level] = opts.level;
this[_strategy] = opts.strategy;
}
params(level, strategy) {
if (this[_sawError])
return;
if (!this[_handle])
throw new Error("cannot switch params when binding is closed");
if (!this[_handle].params)
throw new Error("not supported in this implementation");
if (this[_level] !== level || this[_strategy] !== strategy) {
this.flush(constants.Z_SYNC_FLUSH);
assert(this[_handle], "zlib binding closed");
const origFlush = this[_handle].flush;
this[_handle].flush = (flushFlag, cb) => {
this.flush(flushFlag);
cb();
};
try {
this[_handle].params(level, strategy);
} finally {
this[_handle].flush = origFlush;
}
if (this[_handle]) {
this[_level] = level;
this[_strategy] = strategy;
}
}
}
};
var Deflate = class extends Zlib {
constructor(opts) {
super(opts, "Deflate");
}
};
var Inflate = class extends Zlib {
constructor(opts) {
super(opts, "Inflate");
}
};
var _portable = Symbol("_portable");
var Gzip = class extends Zlib {
constructor(opts) {
super(opts, "Gzip");
this[_portable] = opts && !!opts.portable;
}
[_superWrite](data) {
if (!this[_portable])
return super[_superWrite](data);
this[_portable] = false;
dat