@shelf/aws-lambda-tesseract
Version:
6 MB Tesseract 4.1 (with English training data) to fit inside AWS Lambda
1,502 lines (1,497 loc) • 205 kB
JavaScript
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 __commonJS = (cb, mod) => function __require() {
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/tar/lib/high-level-opt.js
var require_high_level_opt = __commonJS({
"node_modules/tar/lib/high-level-opt.js"(exports, module2) {
"use strict";
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"]
]);
module2.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/tar/node_modules/minipass/index.js
var require_minipass = __commonJS({
"node_modules/tar/node_modules/minipass/index.js"(exports) {
"use strict";
var proc = typeof process === "object" && process ? process : {
stdout: null,
stderr: null
};
var EE = require("events");
var Stream = require("stream");
var stringdecoder = require("string_decoder");
var SD = stringdecoder.StringDecoder;
var EOF = Symbol("EOF");
var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
var EMITTED_END = Symbol("emittedEnd");
var EMITTING_END = Symbol("emittingEnd");
var EMITTED_ERROR = Symbol("emittedError");
var CLOSED = Symbol("closed");
var READ = Symbol("read");
var FLUSH = Symbol("flush");
var FLUSHCHUNK = Symbol("flushChunk");
var ENCODING = Symbol("encoding");
var DECODER = Symbol("decoder");
var FLOWING = Symbol("flowing");
var PAUSED = Symbol("paused");
var RESUME = Symbol("resume");
var BUFFER = Symbol("buffer");
var PIPES = Symbol("pipes");
var BUFFERLENGTH = Symbol("bufferLength");
var BUFFERPUSH = Symbol("bufferPush");
var BUFFERSHIFT = Symbol("bufferShift");
var OBJECTMODE = Symbol("objectMode");
var DESTROYED = Symbol("destroyed");
var ERROR = Symbol("error");
var EMITDATA = Symbol("emitData");
var EMITEND = Symbol("emitEnd");
var EMITEND2 = Symbol("emitEnd2");
var ASYNC = Symbol("async");
var ABORT = Symbol("abort");
var ABORTED = Symbol("aborted");
var SIGNAL = Symbol("signal");
var defer = (fn) => Promise.resolve().then(fn);
var doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1";
var ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented");
var ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented");
var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
var isArrayBuffer = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
var 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();
}
};
var 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);
}
};
var 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(n) {
if (this[DESTROYED])
return null;
if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
this[MAYBE_EMIT_END]();
return null;
}
if (this[OBJECTMODE])
n = 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](n || null, this[BUFFER][0]);
this[MAYBE_EMIT_END]();
return ret;
}
[READ](n, chunk) {
if (n === chunk.length || n === null)
this[BUFFERSHIFT]();
else {
this[BUFFER][0] = chunk.slice(n);
chunk = chunk.slice(0, n);
this[BUFFERLENGTH] -= n;
}
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 p = this[PIPES].find((p2) => p2.dest === dest);
if (p) {
this[PIPES].splice(this[PIPES].indexOf(p), 1);
p.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 p of this[PIPES]) {
if (p.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 p of this[PIPES]) {
p.dest.write(data);
}
super.emit("data", data);
}
}
for (const p of this[PIPES]) {
p.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 p = this.promise();
this.on("data", (c) => {
buf.push(c);
if (!this[OBJECTMODE])
buf.dataLength += c.length;
});
return p.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((resolve, reject) => {
this.on(DESTROYED, () => reject(new Error("stream destroyed")));
this.on("error", (er) => reject(er));
this.on("end", () => resolve());
});
}
// 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 resolve = 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();
resolve({ value, done: !!this[EOF] });
};
const onend = () => {
this.removeListener("error", onerr);
this.removeListener("data", ondata);
this.removeListener(DESTROYED, ondestroy);
stop();
resolve({ done: true });
};
const ondestroy = () => onerr(new Error("stream destroyed"));
return new Promise((res2, rej) => {
reject = rej;
resolve = 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"));
}
};
exports.Minipass = Minipass;
}
});
// node_modules/minizlib/constants.js
var require_constants = __commonJS({
"node_modules/minizlib/constants.js"(exports, module2) {
var realZlibConstants = require("zlib").constants || /* istanbul ignore next */
{ ZLIB_VERNUM: 4736 };
module2.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/minipass/index.js
var require_minipass2 = __commonJS({
"node_modules/minipass/index.js"(exports, module2) {
"use strict";
var proc = typeof process === "object" && process ? process : {
stdout: null,
stderr: null
};
var EE = require("events");
var Stream = require("stream");
var SD = require("string_decoder").StringDecoder;
var EOF = Symbol("EOF");
var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
var EMITTED_END = Symbol("emittedEnd");
var EMITTING_END = Symbol("emittingEnd");
var EMITTED_ERROR = Symbol("emittedError");
var CLOSED = Symbol("closed");
var READ = Symbol("read");
var FLUSH = Symbol("flush");
var FLUSHCHUNK = Symbol("flushChunk");
var ENCODING = Symbol("encoding");
var DECODER = Symbol("decoder");
var FLOWING = Symbol("flowing");
var PAUSED = Symbol("paused");
var RESUME = Symbol("resume");
var BUFFERLENGTH = Symbol("bufferLength");
var BUFFERPUSH = Symbol("bufferPush");
var BUFFERSHIFT = Symbol("bufferShift");
var OBJECTMODE = Symbol("objectMode");
var DESTROYED = Symbol("destroyed");
var EMITDATA = Symbol("emitData");
var EMITEND = Symbol("emitEnd");
var EMITEND2 = Symbol("emitEnd2");
var ASYNC = Symbol("async");
var defer = (fn) => Promise.resolve().then(fn);
var doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1";
var ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented");
var ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented");
var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
var isArrayBuffer = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
var 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();
}
};
var 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);
}
};
module2.exports = 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;
}
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;
}
write(chunk, encoding, cb) {
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(n) {
if (this[DESTROYED])
return null;
if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
this[MAYBE_EMIT_END]();
return null;
}
if (this[OBJECTMODE])
n = 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](n || null, this.buffer[0]);
this[MAYBE_EMIT_END]();
return ret;
}
[READ](n, chunk) {
if (n === chunk.length || n === null)
this[BUFFERSHIFT]();
else {
this.buffer[0] = chunk.slice(n);
chunk = chunk.slice(0, n);
this[BUFFERLENGTH] -= n;
}
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.buffer.length) {
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]()));
if (!noDrain && !this.buffer.length && !this[EOF])
this.emit("drain");
}
[FLUSHCHUNK](chunk) {
return chunk ? (this.emit("data", chunk), this.flowing) : false;
}
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 p = this.pipes.find((p2) => p2.dest === dest);
if (p) {
this.pipes.splice(this.pipes.indexOf(p), 1);
p.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 !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;
const ret2 = super.emit("error", data);
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 p of this.pipes) {
if (p.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 p of this.pipes) {
p.dest.write(data);
}
super.emit("data", data);
}
}
for (const p of this.pipes) {
p.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 p = this.promise();
this.on("data", (c) => {
buf.push(c);
if (!this[OBJECTMODE])
buf.dataLength += c.length;
});
return p.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((resolve, reject) => {
this.on(DESTROYED, () => reject(new Error("stream destroyed")));
this.on("error", (er) => reject(er));
this.on("end", () => resolve());
});
}
// for await (let chunk of stream)
[ASYNCITERATOR]() {
const next = () => {
const res = this.read();
if (res !== null)
return Promise.resolve({ done: false, value: res });
if (this[EOF])
return Promise.resolve({ done: true });
let resolve = 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();
resolve({ value, done: !!this[EOF] });
};
const onend = () => {
this.removeListener("error", onerr);
this.removeListener("data", ondata);
resolve({ done: true });
};
const ondestroy = () => onerr(new Error("stream destroyed"));
return new Promise((res2, rej) => {
reject = rej;
resolve = res2;
this.once(DESTROYED, ondestroy);
this.once("error", onerr);
this.once("end", onend);
this.once("data", ondata);
});
};
return { next };
}
// for (let chunk of stream)
[ITERATOR]() {
const next = () => {
const value = this.read();
const done = value === null;
return { value, done };
};
return { next };
}
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 && (typeof s.pipe === "function" || // readable
typeof s.write === "function" && typeof s.end === "function"));
}
};
}
});
// node_modules/minizlib/index.js
var require_minizlib = __commonJS({
"node_modules/minizlib/index.js"(exports) {
"use strict";
var assert = require("assert");
var Buffer2 = require("buffer").Buffer;
var realZlib = require("zlib");
var constants = exports.constants = require_constants();
var Minipass = require_minipass2();
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 Minipass {
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 = Sym