lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.42.mjs

@@ -1,247 +1,2354 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import { i as t } from "./Package.internal.122.mjs";
-
-const e = t;
-
-const r = (t, l, a) => {
-    if (e(t) === false) {
-        throw new TypeError("toRegexRange: expected the first argument to be a number");
-    }
-    if (l === void 0 || t === l) {
-        return String(t);
-    }
-    if (e(l) === false) {
-        throw new TypeError("toRegexRange: expected the second argument to be a number.");
-    }
-    let u = {
-        relaxZeros: true,
-        ...a
-    };
-    if (typeof u.strictZeros === "boolean") {
-        u.relaxZeros = u.strictZeros === false;
-    }
-    let s = String(u.relaxZeros);
-    let o = String(u.shorthand);
-    let c = String(u.capture);
-    let f = String(u.wrap);
-    let h = t + ":" + l + "=" + s + o + c + f;
-    if (r.cache.hasOwnProperty(h)) {
-        return r.cache[h].result;
-    }
-    let g = Math.min(t, l);
-    let p = Math.max(t, l);
-    if (Math.abs(g - p) === 1) {
-        let e = t + "|" + l;
-        if (u.capture) {
-            return `(${e})`;
-        }
-        if (u.wrap === false) {
-            return e;
-        }
-        return `(?:${e})`;
-    }
-    let m = d(t) || d(l);
-    let x = {
-        min: t,
-        max: l,
-        a: g,
-        b: p
-    };
-    let w = [];
-    let b = [];
-    if (m) {
-        x.isPadded = m;
-        x.maxLen = String(x.max).length;
-    }
-    if (g < 0) {
-        let t = p < 0 ? Math.abs(p) : 1;
-        b = i(t, Math.abs(g), x, u);
-        g = x.a = 0;
-    }
-    if (p >= 0) {
-        w = i(g, p, x, u);
-    }
-    x.negatives = b;
-    x.positives = w;
-    x.result = n(b, w);
-    if (u.capture === true) {
-        x.result = `(${x.result})`;
-    } else if (u.wrap !== false && w.length + b.length > 1) {
-        x.result = `(?:${x.result})`;
-    }
-    r.cache[h] = x;
-    return x.result;
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import e from "stream";
+
+import { c as t } from "./Package.internal.8.mjs";
+
+import r from "events";
+
+import n from "buffer";
+
+import i from "util";
+
+import { r as a } from "./Package.internal.43.mjs";
+
+import { r as o } from "./Package.internal.173.mjs";
+
+import { r as f } from "./Package.internal.174.mjs";
+
+var s = {
+    exports: {}
 };
 
-function n(t, e, r) {
-    let n = u(t, e, "-", false) || [];
-    let l = u(e, t, "", false) || [];
-    let a = u(t, e, "-?", true) || [];
-    let i = n.concat(a).concat(l);
-    return i.join("|");
-}
+var l;
+
+var u;
 
-function l(t, e) {
-    let r = 1;
-    let n = 1;
-    let l = f(t, r);
-    let a = new Set([ e ]);
-    while (t <= l && l <= e) {
-        a.add(l);
-        r += 1;
-        l = f(t, r);
-    }
-    l = h(e + 1, n) - 1;
-    while (t < l && l <= e) {
-        a.add(l);
-        n += 1;
-        l = h(e + 1, n) - 1;
-    }
-    a = [ ...a ];
-    a.sort(o);
-    return a;
+function d() {
+    if (u) return l;
+    u = 1;
+    l = e;
+    return l;
 }
 
-function a(t, e, r) {
-    if (t === e) {
-        return {
-            pattern: t,
-            count: [],
-            digits: 0
-        };
+var c;
+
+var h;
+
+function p() {
+    if (h) return c;
+    h = 1;
+    function e(e, t) {
+        var r = Object.keys(e);
+        if (Object.getOwnPropertySymbols) {
+            var n = Object.getOwnPropertySymbols(e);
+            t && (n = n.filter(function(t) {
+                return Object.getOwnPropertyDescriptor(e, t).enumerable;
+            })), r.push.apply(r, n);
+        }
+        return r;
     }
-    let n = s(t, e);
-    let l = n.length;
-    let a = "";
-    let i = 0;
-    for (let t = 0; t < l; t++) {
-        let [e, r] = n[t];
-        if (e === r) {
-            a += e;
-        } else if (e !== "0" || r !== "9") {
-            a += p(e, r);
+    function t(t) {
+        for (var n = 1; n < arguments.length; n++) {
+            var i = null != arguments[n] ? arguments[n] : {};
+            n % 2 ? e(Object(i), true).forEach(function(e) {
+                r(t, e, i[e]);
+            }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(i)) : e(Object(i)).forEach(function(e) {
+                Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(i, e));
+            });
+        }
+        return t;
+    }
+    function r(e, t, r) {
+        t = s(t);
+        if (t in e) {
+            Object.defineProperty(e, t, {
+                value: r,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
         } else {
-            i++;
+            e[t] = r;
         }
+        return e;
     }
-    if (i) {
-        a += r.shorthand === true ? "\\d" : "[0-9]";
+    function a(e, t) {
+        if (!(e instanceof t)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
     }
-    return {
-        pattern: a,
-        count: [ i ],
-        digits: l
-    };
+    function o(e, t) {
+        for (var r = 0; r < t.length; r++) {
+            var n = t[r];
+            n.enumerable = n.enumerable || false;
+            n.configurable = true;
+            if ("value" in n) n.writable = true;
+            Object.defineProperty(e, s(n.key), n);
+        }
+    }
+    function f(e, t, r) {
+        if (t) o(e.prototype, t);
+        Object.defineProperty(e, "prototype", {
+            writable: false
+        });
+        return e;
+    }
+    function s(e) {
+        var t = l(e, "string");
+        return typeof t === "symbol" ? t : String(t);
+    }
+    function l(e, t) {
+        if (typeof e !== "object" || e === null) return e;
+        var r = e[Symbol.toPrimitive];
+        if (r !== undefined) {
+            var n = r.call(e, t);
+            if (typeof n !== "object") return n;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return String(e);
+    }
+    var u = n, d = u.Buffer;
+    var p = i, b = p.inspect;
+    var v = b && b.custom || "inspect";
+    function g(e, t, r) {
+        d.prototype.copy.call(e, t, r);
+    }
+    c = function() {
+        function e() {
+            a(this, e);
+            this.head = null;
+            this.tail = null;
+            this.length = 0;
+        }
+        f(e, [ {
+            key: "push",
+            value: function e(t) {
+                var r = {
+                    data: t,
+                    next: null
+                };
+                if (this.length > 0) this.tail.next = r; else this.head = r;
+                this.tail = r;
+                ++this.length;
+            }
+        }, {
+            key: "unshift",
+            value: function e(t) {
+                var r = {
+                    data: t,
+                    next: this.head
+                };
+                if (this.length === 0) this.tail = r;
+                this.head = r;
+                ++this.length;
+            }
+        }, {
+            key: "shift",
+            value: function e() {
+                if (this.length === 0) return;
+                var t = this.head.data;
+                if (this.length === 1) this.head = this.tail = null; else this.head = this.head.next;
+                --this.length;
+                return t;
+            }
+        }, {
+            key: "clear",
+            value: function e() {
+                this.head = this.tail = null;
+                this.length = 0;
+            }
+        }, {
+            key: "join",
+            value: function e(t) {
+                if (this.length === 0) return "";
+                var r = this.head;
+                var n = "" + r.data;
+                while (r = r.next) n += t + r.data;
+                return n;
+            }
+        }, {
+            key: "concat",
+            value: function e(t) {
+                if (this.length === 0) return d.alloc(0);
+                var r = d.allocUnsafe(t >>> 0);
+                var n = this.head;
+                var i = 0;
+                while (n) {
+                    g(n.data, r, i);
+                    i += n.data.length;
+                    n = n.next;
+                }
+                return r;
+            }
+        }, {
+            key: "consume",
+            value: function e(t, r) {
+                var n;
+                if (t < this.head.data.length) {
+                    n = this.head.data.slice(0, t);
+                    this.head.data = this.head.data.slice(t);
+                } else if (t === this.head.data.length) {
+                    n = this.shift();
+                } else {
+                    n = r ? this._getString(t) : this._getBuffer(t);
+                }
+                return n;
+            }
+        }, {
+            key: "first",
+            value: function e() {
+                return this.head.data;
+            }
+        }, {
+            key: "_getString",
+            value: function e(t) {
+                var r = this.head;
+                var n = 1;
+                var i = r.data;
+                t -= i.length;
+                while (r = r.next) {
+                    var a = r.data;
+                    var o = t > a.length ? a.length : t;
+                    if (o === a.length) i += a; else i += a.slice(0, t);
+                    t -= o;
+                    if (t === 0) {
+                        if (o === a.length) {
+                            ++n;
+                            if (r.next) this.head = r.next; else this.head = this.tail = null;
+                        } else {
+                            this.head = r;
+                            r.data = a.slice(o);
+                        }
+                        break;
+                    }
+                    ++n;
+                }
+                this.length -= n;
+                return i;
+            }
+        }, {
+            key: "_getBuffer",
+            value: function e(t) {
+                var r = d.allocUnsafe(t);
+                var n = this.head;
+                var i = 1;
+                n.data.copy(r);
+                t -= n.data.length;
+                while (n = n.next) {
+                    var a = n.data;
+                    var o = t > a.length ? a.length : t;
+                    a.copy(r, r.length - t, 0, o);
+                    t -= o;
+                    if (t === 0) {
+                        if (o === a.length) {
+                            ++i;
+                            if (n.next) this.head = n.next; else this.head = this.tail = null;
+                        } else {
+                            this.head = n;
+                            n.data = a.slice(o);
+                        }
+                        break;
+                    }
+                    ++i;
+                }
+                this.length -= i;
+                return r;
+            }
+        }, {
+            key: v,
+            value: function e(r, n) {
+                return b(this, t(t({}, n), {}, {
+                    depth: 0,
+                    customInspect: false
+                }));
+            }
+        } ]);
+        return e;
+    }();
+    return c;
 }
 
-function i(t, e, r, n) {
-    let i = l(t, e);
-    let u = [];
-    let s = t;
-    let o;
-    for (let t = 0; t < i.length; t++) {
-        let e = i[t];
-        let l = a(String(s), String(e), n);
-        let c = "";
-        if (!r.isPadded && o && o.pattern === l.pattern) {
-            if (o.count.length > 1) {
-                o.count.pop();
-            }
-            o.count.push(l.count[0]);
-            o.string = o.pattern + g(o.count);
-            s = e + 1;
-            continue;
-        }
-        if (r.isPadded) {
-            c = m(e, r, n);
-        }
-        l.string = c + l.pattern + g(l.count);
-        u.push(l);
-        s = e + 1;
-        o = l;
-    }
-    return u;
+var b;
+
+var v;
+
+function g() {
+    if (v) return b;
+    v = 1;
+    function e(e, n) {
+        var a = this;
+        var o = this._readableState && this._readableState.destroyed;
+        var f = this._writableState && this._writableState.destroyed;
+        if (o || f) {
+            if (n) {
+                n(e);
+            } else if (e) {
+                if (!this._writableState) {
+                    process.nextTick(i, this, e);
+                } else if (!this._writableState.errorEmitted) {
+                    this._writableState.errorEmitted = true;
+                    process.nextTick(i, this, e);
+                }
+            }
+            return this;
+        }
+        if (this._readableState) {
+            this._readableState.destroyed = true;
+        }
+        if (this._writableState) {
+            this._writableState.destroyed = true;
+        }
+        this._destroy(e || null, function(e) {
+            if (!n && e) {
+                if (!a._writableState) {
+                    process.nextTick(t, a, e);
+                } else if (!a._writableState.errorEmitted) {
+                    a._writableState.errorEmitted = true;
+                    process.nextTick(t, a, e);
+                } else {
+                    process.nextTick(r, a);
+                }
+            } else if (n) {
+                process.nextTick(r, a);
+                n(e);
+            } else {
+                process.nextTick(r, a);
+            }
+        });
+        return this;
+    }
+    function t(e, t) {
+        i(e, t);
+        r(e);
+    }
+    function r(e) {
+        if (e._writableState && !e._writableState.emitClose) return;
+        if (e._readableState && !e._readableState.emitClose) return;
+        e.emit("close");
+    }
+    function n() {
+        if (this._readableState) {
+            this._readableState.destroyed = false;
+            this._readableState.reading = false;
+            this._readableState.ended = false;
+            this._readableState.endEmitted = false;
+        }
+        if (this._writableState) {
+            this._writableState.destroyed = false;
+            this._writableState.ended = false;
+            this._writableState.ending = false;
+            this._writableState.finalCalled = false;
+            this._writableState.prefinished = false;
+            this._writableState.finished = false;
+            this._writableState.errorEmitted = false;
+        }
+    }
+    function i(e, t) {
+        e.emit("error", t);
+    }
+    function a(e, t) {
+        var r = e._readableState;
+        var n = e._writableState;
+        if (r && r.autoDestroy || n && n.autoDestroy) e.destroy(t); else e.emit("error", t);
+    }
+    b = {
+        destroy: e,
+        undestroy: n,
+        errorOrDestroy: a
+    };
+    return b;
 }
 
-function u(t, e, r, n, l) {
-    let a = [];
-    for (let l of t) {
-        let {string: t} = l;
-        if (!n && !c(e, "string", t)) {
-            a.push(r + t);
+var y = {};
+
+var w;
+
+function _() {
+    if (w) return y;
+    w = 1;
+    const e = {};
+    function t(t, r, n) {
+        if (!n) {
+            n = Error;
+        }
+        function i(e, t, n) {
+            if (typeof r === "string") {
+                return r;
+            } else {
+                return r(e, t, n);
+            }
+        }
+        class NodeError extends n {
+            constructor(e, t, r) {
+                super(i(e, t, r));
+            }
+        }
+        NodeError.prototype.name = n.name;
+        NodeError.prototype.code = t;
+        e[t] = NodeError;
+    }
+    function r(e, t) {
+        if (Array.isArray(e)) {
+            const r = e.length;
+            e = e.map(e => String(e));
+            if (r > 2) {
+                return `one of ${t} ${e.slice(0, r - 1).join(", ")}, or ` + e[r - 1];
+            } else if (r === 2) {
+                return `one of ${t} ${e[0]} or ${e[1]}`;
+            } else {
+                return `of ${t} ${e[0]}`;
+            }
+        } else {
+            return `of ${t} ${String(e)}`;
         }
-        if (n && c(e, "string", t)) {
-            a.push(r + t);
+    }
+    function n(e, t, r) {
+        return e.substr(0, t.length) === t;
+    }
+    function i(e, t, r) {
+        if (r === undefined || r > e.length) {
+            r = e.length;
         }
+        return e.substring(r - t.length, r) === t;
     }
-    return a;
+    function a(e, t, r) {
+        if (typeof r !== "number") {
+            r = 0;
+        }
+        if (r + t.length > e.length) {
+            return false;
+        } else {
+            return e.indexOf(t, r) !== -1;
+        }
+    }
+    t("ERR_INVALID_OPT_VALUE", function(e, t) {
+        return 'The value "' + t + '" is invalid for option "' + e + '"';
+    }, TypeError);
+    t("ERR_INVALID_ARG_TYPE", function(e, t, o) {
+        let f;
+        if (typeof t === "string" && n(t, "not ")) {
+            f = "must not be";
+            t = t.replace(/^not /, "");
+        } else {
+            f = "must be";
+        }
+        let s;
+        if (i(e, " argument")) {
+            s = `The ${e} ${f} ${r(t, "type")}`;
+        } else {
+            const n = a(e, ".") ? "property" : "argument";
+            s = `The "${e}" ${n} ${f} ${r(t, "type")}`;
+        }
+        s += `. Received type ${typeof o}`;
+        return s;
+    }, TypeError);
+    t("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+    t("ERR_METHOD_NOT_IMPLEMENTED", function(e) {
+        return "The " + e + " method is not implemented";
+    });
+    t("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+    t("ERR_STREAM_DESTROYED", function(e) {
+        return "Cannot call " + e + " after a stream was destroyed";
+    });
+    t("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+    t("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+    t("ERR_STREAM_WRITE_AFTER_END", "write after end");
+    t("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+    t("ERR_UNKNOWN_ENCODING", function(e) {
+        return "Unknown encoding: " + e;
+    }, TypeError);
+    t("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+    y.codes = e;
+    return y;
 }
 
-function s(t, e) {
-    let r = [];
-    for (let n = 0; n < t.length; n++) r.push([ t[n], e[n] ]);
-    return r;
+var m;
+
+var S;
+
+function R() {
+    if (S) return m;
+    S = 1;
+    var e = _().codes.ERR_INVALID_OPT_VALUE;
+    function t(e, t, r) {
+        return e.highWaterMark != null ? e.highWaterMark : t ? e[r] : null;
+    }
+    function r(r, n, i, a) {
+        var o = t(n, a, i);
+        if (o != null) {
+            if (!(isFinite(o) && Math.floor(o) === o) || o < 0) {
+                var f = a ? i : "highWaterMark";
+                throw new e(f, o);
+            }
+            return Math.floor(o);
+        }
+        return r.objectMode ? 16 : 16 * 1024;
+    }
+    m = {
+        getHighWaterMark: r
+    };
+    return m;
 }
 
-function o(t, e) {
-    return t > e ? 1 : e > t ? -1 : 0;
+var E;
+
+var k;
+
+function T() {
+    if (k) return E;
+    k = 1;
+    E = C;
+    function e(e) {
+        var t = this;
+        this.next = null;
+        this.entry = null;
+        this.finish = function() {
+            X(t, e);
+        };
+    }
+    var r;
+    C.WritableState = D;
+    var i = {
+        deprecate: o()
+    };
+    var f = d();
+    var s = n.Buffer;
+    var l = (typeof t !== "undefined" ? t : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
+    function u(e) {
+        return s.from(e);
+    }
+    function c(e) {
+        return s.isBuffer(e) || e instanceof l;
+    }
+    var h = g();
+    var p = R(), b = p.getHighWaterMark;
+    var v = _().codes, y = v.ERR_INVALID_ARG_TYPE, w = v.ERR_METHOD_NOT_IMPLEMENTED, m = v.ERR_MULTIPLE_CALLBACK, S = v.ERR_STREAM_CANNOT_PIPE, T = v.ERR_STREAM_DESTROYED, M = v.ERR_STREAM_NULL_VALUES, O = v.ERR_STREAM_WRITE_AFTER_END, P = v.ERR_UNKNOWN_ENCODING;
+    var L = h.errorOrDestroy;
+    a()(C, f);
+    function A() {}
+    function D(t, n, i) {
+        r = r || j();
+        t = t || {};
+        if (typeof i !== "boolean") i = n instanceof r;
+        this.objectMode = !!t.objectMode;
+        if (i) this.objectMode = this.objectMode || !!t.writableObjectMode;
+        this.highWaterMark = b(this, t, "writableHighWaterMark", i);
+        this.finalCalled = false;
+        this.needDrain = false;
+        this.ending = false;
+        this.ended = false;
+        this.finished = false;
+        this.destroyed = false;
+        var a = t.decodeStrings === false;
+        this.decodeStrings = !a;
+        this.defaultEncoding = t.defaultEncoding || "utf8";
+        this.length = 0;
+        this.writing = false;
+        this.corked = 0;
+        this.sync = true;
+        this.bufferProcessing = false;
+        this.onwrite = function(e) {
+            H(n, e);
+        };
+        this.writecb = null;
+        this.writelen = 0;
+        this.bufferedRequest = null;
+        this.lastBufferedRequest = null;
+        this.pendingcb = 0;
+        this.prefinished = false;
+        this.errorEmitted = false;
+        this.emitClose = t.emitClose !== false;
+        this.autoDestroy = !!t.autoDestroy;
+        this.bufferedRequestCount = 0;
+        this.corkedRequestsFree = new e(this);
+    }
+    D.prototype.getBuffer = function e() {
+        var t = this.bufferedRequest;
+        var r = [];
+        while (t) {
+            r.push(t);
+            t = t.next;
+        }
+        return r;
+    };
+    (function() {
+        try {
+            Object.defineProperty(D.prototype, "buffer", {
+                get: i.deprecate(function e() {
+                    return this.getBuffer();
+                }, "_writableState.buffer is deprecated. Use _writableState.getBuffer " + "instead.", "DEP0003")
+            });
+        } catch (e) {}
+    })();
+    var x;
+    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+        x = Function.prototype[Symbol.hasInstance];
+        Object.defineProperty(C, Symbol.hasInstance, {
+            value: function e(t) {
+                if (x.call(this, t)) return true;
+                if (this !== C) return false;
+                return t && t._writableState instanceof D;
+            }
+        });
+    } else {
+        x = function e(t) {
+            return t instanceof this;
+        };
+    }
+    function C(e) {
+        r = r || j();
+        var t = this instanceof r;
+        if (!t && !x.call(C, this)) return new C(e);
+        this._writableState = new D(e, this, t);
+        this.writable = true;
+        if (e) {
+            if (typeof e.write === "function") this._write = e.write;
+            if (typeof e.writev === "function") this._writev = e.writev;
+            if (typeof e.destroy === "function") this._destroy = e.destroy;
+            if (typeof e.final === "function") this._final = e.final;
+        }
+        f.call(this);
+    }
+    C.prototype.pipe = function() {
+        L(this, new S);
+    };
+    function N(e, t) {
+        var r = new O;
+        L(e, r);
+        process.nextTick(t, r);
+    }
+    function I(e, t, r, n) {
+        var i;
+        if (r === null) {
+            i = new M;
+        } else if (typeof r !== "string" && !t.objectMode) {
+            i = new y("chunk", [ "string", "Buffer" ], r);
+        }
+        if (i) {
+            L(e, i);
+            process.nextTick(n, i);
+            return false;
+        }
+        return true;
+    }
+    C.prototype.write = function(e, t, r) {
+        var n = this._writableState;
+        var i = false;
+        var a = !n.objectMode && c(e);
+        if (a && !s.isBuffer(e)) {
+            e = u(e);
+        }
+        if (typeof t === "function") {
+            r = t;
+            t = null;
+        }
+        if (a) t = "buffer"; else if (!t) t = n.defaultEncoding;
+        if (typeof r !== "function") r = A;
+        if (n.ending) N(this, r); else if (a || I(this, n, e, r)) {
+            n.pendingcb++;
+            i = B(this, n, a, e, t, r);
+        }
+        return i;
+    };
+    C.prototype.cork = function() {
+        this._writableState.corked++;
+    };
+    C.prototype.uncork = function() {
+        var e = this._writableState;
+        if (e.corked) {
+            e.corked--;
+            if (!e.writing && !e.corked && !e.bufferProcessing && e.bufferedRequest) G(this, e);
+        }
+    };
+    C.prototype.setDefaultEncoding = function e(t) {
+        if (typeof t === "string") t = t.toLowerCase();
+        if (!([ "hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw" ].indexOf((t + "").toLowerCase()) > -1)) throw new P(t);
+        this._writableState.defaultEncoding = t;
+        return this;
+    };
+    Object.defineProperty(C.prototype, "writableBuffer", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState && this._writableState.getBuffer();
+        }
+    });
+    function W(e, t, r) {
+        if (!e.objectMode && e.decodeStrings !== false && typeof t === "string") {
+            t = s.from(t, r);
+        }
+        return t;
+    }
+    Object.defineProperty(C.prototype, "writableHighWaterMark", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState.highWaterMark;
+        }
+    });
+    function B(e, t, r, n, i, a) {
+        if (!r) {
+            var o = W(t, n, i);
+            if (n !== o) {
+                r = true;
+                i = "buffer";
+                n = o;
+            }
+        }
+        var f = t.objectMode ? 1 : n.length;
+        t.length += f;
+        var s = t.length < t.highWaterMark;
+        if (!s) t.needDrain = true;
+        if (t.writing || t.corked) {
+            var l = t.lastBufferedRequest;
+            t.lastBufferedRequest = {
+                chunk: n,
+                encoding: i,
+                isBuf: r,
+                callback: a,
+                next: null
+            };
+            if (l) {
+                l.next = t.lastBufferedRequest;
+            } else {
+                t.bufferedRequest = t.lastBufferedRequest;
+            }
+            t.bufferedRequestCount += 1;
+        } else {
+            q(e, t, false, f, n, i, a);
+        }
+        return s;
+    }
+    function q(e, t, r, n, i, a, o) {
+        t.writelen = n;
+        t.writecb = o;
+        t.writing = true;
+        t.sync = true;
+        if (t.destroyed) t.onwrite(new T("write")); else if (r) e._writev(i, t.onwrite); else e._write(i, a, t.onwrite);
+        t.sync = false;
+    }
+    function U(e, t, r, n, i) {
+        --t.pendingcb;
+        if (r) {
+            process.nextTick(i, n);
+            process.nextTick(J, e, t);
+            e._writableState.errorEmitted = true;
+            L(e, n);
+        } else {
+            i(n);
+            e._writableState.errorEmitted = true;
+            L(e, n);
+            J(e, t);
+        }
+    }
+    function F(e) {
+        e.writing = false;
+        e.writecb = null;
+        e.length -= e.writelen;
+        e.writelen = 0;
+    }
+    function H(e, t) {
+        var r = e._writableState;
+        var n = r.sync;
+        var i = r.writecb;
+        if (typeof i !== "function") throw new m;
+        F(r);
+        if (t) U(e, r, n, t, i); else {
+            var a = Y(r) || e.destroyed;
+            if (!a && !r.corked && !r.bufferProcessing && r.bufferedRequest) {
+                G(e, r);
+            }
+            if (n) {
+                process.nextTick($, e, r, a, i);
+            } else {
+                $(e, r, a, i);
+            }
+        }
+    }
+    function $(e, t, r, n) {
+        if (!r) V(e, t);
+        t.pendingcb--;
+        n();
+        J(e, t);
+    }
+    function V(e, t) {
+        if (t.length === 0 && t.needDrain) {
+            t.needDrain = false;
+            e.emit("drain");
+        }
+    }
+    function G(t, r) {
+        r.bufferProcessing = true;
+        var n = r.bufferedRequest;
+        if (t._writev && n && n.next) {
+            var i = r.bufferedRequestCount;
+            var a = new Array(i);
+            var o = r.corkedRequestsFree;
+            o.entry = n;
+            var f = 0;
+            var s = true;
+            while (n) {
+                a[f] = n;
+                if (!n.isBuf) s = false;
+                n = n.next;
+                f += 1;
+            }
+            a.allBuffers = s;
+            q(t, r, true, r.length, a, "", o.finish);
+            r.pendingcb++;
+            r.lastBufferedRequest = null;
+            if (o.next) {
+                r.corkedRequestsFree = o.next;
+                o.next = null;
+            } else {
+                r.corkedRequestsFree = new e(r);
+            }
+            r.bufferedRequestCount = 0;
+        } else {
+            while (n) {
+                var l = n.chunk;
+                var u = n.encoding;
+                var d = n.callback;
+                var c = r.objectMode ? 1 : l.length;
+                q(t, r, false, c, l, u, d);
+                n = n.next;
+                r.bufferedRequestCount--;
+                if (r.writing) {
+                    break;
+                }
+            }
+            if (n === null) r.lastBufferedRequest = null;
+        }
+        r.bufferedRequest = n;
+        r.bufferProcessing = false;
+    }
+    C.prototype._write = function(e, t, r) {
+        r(new w("_write()"));
+    };
+    C.prototype._writev = null;
+    C.prototype.end = function(e, t, r) {
+        var n = this._writableState;
+        if (typeof e === "function") {
+            r = e;
+            e = null;
+            t = null;
+        } else if (typeof t === "function") {
+            r = t;
+            t = null;
+        }
+        if (e !== null && e !== undefined) this.write(e, t);
+        if (n.corked) {
+            n.corked = 1;
+            this.uncork();
+        }
+        if (!n.ending) Q(this, n, r);
+        return this;
+    };
+    Object.defineProperty(C.prototype, "writableLength", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState.length;
+        }
+    });
+    function Y(e) {
+        return e.ending && e.length === 0 && e.bufferedRequest === null && !e.finished && !e.writing;
+    }
+    function K(e, t) {
+        e._final(function(r) {
+            t.pendingcb--;
+            if (r) {
+                L(e, r);
+            }
+            t.prefinished = true;
+            e.emit("prefinish");
+            J(e, t);
+        });
+    }
+    function z(e, t) {
+        if (!t.prefinished && !t.finalCalled) {
+            if (typeof e._final === "function" && !t.destroyed) {
+                t.pendingcb++;
+                t.finalCalled = true;
+                process.nextTick(K, e, t);
+            } else {
+                t.prefinished = true;
+                e.emit("prefinish");
+            }
+        }
+    }
+    function J(e, t) {
+        var r = Y(t);
+        if (r) {
+            z(e, t);
+            if (t.pendingcb === 0) {
+                t.finished = true;
+                e.emit("finish");
+                if (t.autoDestroy) {
+                    var n = e._readableState;
+                    if (!n || n.autoDestroy && n.endEmitted) {
+                        e.destroy();
+                    }
+                }
+            }
+        }
+        return r;
+    }
+    function Q(e, t, r) {
+        t.ending = true;
+        J(e, t);
+        if (r) {
+            if (t.finished) process.nextTick(r); else e.once("finish", r);
+        }
+        t.ended = true;
+        e.writable = false;
+    }
+    function X(e, t, r) {
+        var n = e.entry;
+        e.entry = null;
+        while (n) {
+            var i = n.callback;
+            t.pendingcb--;
+            i(r);
+            n = n.next;
+        }
+        t.corkedRequestsFree.next = e;
+    }
+    Object.defineProperty(C.prototype, "destroyed", {
+        enumerable: false,
+        get: function e() {
+            if (this._writableState === undefined) {
+                return false;
+            }
+            return this._writableState.destroyed;
+        },
+        set: function e(t) {
+            if (!this._writableState) {
+                return;
+            }
+            this._writableState.destroyed = t;
+        }
+    });
+    C.prototype.destroy = h.destroy;
+    C.prototype._undestroy = h.undestroy;
+    C.prototype._destroy = function(e, t) {
+        t(e);
+    };
+    return E;
 }
 
-function c(t, e, r) {
-    return t.some(t => t[e] === r);
+var M;
+
+var O;
+
+function j() {
+    if (O) return M;
+    O = 1;
+    var e = Object.keys || function(e) {
+        var t = [];
+        for (var r in e) t.push(r);
+        return t;
+    };
+    M = f;
+    var t = U();
+    var r = T();
+    a()(f, t);
+    {
+        var n = e(r.prototype);
+        for (var i = 0; i < n.length; i++) {
+            var o = n[i];
+            if (!f.prototype[o]) f.prototype[o] = r.prototype[o];
+        }
+    }
+    function f(e) {
+        if (!(this instanceof f)) return new f(e);
+        t.call(this, e);
+        r.call(this, e);
+        this.allowHalfOpen = true;
+        if (e) {
+            if (e.readable === false) this.readable = false;
+            if (e.writable === false) this.writable = false;
+            if (e.allowHalfOpen === false) {
+                this.allowHalfOpen = false;
+                this.once("end", s);
+            }
+        }
+    }
+    Object.defineProperty(f.prototype, "writableHighWaterMark", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState.highWaterMark;
+        }
+    });
+    Object.defineProperty(f.prototype, "writableBuffer", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState && this._writableState.getBuffer();
+        }
+    });
+    Object.defineProperty(f.prototype, "writableLength", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState.length;
+        }
+    });
+    function s() {
+        if (this._writableState.ended) return;
+        process.nextTick(l, this);
+    }
+    function l(e) {
+        e.end();
+    }
+    Object.defineProperty(f.prototype, "destroyed", {
+        enumerable: false,
+        get: function e() {
+            if (this._readableState === undefined || this._writableState === undefined) {
+                return false;
+            }
+            return this._readableState.destroyed && this._writableState.destroyed;
+        },
+        set: function e(t) {
+            if (this._readableState === undefined || this._writableState === undefined) {
+                return;
+            }
+            this._readableState.destroyed = t;
+            this._writableState.destroyed = t;
+        }
+    });
+    return M;
 }
 
-function f(t, e) {
-    return Number(String(t).slice(0, -e) + "9".repeat(e));
+var P;
+
+var L;
+
+function A() {
+    if (L) return P;
+    L = 1;
+    var e = _().codes.ERR_STREAM_PREMATURE_CLOSE;
+    function t(e) {
+        var t = false;
+        return function() {
+            if (t) return;
+            t = true;
+            for (var r = arguments.length, n = new Array(r), i = 0; i < r; i++) {
+                n[i] = arguments[i];
+            }
+            e.apply(this, n);
+        };
+    }
+    function r() {}
+    function n(e) {
+        return e.setHeader && typeof e.abort === "function";
+    }
+    function i(a, o, f) {
+        if (typeof o === "function") return i(a, null, o);
+        if (!o) o = {};
+        f = t(f || r);
+        var s = o.readable || o.readable !== false && a.readable;
+        var l = o.writable || o.writable !== false && a.writable;
+        var u = function e() {
+            if (!a.writable) c();
+        };
+        var d = a._writableState && a._writableState.finished;
+        var c = function e() {
+            l = false;
+            d = true;
+            if (!s) f.call(a);
+        };
+        var h = a._readableState && a._readableState.endEmitted;
+        var p = function e() {
+            s = false;
+            h = true;
+            if (!l) f.call(a);
+        };
+        var b = function e(t) {
+            f.call(a, t);
+        };
+        var v = function t() {
+            var r;
+            if (s && !h) {
+                if (!a._readableState || !a._readableState.ended) r = new e;
+                return f.call(a, r);
+            }
+            if (l && !d) {
+                if (!a._writableState || !a._writableState.ended) r = new e;
+                return f.call(a, r);
+            }
+        };
+        var g = function e() {
+            a.req.on("finish", c);
+        };
+        if (n(a)) {
+            a.on("complete", c);
+            a.on("abort", v);
+            if (a.req) g(); else a.on("request", g);
+        } else if (l && !a._writableState) {
+            a.on("end", u);
+            a.on("close", u);
+        }
+        a.on("end", p);
+        a.on("finish", c);
+        if (o.error !== false) a.on("error", b);
+        a.on("close", v);
+        return function() {
+            a.removeListener("complete", c);
+            a.removeListener("abort", v);
+            a.removeListener("request", g);
+            if (a.req) a.req.removeListener("finish", c);
+            a.removeListener("end", u);
+            a.removeListener("close", u);
+            a.removeListener("finish", c);
+            a.removeListener("end", p);
+            a.removeListener("error", b);
+            a.removeListener("close", v);
+        };
+    }
+    P = i;
+    return P;
 }
 
-function h(t, e) {
-    return t - t % Math.pow(10, e);
+var D;
+
+var x;
+
+function C() {
+    if (x) return D;
+    x = 1;
+    var e;
+    function t(e, t, n) {
+        t = r(t);
+        if (t in e) {
+            Object.defineProperty(e, t, {
+                value: n,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        } else {
+            e[t] = n;
+        }
+        return e;
+    }
+    function r(e) {
+        var t = n(e, "string");
+        return typeof t === "symbol" ? t : String(t);
+    }
+    function n(e, t) {
+        if (typeof e !== "object" || e === null) return e;
+        var r = e[Symbol.toPrimitive];
+        if (r !== undefined) {
+            var n = r.call(e, t);
+            if (typeof n !== "object") return n;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return String(e);
+    }
+    var i = A();
+    var a = Symbol("lastResolve");
+    var o = Symbol("lastReject");
+    var f = Symbol("error");
+    var s = Symbol("ended");
+    var l = Symbol("lastPromise");
+    var u = Symbol("handlePromise");
+    var d = Symbol("stream");
+    function c(e, t) {
+        return {
+            value: e,
+            done: t
+        };
+    }
+    function h(e) {
+        var t = e[a];
+        if (t !== null) {
+            var r = e[d].read();
+            if (r !== null) {
+                e[l] = null;
+                e[a] = null;
+                e[o] = null;
+                t(c(r, false));
+            }
+        }
+    }
+    function p(e) {
+        process.nextTick(h, e);
+    }
+    function b(e, t) {
+        return function(r, n) {
+            e.then(function() {
+                if (t[s]) {
+                    r(c(undefined, true));
+                    return;
+                }
+                t[u](r, n);
+            }, n);
+        };
+    }
+    var v = Object.getPrototypeOf(function() {});
+    var g = Object.setPrototypeOf((e = {
+        get stream() {
+            return this[d];
+        },
+        next: function e() {
+            var t = this;
+            var r = this[f];
+            if (r !== null) {
+                return Promise.reject(r);
+            }
+            if (this[s]) {
+                return Promise.resolve(c(undefined, true));
+            }
+            if (this[d].destroyed) {
+                return new Promise(function(e, r) {
+                    process.nextTick(function() {
+                        if (t[f]) {
+                            r(t[f]);
+                        } else {
+                            e(c(undefined, true));
+                        }
+                    });
+                });
+            }
+            var n = this[l];
+            var i;
+            if (n) {
+                i = new Promise(b(n, this));
+            } else {
+                var a = this[d].read();
+                if (a !== null) {
+                    return Promise.resolve(c(a, false));
+                }
+                i = new Promise(this[u]);
+            }
+            this[l] = i;
+            return i;
+        }
+    }, t(e, Symbol.asyncIterator, function() {
+        return this;
+    }), t(e, "return", function e() {
+        var t = this;
+        return new Promise(function(e, r) {
+            t[d].destroy(null, function(t) {
+                if (t) {
+                    r(t);
+                    return;
+                }
+                e(c(undefined, true));
+            });
+        });
+    }), e), v);
+    var y = function e(r) {
+        var n;
+        var h = Object.create(g, (n = {}, t(n, d, {
+            value: r,
+            writable: true
+        }), t(n, a, {
+            value: null,
+            writable: true
+        }), t(n, o, {
+            value: null,
+            writable: true
+        }), t(n, f, {
+            value: null,
+            writable: true
+        }), t(n, s, {
+            value: r._readableState.endEmitted,
+            writable: true
+        }), t(n, u, {
+            value: function e(t, r) {
+                var n = h[d].read();
+                if (n) {
+                    h[l] = null;
+                    h[a] = null;
+                    h[o] = null;
+                    t(c(n, false));
+                } else {
+                    h[a] = t;
+                    h[o] = r;
+                }
+            },
+            writable: true
+        }), n));
+        h[l] = null;
+        i(r, function(e) {
+            if (e && e.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+                var t = h[o];
+                if (t !== null) {
+                    h[l] = null;
+                    h[a] = null;
+                    h[o] = null;
+                    t(e);
+                }
+                h[f] = e;
+                return;
+            }
+            var r = h[a];
+            if (r !== null) {
+                h[l] = null;
+                h[a] = null;
+                h[o] = null;
+                r(c(undefined, true));
+            }
+            h[s] = true;
+        });
+        r.on("readable", p.bind(null, h));
+        return h;
+    };
+    D = y;
+    return D;
 }
 
-function g(t) {
-    let [e = 0, r = ""] = t;
-    if (r || e > 1) {
-        return `{${e + (r ? "," + r : "")}}`;
+var N;
+
+var I;
+
+function W() {
+    if (I) return N;
+    I = 1;
+    function e(e, t, r, n, i, a, o) {
+        try {
+            var f = e[a](o);
+            var s = f.value;
+        } catch (e) {
+            r(e);
+            return;
+        }
+        if (f.done) {
+            t(s);
+        } else {
+            Promise.resolve(s).then(n, i);
+        }
+    }
+    function t(t) {
+        return function() {
+            var r = this, n = arguments;
+            return new Promise(function(i, a) {
+                var o = t.apply(r, n);
+                function f(t) {
+                    e(o, i, a, f, s, "next", t);
+                }
+                function s(t) {
+                    e(o, i, a, f, s, "throw", t);
+                }
+                f(undefined);
+            });
+        };
+    }
+    function r(e, t) {
+        var r = Object.keys(e);
+        if (Object.getOwnPropertySymbols) {
+            var n = Object.getOwnPropertySymbols(e);
+            t && (n = n.filter(function(t) {
+                return Object.getOwnPropertyDescriptor(e, t).enumerable;
+            })), r.push.apply(r, n);
+        }
+        return r;
+    }
+    function n(e) {
+        for (var t = 1; t < arguments.length; t++) {
+            var n = null != arguments[t] ? arguments[t] : {};
+            t % 2 ? r(Object(n), true).forEach(function(t) {
+                i(e, t, n[t]);
+            }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : r(Object(n)).forEach(function(t) {
+                Object.defineProperty(e, t, Object.getOwnPropertyDescriptor(n, t));
+            });
+        }
+        return e;
     }
-    return "";
+    function i(e, t, r) {
+        t = a(t);
+        if (t in e) {
+            Object.defineProperty(e, t, {
+                value: r,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        } else {
+            e[t] = r;
+        }
+        return e;
+    }
+    function a(e) {
+        var t = o(e, "string");
+        return typeof t === "symbol" ? t : String(t);
+    }
+    function o(e, t) {
+        if (typeof e !== "object" || e === null) return e;
+        var r = e[Symbol.toPrimitive];
+        if (r !== undefined) {
+            var n = r.call(e, t);
+            if (typeof n !== "object") return n;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return String(e);
+    }
+    var f = _().codes.ERR_INVALID_ARG_TYPE;
+    function s(e, r, i) {
+        var a;
+        if (r && typeof r.next === "function") {
+            a = r;
+        } else if (r && r[Symbol.asyncIterator]) a = r[Symbol.asyncIterator](); else if (r && r[Symbol.iterator]) a = r[Symbol.iterator](); else throw new f("iterable", [ "Iterable" ], r);
+        var o = new e(n({
+            objectMode: true
+        }, i));
+        var s = false;
+        o._read = function() {
+            if (!s) {
+                s = true;
+                l();
+            }
+        };
+        function l() {
+            return u.apply(this, arguments);
+        }
+        function u() {
+            u = t(function*() {
+                try {
+                    var e = yield a.next(), t = e.value, r = e.done;
+                    if (r) {
+                        o.push(null);
+                    } else if (o.push(yield t)) {
+                        l();
+                    } else {
+                        s = false;
+                    }
+                } catch (e) {
+                    o.destroy(e);
+                }
+            });
+            return u.apply(this, arguments);
+        }
+        return o;
+    }
+    N = s;
+    return N;
 }
 
-function p(t, e, r) {
-    return `[${t}${e - t === 1 ? "" : "-"}${e}]`;
+var B;
+
+var q;
+
+function U() {
+    if (q) return B;
+    q = 1;
+    B = U;
+    var e;
+    U.ReadableState = I;
+    r.EventEmitter;
+    var o = function e(t, r) {
+        return t.listeners(r).length;
+    };
+    var s = d();
+    var l = n.Buffer;
+    var u = (typeof t !== "undefined" ? t : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
+    function c(e) {
+        return l.from(e);
+    }
+    function h(e) {
+        return l.isBuffer(e) || e instanceof u;
+    }
+    var b = i;
+    var v;
+    if (b && b.debuglog) {
+        v = b.debuglog("stream");
+    } else {
+        v = function e() {};
+    }
+    var y = p();
+    var w = g();
+    var m = R(), S = m.getHighWaterMark;
+    var E = _().codes, k = E.ERR_INVALID_ARG_TYPE, T = E.ERR_STREAM_PUSH_AFTER_EOF, M = E.ERR_METHOD_NOT_IMPLEMENTED, O = E.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+    var P;
+    var L;
+    var A;
+    a()(U, s);
+    var D = w.errorOrDestroy;
+    var x = [ "error", "close", "destroy", "pause", "resume" ];
+    function N(e, t, r) {
+        if (typeof e.prependListener === "function") return e.prependListener(t, r);
+        if (!e._events || !e._events[t]) e.on(t, r); else if (Array.isArray(e._events[t])) e._events[t].unshift(r); else e._events[t] = [ r, e._events[t] ];
+    }
+    function I(t, r, n) {
+        e = e || j();
+        t = t || {};
+        if (typeof n !== "boolean") n = r instanceof e;
+        this.objectMode = !!t.objectMode;
+        if (n) this.objectMode = this.objectMode || !!t.readableObjectMode;
+        this.highWaterMark = S(this, t, "readableHighWaterMark", n);
+        this.buffer = new y;
+        this.length = 0;
+        this.pipes = null;
+        this.pipesCount = 0;
+        this.flowing = null;
+        this.ended = false;
+        this.endEmitted = false;
+        this.reading = false;
+        this.sync = true;
+        this.needReadable = false;
+        this.emittedReadable = false;
+        this.readableListening = false;
+        this.resumeScheduled = false;
+        this.paused = true;
+        this.emitClose = t.emitClose !== false;
+        this.autoDestroy = !!t.autoDestroy;
+        this.destroyed = false;
+        this.defaultEncoding = t.defaultEncoding || "utf8";
+        this.awaitDrain = 0;
+        this.readingMore = false;
+        this.decoder = null;
+        this.encoding = null;
+        if (t.encoding) {
+            if (!P) P = f().StringDecoder;
+            this.decoder = new P(t.encoding);
+            this.encoding = t.encoding;
+        }
+    }
+    function U(t) {
+        e = e || j();
+        if (!(this instanceof U)) return new U(t);
+        var r = this instanceof e;
+        this._readableState = new I(t, this, r);
+        this.readable = true;
+        if (t) {
+            if (typeof t.read === "function") this._read = t.read;
+            if (typeof t.destroy === "function") this._destroy = t.destroy;
+        }
+        s.call(this);
+    }
+    Object.defineProperty(U.prototype, "destroyed", {
+        enumerable: false,
+        get: function e() {
+            if (this._readableState === undefined) {
+                return false;
+            }
+            return this._readableState.destroyed;
+        },
+        set: function e(t) {
+            if (!this._readableState) {
+                return;
+            }
+            this._readableState.destroyed = t;
+        }
+    });
+    U.prototype.destroy = w.destroy;
+    U.prototype._undestroy = w.undestroy;
+    U.prototype._destroy = function(e, t) {
+        t(e);
+    };
+    U.prototype.push = function(e, t) {
+        var r = this._readableState;
+        var n;
+        if (!r.objectMode) {
+            if (typeof e === "string") {
+                t = t || r.defaultEncoding;
+                if (t !== r.encoding) {
+                    e = l.from(e, t);
+                    t = "";
+                }
+                n = true;
+            }
+        } else {
+            n = true;
+        }
+        return F(this, e, t, false, n);
+    };
+    U.prototype.unshift = function(e) {
+        return F(this, e, null, true, false);
+    };
+    function F(e, t, r, n, i) {
+        v("readableAddChunk", t);
+        var a = e._readableState;
+        if (t === null) {
+            a.reading = false;
+            K(e, a);
+        } else {
+            var o;
+            if (!i) o = $(a, t);
+            if (o) {
+                D(e, o);
+            } else if (a.objectMode || t && t.length > 0) {
+                if (typeof t !== "string" && !a.objectMode && Object.getPrototypeOf(t) !== l.prototype) {
+                    t = c(t);
+                }
+                if (n) {
+                    if (a.endEmitted) D(e, new O); else H(e, a, t, true);
+                } else if (a.ended) {
+                    D(e, new T);
+                } else if (a.destroyed) {
+                    return false;
+                } else {
+                    a.reading = false;
+                    if (a.decoder && !r) {
+                        t = a.decoder.write(t);
+                        if (a.objectMode || t.length !== 0) H(e, a, t, false); else Q(e, a);
+                    } else {
+                        H(e, a, t, false);
+                    }
+                }
+            } else if (!n) {
+                a.reading = false;
+                Q(e, a);
+            }
+        }
+        return !a.ended && (a.length < a.highWaterMark || a.length === 0);
+    }
+    function H(e, t, r, n) {
+        if (t.flowing && t.length === 0 && !t.sync) {
+            t.awaitDrain = 0;
+            e.emit("data", r);
+        } else {
+            t.length += t.objectMode ? 1 : r.length;
+            if (n) t.buffer.unshift(r); else t.buffer.push(r);
+            if (t.needReadable) z(e);
+        }
+        Q(e, t);
+    }
+    function $(e, t) {
+        var r;
+        if (!h(t) && typeof t !== "string" && t !== undefined && !e.objectMode) {
+            r = new k("chunk", [ "string", "Buffer", "Uint8Array" ], t);
+        }
+        return r;
+    }
+    U.prototype.isPaused = function() {
+        return this._readableState.flowing === false;
+    };
+    U.prototype.setEncoding = function(e) {
+        if (!P) P = f().StringDecoder;
+        var t = new P(e);
+        this._readableState.decoder = t;
+        this._readableState.encoding = this._readableState.decoder.encoding;
+        var r = this._readableState.buffer.head;
+        var n = "";
+        while (r !== null) {
+            n += t.write(r.data);
+            r = r.next;
+        }
+        this._readableState.buffer.clear();
+        if (n !== "") this._readableState.buffer.push(n);
+        this._readableState.length = n.length;
+        return this;
+    };
+    var V = 1073741824;
+    function G(e) {
+        if (e >= V) {
+            e = V;
+        } else {
+            e--;
+            e |= e >>> 1;
+            e |= e >>> 2;
+            e |= e >>> 4;
+            e |= e >>> 8;
+            e |= e >>> 16;
+            e++;
+        }
+        return e;
+    }
+    function Y(e, t) {
+        if (e <= 0 || t.length === 0 && t.ended) return 0;
+        if (t.objectMode) return 1;
+        if (e !== e) {
+            if (t.flowing && t.length) return t.buffer.head.data.length; else return t.length;
+        }
+        if (e > t.highWaterMark) t.highWaterMark = G(e);
+        if (e <= t.length) return e;
+        if (!t.ended) {
+            t.needReadable = true;
+            return 0;
+        }
+        return t.length;
+    }
+    U.prototype.read = function(e) {
+        v("read", e);
+        e = parseInt(e, 10);
+        var t = this._readableState;
+        var r = e;
+        if (e !== 0) t.emittedReadable = false;
+        if (e === 0 && t.needReadable && ((t.highWaterMark !== 0 ? t.length >= t.highWaterMark : t.length > 0) || t.ended)) {
+            v("read: emitReadable", t.length, t.ended);
+            if (t.length === 0 && t.ended) oe(this); else z(this);
+            return null;
+        }
+        e = Y(e, t);
+        if (e === 0 && t.ended) {
+            if (t.length === 0) oe(this);
+            return null;
+        }
+        var n = t.needReadable;
+        v("need readable", n);
+        if (t.length === 0 || t.length - e < t.highWaterMark) {
+            n = true;
+            v("length less than watermark", n);
+        }
+        if (t.ended || t.reading) {
+            n = false;
+            v("reading or ended", n);
+        } else if (n) {
+            v("do read");
+            t.reading = true;
+            t.sync = true;
+            if (t.length === 0) t.needReadable = true;
+            this._read(t.highWaterMark);
+            t.sync = false;
+            if (!t.reading) e = Y(r, t);
+        }
+        var i;
+        if (e > 0) i = ae(e, t); else i = null;
+        if (i === null) {
+            t.needReadable = t.length <= t.highWaterMark;
+            e = 0;
+        } else {
+            t.length -= e;
+            t.awaitDrain = 0;
+        }
+        if (t.length === 0) {
+            if (!t.ended) t.needReadable = true;
+            if (r !== e && t.ended) oe(this);
+        }
+        if (i !== null) this.emit("data", i);
+        return i;
+    };
+    function K(e, t) {
+        v("onEofChunk");
+        if (t.ended) return;
+        if (t.decoder) {
+            var r = t.decoder.end();
+            if (r && r.length) {
+                t.buffer.push(r);
+                t.length += t.objectMode ? 1 : r.length;
+            }
+        }
+        t.ended = true;
+        if (t.sync) {
+            z(e);
+        } else {
+            t.needReadable = false;
+            if (!t.emittedReadable) {
+                t.emittedReadable = true;
+                J(e);
+            }
+        }
+    }
+    function z(e) {
+        var t = e._readableState;
+        v("emitReadable", t.needReadable, t.emittedReadable);
+        t.needReadable = false;
+        if (!t.emittedReadable) {
+            v("emitReadable", t.flowing);
+            t.emittedReadable = true;
+            process.nextTick(J, e);
+        }
+    }
+    function J(e) {
+        var t = e._readableState;
+        v("emitReadable_", t.destroyed, t.length, t.ended);
+        if (!t.destroyed && (t.length || t.ended)) {
+            e.emit("readable");
+            t.emittedReadable = false;
+        }
+        t.needReadable = !t.flowing && !t.ended && t.length <= t.highWaterMark;
+        ie(e);
+    }
+    function Q(e, t) {
+        if (!t.readingMore) {
+            t.readingMore = true;
+            process.nextTick(X, e, t);
+        }
+    }
+    function X(e, t) {
+        while (!t.reading && !t.ended && (t.length < t.highWaterMark || t.flowing && t.length === 0)) {
+            var r = t.length;
+            v("maybeReadMore read 0");
+            e.read(0);
+            if (r === t.length) break;
+        }
+        t.readingMore = false;
+    }
+    U.prototype._read = function(e) {
+        D(this, new M("_read()"));
+    };
+    U.prototype.pipe = function(e, t) {
+        var r = this;
+        var n = this._readableState;
+        switch (n.pipesCount) {
+          case 0:
+            n.pipes = e;
+            break;
+
+          case 1:
+            n.pipes = [ n.pipes, e ];
+            break;
+
+          default:
+            n.pipes.push(e);
+            break;
+        }
+        n.pipesCount += 1;
+        v("pipe count=%d opts=%j", n.pipesCount, t);
+        var i = (!t || t.end !== false) && e !== process.stdout && e !== process.stderr;
+        var a = i ? s : g;
+        if (n.endEmitted) process.nextTick(a); else r.once("end", a);
+        e.on("unpipe", f);
+        function f(e, t) {
+            v("onunpipe");
+            if (e === r) {
+                if (t && t.hasUnpiped === false) {
+                    t.hasUnpiped = true;
+                    d();
+                }
+            }
+        }
+        function s() {
+            v("onend");
+            e.end();
+        }
+        var l = Z(r);
+        e.on("drain", l);
+        var u = false;
+        function d() {
+            v("cleanup");
+            e.removeListener("close", p);
+            e.removeListener("finish", b);
+            e.removeListener("drain", l);
+            e.removeListener("error", h);
+            e.removeListener("unpipe", f);
+            r.removeListener("end", s);
+            r.removeListener("end", g);
+            r.removeListener("data", c);
+            u = true;
+            if (n.awaitDrain && (!e._writableState || e._writableState.needDrain)) l();
+        }
+        r.on("data", c);
+        function c(t) {
+            v("ondata");
+            var i = e.write(t);
+            v("dest.write", i);
+            if (i === false) {
+                if ((n.pipesCount === 1 && n.pipes === e || n.pipesCount > 1 && se(n.pipes, e) !== -1) && !u) {
+                    v("false write response, pause", n.awaitDrain);
+                    n.awaitDrain++;
+                }
+                r.pause();
+            }
+        }
+        function h(t) {
+            v("onerror", t);
+            g();
+            e.removeListener("error", h);
+            if (o(e, "error") === 0) D(e, t);
+        }
+        N(e, "error", h);
+        function p() {
+            e.removeListener("finish", b);
+            g();
+        }
+        e.once("close", p);
+        function b() {
+            v("onfinish");
+            e.removeListener("close", p);
+            g();
+        }
+        e.once("finish", b);
+        function g() {
+            v("unpipe");
+            r.unpipe(e);
+        }
+        e.emit("pipe", r);
+        if (!n.flowing) {
+            v("pipe resume");
+            r.resume();
+        }
+        return e;
+    };
+    function Z(e) {
+        return function t() {
+            var r = e._readableState;
+            v("pipeOnDrain", r.awaitDrain);
+            if (r.awaitDrain) r.awaitDrain--;
+            if (r.awaitDrain === 0 && o(e, "data")) {
+                r.flowing = true;
+                ie(e);
+            }
+        };
+    }
+    U.prototype.unpipe = function(e) {
+        var t = this._readableState;
+        var r = {
+            hasUnpiped: false
+        };
+        if (t.pipesCount === 0) return this;
+        if (t.pipesCount === 1) {
+            if (e && e !== t.pipes) return this;
+            if (!e) e = t.pipes;
+            t.pipes = null;
+            t.pipesCount = 0;
+            t.flowing = false;
+            if (e) e.emit("unpipe", this, r);
+            return this;
+        }
+        if (!e) {
+            var n = t.pipes;
+            var i = t.pipesCount;
+            t.pipes = null;
+            t.pipesCount = 0;
+            t.flowing = false;
+            for (var a = 0; a < i; a++) n[a].emit("unpipe", this, {
+                hasUnpiped: false
+            });
+            return this;
+        }
+        var o = se(t.pipes, e);
+        if (o === -1) return this;
+        t.pipes.splice(o, 1);
+        t.pipesCount -= 1;
+        if (t.pipesCount === 1) t.pipes = t.pipes[0];
+        e.emit("unpipe", this, r);
+        return this;
+    };
+    U.prototype.on = function(e, t) {
+        var r = s.prototype.on.call(this, e, t);
+        var n = this._readableState;
+        if (e === "data") {
+            n.readableListening = this.listenerCount("readable") > 0;
+            if (n.flowing !== false) this.resume();
+        } else if (e === "readable") {
+            if (!n.endEmitted && !n.readableListening) {
+                n.readableListening = n.needReadable = true;
+                n.flowing = false;
+                n.emittedReadable = false;
+                v("on readable", n.length, n.reading);
+                if (n.length) {
+                    z(this);
+                } else if (!n.reading) {
+                    process.nextTick(te, this);
+                }
+            }
+        }
+        return r;
+    };
+    U.prototype.addListener = U.prototype.on;
+    U.prototype.removeListener = function(e, t) {
+        var r = s.prototype.removeListener.call(this, e, t);
+        if (e === "readable") {
+            process.nextTick(ee, this);
+        }
+        return r;
+    };
+    U.prototype.removeAllListeners = function(e) {
+        var t = s.prototype.removeAllListeners.apply(this, arguments);
+        if (e === "readable" || e === undefined) {
+            process.nextTick(ee, this);
+        }
+        return t;
+    };
+    function ee(e) {
+        var t = e._readableState;
+        t.readableListening = e.listenerCount("readable") > 0;
+        if (t.resumeScheduled && !t.paused) {
+            t.flowing = true;
+        } else if (e.listenerCount("data") > 0) {
+            e.resume();
+        }
+    }
+    function te(e) {
+        v("readable nexttick read 0");
+        e.read(0);
+    }
+    U.prototype.resume = function() {
+        var e = this._readableState;
+        if (!e.flowing) {
+            v("resume");
+            e.flowing = !e.readableListening;
+            re(this, e);
+        }
+        e.paused = false;
+        return this;
+    };
+    function re(e, t) {
+        if (!t.resumeScheduled) {
+            t.resumeScheduled = true;
+            process.nextTick(ne, e, t);
+        }
+    }
+    function ne(e, t) {
+        v("resume", t.reading);
+        if (!t.reading) {
+            e.read(0);
+        }
+        t.resumeScheduled = false;
+        e.emit("resume");
+        ie(e);
+        if (t.flowing && !t.reading) e.read(0);
+    }
+    U.prototype.pause = function() {
+        v("call pause flowing=%j", this._readableState.flowing);
+        if (this._readableState.flowing !== false) {
+            v("pause");
+            this._readableState.flowing = false;
+            this.emit("pause");
+        }
+        this._readableState.paused = true;
+        return this;
+    };
+    function ie(e) {
+        var t = e._readableState;
+        v("flow", t.flowing);
+        while (t.flowing && e.read() !== null) ;
+    }
+    U.prototype.wrap = function(e) {
+        var t = this;
+        var r = this._readableState;
+        var n = false;
+        e.on("end", function() {
+            v("wrapped end");
+            if (r.decoder && !r.ended) {
+                var e = r.decoder.end();
+                if (e && e.length) t.push(e);
+            }
+            t.push(null);
+        });
+        e.on("data", function(i) {
+            v("wrapped data");
+            if (r.decoder) i = r.decoder.write(i);
+            if (r.objectMode && (i === null || i === undefined)) return; else if (!r.objectMode && (!i || !i.length)) return;
+            var a = t.push(i);
+            if (!a) {
+                n = true;
+                e.pause();
+            }
+        });
+        for (var i in e) {
+            if (this[i] === undefined && typeof e[i] === "function") {
+                this[i] = function t(r) {
+                    return function t() {
+                        return e[r].apply(e, arguments);
+                    };
+                }(i);
+            }
+        }
+        for (var a = 0; a < x.length; a++) {
+            e.on(x[a], this.emit.bind(this, x[a]));
+        }
+        this._read = function(t) {
+            v("wrapped _read", t);
+            if (n) {
+                n = false;
+                e.resume();
+            }
+        };
+        return this;
+    };
+    if (typeof Symbol === "function") {
+        U.prototype[Symbol.asyncIterator] = function() {
+            if (L === undefined) {
+                L = C();
+            }
+            return L(this);
+        };
+    }
+    Object.defineProperty(U.prototype, "readableHighWaterMark", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState.highWaterMark;
+        }
+    });
+    Object.defineProperty(U.prototype, "readableBuffer", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState && this._readableState.buffer;
+        }
+    });
+    Object.defineProperty(U.prototype, "readableFlowing", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState.flowing;
+        },
+        set: function e(t) {
+            if (this._readableState) {
+                this._readableState.flowing = t;
+            }
+        }
+    });
+    U._fromList = ae;
+    Object.defineProperty(U.prototype, "readableLength", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState.length;
+        }
+    });
+    function ae(e, t) {
+        if (t.length === 0) return null;
+        var r;
+        if (t.objectMode) r = t.buffer.shift(); else if (!e || e >= t.length) {
+            if (t.decoder) r = t.buffer.join(""); else if (t.buffer.length === 1) r = t.buffer.first(); else r = t.buffer.concat(t.length);
+            t.buffer.clear();
+        } else {
+            r = t.buffer.consume(e, t.decoder);
+        }
+        return r;
+    }
+    function oe(e) {
+        var t = e._readableState;
+        v("endReadable", t.endEmitted);
+        if (!t.endEmitted) {
+            t.ended = true;
+            process.nextTick(fe, t, e);
+        }
+    }
+    function fe(e, t) {
+        v("endReadableNT", e.endEmitted, e.length);
+        if (!e.endEmitted && e.length === 0) {
+            e.endEmitted = true;
+            t.readable = false;
+            t.emit("end");
+            if (e.autoDestroy) {
+                var r = t._writableState;
+                if (!r || r.autoDestroy && r.finished) {
+                    t.destroy();
+                }
+            }
+        }
+    }
+    if (typeof Symbol === "function") {
+        U.from = function(e, t) {
+            if (A === undefined) {
+                A = W();
+            }
+            return A(U, e, t);
+        };
+    }
+    function se(e, t) {
+        for (var r = 0, n = e.length; r < n; r++) {
+            if (e[r] === t) return r;
+        }
+        return -1;
+    }
+    return B;
 }
 
-function d(t) {
-    return /^-?(0+)\d/.test(t);
+var F;
+
+var H;
+
+function $() {
+    if (H) return F;
+    H = 1;
+    F = s;
+    var e = _().codes, t = e.ERR_METHOD_NOT_IMPLEMENTED, r = e.ERR_MULTIPLE_CALLBACK, n = e.ERR_TRANSFORM_ALREADY_TRANSFORMING, i = e.ERR_TRANSFORM_WITH_LENGTH_0;
+    var o = j();
+    a()(s, o);
+    function f(e, t) {
+        var n = this._transformState;
+        n.transforming = false;
+        var i = n.writecb;
+        if (i === null) {
+            return this.emit("error", new r);
+        }
+        n.writechunk = null;
+        n.writecb = null;
+        if (t != null) this.push(t);
+        i(e);
+        var a = this._readableState;
+        a.reading = false;
+        if (a.needReadable || a.length < a.highWaterMark) {
+            this._read(a.highWaterMark);
+        }
+    }
+    function s(e) {
+        if (!(this instanceof s)) return new s(e);
+        o.call(this, e);
+        this._transformState = {
+            afterTransform: f.bind(this),
+            needTransform: false,
+            transforming: false,
+            writecb: null,
+            writechunk: null,
+            writeencoding: null
+        };
+        this._readableState.needReadable = true;
+        this._readableState.sync = false;
+        if (e) {
+            if (typeof e.transform === "function") this._transform = e.transform;
+            if (typeof e.flush === "function") this._flush = e.flush;
+        }
+        this.on("prefinish", l);
+    }
+    function l() {
+        var e = this;
+        if (typeof this._flush === "function" && !this._readableState.destroyed) {
+            this._flush(function(t, r) {
+                u(e, t, r);
+            });
+        } else {
+            u(this, null, null);
+        }
+    }
+    s.prototype.push = function(e, t) {
+        this._transformState.needTransform = false;
+        return o.prototype.push.call(this, e, t);
+    };
+    s.prototype._transform = function(e, r, n) {
+        n(new t("_transform()"));
+    };
+    s.prototype._write = function(e, t, r) {
+        var n = this._transformState;
+        n.writecb = r;
+        n.writechunk = e;
+        n.writeencoding = t;
+        if (!n.transforming) {
+            var i = this._readableState;
+            if (n.needTransform || i.needReadable || i.length < i.highWaterMark) this._read(i.highWaterMark);
+        }
+    };
+    s.prototype._read = function(e) {
+        var t = this._transformState;
+        if (t.writechunk !== null && !t.transforming) {
+            t.transforming = true;
+            this._transform(t.writechunk, t.writeencoding, t.afterTransform);
+        } else {
+            t.needTransform = true;
+        }
+    };
+    s.prototype._destroy = function(e, t) {
+        o.prototype._destroy.call(this, e, function(e) {
+            t(e);
+        });
+    };
+    function u(e, t, r) {
+        if (t) return e.emit("error", t);
+        if (r != null) e.push(r);
+        if (e._writableState.length) throw new i;
+        if (e._transformState.transforming) throw new n;
+        return e.push(null);
+    }
+    return F;
 }
 
-function m(t, e, r) {
-    if (!e.isPadded) {
-        return t;
+var V;
+
+var G;
+
+function Y() {
+    if (G) return V;
+    G = 1;
+    V = t;
+    var e = $();
+    a()(t, e);
+    function t(r) {
+        if (!(this instanceof t)) return new t(r);
+        e.call(this, r);
     }
-    let n = Math.abs(e.maxLen - String(t).length);
-    let l = r.relaxZeros !== false;
-    switch (n) {
-      case 0:
-        return "";
+    t.prototype._transform = function(e, t, r) {
+        r(null, e);
+    };
+    return V;
+}
 
-      case 1:
-        return l ? "0?" : "0";
+var K;
 
-      case 2:
-        return l ? "0{0,2}" : "00";
+var z;
 
-      default:
-        {
-            return l ? `0{0,${n}}` : `0{${n}}`;
+function J() {
+    if (z) return K;
+    z = 1;
+    var e;
+    function t(e) {
+        var t = false;
+        return function() {
+            if (t) return;
+            t = true;
+            e.apply(void 0, arguments);
+        };
+    }
+    var r = _().codes, n = r.ERR_MISSING_ARGS, i = r.ERR_STREAM_DESTROYED;
+    function a(e) {
+        if (e) throw e;
+    }
+    function o(e) {
+        return e.setHeader && typeof e.abort === "function";
+    }
+    function f(r, n, a, f) {
+        f = t(f);
+        var s = false;
+        r.on("close", function() {
+            s = true;
+        });
+        if (e === undefined) e = A();
+        e(r, {
+            readable: n,
+            writable: a
+        }, function(e) {
+            if (e) return f(e);
+            s = true;
+            f();
+        });
+        var l = false;
+        return function(e) {
+            if (s) return;
+            if (l) return;
+            l = true;
+            if (o(r)) return r.abort();
+            if (typeof r.destroy === "function") return r.destroy();
+            f(e || new i("pipe"));
+        };
+    }
+    function s(e) {
+        e();
+    }
+    function l(e, t) {
+        return e.pipe(t);
+    }
+    function u(e) {
+        if (!e.length) return a;
+        if (typeof e[e.length - 1] !== "function") return a;
+        return e.pop();
+    }
+    function d() {
+        for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) {
+            t[r] = arguments[r];
+        }
+        var i = u(t);
+        if (Array.isArray(t[0])) t = t[0];
+        if (t.length < 2) {
+            throw new n("streams");
         }
+        var a;
+        var o = t.map(function(e, r) {
+            var n = r < t.length - 1;
+            var l = r > 0;
+            return f(e, n, l, function(e) {
+                if (!a) a = e;
+                if (e) o.forEach(s);
+                if (n) return;
+                o.forEach(s);
+                i(a);
+            });
+        });
+        return t.reduce(l);
     }
+    K = d;
+    return K;
 }
 
-r.cache = {};
+s.exports;
 
-r.clearCache = () => r.cache = {};
+(function(t, r) {
+    var n = e;
+    if (process.env.READABLE_STREAM === "disable" && n) {
+        t.exports = n.Readable;
+        Object.assign(t.exports, n);
+        t.exports.Stream = n;
+    } else {
+        r = t.exports = U();
+        r.Stream = n || r;
+        r.Readable = r;
+        r.Writable = T();
+        r.Duplex = j();
+        r.Transform = $();
+        r.PassThrough = Y();
+        r.finished = A();
+        r.pipeline = J();
+    }
+})(s, s.exports);
 
-var x = r;
+var Q = s.exports;
 
-export { x as t };
+export { Q as r };