lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.81.cjs

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