lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.42.cjs

@@ -1,247 +1,2366 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const e = require("./Package.internal.122.cjs");
+const e = require("stream");
 
-const t = e.isNumber;
+const t = require("./Package.internal.8.cjs");
 
-const r = (e, l, i) => {
-    if (t(e) === false) {
-        throw new TypeError("toRegexRange: expected the first argument to be a number");
+const r = require("events");
+
+const n = require("buffer");
+
+const i = require("util");
+
+const a = require("./Package.internal.43.cjs");
+
+const o = require("./Package.internal.173.cjs");
+
+const f = require("./Package.internal.174.cjs");
+
+const s = e => e && e.__esModule ? e : {
+    default: e
+};
+
+const l = s(e);
+
+const u = s(r);
+
+const d = s(n);
+
+const c = s(i);
+
+var h = {
+    exports: {}
+};
+
+var p;
+
+var b;
+
+function v() {
+    if (b) return p;
+    b = 1;
+    p = l.default;
+    return p;
+}
+
+var g;
+
+var y;
+
+function _() {
+    if (y) return g;
+    y = 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;
+    }
+    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 = o(t);
+        if (t in e) {
+            Object.defineProperty(e, t, {
+                value: r,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        } else {
+            e[t] = r;
+        }
+        return e;
     }
-    if (l === void 0 || e === l) {
+    function n(e, t) {
+        if (!(e instanceof t)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
+    function i(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, o(n.key), n);
+        }
+    }
+    function a(e, t, r) {
+        if (t) i(e.prototype, t);
+        Object.defineProperty(e, "prototype", {
+            writable: false
+        });
+        return e;
+    }
+    function o(e) {
+        var t = f(e, "string");
+        return typeof t === "symbol" ? t : String(t);
+    }
+    function f(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);
     }
-    if (t(l) === false) {
-        throw new TypeError("toRegexRange: expected the second argument to be a number.");
-    }
-    let u = {
-        relaxZeros: true,
-        ...i
-    };
-    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 = e + ":" + l + "=" + s + o + c + f;
-    if (r.cache.hasOwnProperty(h)) {
-        return r.cache[h].result;
-    }
-    let g = Math.min(e, l);
-    let p = Math.max(e, l);
-    if (Math.abs(g - p) === 1) {
-        let t = e + "|" + l;
-        if (u.capture) {
-            return `(${t})`;
-        }
-        if (u.wrap === false) {
-            return t;
-        }
-        return `(?:${t})`;
-    }
-    let x = d(e) || d(l);
-    let m = {
-        min: e,
-        max: l,
-        a: g,
-        b: p
-    };
-    let w = [];
-    let b = [];
-    if (x) {
-        m.isPadded = x;
-        m.maxLen = String(m.max).length;
-    }
-    if (g < 0) {
-        let e = p < 0 ? Math.abs(p) : 1;
-        b = a(e, Math.abs(g), m, u);
-        g = m.a = 0;
-    }
-    if (p >= 0) {
-        w = a(g, p, m, u);
-    }
-    m.negatives = b;
-    m.positives = w;
-    m.result = n(b, w);
-    if (u.capture === true) {
-        m.result = `(${m.result})`;
-    } else if (u.wrap !== false && w.length + b.length > 1) {
-        m.result = `(?:${m.result})`;
-    }
-    r.cache[h] = m;
-    return m.result;
-};
+    var s = d.default, l = s.Buffer;
+    var u = c.default, h = u.inspect;
+    var p = h && h.custom || "inspect";
+    function b(e, t, r) {
+        l.prototype.copy.call(e, t, r);
+    }
+    g = function() {
+        function e() {
+            n(this, e);
+            this.head = null;
+            this.tail = null;
+            this.length = 0;
+        }
+        a(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 l.alloc(0);
+                var r = l.allocUnsafe(t >>> 0);
+                var n = this.head;
+                var i = 0;
+                while (n) {
+                    b(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 = l.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: p,
+            value: function e(r, n) {
+                return h(this, t(t({}, n), {}, {
+                    depth: 0,
+                    customInspect: false
+                }));
+            }
+        } ]);
+        return e;
+    }();
+    return g;
+}
+
+var w;
+
+var m;
 
-function n(e, t, r) {
-    let n = u(e, t, "-", false) || [];
-    let l = u(t, e, "", false) || [];
-    let i = u(e, t, "-?", true) || [];
-    let a = n.concat(i).concat(l);
-    return a.join("|");
+function S() {
+    if (m) return w;
+    m = 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);
+    }
+    w = {
+        destroy: e,
+        undestroy: n,
+        errorOrDestroy: a
+    };
+    return w;
 }
 
