lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.81.mjs

@@ -1,55 +1,1225 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import { w as e } from "./Package.internal.149.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import e from "fs";
 
-var r = {
-    exports: {}
+import r from "path";
+
+import t from "util";
+
+import { b as n } from "./Package.internal.41.mjs";
+
+import { r as i } from "./Package.internal.42.mjs";
+
+import { f as a } from "./Package.internal.102.mjs";
+
+import { e as o } from "./Package.internal.84.mjs";
+
+import { r as s } from "./Package.internal.43.mjs";
+
+import f from "string_decoder";
+
+import { p as u } from "./Package.internal.166.mjs";
+
+import { m as c } from "./Package.internal.136.mjs";
+
+import l from "os";
+
+var h = {};
+
+const d = e;
+
+const m = r;
+
+const v = d.lchown ? "lchown" : "chown";
+
+const p = d.lchownSync ? "lchownSync" : "chownSync";
+
+const y = d.lchown && !process.version.match(/v1[1-9]+\./) && !process.version.match(/v10\.[6-9]/);
+
+const _ = (e, r, t) => {
+    try {
+        return d[p](e, r, t);
+    } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+    }
+};
+
+const g = (e, r, t) => {
+    try {
+        return d.chownSync(e, r, t);
+    } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+    }
 };
 
-r.exports;
+const w = y ? (e, r, t, n) => i => {
+    if (!i || i.code !== "EISDIR") n(i); else d.chown(e, r, t, n);
+} : (e, r, t, n) => n;
+
+const k = y ? (e, r, t) => {
+    try {
+        return _(e, r, t);
+    } catch (n) {
+        if (n.code !== "EISDIR") throw n;
+        g(e, r, t);
+    }
+} : (e, r, t) => _(e, r, t);
 
-var t = e;
+const b = process.version;
 
-r.exports = t(n);
+let z = (e, r, t) => d.readdir(e, r, t);
 
-r.exports.strict = t(o);
+let x = (e, r) => d.readdirSync(e, r);
 