-function l(e, t) {
-    let r = 1;
-    let n = 1;
-    let l = f(e, r);
-    let i = new Set([ t ]);
-    while (e <= l && l <= t) {
-        i.add(l);
-        r += 1;
-        l = f(e, r);
-    }
-    l = h(t + 1, n) - 1;
-    while (e < l && l <= t) {
-        i.add(l);
-        n += 1;
-        l = h(t + 1, n) - 1;
-    }
-    i = [ ...i ];
-    i.sort(o);
-    return i;
+var R = {};
+
+var E;
+
+function k() {
+    if (E) return R;
+    E = 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)}`;
+        }
+    }
+    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;
+    }
+    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");
+    R.codes = e;
+    return R;
 }
 
-function i(e, t, r) {
-    if (e === t) {
-        return {
-            pattern: e,
-            count: [],
-            digits: 0
+var T;
+
+var M;
+
+function O() {
+    if (M) return T;
+    M = 1;
+    var e = k().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;
+    }
+    T = {
+        getHighWaterMark: r
+    };
+    return T;
+}
+
+var j;
+
+var P;
+
+function L() {
+    if (P) return j;
+    P = 1;
+    j = C;
+    function e(e) {
+        var t = this;
+        this.next = null;
+        this.entry = null;
+        this.finish = function() {
+            X(t, e);
+        };
+    }
+    var r;
+    C.WritableState = A;
+    var n = {
+        deprecate: o.requireNode()
+    };
+    var i = v();
+    var f = d.default.Buffer;
+    var s = (typeof t.commonjsGlobal !== "undefined" ? t.commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
+    function l(e) {
+        return f.from(e);
+    }
+    function u(e) {
+        return f.isBuffer(e) || e instanceof s;
+    }
+    var c = S();
+    var h = O(), p = h.getHighWaterMark;
+    var b = k().codes, g = b.ERR_INVALID_ARG_TYPE, y = b.ERR_METHOD_NOT_IMPLEMENTED, _ = b.ERR_MULTIPLE_CALLBACK, w = b.ERR_STREAM_CANNOT_PIPE, m = b.ERR_STREAM_DESTROYED, R = b.ERR_STREAM_NULL_VALUES, E = b.ERR_STREAM_WRITE_AFTER_END, T = b.ERR_UNKNOWN_ENCODING;
+    var M = c.errorOrDestroy;
+    a.requireInherits()(C, i);
+    function L() {}
+    function A(t, n, i) {
+        r = r || D();
+        t = t || {};
+        if (typeof i !== "boolean") i = n instanceof r;
+        this.objectMode = !!t.objectMode;
+        if (i) this.objectMode = this.objectMode || !!t.writableObjectMode;
+        this.highWaterMark = p(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);
+    }
+    A.prototype.getBuffer = function e() {
+        var t = this.bufferedRequest;
+        var r = [];
+        while (t) {
+            r.push(t);
+            t = t.next;
+        }
+        return r;
+    };
+    (function() {
+        try {
+            Object.defineProperty(A.prototype, "buffer", {
+                get: n.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 A;
+            }
+        });
+    } else {
+        x = function e(t) {
+            return t instanceof this;
+        };
+    }
+    function C(e) {
+        r = r || D();
+        var t = this instanceof r;
+        if (!t && !x.call(C, this)) return new C(e);
+        this._writableState = new A(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;
+        }
+        i.call(this);
+    }
+    C.prototype.pipe = function() {
+        M(this, new w);
+    };
+    function N(e, t) {
+        var r = new E;
+        M(e, r);
+        process.nextTick(t, r);
     }
-    let n = s(e, t);
-    let l = n.length;
-    let i = "";
-    let a = 0;
-    for (let e = 0; e < l; e++) {
-        let [t, r] = n[e];
-        if (t === r) {
-            i += t;
-        } else if (t !== "0" || r !== "9") {
-            i += p(t, r);
+    function q(e, t, r, n) {
+        var i;
+        if (r === null) {
+            i = new R;
+        } else if (typeof r !== "string" && !t.objectMode) {
+            i = new g("chunk", [ "string", "Buffer" ], r);
+        }
+        if (i) {
+            M(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 && u(e);
+        if (a && !f.isBuffer(e)) {
+            e = l(e);
+        }
+        if (typeof t === "function") {
+            r = t;
+            t = null;
+        }
+        if (a) t = "buffer"; else if (!t) t = n.defaultEncoding;
+        if (typeof r !== "function") r = L;
+        if (n.ending) N(this, r); else if (a || q(this, n, e, r)) {
+            n.pendingcb++;
+            i = W(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) V(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 T(t);
+        this._writableState.defaultEncoding = t;
+        return this;
+    };
+    Object.defineProperty(C.prototype, "writableBuffer", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState && this._writableState.getBuffer();
+        }
+    });
+    function I(e, t, r) {
+        if (!e.objectMode && e.decodeStrings !== false && typeof t === "string") {
+            t = f.from(t, r);
+        }
+        return t;
+    }
+    Object.defineProperty(C.prototype, "writableHighWaterMark", {
+        enumerable: false,
+        get: function e() {
+            return this._writableState.highWaterMark;
+        }
+    });
+    function W(e, t, r, n, i, a) {
+        if (!r) {
+            var o = I(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 {
+            B(e, t, false, f, n, i, a);
+        }
+        return s;
+    }
+    function B(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 m("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;
+            M(e, n);
+        } else {
+            i(n);
+            e._writableState.errorEmitted = true;
+            M(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 _;
+        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) {
+                V(e, r);
+            }
+            if (n) {
+                process.nextTick($, e, r, a, i);
+            } else {
+                $(e, r, a, i);
+            }
+        }
+    }
+    function $(e, t, r, n) {
+        if (!r) G(e, t);
+        t.pendingcb--;
+        n();
+        J(e, t);
+    }
+    function G(e, t) {
+        if (t.length === 0 && t.needDrain) {
+            t.needDrain = false;
+            e.emit("drain");
+        }
+    }
+    function V(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;
+            B(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 {
-            a++;
+            while (n) {
+                var l = n.chunk;
+                var u = n.encoding;
+                var d = n.callback;
+                var c = r.objectMode ? 1 : l.length;
+                B(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 y("_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) {
+                M(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;
     }
-    if (a) {
-        i += r.shorthand === true ? "\\d" : "[0-9]";
+    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;
     }
-    return {
-        pattern: i,
-        count: [ a ],
-        digits: l
+    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 = c.destroy;
+    C.prototype._undestroy = c.undestroy;
+    C.prototype._destroy = function(e, t) {
+        t(e);
     };
+    return j;
 }
 
-function a(e, t, r, n) {
-    let a = l(e, t);
-    let u = [];
-    let s = e;
-    let o;
-    for (let e = 0; e < a.length; e++) {
-        let t = a[e];
-        let l = i(String(s), String(t), 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 = t + 1;
-            continue;
-        }
-        if (r.isPadded) {
-            c = x(t, r, n);
-        }
-        l.string = c + l.pattern + g(l.count);
-        u.push(l);
-        s = t + 1;
-        o = l;
-    }
-    return u;
-}
+var A;
 
-function u(e, t, r, n, l) {
-    let i = [];
-    for (let l of e) {
-        let {string: e} = l;
-        if (!n && !c(t, "string", e)) {
-            i.push(r + e);
+var x;
+
+function D() {
+    if (x) return A;
+    x = 1;
+    var e = Object.keys || function(e) {
+        var t = [];
+        for (var r in e) t.push(r);
+        return t;
+    };
+    A = f;
+    var t = V();
+    var r = L();
+    a.requireInherits()(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];
         }
-        if (n && c(t, "string", e)) {
-            i.push(r + e);
+    }
+    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);
+            }
         }
     }
-    return i;
+    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 A;
 }
 
-function s(e, t) {
-    let r = [];
-    for (let n = 0; n < e.length; n++) r.push([ e[n], t[n] ]);
-    return r;
-}
+var C;
 
-function o(e, t) {
-    return e > t ? 1 : t > e ? -1 : 0;
-}
+var N;
 
-function c(e, t, r) {
-    return e.some(e => e[t] === r);
+function q() {
+    if (N) return C;
+    N = 1;
+    var e = k().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);
+        };
+    }
+    C = i;
+    return C;
 }
 
-function f(e, t) {
-    return Number(String(e).slice(0, -t) + "9".repeat(t));
-}
+var I;
 
-function h(e, t) {
-    return e - e % Math.pow(10, t);
+var W;
+
+function B() {
+    if (W) return I;
+    W = 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 = q();
+    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;
+    };
+    I = y;
+    return I;
 }
 
-function g(e) {
-    let [t = 0, r = ""] = e;
-    if (r || t > 1) {
-        return `{${t + (r ? "," + r : "")}}`;
+var U;
+
+var F;
+
+function H() {
+    if (F) return U;
+    F = 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);
+            });
+        };
     }
-    return "";
+    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;
+    }
+    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 = k().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;
+    }
+    U = s;
+    return U;
 }
 
-function p(e, t, r) {
-    return `[${e}${t - e === 1 ? "" : "-"}${t}]`;
+var $;
+
+var G;
+
+function V() {
+    if (G) return $;
+    G = 1;
+    $ = q;
+    var e;
+    q.ReadableState = N;
+    u.default.EventEmitter;
+    var r = function e(t, r) {
+        return t.listeners(r).length;
+    };
+    var n = v();
+    var i = d.default.Buffer;
+    var o = (typeof t.commonjsGlobal !== "undefined" ? t.commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
+    function s(e) {
+        return i.from(e);
+    }
+    function l(e) {
+        return i.isBuffer(e) || e instanceof o;
+    }
+    var h = c.default;
+    var p;
+    if (h && h.debuglog) {
+        p = h.debuglog("stream");
+    } else {
+        p = function e() {};
+    }
+    var b = _();
+    var g = S();
+    var y = O(), w = y.getHighWaterMark;
+    var m = k().codes, R = m.ERR_INVALID_ARG_TYPE, E = m.ERR_STREAM_PUSH_AFTER_EOF, T = m.ERR_METHOD_NOT_IMPLEMENTED, M = m.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+    var j;
+    var P;
+    var L;
+    a.requireInherits()(q, n);
+    var A = g.errorOrDestroy;
+    var x = [ "error", "close", "destroy", "pause", "resume" ];
+    function C(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 N(t, r, n) {
+        e = e || D();
+        t = t || {};
+        if (typeof n !== "boolean") n = r instanceof e;
+        this.objectMode = !!t.objectMode;
+        if (n) this.objectMode = this.objectMode || !!t.readableObjectMode;
+        this.highWaterMark = w(this, t, "readableHighWaterMark", n);
+        this.buffer = new b;
+        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 (!j) j = f.requireString_decoder().StringDecoder;
+            this.decoder = new j(t.encoding);
+            this.encoding = t.encoding;
+        }
+    }
+    function q(t) {
+        e = e || D();
+        if (!(this instanceof q)) return new q(t);
+        var r = this instanceof e;
+        this._readableState = new N(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;
+        }
+        n.call(this);
+    }
+    Object.defineProperty(q.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;
+        }
+    });
+    q.prototype.destroy = g.destroy;
+    q.prototype._undestroy = g.undestroy;
+    q.prototype._destroy = function(e, t) {
+        t(e);
+    };
+    q.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 = i.from(e, t);
+                    t = "";
+                }
+                n = true;
+            }
+        } else {
+            n = true;
+        }
+        return I(this, e, t, false, n);
+    };
+    q.prototype.unshift = function(e) {
+        return I(this, e, null, true, false);
+    };
+    function I(e, t, r, n, a) {
+        p("readableAddChunk", t);
+        var o = e._readableState;
+        if (t === null) {
+            o.reading = false;
+            K(e, o);
+        } else {
+            var f;
+            if (!a) f = U(o, t);
+            if (f) {
+                A(e, f);
+            } else if (o.objectMode || t && t.length > 0) {
+                if (typeof t !== "string" && !o.objectMode && Object.getPrototypeOf(t) !== i.prototype) {
+                    t = s(t);
+                }
+                if (n) {
+                    if (o.endEmitted) A(e, new M); else W(e, o, t, true);
+                } else if (o.ended) {
+                    A(e, new E);
+                } else if (o.destroyed) {
+                    return false;
+                } else {
+                    o.reading = false;
+                    if (o.decoder && !r) {
+                        t = o.decoder.write(t);
+                        if (o.objectMode || t.length !== 0) W(e, o, t, false); else Q(e, o);
+                    } else {
+                        W(e, o, t, false);
+                    }
+                }
+            } else if (!n) {
+                o.reading = false;
+                Q(e, o);
+            }
+        }
+        return !o.ended && (o.length < o.highWaterMark || o.length === 0);
+    }
+    function W(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 U(e, t) {
+        var r;
+        if (!l(t) && typeof t !== "string" && t !== undefined && !e.objectMode) {
+            r = new R("chunk", [ "string", "Buffer", "Uint8Array" ], t);
+        }
+        return r;
+    }
+    q.prototype.isPaused = function() {
+        return this._readableState.flowing === false;
+    };
+    q.prototype.setEncoding = function(e) {
+        if (!j) j = f.requireString_decoder().StringDecoder;
+        var t = new j(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 F = 1073741824;
+    function V(e) {
+        if (e >= F) {
+            e = F;
+        } 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 = V(e);
+        if (e <= t.length) return e;
+        if (!t.ended) {
+            t.needReadable = true;
+            return 0;
+        }
+        return t.length;
+    }
+    q.prototype.read = function(e) {
+        p("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)) {
+            p("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;
+        p("need readable", n);
+        if (t.length === 0 || t.length - e < t.highWaterMark) {
+            n = true;
+            p("length less than watermark", n);
+        }
+        if (t.ended || t.reading) {
+            n = false;
+            p("reading or ended", n);
+        } else if (n) {
+            p("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) {
+        p("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;
+        p("emitReadable", t.needReadable, t.emittedReadable);
+        t.needReadable = false;
+        if (!t.emittedReadable) {
+            p("emitReadable", t.flowing);
+            t.emittedReadable = true;
+            process.nextTick(J, e);
+        }
+    }
+    function J(e) {
+        var t = e._readableState;
+        p("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;
+            p("maybeReadMore read 0");
+            e.read(0);
+            if (r === t.length) break;
+        }
+        t.readingMore = false;
+    }
+    q.prototype._read = function(e) {
+        A(this, new T("_read()"));
+    };
+    q.prototype.pipe = function(e, t) {
+        var n = this;
+        var i = this._readableState;
+        switch (i.pipesCount) {
+          case 0:
+            i.pipes = e;
+            break;
+
+          case 1:
+            i.pipes = [ i.pipes, e ];
+            break;
+
+          default:
+            i.pipes.push(e);
+            break;
+        }
+        i.pipesCount += 1;
+        p("pipe count=%d opts=%j", i.pipesCount, t);
+        var a = (!t || t.end !== false) && e !== process.stdout && e !== process.stderr;
+        var o = a ? s : g;
+        if (i.endEmitted) process.nextTick(o); else n.once("end", o);
+        e.on("unpipe", f);
+        function f(e, t) {
+            p("onunpipe");
+            if (e === n) {
+                if (t && t.hasUnpiped === false) {
+                    t.hasUnpiped = true;
+                    d();
+                }
+            }
+        }
+        function s() {
+            p("onend");
+            e.end();
+        }
+        var l = Z(n);
+        e.on("drain", l);
+        var u = false;
+        function d() {
+            p("cleanup");
+            e.removeListener("close", b);
+            e.removeListener("finish", v);
+            e.removeListener("drain", l);
+            e.removeListener("error", h);
+            e.removeListener("unpipe", f);
+            n.removeListener("end", s);
+            n.removeListener("end", g);
+            n.removeListener("data", c);
+            u = true;
+            if (i.awaitDrain && (!e._writableState || e._writableState.needDrain)) l();
+        }
+        n.on("data", c);
+        function c(t) {
+            p("ondata");
+            var r = e.write(t);
+            p("dest.write", r);
+            if (r === false) {
+                if ((i.pipesCount === 1 && i.pipes === e || i.pipesCount > 1 && se(i.pipes, e) !== -1) && !u) {
+                    p("false write response, pause", i.awaitDrain);
+                    i.awaitDrain++;
+                }
+                n.pause();
+            }
+        }
+        function h(t) {
+            p("onerror", t);
+            g();
+            e.removeListener("error", h);
+            if (r(e, "error") === 0) A(e, t);
+        }
+        C(e, "error", h);
+        function b() {
+            e.removeListener("finish", v);
+            g();
+        }
+        e.once("close", b);
+        function v() {
+            p("onfinish");
+            e.removeListener("close", b);
+            g();
+        }
+        e.once("finish", v);
+        function g() {
+            p("unpipe");
+            n.unpipe(e);
+        }
+        e.emit("pipe", n);
+        if (!i.flowing) {
+            p("pipe resume");
+            n.resume();
+        }
+        return e;
+    };
+    function Z(e) {
+        return function t() {
+            var n = e._readableState;
+            p("pipeOnDrain", n.awaitDrain);
+            if (n.awaitDrain) n.awaitDrain--;
+            if (n.awaitDrain === 0 && r(e, "data")) {
+                n.flowing = true;
+                ie(e);
+            }
+        };
+    }
+    q.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;
+    };
+    q.prototype.on = function(e, t) {
+        var r = n.prototype.on.call(this, e, t);
+        var i = this._readableState;
+        if (e === "data") {
+            i.readableListening = this.listenerCount("readable") > 0;
+            if (i.flowing !== false) this.resume();
+        } else if (e === "readable") {
+            if (!i.endEmitted && !i.readableListening) {
+                i.readableListening = i.needReadable = true;
+                i.flowing = false;
+                i.emittedReadable = false;
+                p("on readable", i.length, i.reading);
+                if (i.length) {
+                    z(this);
+                } else if (!i.reading) {
+                    process.nextTick(te, this);
+                }
+            }
+        }
+        return r;
+    };
+    q.prototype.addListener = q.prototype.on;
+    q.prototype.removeListener = function(e, t) {
+        var r = n.prototype.removeListener.call(this, e, t);
+        if (e === "readable") {
+            process.nextTick(ee, this);
+        }
+        return r;
+    };
+    q.prototype.removeAllListeners = function(e) {
+        var t = n.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) {
+        p("readable nexttick read 0");
+        e.read(0);
+    }
+    q.prototype.resume = function() {
+        var e = this._readableState;
+        if (!e.flowing) {
+            p("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) {
+        p("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);
+    }
+    q.prototype.pause = function() {
+        p("call pause flowing=%j", this._readableState.flowing);
+        if (this._readableState.flowing !== false) {
+            p("pause");
+            this._readableState.flowing = false;
+            this.emit("pause");
+        }
+        this._readableState.paused = true;
+        return this;
+    };
+    function ie(e) {
+        var t = e._readableState;
+        p("flow", t.flowing);
+        while (t.flowing && e.read() !== null) ;
+    }
+    q.prototype.wrap = function(e) {
+        var t = this;
+        var r = this._readableState;
+        var n = false;
+        e.on("end", function() {
+            p("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) {
+            p("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) {
+            p("wrapped _read", t);
+            if (n) {
+                n = false;
+                e.resume();
+            }
+        };
+        return this;
+    };
+    if (typeof Symbol === "function") {
+        q.prototype[Symbol.asyncIterator] = function() {
+            if (P === undefined) {
+                P = B();
+            }
+            return P(this);
+        };
+    }
+    Object.defineProperty(q.prototype, "readableHighWaterMark", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState.highWaterMark;
+        }
+    });
+    Object.defineProperty(q.prototype, "readableBuffer", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState && this._readableState.buffer;
+        }
+    });
+    Object.defineProperty(q.prototype, "readableFlowing", {
+        enumerable: false,
+        get: function e() {
+            return this._readableState.flowing;
+        },
+        set: function e(t) {
+            if (this._readableState) {
+                this._readableState.flowing = t;
+            }
+        }
+    });
+    q._fromList = ae;
+    Object.defineProperty(q.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;
+        p("endReadable", t.endEmitted);
+        if (!t.endEmitted) {
+            t.ended = true;
+            process.nextTick(fe, t, e);
+        }
+    }
+    function fe(e, t) {
+        p("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") {
+        q.from = function(e, t) {
+            if (L === undefined) {
+                L = H();
+            }
+            return L(q, 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 $;
 }
 
-function d(e) {
-    return /^-?(0+)\d/.test(e);
+var Y;
+
+var K;
+
+function z() {
+    if (K) return Y;
+    K = 1;
+    Y = s;
+    var e = k().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 = D();
+    a.requireInherits()(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 Y;
 }
 
-function x(e, t, r) {
-    if (!t.isPadded) {
-        return e;
+var J;
+
+var Q;
+
+function X() {
+    if (Q) return J;
+    Q = 1;
+    J = t;
+    var e = z();
+    a.requireInherits()(t, e);
+    function t(r) {
+        if (!(this instanceof t)) return new t(r);
+        e.call(this, r);
     }
-    let n = Math.abs(t.maxLen - String(e).length);
-    let l = r.relaxZeros !== false;
-    switch (n) {
-      case 0:
-        return "";
+    t.prototype._transform = function(e, t, r) {
+        r(null, e);
+    };
+    return J;
+}
 
-      case 1:
-        return l ? "0?" : "0";
+var Z;
 
-      case 2:
-        return l ? "0{0,2}" : "00";
+var ee;
 
-      default:
-        {
-            return l ? `0{0,${n}}` : `0{${n}}`;
+function te() {
+    if (ee) return Z;
+    ee = 1;
+    var e;
+    function t(e) {
+        var t = false;
+        return function() {
+            if (t) return;
+            t = true;
+            e.apply(void 0, arguments);
+        };
+    }
+    var r = k().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 = q();
+        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);
     }
+    Z = d;
+    return Z;
 }
 
-r.cache = {};
+h.exports;
 
-r.clearCache = () => r.cache = {};
+(function(e, t) {
+    var r = l.default;
+    if (process.env.READABLE_STREAM === "disable" && r) {
+        e.exports = r.Readable;
+        Object.assign(e.exports, r);
+        e.exports.Stream = r;
+    } else {
+        t = e.exports = V();
+        t.Stream = r || t;
+        t.Readable = t;
+        t.Writable = L();
+        t.Duplex = D();
+        t.Transform = z();
+        t.PassThrough = X();
+        t.finished = q();
+        t.pipeline = te();
+    }
+})(h, h.exports);
 
-exports.toRegexRange_1 = r;
+exports.readableExports = h.exports;