-n.proto = n(function() {
-    Object.defineProperty(Function.prototype, "once", {
-        value: function() {
-            return n(this);
-        },
-        configurable: true
+if (/^v4\./.test(b)) z = (e, r, t) => d.readdir(e, t);
+
+const E = (e, r, t, n) => {
+    d[v](e, r, t, w(e, r, t, e => {
+        n(e && e.code !== "ENOENT" ? e : null);
+    }));
+};
+
+const P = (e, r, t, n, i) => {
+    if (typeof r === "string") return d.lstat(m.resolve(e, r), (a, o) => {
+        if (a) return i(a.code !== "ENOENT" ? a : null);
+        o.name = r;
+        P(e, o, t, n, i);
     });
-    Object.defineProperty(Function.prototype, "onceStrict", {
-        value: function() {
-            return o(this);
-        },
-        configurable: true
+    if (r.isDirectory()) {
+        I(m.resolve(e, r.name), t, n, a => {
+            if (a) return i(a);
+            const o = m.resolve(e, r.name);
+            E(o, t, n, i);
+        });
+    } else {
+        const a = m.resolve(e, r.name);
+        E(a, t, n, i);
+    }
+};
+
+const I = (e, r, t, n) => {
+    z(e, {
+        withFileTypes: true
+    }, (i, a) => {
+        if (i) {
+            if (i.code === "ENOENT") return n(); else if (i.code !== "ENOTDIR" && i.code !== "ENOTSUP") return n(i);
+        }
+        if (i || !a.length) return E(e, r, t, n);
+        let o = a.length;
+        let s = null;
+        const f = i => {
+            if (s) return;
+            if (i) return n(s = i);
+            if (--o === 0) return E(e, r, t, n);
+        };
+        a.forEach(n => P(e, n, r, t, f));
     });
-});
+};
 
-function n(e) {
-    var r = function() {
-        if (r.called) return r.value;
-        r.called = true;
-        return r.value = e.apply(this, arguments);
-    };
-    r.called = false;
+const S = (e, r, t, n) => {
+    if (typeof r === "string") {
+        try {
+            const t = d.lstatSync(m.resolve(e, r));
+            t.name = r;
+            r = t;
+        } catch (e) {
+            if (e.code === "ENOENT") return; else throw e;
+        }
+    }
+    if (r.isDirectory()) L(m.resolve(e, r.name), t, n);
+    k(m.resolve(e, r.name), t, n);
+};
+
+const L = (e, r, t) => {
+    let n;
+    try {
+        n = x(e, {
+            withFileTypes: true
+        });
+    } catch (n) {
+        if (n.code === "ENOENT") return; else if (n.code === "ENOTDIR" || n.code === "ENOTSUP") return k(e, r, t); else throw n;
+    }
+    if (n && n.length) n.forEach(n => S(e, n, r, t));
+    return k(e, r, t);
+};
+
+var j = I;
+
+I.sync = L;
+
+var N = {};
+
+var T = {};
+
+var B = Buffer.alloc;
+
+var D = "0000000000000000000";
+
+var O = "7777777777777777777";
+
+var F = "0".charCodeAt(0);
+
+var R = Buffer.from("ustar\0", "binary");
+
+var M = Buffer.from("00", "binary");
+
+var G = Buffer.from("ustar ", "binary");
+
+var U = Buffer.from(" \0", "binary");
+
+var W = parseInt("7777", 8);
+
+var A = 257;
+
+var H = 263;
+
+var C = function(e, r, t) {
+    if (typeof e !== "number") return t;
+    e = ~~e;
+    if (e >= r) return r;
+    if (e >= 0) return e;
+    e += r;
+    if (e >= 0) return e;
+    return 0;
+};
+
+var K = function(e) {
+    switch (e) {
+      case 0:
+        return "file";
+
+      case 1:
+        return "link";
+
+      case 2:
+        return "symlink";
+
+      case 3:
+        return "character-device";
+
+      case 4:
+        return "block-device";
+
+      case 5:
+        return "directory";
+
+      case 6:
+        return "fifo";
+
+      case 7:
+        return "contiguous-file";
+
+      case 72:
+        return "pax-header";
+
+      case 55:
+        return "pax-global-header";
+
+      case 27:
+        return "gnu-long-link-path";
+
+      case 28:
+      case 30:
+        return "gnu-long-path";
+    }
+    return null;
+};
+
+var q = function(e) {
+    switch (e) {
+      case "file":
+        return 0;
+
+      case "link":
+        return 1;
+
+      case "symlink":
+        return 2;
+
+      case "character-device":
+        return 3;
+
+      case "block-device":
+        return 4;
+
+      case "directory":
+        return 5;
+
+      case "fifo":
+        return 6;
+
+      case "contiguous-file":
+        return 7;
+
+      case "pax-header":
+        return 72;
+    }
+    return 0;
+};
+
+var J = function(e, r, t, n) {
+    for (;t < n; t++) {
+        if (e[t] === r) return t;
+    }
+    return n;
+};
+
+var Q = function(e) {
+    var r = 8 * 32;
+    for (var t = 0; t < 148; t++) r += e[t];
+    for (var n = 156; n < 512; n++) r += e[n];
     return r;
+};
+
+var V = function(e, r) {
+    e = e.toString(8);
+    if (e.length > r) return O.slice(0, r) + " "; else return D.slice(0, r - e.length) + e + " ";
+};
+
+function X(e) {
+    var r;
+    if (e[0] === 128) r = true; else if (e[0] === 255) r = false; else return null;
+    var t = [];
+    for (var n = e.length - 1; n > 0; n--) {
+        var i = e[n];
+        if (r) t.push(i); else t.push(255 - i);
+    }
+    var a = 0;
+    var o = t.length;
+    for (n = 0; n < o; n++) {
+        a += t[n] * Math.pow(256, n);
+    }
+    return r ? a : -1 * a;
 }
 
-function o(e) {
-    var r = function() {
-        if (r.called) throw new Error(r.onceError);
-        r.called = true;
-        return r.value = e.apply(this, arguments);
-    };
-    var t = e.name || "Function wrapped with `once`";
-    r.onceError = t + " shouldn't be called more than once";
-    r.called = false;
+var Y = function(e, r, t) {
+    e = e.slice(r, r + t);
+    r = 0;
+    if (e[r] & 128) {
+        return X(e);
+    } else {
+        while (r < e.length && e[r] === 32) r++;
+        var n = C(J(e, 32, r, e.length), e.length, e.length);
+        while (r < n && e[r] === 0) r++;
+        if (n === r) return 0;
+        return parseInt(e.slice(r, n).toString(), 8);
+    }
+};
+
+var Z = function(e, r, t, n) {
+    return e.slice(r, J(e, 0, r, r + t)).toString(n);
+};
+
+var $ = function(e) {
+    var r = Buffer.byteLength(e);
+    var t = Math.floor(Math.log(r) / Math.log(10)) + 1;
+    if (r + t >= Math.pow(10, t)) t++;
+    return r + t + e;
+};
+
+T.decodeLongPath = function(e, r) {
+    return Z(e, 0, e.length, r);
+};
+
+T.encodePax = function(e) {
+    var r = "";
+    if (e.name) r += $(" path=" + e.name + "\n");
+    if (e.linkname) r += $(" linkpath=" + e.linkname + "\n");
+    var t = e.pax;
+    if (t) {
+        for (var n in t) {
+            r += $(" " + n + "=" + t[n] + "\n");
+        }
+    }
+    return Buffer.from(r);
+};
+
+T.decodePax = function(e) {
+    var r = {};
+    while (e.length) {
+        var t = 0;
+        while (t < e.length && e[t] !== 32) t++;
+        var n = parseInt(e.slice(0, t).toString(), 10);
+        if (!n) return r;
+        var i = e.slice(t + 1, n - 1).toString();
+        var a = i.indexOf("=");
+        if (a === -1) return r;
+        r[i.slice(0, a)] = i.slice(a + 1);
+        e = e.slice(n);
+    }
+    return r;
+};
+
+T.encode = function(e) {
+    var r = B(512);
+    var t = e.name;
+    var n = "";
+    if (e.typeflag === 5 && t[t.length - 1] !== "/") t += "/";
+    if (Buffer.byteLength(t) !== t.length) return null;
+    while (Buffer.byteLength(t) > 100) {
+        var i = t.indexOf("/");
+        if (i === -1) return null;
+        n += n ? "/" + t.slice(0, i) : t.slice(0, i);
+        t = t.slice(i + 1);
+    }
+    if (Buffer.byteLength(t) > 100 || Buffer.byteLength(n) > 155) return null;
+    if (e.linkname && Buffer.byteLength(e.linkname) > 100) return null;
+    r.write(t);
+    r.write(V(e.mode & W, 6), 100);
+    r.write(V(e.uid, 6), 108);
+    r.write(V(e.gid, 6), 116);
+    r.write(V(e.size, 11), 124);
+    r.write(V(e.mtime.getTime() / 1e3 | 0, 11), 136);
+    r[156] = F + q(e.type);
+    if (e.linkname) r.write(e.linkname, 157);
+    R.copy(r, A);
+    M.copy(r, H);
+    if (e.uname) r.write(e.uname, 265);
+    if (e.gname) r.write(e.gname, 297);
+    r.write(V(e.devmajor || 0, 6), 329);
+    r.write(V(e.devminor || 0, 6), 337);
+    if (n) r.write(n, 345);
+    r.write(V(Q(r), 6), 148);
     return r;
+};
+
+T.decode = function(e, r, t) {
+    var n = e[156] === 0 ? 0 : e[156] - F;
+    var i = Z(e, 0, 100, r);
+    var a = Y(e, 100, 8);
+    var o = Y(e, 108, 8);
+    var s = Y(e, 116, 8);
+    var f = Y(e, 124, 12);
+    var u = Y(e, 136, 12);
+    var c = K(n);
+    var l = e[157] === 0 ? null : Z(e, 157, 100, r);
+    var h = Z(e, 265, 32);
+    var d = Z(e, 297, 32);
+    var m = Y(e, 329, 8);
+    var v = Y(e, 337, 8);
+    var p = Q(e);
+    if (p === 8 * 32) return null;
+    if (p !== Y(e, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
+    if (R.compare(e, A, A + 6) === 0) {
+        if (e[345]) i = Z(e, 345, 155, r) + "/" + i;
+    } else if (G.compare(e, A, A + 6) === 0 && U.compare(e, H, H + 2) === 0) ; else {
+        if (!t) {
+            throw new Error("Invalid tar header: unknown format.");
+        }
+    }
+    if (n === 0 && i && i[i.length - 1] === "/") n = 5;
+    return {
+        name: i,
+        mode: a,
+        uid: o,
+        gid: s,
+        size: f,
+        mtime: new Date(1e3 * u),
+        type: c,
+        linkname: l,
+        uname: h,
+        gname: d,
+        devmajor: m,
+        devminor: v
+    };
+};
+
+var ee = t;
+
+var re = n;
+
+var te = T;
+
+var ne = i.Writable;
+
+var ie = i.PassThrough;
+
+var ae = function() {};
+
+var oe = function(e) {
+    e &= 511;
+    return e && 512 - e;
+};
+
+var se = function(e, r) {
+    var t = new ue(e, r);
+    t.end();
+    return t;
+};
+
+var fe = function(e, r) {
+    if (r.path) e.name = r.path;
+    if (r.linkpath) e.linkname = r.linkpath;
+    if (r.size) e.size = parseInt(r.size, 10);
+    e.pax = r;
+    return e;
+};
+
+var ue = function(e, r) {
+    this._parent = e;
+    this.offset = r;
+    ie.call(this, {
+        autoDestroy: false
+    });
+};
+
+ee.inherits(ue, ie);
+
+ue.prototype.destroy = function(e) {
+    this._parent.destroy(e);
+};
+
+var ce = function(e) {
+    if (!(this instanceof ce)) return new ce(e);
+    ne.call(this, e);
+    e = e || {};
+    this._offset = 0;
+    this._buffer = re();
+    this._missing = 0;
+    this._partial = false;
+    this._onparse = ae;
+    this._header = null;
+    this._stream = null;
+    this._overflow = null;
+    this._cb = null;
+    this._locked = false;
+    this._destroyed = false;
+    this._pax = null;
+    this._paxGlobal = null;
+    this._gnuLongPath = null;
+    this._gnuLongLinkPath = null;
+    var r = this;
+    var t = r._buffer;
+    var n = function() {
+        r._continue();
+    };
+    var i = function(e) {
+        r._locked = false;
+        if (e) return r.destroy(e);
+        if (!r._stream) n();
+    };
+    var a = function() {
+        r._stream = null;
+        var e = oe(r._header.size);
+        if (e) r._parse(e, o); else r._parse(512, l);
+        if (!r._locked) n();
+    };
+    var o = function() {
+        r._buffer.consume(oe(r._header.size));
+        r._parse(512, l);
+        n();
+    };
+    var s = function() {
+        var e = r._header.size;
+        r._paxGlobal = te.decodePax(t.slice(0, e));
+        t.consume(e);
+        a();
+    };
+    var f = function() {
+        var e = r._header.size;
+        r._pax = te.decodePax(t.slice(0, e));
+        if (r._paxGlobal) r._pax = Object.assign({}, r._paxGlobal, r._pax);
+        t.consume(e);
+        a();
+    };
+    var u = function() {
+        var n = r._header.size;
+        this._gnuLongPath = te.decodeLongPath(t.slice(0, n), e.filenameEncoding);
+        t.consume(n);
+        a();
+    };
+    var c = function() {
+        var n = r._header.size;
+        this._gnuLongLinkPath = te.decodeLongPath(t.slice(0, n), e.filenameEncoding);
+        t.consume(n);
+        a();
+    };
+    var l = function() {
+        var o = r._offset;
+        var h;
+        try {
+            h = r._header = te.decode(t.slice(0, 512), e.filenameEncoding, e.allowUnknownFormat);
+        } catch (e) {
+            r.emit("error", e);
+        }
+        t.consume(512);
+        if (!h) {
+            r._parse(512, l);
+            n();
+            return;
+        }
+        if (h.type === "gnu-long-path") {
+            r._parse(h.size, u);
+            n();
+            return;
+        }
+        if (h.type === "gnu-long-link-path") {
+            r._parse(h.size, c);
+            n();
+            return;
+        }
+        if (h.type === "pax-global-header") {
+            r._parse(h.size, s);
+            n();
+            return;
+        }
+        if (h.type === "pax-header") {
+            r._parse(h.size, f);
+            n();
+            return;
+        }
+        if (r._gnuLongPath) {
+            h.name = r._gnuLongPath;
+            r._gnuLongPath = null;
+        }
+        if (r._gnuLongLinkPath) {
+            h.linkname = r._gnuLongLinkPath;
+            r._gnuLongLinkPath = null;
+        }
+        if (r._pax) {
+            r._header = h = fe(h, r._pax);
+            r._pax = null;
+        }
+        r._locked = true;
+        if (!h.size || h.type === "directory") {
+            r._parse(512, l);
+            r.emit("entry", h, se(r, o), i);
+            return;
+        }
+        r._stream = new ue(r, o);
+        r.emit("entry", h, r._stream, i);
+        r._parse(h.size, a);
+        n();
+    };
+    this._onheader = l;
+    this._parse(512, l);
+};
+
+ee.inherits(ce, ne);
+
+ce.prototype.destroy = function(e) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (e) this.emit("error", e);
+    this.emit("close");
+    if (this._stream) this._stream.emit("close");
+};
+
+ce.prototype._parse = function(e, r) {
+    if (this._destroyed) return;
+    this._offset += e;
+    this._missing = e;
+    if (r === this._onheader) this._partial = false;
+    this._onparse = r;
+};
+
+ce.prototype._continue = function() {
+    if (this._destroyed) return;
+    var e = this._cb;
+    this._cb = ae;
+    if (this._overflow) this._write(this._overflow, undefined, e); else e();
+};
+
+ce.prototype._write = function(e, r, t) {
+    if (this._destroyed) return;
+    var n = this._stream;
+    var i = this._buffer;
+    var a = this._missing;
+    if (e.length) this._partial = true;
+    if (e.length < a) {
+        this._missing -= e.length;
+        this._overflow = null;
+        if (n) return n.write(e, t);
+        i.append(e);
+        return t();
+    }
+    this._cb = t;
+    this._missing = 0;
+    var o = null;
+    if (e.length > a) {
+        o = e.slice(a);
+        e = e.slice(0, a);
+    }
+    if (n) n.end(e); else i.append(e);
+    this._overflow = o;
+    this._onparse();
+};
+
+ce.prototype._final = function(e) {
+    if (this._partial) return this.destroy(new Error("Unexpected end of data"));
+    e();
+};
+
+var le = ce;
+
+var he = a;
+
+var de = o;
+
+var me = s();
+
+var ve = Buffer.alloc;
+
+var pe = i.Readable;
+
+var ye = i.Writable;
+
+var _e = f.StringDecoder;
+
+var ge = T;
+
+var we = parseInt("755", 8);
+
+var ke = parseInt("644", 8);
+
+var be = ve(1024);
+
+var ze = function() {};
+
+var xe = function(e, r) {
+    r &= 511;
+    if (r) e.push(be.slice(0, 512 - r));
+};
+
+function Ee(e) {
+    switch (e & he.S_IFMT) {
+      case he.S_IFBLK:
+        return "block-device";
+
+      case he.S_IFCHR:
+        return "character-device";
+
+      case he.S_IFDIR:
+        return "directory";
+
+      case he.S_IFIFO:
+        return "fifo";
+
+      case he.S_IFLNK:
+        return "symlink";
+    }
+    return "file";
 }
 
-var a = r.exports;
+var Pe = function(e) {
+    ye.call(this);
+    this.written = 0;
+    this._to = e;
+    this._destroyed = false;
+};
+
+me(Pe, ye);
+
+Pe.prototype._write = function(e, r, t) {
+    this.written += e.length;
+    if (this._to.push(e)) return t();
+    this._to._drain = t;
+};
+
+Pe.prototype.destroy = function() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this.emit("close");
+};
+
+var Ie = function() {
+    ye.call(this);
+    this.linkname = "";
+    this._decoder = new _e("utf-8");
+    this._destroyed = false;
+};
+
+me(Ie, ye);
+
+Ie.prototype._write = function(e, r, t) {
+    this.linkname += this._decoder.write(e);
+    t();
+};
+
+Ie.prototype.destroy = function() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this.emit("close");
+};
+
+var Se = function() {
+    ye.call(this);
+    this._destroyed = false;
+};
+
+me(Se, ye);
+
+Se.prototype._write = function(e, r, t) {
+    t(new Error("No body allowed for this entry"));
+};
+
+Se.prototype.destroy = function() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this.emit("close");
+};
+
+var Le = function(e) {
+    if (!(this instanceof Le)) return new Le(e);
+    pe.call(this, e);
+    this._drain = ze;
+    this._finalized = false;
+    this._finalizing = false;
+    this._destroyed = false;
+    this._stream = null;
+};
+
+me(Le, pe);
+
+Le.prototype.entry = function(e, r, t) {
+    if (this._stream) throw new Error("already piping an entry");
+    if (this._finalized || this._destroyed) return;
+    if (typeof r === "function") {
+        t = r;
+        r = null;
+    }
+    if (!t) t = ze;
+    var n = this;
+    if (!e.size || e.type === "symlink") e.size = 0;
+    if (!e.type) e.type = Ee(e.mode);
+    if (!e.mode) e.mode = e.type === "directory" ? we : ke;
+    if (!e.uid) e.uid = 0;
+    if (!e.gid) e.gid = 0;
+    if (!e.mtime) e.mtime = new Date;
+    if (typeof r === "string") r = Buffer.from(r);
+    if (Buffer.isBuffer(r)) {
+        e.size = r.length;
+        this._encode(e);
+        var i = this.push(r);
+        xe(n, e.size);
+        if (i) process.nextTick(t); else this._drain = t;
+        return new Se;
+    }
+    if (e.type === "symlink" && !e.linkname) {
+        var a = new Ie;
+        de(a, function(r) {
+            if (r) {
+                n.destroy();
+                return t(r);
+            }
+            e.linkname = a.linkname;
+            n._encode(e);
+            t();
+        });
+        return a;
+    }
+    this._encode(e);
+    if (e.type !== "file" && e.type !== "contiguous-file") {
+        process.nextTick(t);
+        return new Se;
+    }
+    var o = new Pe(this);
+    this._stream = o;
+    de(o, function(r) {
+        n._stream = null;
+        if (r) {
+            n.destroy();
+            return t(r);
+        }
+        if (o.written !== e.size) {
+            n.destroy();
+            return t(new Error("size mismatch"));
+        }
+        xe(n, e.size);
+        if (n._finalizing) n.finalize();
+        t();
+    });
+    return o;
+};
+
+Le.prototype.finalize = function() {
+    if (this._stream) {
+        this._finalizing = true;
+        return;
+    }
+    if (this._finalized) return;
+    this._finalized = true;
+    this.push(be);
+    this.push(null);
+};
+
+Le.prototype.destroy = function(e) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (e) this.emit("error", e);
+    this.emit("close");
+    if (this._stream && this._stream.destroy) this._stream.destroy();
+};
+
+Le.prototype._encode = function(e) {
+    if (!e.pax) {
+        var r = ge.encode(e);
+        if (r) {
+            this.push(r);
+            return;
+        }
+    }
+    this._encodePax(e);
+};
+
+Le.prototype._encodePax = function(e) {
+    var r = ge.encodePax({
+        name: e.name,
+        linkname: e.linkname,
+        pax: e.pax
+    });
+    var t = {
+        name: "PaxHeader",
+        mode: e.mode,
+        uid: e.uid,
+        gid: e.gid,
+        size: r.length,
+        mtime: e.mtime,
+        type: "pax-header",
+        linkname: e.linkname && "PaxHeader",
+        uname: e.uname,
+        gname: e.gname,
+        devmajor: e.devmajor,
+        devminor: e.devminor
+    };
+    this.push(ge.encode(t));
+    this.push(r);
+    xe(this, r.length);
+    t.size = e.size;
+    t.type = e.type;
+    this.push(ge.encode(t));
+};
+
+Le.prototype._read = function(e) {
+    var r = this._drain;
+    this._drain = ze;
+    r();
+};
+
+var je = Le;
+
+N.extract = le;
+
+N.pack = je;
+
+var Ne = j;
+
+var Te = N;
+
+var Be = u;
+
+var De = c;
+
+var Oe = e;
+
+var Fe = r;
+
+var Re = l;
+
+var Me = Re.platform() === "win32";
+
+var Ge = function() {};
+
+var Ue = function(e) {
+    return e;
+};
+
+var We = !Me ? Ue : function(e) {
+    return e.replace(/\\/g, "/").replace(/[:?<>|]/g, "_");
+};
+
+var Ae = function(e, r, t, n, i, a) {
+    var o = i || [ "." ];
+    return function i(s) {
+        if (!o.length) return s();
+        var f = o.shift();
+        var u = Fe.join(t, f);
+        r.call(e, u, function(r, i) {
+            if (r) return s(r);
+            if (!i.isDirectory()) return s(null, f, i);
+            e.readdir(u, function(e, r) {
+                if (e) return s(e);
+                if (a) r.sort();
+                for (var u = 0; u < r.length; u++) {
+                    if (!n(Fe.join(t, f, r[u]))) o.push(Fe.join(f, r[u]));
+                }
+                s(null, f, i);
+            });
+        });
+    };
+};
+
+var He = function(e, r) {
+    return function(t) {
+        t.name = t.name.split("/").slice(r).join("/");
+        var n = t.linkname;
+        if (n && (t.type === "link" || Fe.isAbsolute(n))) {
+            t.linkname = n.split("/").slice(r).join("/");
+        }
+        return e(t);
+    };
+};
+
+h.pack = function(e, r) {
+    if (!e) e = ".";
+    if (!r) r = {};
+    var t = r.fs || Oe;
+    var n = r.ignore || r.filter || Ge;
+    var i = r.map || Ge;
+    var a = r.mapStream || Ue;
+    var o = Ae(t, r.dereference ? t.stat : t.lstat, e, n, r.entries, r.sort);
+    var s = r.strict !== false;
+    var f = typeof r.umask === "number" ? ~r.umask : ~qe();
+    var u = typeof r.dmode === "number" ? r.dmode : 0;
+    var c = typeof r.fmode === "number" ? r.fmode : 0;
+    var l = r.pack || Te.pack();
+    var h = r.finish || Ge;
+    if (r.strip) i = He(i, r.strip);
+    if (r.readable) {
+        u |= parseInt(555, 8);
+        c |= parseInt(444, 8);
+    }
+    if (r.writable) {
+        u |= parseInt(333, 8);
+        c |= parseInt(222, 8);
+    }
+    var d = function(r, n) {
+        t.readlink(Fe.join(e, r), function(e, r) {
+            if (e) return l.destroy(e);
+            n.linkname = We(r);
+            l.entry(n, v);
+        });
+    };
+    var m = function(n, o, m) {
+        if (n) return l.destroy(n);
+        if (!o) {
+            if (r.finalize !== false) l.finalize();
+            return h(l);
+        }
+        if (m.isSocket()) return v();
+        var p = {
+            name: We(o),
+            mode: (m.mode | (m.isDirectory() ? u : c)) & f,
+            mtime: m.mtime,
+            size: m.size,
+            type: "file",
+            uid: m.uid,
+            gid: m.gid
+        };
+        if (m.isDirectory()) {
+            p.size = 0;
+            p.type = "directory";
+            p = i(p) || p;
+            return l.entry(p, v);
+        }
+        if (m.isSymbolicLink()) {
+            p.size = 0;
+            p.type = "symlink";
+            p = i(p) || p;
+            return d(o, p);
+        }
+        p = i(p) || p;
+        if (!m.isFile()) {
+            if (s) return l.destroy(new Error("unsupported type for " + o));
+            return v();
+        }
+        var y = l.entry(p, v);
+        if (!y) return;
+        var _ = a(t.createReadStream(Fe.join(e, o), {
+            start: 0,
+            end: p.size > 0 ? p.size - 1 : p.size
+        }), p);
+        _.on("error", function(e) {
+            y.destroy(e);
+        });
+        Be(_, y);
+    };
+    var v = function(e) {
+        if (e) return l.destroy(e);
+        o(m);
+    };
+    v();
+    return l;
+};
+
+var Ce = function(e) {
+    return e.length ? e[e.length - 1] : null;
+};
+
+var Ke = function() {
+    return process.getuid ? process.getuid() : -1;
+};
+
+var qe = function() {
+    return process.umask ? process.umask() : 0;
+};
+
+h.extract = function(e, r) {
+    if (!e) e = ".";
+    if (!r) r = {};
+    var t = r.fs || Oe;
+    var n = r.ignore || r.filter || Ge;
+    var i = r.map || Ge;
+    var a = r.mapStream || Ue;
+    var o = r.chown !== false && !Me && Ke() === 0;
+    var s = r.extract || Te.extract();
+    var f = [];
+    var u = new Date;
+    var c = typeof r.umask === "number" ? ~r.umask : ~qe();
+    var l = typeof r.dmode === "number" ? r.dmode : 0;
+    var h = typeof r.fmode === "number" ? r.fmode : 0;
+    var d = r.strict !== false;
+    if (r.strip) i = He(i, r.strip);
+    if (r.readable) {
+        l |= parseInt(555, 8);
+        h |= parseInt(444, 8);
+    }
+    if (r.writable) {
+        l |= parseInt(333, 8);
+        h |= parseInt(222, 8);
+    }
+    var m = function(e, r) {
+        var n;
+        while ((n = Ce(f)) && e.slice(0, n[0].length) !== n[0]) f.pop();
+        if (!n) return r();
+        t.utimes(n[0], u, n[1], r);
+    };
+    var v = function(e, n, i) {
+        if (r.utimes === false) return i();
+        if (n.type === "directory") return t.utimes(e, u, n.mtime, i);
+        if (n.type === "symlink") return m(e, i);
+        t.utimes(e, u, n.mtime, function(r) {
+            if (r) return i(r);
+            m(e, i);
+        });
+    };
+    var p = function(e, r, n) {
+        var i = r.type === "symlink";
+        var a = i ? t.lchmod : t.chmod;
+        var s = i ? t.lchown : t.chown;
+        if (!a) return n();
+        var f = (r.mode | (r.type === "directory" ? l : h)) & c;
+        if (s && o) s.call(t, e, r.uid, r.gid, u); else u(null);
+        function u(r) {
+            if (r) return n(r);
+            if (!a) return n();
+            a.call(t, e, f, n);
+        }
+    };
+    s.on("entry", function(s, u, c) {
+        s = i(s) || s;
+        s.name = We(s.name);
+        var l = Fe.join(e, Fe.join("/", s.name));
+        if (n(l, s)) {
+            u.resume();
+            return c();
+        }
+        var h = function(e) {
+            if (e) return c(e);
+            v(l, s, function(e) {
+                if (e) return c(e);
+                if (Me) return c();
+                p(l, s, c);
+            });
+        };
+        var m = function() {
+            if (Me) return c();
+            t.unlink(l, function() {
+                var r = Fe.resolve(Fe.dirname(l), s.linkname);
+                if (!Ve(r, e)) return c(new Error(l + " is not a valid symlink"));
+                t.symlink(s.linkname, l, h);
+            });
+        };
+        var y = function() {
+            if (Me) return c();
+            t.unlink(l, function() {
+                var n = Fe.join(e, Fe.join("/", s.linkname));
+                t.realpath(n, function(i, a) {
+                    if (i || !Ve(a, e)) return c(new Error(l + " is not a valid hardlink"));
+                    t.link(a, l, function(e) {
+                        if (e && e.code === "EPERM" && r.hardlinkAsFilesFallback) {
+                            u = t.createReadStream(n);
+                            return _();
+                        }
+                        h(e);
+                    });
+                });
+            });
+        };
+        var _ = function() {
+            var e = t.createWriteStream(l);
+            var r = a(u, s);
+            e.on("error", function(e) {
+                r.destroy(e);
+            });
+            Be(r, e, function(r) {
+                if (r) return c(r);
+                e.on("close", h);
+            });
+        };
+        if (s.type === "directory") {
+            f.push([ l, s.mtime ]);
+            return Qe(l, {
+                fs: t,
+                own: o,
+                uid: s.uid,
+                gid: s.gid
+            }, h);
+        }
+        var g = Fe.dirname(l);
+        Je(t, g, Fe.join(e, "."), function(e, r) {
+            if (e) return c(e);
+            if (!r) return c(new Error(g + " is not a valid path"));
+            Qe(g, {
+                fs: t,
+                own: o,
+                uid: s.uid,
+                gid: s.gid
+            }, function(e) {
+                if (e) return c(e);
+                switch (s.type) {
+                  case "file":
+                    return _();
+
+                  case "link":
+                    return y();
+
+                  case "symlink":
+                    return m();
+                }
+                if (d) return c(new Error("unsupported type for " + l + " (" + s.type + ")"));
+                u.resume();
+                c();
+            });
+        });
+    });
+    if (r.finish) s.on("finish", r.finish);
+    return s;
+};
+
+function Je(e, r, t, n) {
+    if (r === t) return n(null, true);
+    e.lstat(r, function(i, a) {
+        if (i && i.code !== "ENOENT") return n(i);
+        if (i || a.isDirectory()) return Je(e, Fe.join(r, ".."), t, n);
+        n(null, false);
+    });
+}
+
+function Qe(e, r, t) {
+    De(e, {
+        fs: r.fs
+    }, function(e, n) {
+        if (!e && n && r.own) {
+            Ne(n, r.uid, r.gid, t);
+        } else {
+            t(e);
+        }
+    });
+}
+
+function Ve(e, r) {
+    r = Fe.resolve(r);
+    return r === e || e.startsWith(r + Fe.sep);
+}
 
-export { a as o };
+export { h as t };