lakutata 2.0.18 → 2.0.20

package/src/components/docker/Docker.cjs

@@ -68,6 +68,8 @@ const O = require("./options/DockerPruneOptions.cjs");
 
 const I = require("./options/auth/DockerAuthOptions.cjs");
 
+const T = require("../../lib/helpers/DevNull.cjs");
+
 require("../../../vendor/Package.3.cjs");
 
 require("../../lib/base/async-constructor/AsyncConstructor.cjs");
@@ -178,8 +180,6 @@ require("../../lib/base/internal/ObjectInjection.cjs");
 
 require("../../lib/base/internal/ObjectContainer.cjs");
 
-require("../../lib/helpers/DevNull.cjs");
-
 require("../../decorators/dto/Expect.cjs");
 
 require("../../decorators/dto/IndexSignature.cjs");
@@ -282,30 +282,30 @@ require("../../decorators/di/Inject.cjs");
 
 require("./types/ContainerCapability.cjs");
 
-const T = e => e && e.__esModule ? e : {
+const C = e => e && e.__esModule ? e : {
     default: e
 };
 
-const C = T(S);
+const E = C(S);
 
-var E = {};
-
-var L;
+var L = {};
 
 var A;
 
-function N() {
-    if (A) return L;
-    A = 1;
-    L = typeof queueMicrotask === "function" ? queueMicrotask : e => Promise.resolve().then(e);
-    return L;
+var N;
+
+function F() {
+    if (N) return A;
+    N = 1;
+    A = typeof queueMicrotask === "function" ? queueMicrotask : e => Promise.resolve().then(e);
+    return A;
 }
 
-var F = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : N();
+var B = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : F();
 
-const B = x.getDefaultExportFromCjs(F);
+const z = x.getDefaultExportFromCjs(B);
 
-var z = class FixedFIFO {
+var M = class FixedFIFO {
     constructor(e) {
         if (!(e > 0) || (e - 1 & e) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
         this.buffer = new Array(e);
@@ -340,14 +340,14 @@ var z = class FixedFIFO {
     }
 };
 
-const M = x.getDefaultExportFromCjs(z);
+const R = x.getDefaultExportFromCjs(M);
 
-const R = z;
+const W = M;
 
-var W = class FastFIFO {
+var U = class FastFIFO {
     constructor(e) {
         this.hwm = e || 16;
-        this.head = new R(this.hwm);
+        this.head = new W(this.hwm);
         this.tail = this.head;
         this.length = 0;
     }
@@ -360,7 +360,7 @@ var W = class FastFIFO {
         this.length++;
         if (!this.head.push(e)) {
             const t = this.head;
-            this.head = t.next = new R(2 * this.head.buffer.length);
+            this.head = t.next = new W(2 * this.head.buffer.length);
             this.head.push(e);
         }
     }
@@ -385,307 +385,307 @@ var W = class FastFIFO {
     }
 };
 
-const U = x.getDefaultExportFromCjs(W);
+const H = x.getDefaultExportFromCjs(U);
 
-const {EventEmitter: H} = C.default;
+const {EventEmitter: $} = E.default;
 
-const $ = new Error("Stream was destroyed");
+const Z = new Error("Stream was destroyed");
 
-const Z = new Error("Premature close");
+const G = new Error("Premature close");
 
-const G = F;
+const K = B;
 
-const K = W;
+const V = U;
 
-const V = (1 << 28) - 1;
+const J = (1 << 28) - 1;
 
-const J = 1;
+const Y = 1;
 
-const Y = 2;
+const X = 2;
 
-const X = 4;
+const Q = 4;
 
-const Q = 8;
+const ee = 8;
 
-const ee = V ^ J;
+const te = J ^ Y;
 
-const te = V ^ Y;
+const re = J ^ X;
 
-const re = 1 << 4;
+const ie = 1 << 4;
 
-const ie = 2 << 4;
+const ne = 2 << 4;
 
-const ne = 4 << 4;
+const se = 4 << 4;
 
-const se = 8 << 4;
+const ae = 8 << 4;
 
-const ae = 16 << 4;
+const oe = 16 << 4;
 
-const oe = 32 << 4;
+const ue = 32 << 4;
 
-const ue = 64 << 4;
+const le = 64 << 4;
 
-const le = 128 << 4;
+const ce = 128 << 4;
 
-const ce = 256 << 4;
+const he = 256 << 4;
 
-const he = 512 << 4;
+const de = 512 << 4;
 
-const de = 1024 << 4;
+const fe = 1024 << 4;
 
-const fe = 2048 << 4;
+const pe = 2048 << 4;
 
-const pe = 4096 << 4;
+const _e = 4096 << 4;
 
-const _e = 8192 << 4;
+const me = 8192 << 4;
 
-const me = ae | oe;
+const ge = oe | ue;
 
-const ge = re | pe;
+const be = ie | _e;
 
-const be = ne | re;
+const ye = se | ie;
 
-const ye = ce | se;
+const xe = he | ae;
 
-const xe = ae | _e;
+const Se = oe | me;
 
-const Se = V ^ re;
+const we = J ^ ie;
 
-const we = V ^ ne;
+const ke = J ^ se;
 
-const ke = V ^ (ne | pe);
+const qe = J ^ (se | _e);
 
-const qe = V ^ pe;
+const je = J ^ _e;
 
-const je = V ^ ae;
+const ve = J ^ oe;
 
-const ve = V ^ (se | he);
+const De = J ^ (ae | de);
 
-const De = V ^ ue;
+const Pe = J ^ le;
 
-const Pe = V ^ me;
+const Oe = J ^ ge;
 
-const Oe = V ^ fe;
+const Ie = J ^ pe;
 
-const Ie = V ^ ie;
+const Te = J ^ ne;
 
-const Te = V ^ _e;
+const Ce = J ^ me;
 
-const Ce = V ^ xe;
+const Ee = J ^ Se;
 
-const Ee = 1 << 18;
+const Le = 1 << 18;
 
-const Le = 2 << 18;
+const Ae = 2 << 18;
 
-const Ae = 4 << 18;
+const Ne = 4 << 18;
 
-const Ne = 8 << 18;
+const Fe = 8 << 18;
 
-const Fe = 16 << 18;
+const Be = 16 << 18;
 
-const Be = 32 << 18;
+const ze = 32 << 18;
 
-const ze = 64 << 18;
+const Me = 64 << 18;
 
-const Me = 128 << 18;
+const Re = 128 << 18;
 
-const Re = 256 << 18;
+const We = 256 << 18;
 
-const We = 512 << 18;
+const Ue = 512 << 18;
 
-const Ue = V ^ (Ee | Re);
+const He = J ^ (Le | We);
 
-const He = V ^ Ae;
+const $e = J ^ Ne;
 
-const $e = V ^ We;
+const Ze = J ^ Ue;
 
-const Ze = V ^ Fe;
+const Ge = J ^ Be;
 
-const Ge = V ^ Ne;
+const Ke = J ^ Fe;
 
-const Ke = V ^ Me;
+const Ve = J ^ Re;
 
-const Ve = V ^ Le;
+const Je = J ^ Ae;
 
-const Je = re | Ee;
+const Ye = ie | Le;
 
-const Ye = V ^ Je;
+const Xe = J ^ Ye;
 
-const Xe = de | Be;
+const Qe = fe | ze;
 
-const Qe = X | Q | Y;
+const et = Q | ee | X;
 
-const et = Qe | J;
+const tt = et | Y;
 
-const tt = Qe | Xe;
+const rt = et | Qe;
 
-const rt = He & we;
+const it = $e & ke;
 
-const it = Me | fe;
+const nt = Re | pe;
 
-const nt = it & Ye;
+const st = nt & Xe;
 
-const st = et | nt;
+const at = tt | st;
 
-const at = et | ue | de;
+const ot = tt | le | fe;
 
-const ot = et | de | se;
+const ut = tt | fe | ae;
 
-const ut = et | ue | se;
+const lt = tt | le | ae;
 
-const lt = et | ce | se | he;
+const ct = tt | he | ae | de;
 
-const ct = et | re | ue | de | pe | _e;
+const ht = tt | ie | le | fe | _e | me;
 
-const ht = Qe | ue | de;
+const dt = et | le | fe;
 
-const dt = ie | et | fe | ne;
+const ft = ne | tt | pe | se;
 
-const ft = et | We | Be;
+const pt = tt | Ue | ze;
 
-const pt = Ne | Fe;
+const _t = Fe | Be;
 
-const _t = Ne | Ee;
+const mt = Fe | Le;
 
-const mt = Ne | Fe | et | Ee;
+const gt = Fe | Be | tt | Le;
 
-const gt = et | Ee | Ne;
+const bt = tt | Le | Fe;
 
-const bt = Ae | Ee;
+const yt = Ne | Le;
 
-const yt = Ee | Re;
+const xt = Le | We;
 
-const xt = et | We | _t | Be;
+const St = tt | Ue | mt | ze;
 
-const St = Fe | Qe | We | Be;
+const wt = Be | et | Ue | ze;
 
-const wt = Le | et | Me | Ae;
+const kt = Ae | tt | Re | Ne;
 
-const kt = Symbol.asyncIterator || Symbol("asyncIterator");
+const qt = Symbol.asyncIterator || Symbol("asyncIterator");
 
 class WritableState {
     constructor(e, {highWaterMark: t = 16384, map: r = null, mapWritable: i, byteLength: n, byteLengthWritable: s} = {}) {
         this.stream = e;
-        this.queue = new K;
+        this.queue = new V;
         this.highWaterMark = t;
         this.buffered = 0;
         this.error = null;
         this.pipeline = null;
         this.drains = null;
-        this.byteLength = s || n || $t;
+        this.byteLength = s || n || Zt;
         this.map = i || r;
-        this.afterWrite = Dt.bind(this);
-        this.afterUpdateNextTick = It.bind(this);
+        this.afterWrite = Pt.bind(this);
+        this.afterUpdateNextTick = Tt.bind(this);
     }
     get ended() {
-        return (this.stream._duplexState & Be) !== 0;
+        return (this.stream._duplexState & ze) !== 0;
     }
     push(e) {
         if (this.map !== null) e = this.map(e);
         this.buffered += this.byteLength(e);
         this.queue.push(e);
         if (this.buffered < this.highWaterMark) {
-            this.stream._duplexState |= Ne;
+            this.stream._duplexState |= Fe;
             return true;
         }
-        this.stream._duplexState |= pt;
+        this.stream._duplexState |= _t;
         return false;
     }
     shift() {
         const e = this.queue.shift();
         this.buffered -= this.byteLength(e);
-        if (this.buffered === 0) this.stream._duplexState &= Ge;
+        if (this.buffered === 0) this.stream._duplexState &= Ke;
         return e;
     }
     end(e) {
         if (typeof e === "function") this.stream.once("finish", e); else if (e !== undefined && e !== null) this.push(e);
-        this.stream._duplexState = (this.stream._duplexState | We) & He;
+        this.stream._duplexState = (this.stream._duplexState | Ue) & $e;
     }
     autoBatch(e, t) {
         const r = [];
         const i = this.stream;
         r.push(e);
-        while ((i._duplexState & gt) === _t) {
+        while ((i._duplexState & bt) === mt) {
             r.push(i._writableState.shift());
         }
-        if ((i._duplexState & et) !== 0) return t(null);
+        if ((i._duplexState & tt) !== 0) return t(null);
         i._writev(r, t);
     }
     update() {
         const e = this.stream;
-        e._duplexState |= Le;
+        e._duplexState |= Ae;
         do {
-            while ((e._duplexState & gt) === Ne) {
+            while ((e._duplexState & bt) === Fe) {
                 const t = this.shift();
-                e._duplexState |= yt;
+                e._duplexState |= xt;
                 e._write(t, this.afterWrite);
             }
-            if ((e._duplexState & bt) === 0) this.updateNonPrimary();
+            if ((e._duplexState & yt) === 0) this.updateNonPrimary();
         } while (this.continueUpdate() === true);
-        e._duplexState &= Ve;
+        e._duplexState &= Je;
     }
     updateNonPrimary() {
         const e = this.stream;
-        if ((e._duplexState & xt) === We) {
-            e._duplexState = (e._duplexState | Ee) & $e;
-            e._final(jt.bind(this));
+        if ((e._duplexState & St) === Ue) {
+            e._duplexState = (e._duplexState | Le) & Ze;
+            e._final(vt.bind(this));
             return;
         }
-        if ((e._duplexState & Qe) === X) {
-            if ((e._duplexState & it) === 0) {
-                e._duplexState |= Je;
-                e._destroy(vt.bind(this));
+        if ((e._duplexState & et) === Q) {
+            if ((e._duplexState & nt) === 0) {
+                e._duplexState |= Ye;
+                e._destroy(Dt.bind(this));
             }
             return;
         }
-        if ((e._duplexState & st) === J) {
-            e._duplexState = (e._duplexState | Je) & ee;
-            e._open(Ct.bind(this));
+        if ((e._duplexState & at) === Y) {
+            e._duplexState = (e._duplexState | Ye) & te;
+            e._open(Et.bind(this));
         }
     }
     continueUpdate() {
-        if ((this.stream._duplexState & Me) === 0) return false;
-        this.stream._duplexState &= Ke;
+        if ((this.stream._duplexState & Re) === 0) return false;
+        this.stream._duplexState &= Ve;
         return true;
     }
     updateCallback() {
-        if ((this.stream._duplexState & wt) === Ae) this.update(); else this.updateNextTick();
+        if ((this.stream._duplexState & kt) === Ne) this.update(); else this.updateNextTick();
     }
     updateNextTick() {
-        if ((this.stream._duplexState & Me) !== 0) return;
-        this.stream._duplexState |= Me;
-        if ((this.stream._duplexState & Le) === 0) G(this.afterUpdateNextTick);
+        if ((this.stream._duplexState & Re) !== 0) return;
+        this.stream._duplexState |= Re;
+        if ((this.stream._duplexState & Ae) === 0) K(this.afterUpdateNextTick);
     }
 }
 
 class ReadableState {
     constructor(e, {highWaterMark: t = 16384, map: r = null, mapReadable: i, byteLength: n, byteLengthReadable: s} = {}) {
         this.stream = e;
-        this.queue = new K;
+        this.queue = new V;
         this.highWaterMark = t === 0 ? 1 : t;
         this.buffered = 0;
         this.readAhead = t > 0;
         this.error = null;
         this.pipeline = null;
-        this.byteLength = s || n || $t;
+        this.byteLength = s || n || Zt;
         this.map = i || r;
         this.pipeTo = null;
-        this.afterRead = Pt.bind(this);
-        this.afterUpdateNextTick = Ot.bind(this);
+        this.afterRead = Ot.bind(this);
+        this.afterUpdateNextTick = It.bind(this);
     }
     get ended() {
-        return (this.stream._duplexState & de) !== 0;
+        return (this.stream._duplexState & fe) !== 0;
     }
     pipe(e, t) {
         if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
         if (typeof t !== "function") t = null;
-        this.stream._duplexState |= oe;
+        this.stream._duplexState |= ue;
         this.pipeTo = e;
         this.pipeline = new Pipeline(this.stream, e, t);
-        if (t) this.stream.on("error", Zt);
-        if (Rt(e)) {
+        if (t) this.stream.on("error", Gt);
+        if (Wt(e)) {
             e._writableState.pipeline = this.pipeline;
-            if (t) e.on("error", Zt);
+            if (t) e.on("error", Gt);
             e.on("finish", this.pipeline.finished.bind(this.pipeline));
         } else {
             const t = this.pipeline.done.bind(this.pipeline, e);
@@ -694,7 +694,7 @@ class ReadableState {
             e.on("close", r);
             e.on("finish", this.pipeline.finished.bind(this.pipeline));
         }
-        e.on("drain", qt.bind(this));
+        e.on("drain", jt.bind(this));
         this.stream.emit("piping", e);
         e.emit("pipe", this.stream);
     }
@@ -702,19 +702,19 @@ class ReadableState {
         const t = this.stream;
         if (e === null) {
             this.highWaterMark = 0;
-            t._duplexState = (t._duplexState | ue) & ke;
+            t._duplexState = (t._duplexState | le) & qe;
             return false;
         }
         if (this.map !== null) e = this.map(e);
         this.buffered += this.byteLength(e);
         this.queue.push(e);
-        t._duplexState = (t._duplexState | se) & qe;
+        t._duplexState = (t._duplexState | ae) & je;
         return this.buffered < this.highWaterMark;
     }
     shift() {
         const e = this.queue.shift();
         this.buffered -= this.byteLength(e);
-        if (this.buffered === 0) this.stream._duplexState &= ve;
+        if (this.buffered === 0) this.stream._duplexState &= De;
         return e;
     }
     unshift(e) {
@@ -729,83 +729,83 @@ class ReadableState {
     }
     read() {
         const e = this.stream;
-        if ((e._duplexState & ot) === se) {
+        if ((e._duplexState & ut) === ae) {
             const t = this.shift();
-            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= Pe;
-            if ((e._duplexState & le) !== 0) e.emit("data", t);
+            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= Oe;
+            if ((e._duplexState & ce) !== 0) e.emit("data", t);
             return t;
         }
         if (this.readAhead === false) {
-            e._duplexState |= _e;
+            e._duplexState |= me;
             this.updateNextTick();
         }
         return null;
     }
     drain() {
         const e = this.stream;
-        while ((e._duplexState & ot) === se && (e._duplexState & me) !== 0) {
+        while ((e._duplexState & ut) === ae && (e._duplexState & ge) !== 0) {
             const t = this.shift();
-            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= Pe;
-            if ((e._duplexState & le) !== 0) e.emit("data", t);
+            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= Oe;
+            if ((e._duplexState & ce) !== 0) e.emit("data", t);
         }
     }
     update() {
         const e = this.stream;
-        e._duplexState |= ie;
+        e._duplexState |= ne;
         do {
             this.drain();
-            while (this.buffered < this.highWaterMark && (e._duplexState & ct) === _e) {
-                e._duplexState |= ge;
+            while (this.buffered < this.highWaterMark && (e._duplexState & ht) === me) {
+                e._duplexState |= be;
                 e._read(this.afterRead);
                 this.drain();
             }
-            if ((e._duplexState & lt) === ye) {
-                e._duplexState |= he;
+            if ((e._duplexState & ct) === xe) {
+                e._duplexState |= de;
                 e.emit("readable");
             }
-            if ((e._duplexState & be) === 0) this.updateNonPrimary();
+            if ((e._duplexState & ye) === 0) this.updateNonPrimary();
         } while (this.continueUpdate() === true);
-        e._duplexState &= Ie;
+        e._duplexState &= Te;
     }
     updateNonPrimary() {
         const e = this.stream;
-        if ((e._duplexState & ut) === ue) {
-            e._duplexState = (e._duplexState | de) & De;
+        if ((e._duplexState & lt) === le) {
+            e._duplexState = (e._duplexState | fe) & Pe;
             e.emit("end");
-            if ((e._duplexState & tt) === Xe) e._duplexState |= X;
+            if ((e._duplexState & rt) === Qe) e._duplexState |= Q;
             if (this.pipeTo !== null) this.pipeTo.end();
         }
-        if ((e._duplexState & Qe) === X) {
-            if ((e._duplexState & it) === 0) {
-                e._duplexState |= Je;
-                e._destroy(vt.bind(this));
+        if ((e._duplexState & et) === Q) {
+            if ((e._duplexState & nt) === 0) {
+                e._duplexState |= Ye;
+                e._destroy(Dt.bind(this));
             }
             return;
         }
-        if ((e._duplexState & st) === J) {
-            e._duplexState = (e._duplexState | Je) & ee;
-            e._open(Ct.bind(this));
+        if ((e._duplexState & at) === Y) {
+            e._duplexState = (e._duplexState | Ye) & te;
+            e._open(Et.bind(this));
         }
     }
     continueUpdate() {
-        if ((this.stream._duplexState & fe) === 0) return false;
-        this.stream._duplexState &= Oe;
+        if ((this.stream._duplexState & pe) === 0) return false;
+        this.stream._duplexState &= Ie;
         return true;
     }
     updateCallback() {
-        if ((this.stream._duplexState & dt) === ne) this.update(); else this.updateNextTick();
+        if ((this.stream._duplexState & ft) === se) this.update(); else this.updateNextTick();
     }
     updateNextTick() {
-        if ((this.stream._duplexState & fe) !== 0) return;
-        this.stream._duplexState |= fe;
-        if ((this.stream._duplexState & ie) === 0) G(this.afterUpdateNextTick);
+        if ((this.stream._duplexState & pe) !== 0) return;
+        this.stream._duplexState |= pe;
+        if ((this.stream._duplexState & ne) === 0) K(this.afterUpdateNextTick);
     }
 }
 
 class TransformState {
     constructor(e) {
         this.data = null;
-        this.afterTransform = Et.bind(e);
+        this.afterTransform = Lt.bind(e);
         this.afterFinal = null;
     }
 }
@@ -826,7 +826,7 @@ class Pipeline {
         if (e === this.to) {
             this.to = null;
             if (this.from !== null) {
-                if ((this.from._duplexState & de) === 0 || !this.pipeToFinished) {
+                if ((this.from._duplexState & fe) === 0 || !this.pipeToFinished) {
                     this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
                 }
                 return;
@@ -835,7 +835,7 @@ class Pipeline {
         if (e === this.from) {
             this.from = null;
             if (this.to !== null) {
-                if ((e._duplexState & de) === 0) {
+                if ((e._duplexState & fe) === 0) {
                     this.to.destroy(this.error || new Error("Readable stream closed before ending"));
                 }
                 return;
@@ -846,30 +846,30 @@ class Pipeline {
     }
 }
 
-function qt() {
-    this.stream._duplexState |= oe;
+function jt() {
+    this.stream._duplexState |= ue;
     this.updateCallback();
 }
 
-function jt(e) {
+function vt(e) {
     const t = this.stream;
     if (e) t.destroy(e);
-    if ((t._duplexState & Qe) === 0) {
-        t._duplexState |= Be;
+    if ((t._duplexState & et) === 0) {
+        t._duplexState |= ze;
         t.emit("finish");
     }
-    if ((t._duplexState & tt) === Xe) {
-        t._duplexState |= X;
+    if ((t._duplexState & rt) === Qe) {
+        t._duplexState |= Q;
     }
-    t._duplexState &= Ue;
-    if ((t._duplexState & Le) === 0) this.update(); else this.updateNextTick();
+    t._duplexState &= He;
+    if ((t._duplexState & Ae) === 0) this.update(); else this.updateNextTick();
 }
 
-function vt(e) {
+function Dt(e) {
     const t = this.stream;
-    if (!e && this.error !== $) e = this.error;
+    if (!e && this.error !== Z) e = this.error;
     if (e) t.emit("error", e);
-    t._duplexState |= Q;
+    t._duplexState |= ee;
     t.emit("close");
     const r = t._readableState;
     const i = t._writableState;
@@ -880,42 +880,42 @@ function vt(e) {
     }
 }
 
-function Dt(e) {
+function Pt(e) {
     const t = this.stream;
     if (e) t.destroy(e);
-    t._duplexState &= Ue;
-    if (this.drains !== null) Tt(this.drains);
-    if ((t._duplexState & mt) === Fe) {
-        t._duplexState &= Ze;
-        if ((t._duplexState & ze) === ze) {
+    t._duplexState &= He;
+    if (this.drains !== null) Ct(this.drains);
+    if ((t._duplexState & gt) === Be) {
+        t._duplexState &= Ge;
+        if ((t._duplexState & Me) === Me) {
             t.emit("drain");
         }
     }
     this.updateCallback();
 }
 
-function Pt(e) {
+function Ot(e) {
     if (e) this.stream.destroy(e);
-    this.stream._duplexState &= Se;
-    if (this.readAhead === false && (this.stream._duplexState & ae) === 0) this.stream._duplexState &= Te;
+    this.stream._duplexState &= we;
+    if (this.readAhead === false && (this.stream._duplexState & oe) === 0) this.stream._duplexState &= Ce;
     this.updateCallback();
 }
 
-function Ot() {
-    if ((this.stream._duplexState & ie) === 0) {
-        this.stream._duplexState &= Oe;
+function It() {
+    if ((this.stream._duplexState & ne) === 0) {
+        this.stream._duplexState &= Ie;
         this.update();
     }
 }
 
-function It() {
-    if ((this.stream._duplexState & Le) === 0) {
-        this.stream._duplexState &= Ke;
+function Tt() {
+    if ((this.stream._duplexState & Ae) === 0) {
+        this.stream._duplexState &= Ve;
         this.update();
     }
 }
 
-function Tt(e) {
+function Ct(e) {
     for (let t = 0; t < e.length; t++) {
         if (--e[t].writes === 0) {
             e.shift().resolve(true);
@@ -924,15 +924,15 @@ function Tt(e) {
     }
 }
 
-function Ct(e) {
+function Et(e) {
     const t = this.stream;
     if (e) t.destroy(e);
-    if ((t._duplexState & X) === 0) {
-        if ((t._duplexState & at) === 0) t._duplexState |= ne;
-        if ((t._duplexState & ft) === 0) t._duplexState |= Ae;
+    if ((t._duplexState & Q) === 0) {
+        if ((t._duplexState & ot) === 0) t._duplexState |= se;
+        if ((t._duplexState & pt) === 0) t._duplexState |= Ne;
         t.emit("open");
     }
-    t._duplexState &= Ye;
+    t._duplexState &= Xe;
     if (t._writableState !== null) {
         t._writableState.updateCallback();
     }
@@ -941,31 +941,31 @@ function Ct(e) {
     }
 }
 
-function Et(e, t) {
+function Lt(e, t) {
     if (t !== undefined && t !== null) this.push(t);
     this._writableState.afterWrite(e);
 }
 
-function Lt(e) {
+function At(e) {
     if (this._readableState !== null) {
         if (e === "data") {
-            this._duplexState |= le | xe;
+            this._duplexState |= ce | Se;
             this._readableState.updateNextTick();
         }
         if (e === "readable") {
-            this._duplexState |= ce;
+            this._duplexState |= he;
             this._readableState.updateNextTick();
         }
     }
     if (this._writableState !== null) {
         if (e === "drain") {
-            this._duplexState |= ze;
+            this._duplexState |= Me;
             this._writableState.updateNextTick();
         }
     }
 }
 
-class Stream extends H {
+class Stream extends $ {
     constructor(e) {
         super();
         this._duplexState = 0;
@@ -976,10 +976,10 @@ class Stream extends H {
             if (e.destroy) this._destroy = e.destroy;
             if (e.predestroy) this._predestroy = e.predestroy;
             if (e.signal) {
-                e.signal.addEventListener("abort", Gt.bind(this));
+                e.signal.addEventListener("abort", Kt.bind(this));
             }
         }
-        this.on("newListener", Lt);
+        this.on("newListener", At);
     }
     _open(e) {
         e(null);
@@ -995,15 +995,15 @@ class Stream extends H {
         return this._writableState !== null ? true : undefined;
     }
     get destroyed() {
-        return (this._duplexState & Q) !== 0;
+        return (this._duplexState & ee) !== 0;
     }
     get destroying() {
-        return (this._duplexState & Qe) !== 0;
+        return (this._duplexState & et) !== 0;
     }
     destroy(e) {
-        if ((this._duplexState & Qe) === 0) {
-            if (!e) e = $;
-            this._duplexState = (this._duplexState | X) & rt;
+        if ((this._duplexState & et) === 0) {
+            if (!e) e = Z;
+            this._duplexState = (this._duplexState | Q) & it;
             if (this._readableState !== null) {
                 this._readableState.highWaterMark = 0;
                 this._readableState.error = e;
@@ -1012,22 +1012,22 @@ class Stream extends H {
                 this._writableState.highWaterMark = 0;
                 this._writableState.error = e;
             }
-            this._duplexState |= Y;
+            this._duplexState |= X;
             this._predestroy();
-            this._duplexState &= te;
+            this._duplexState &= re;
             if (this._readableState !== null) this._readableState.updateNextTick();
             if (this._writableState !== null) this._writableState.updateNextTick();
         }
     }
 }
 
-let At = class Readable extends Stream {
+let Nt = class Readable extends Stream {
     constructor(e) {
         super(e);
-        this._duplexState |= J | Be | _e;
+        this._duplexState |= Y | ze | me;
         this._readableState = new ReadableState(this, e);
         if (e) {
-            if (this._readableState.readAhead === false) this._duplexState &= Te;
+            if (this._readableState.readAhead === false) this._duplexState &= Ce;
             if (e.read) this._read = e.read;
             if (e.eagerOpen) this._readableState.updateNextTick();
         }
@@ -1053,12 +1053,12 @@ let At = class Readable extends Stream {
         return this._readableState.unshift(e);
     }
     resume() {
-        this._duplexState |= xe;
+        this._duplexState |= Se;
         this._readableState.updateNextTick();
         return this;
     }
     pause() {
-        this._duplexState &= this._readableState.readAhead === false ? Ce : je;
+        this._duplexState &= this._readableState.readAhead === false ? Ee : ve;
         return this;
     }
     static _fromAsyncIterator(e, t) {
@@ -1082,8 +1082,8 @@ let At = class Readable extends Stream {
         }
     }
     static from(e, t) {
-        if (Ut(e)) return e;
-        if (e[kt]) return this._fromAsyncIterator(e[kt](), t);
+        if (Ht(e)) return e;
+        if (e[qt]) return this._fromAsyncIterator(e[qt](), t);
         if (!Array.isArray(e)) e = e === undefined ? [] : [ e ];
         let r = 0;
         return new Readable({
@@ -1095,12 +1095,12 @@ let At = class Readable extends Stream {
         });
     }
     static isBackpressured(e) {
-        return (e._duplexState & ht) !== 0 || e._readableState.buffered >= e._readableState.highWaterMark;
+        return (e._duplexState & dt) !== 0 || e._readableState.buffered >= e._readableState.highWaterMark;
     }
     static isPaused(e) {
-        return (e._duplexState & ae) === 0;
+        return (e._duplexState & oe) === 0;
     }
-    [kt]() {
+    [qt]() {
         const e = this;
         let t = null;
         let r = null;
@@ -1111,7 +1111,7 @@ let At = class Readable extends Stream {
         this.on("readable", n);
         this.on("close", s);
         return {
-            [kt]() {
+            [qt]() {
                 return this;
             },
             next() {
@@ -1119,7 +1119,7 @@ let At = class Readable extends Stream {
                     r = t;
                     i = n;
                     const s = e.read();
-                    if (s !== null) a(s); else if ((e._duplexState & Q) !== 0) a(null);
+                    if (s !== null) a(s); else if ((e._duplexState & ee) !== 0) a(null);
                 }));
             },
             return() {
@@ -1137,7 +1137,7 @@ let At = class Readable extends Stream {
         }
         function a(n) {
             if (i === null) return;
-            if (t) i(t); else if (n === null && (e._duplexState & de) === 0) i($); else r({
+            if (t) i(t); else if (n === null && (e._duplexState & fe) === 0) i(Z); else r({
                 value: n,
                 done: n === null
             });
@@ -1146,7 +1146,7 @@ let At = class Readable extends Stream {
         function o(t) {
             e.destroy(t);
             return new Promise(((r, i) => {
-                if (e._duplexState & Q) return r({
+                if (e._duplexState & ee) return r({
                     value: undefined,
                     done: true
                 });
@@ -1161,10 +1161,10 @@ let At = class Readable extends Stream {
     }
 };
 
-let Nt = class Writable extends Stream {
+let Ft = class Writable extends Stream {
     constructor(e) {
         super(e);
-        this._duplexState |= J | de;
+        this._duplexState |= Y | fe;
         this._writableState = new WritableState(this, e);
         if (e) {
             if (e.writev) this._writev = e.writev;
@@ -1183,13 +1183,13 @@ let Nt = class Writable extends Stream {
         e(null);
     }
     static isBackpressured(e) {
-        return (e._duplexState & St) !== 0;
+        return (e._duplexState & wt) !== 0;
     }
     static drained(e) {
         if (e.destroyed) return Promise.resolve(false);
         const t = e._writableState;
-        const r = Kt(e) ? Math.min(1, t.queue.length) : t.queue.length;
-        const i = r + (e._duplexState & Re ? 1 : 0);
+        const r = Vt(e) ? Math.min(1, t.queue.length) : t.queue.length;
+        const i = r + (e._duplexState & We ? 1 : 0);
         if (i === 0) return Promise.resolve(true);
         if (t.drains === null) t.drains = [];
         return new Promise((e => {
@@ -1210,10 +1210,10 @@ let Nt = class Writable extends Stream {
     }
 };
 
-class Duplex extends At {
+class Duplex extends Nt {
     constructor(e) {
         super(e);
-        this._duplexState = J | this._duplexState & _e;
+        this._duplexState = Y | this._duplexState & me;
         this._writableState = new WritableState(this, e);
         if (e) {
             if (e.writev) this._writev = e.writev;
@@ -1282,13 +1282,13 @@ class Transform extends Duplex {
     }
     _final(e) {
         this._transformState.afterFinal = e;
-        this._flush(Ft.bind(this));
+        this._flush(Bt.bind(this));
     }
 }
 
 class PassThrough extends Transform {}
 
-function Ft(e, t) {
+function Bt(e, t) {
     const r = this._transformState.afterFinal;
     if (e) return r(e);
     if (t !== null && t !== undefined) this.push(t);
@@ -1296,14 +1296,14 @@ function Ft(e, t) {
     r(null);
 }
 
-function Bt(...e) {
-    return new Promise(((t, r) => zt(...e, (e => {
+function zt(...e) {
+    return new Promise(((t, r) => Mt(...e, (e => {
         if (e) return r(e);
         t();
     }))));
 }
 
-function zt(e, ...t) {
+function Mt(e, ...t) {
     const r = Array.isArray(e) ? [ ...e, ...t ] : [ e, ...t ];
     const i = r.length && typeof r[r.length - 1] === "function" ? r.pop() : null;
     if (r.length < 2) throw new Error("Pipeline requires at least 2 streams");
@@ -1312,7 +1312,7 @@ function zt(e, ...t) {
     let a = null;
     for (let e = 1; e < r.length; e++) {
         s = r[e];
-        if (Rt(n)) {
+        if (Wt(n)) {
             n.pipe(s, u);
         } else {
             o(n, true, e > 1, u);
@@ -1322,7 +1322,7 @@ function zt(e, ...t) {
     }
     if (i) {
         let e = false;
-        const t = Rt(s) || !!(s._writableState && s._writableState.autoDestroy);
+        const t = Wt(s) || !!(s._writableState && s._writableState.autoDestroy);
         s.on("error", (e => {
             if (a === null) a = e;
         }));
@@ -1331,7 +1331,7 @@ function zt(e, ...t) {
             if (!t) i(a);
         }));
         if (t) {
-            s.on("close", (() => i(a || (e ? null : Z))));
+            s.on("close", (() => i(a || (e ? null : G))));
         }
     }
     return s;
@@ -1339,8 +1339,8 @@ function zt(e, ...t) {
         e.on("error", i);
         e.on("close", n);
         function n() {
-            if (t && e._readableState && !e._readableState.ended) return i(Z);
-            if (r && e._writableState && !e._writableState.ended) return i(Z);
+            if (t && e._readableState && !e._readableState.ended) return i(G);
+            if (r && e._writableState && !e._writableState.ended) return i(G);
         }
     }
     function u(e) {
@@ -1352,257 +1352,257 @@ function zt(e, ...t) {
     }
 }
 
-function Mt(e) {
-    return !!e._readableState || !!e._writableState;
-}
-
 function Rt(e) {
-    return typeof e._duplexState === "number" && Mt(e);
+    return !!e._readableState || !!e._writableState;
 }
 
 function Wt(e) {
-    const t = e._readableState && e._readableState.error || e._writableState && e._writableState.error;
-    return t === $ ? null : t;
+    return typeof e._duplexState === "number" && Rt(e);
 }
 
 function Ut(e) {
-    return Rt(e) && e.readable;
+    const t = e._readableState && e._readableState.error || e._writableState && e._writableState.error;
+    return t === Z ? null : t;
 }
 
 function Ht(e) {
-    return typeof e === "object" && e !== null && typeof e.byteLength === "number";
+    return Wt(e) && e.readable;
 }
 
 function $t(e) {
-    return Ht(e) ? e.byteLength : 1024;
+    return typeof e === "object" && e !== null && typeof e.byteLength === "number";
 }
 
-function Zt() {}
+function Zt(e) {
+    return $t(e) ? e.byteLength : 1024;
+}
 
-function Gt() {
+function Gt() {}
+
+function Kt() {
     this.destroy(new Error("Stream aborted."));
 }
 
-function Kt(e) {
-    return e._writev !== Nt.prototype._writev && e._writev !== Duplex.prototype._writev;
+function Vt(e) {
+    return e._writev !== Ft.prototype._writev && e._writev !== Duplex.prototype._writev;
 }
 
-var Vt = {
-    pipeline: zt,
-    pipelinePromise: Bt,
-    isStream: Mt,
-    isStreamx: Rt,
-    getStreamError: Wt,
+var Jt = {
+    pipeline: Mt,
+    pipelinePromise: zt,
+    isStream: Rt,
+    isStreamx: Wt,
+    getStreamError: Ut,
     Stream: Stream,
-    Writable: Nt,
-    Readable: At,
+    Writable: Ft,
+    Readable: Nt,
     Duplex: Duplex,
     Transform: Transform,
     PassThrough: PassThrough
 };
 
-const Jt = x.getDefaultExportFromCjs(Vt);
+const Yt = x.getDefaultExportFromCjs(Jt);
 
-function Yt(e) {
+function Xt(e) {
     return Buffer.isBuffer(e) || e instanceof Uint8Array;
 }
 
-function Xt(e) {
+function Qt(e) {
     return Buffer.isEncoding(e);
 }
 
-function Qt(e, t, r) {
+function er(e, t, r) {
     return Buffer.alloc(e, t, r);
 }
 
-function er(e) {
+function tr(e) {
     return Buffer.allocUnsafe(e);
 }
 
-function tr(e) {
+function rr(e) {
     return Buffer.allocUnsafeSlow(e);
 }
 
-function rr(e, t) {
+function ir(e, t) {
     return Buffer.byteLength(e, t);
 }
 
-function ir(e, t) {
+function nr(e, t) {
     return Buffer.compare(e, t);
 }
 
-function nr(e, t) {
+function sr(e, t) {
     return Buffer.concat(e, t);
 }
 
-function sr(e, t, r, i, n) {
-    return _r(e).copy(t, r, i, n);
+function ar(e, t, r, i, n) {
+    return mr(e).copy(t, r, i, n);
 }
 
-function ar(e, t) {
-    return _r(e).equals(t);
+function or(e, t) {
+    return mr(e).equals(t);
 }
 
-function or(e, t, r, i, n) {
-    return _r(e).fill(t, r, i, n);
+function ur(e, t, r, i, n) {
+    return mr(e).fill(t, r, i, n);
 }
 
-function ur(e, t, r) {
+function lr(e, t, r) {
     return Buffer.from(e, t, r);
 }
 
-function lr(e, t, r, i) {
-    return _r(e).includes(t, r, i);
-}
-
 function cr(e, t, r, i) {
-    return _r(e).indexOf(t, r, i);
+    return mr(e).includes(t, r, i);
 }
 
 function hr(e, t, r, i) {
-    return _r(e).lastIndexOf(t, r, i);
+    return mr(e).indexOf(t, r, i);
 }
 
-function dr(e) {
-    return _r(e).swap16();
+function dr(e, t, r, i) {
+    return mr(e).lastIndexOf(t, r, i);
 }
 
 function fr(e) {
-    return _r(e).swap32();
+    return mr(e).swap16();
 }
 
 function pr(e) {
-    return _r(e).swap64();
+    return mr(e).swap32();
 }
 
 function _r(e) {
-    if (Buffer.isBuffer(e)) return e;
-    return Buffer.from(e.buffer, e.byteOffset, e.byteLength);
+    return mr(e).swap64();
 }
 
-function mr(e, t, r, i) {
-    return _r(e).toString(t, r, i);
+function mr(e) {
+    if (Buffer.isBuffer(e)) return e;
+    return Buffer.from(e.buffer, e.byteOffset, e.byteLength);
 }
 
-function gr(e, t, r, i, n) {
-    return _r(e).write(t, r, i, n);
+function gr(e, t, r, i) {
+    return mr(e).toString(t, r, i);
 }
 
-function br(e, t, r) {
-    return _r(e).writeDoubleLE(t, r);
+function br(e, t, r, i, n) {
+    return mr(e).write(t, r, i, n);
 }
 
 function yr(e, t, r) {
-    return _r(e).writeFloatLE(t, r);
+    return mr(e).writeDoubleLE(t, r);
 }
 
 function xr(e, t, r) {
-    return _r(e).writeUInt32LE(t, r);
+    return mr(e).writeFloatLE(t, r);
 }
 
 function Sr(e, t, r) {
-    return _r(e).writeInt32LE(t, r);
+    return mr(e).writeUInt32LE(t, r);
 }
 
-function wr(e, t) {
-    return _r(e).readDoubleLE(t);
+function wr(e, t, r) {
+    return mr(e).writeInt32LE(t, r);
 }
 
 function kr(e, t) {
-    return _r(e).readFloatLE(t);
+    return mr(e).readDoubleLE(t);
 }
 
 function qr(e, t) {
-    return _r(e).readUInt32LE(t);
+    return mr(e).readFloatLE(t);
 }
 
 function jr(e, t) {
-    return _r(e).readInt32LE(t);
-}
-
-var vr = {
-    isBuffer: Yt,
-    isEncoding: Xt,
-    alloc: Qt,
-    allocUnsafe: er,
-    allocUnsafeSlow: tr,
-    byteLength: rr,
-    compare: ir,
-    concat: nr,
-    copy: sr,
-    equals: ar,
-    fill: or,
-    from: ur,
-    includes: lr,
-    indexOf: cr,
-    lastIndexOf: hr,
-    swap16: dr,
-    swap32: fr,
-    swap64: pr,
-    toBuffer: _r,
-    toString: mr,
-    write: gr,
-    writeDoubleLE: br,
-    writeFloatLE: yr,
-    writeUInt32LE: xr,
-    writeInt32LE: Sr,
-    readDoubleLE: wr,
-    readFloatLE: kr,
-    readUInt32LE: qr,
-    readInt32LE: jr
+    return mr(e).readUInt32LE(t);
+}
+
+function vr(e, t) {
+    return mr(e).readInt32LE(t);
+}
+
+var Dr = {
+    isBuffer: Xt,
+    isEncoding: Qt,
+    alloc: er,
+    allocUnsafe: tr,
+    allocUnsafeSlow: rr,
+    byteLength: ir,
+    compare: nr,
+    concat: sr,
+    copy: ar,
+    equals: or,
+    fill: ur,
+    from: lr,
+    includes: cr,
+    indexOf: hr,
+    lastIndexOf: dr,
+    swap16: fr,
+    swap32: pr,
+    swap64: _r,
+    toBuffer: mr,
+    toString: gr,
+    write: br,
+    writeDoubleLE: yr,
+    writeFloatLE: xr,
+    writeUInt32LE: Sr,
+    writeInt32LE: wr,
+    readDoubleLE: kr,
+    readFloatLE: qr,
+    readUInt32LE: jr,
+    readInt32LE: vr
 };
 
-const Dr = x.getDefaultExportFromCjs(vr);
+const Pr = x.getDefaultExportFromCjs(Dr);
 
-var Pr = {};
+var Or = {};
 
-const Or = vr;
+const Ir = Dr;
 
-const Ir = "0000000000000000000";
+const Tr = "0000000000000000000";
 
-const Tr = "7777777777777777777";
+const Cr = "7777777777777777777";
 
-const Cr = "0".charCodeAt(0);
+const Er = "0".charCodeAt(0);
 
-const Er = Or.from([ 117, 115, 116, 97, 114, 0 ]);
+const Lr = Ir.from([ 117, 115, 116, 97, 114, 0 ]);
 
-const Lr = Or.from([ Cr, Cr ]);
+const Ar = Ir.from([ Er, Er ]);
 
-const Ar = Or.from([ 117, 115, 116, 97, 114, 32 ]);
+const Nr = Ir.from([ 117, 115, 116, 97, 114, 32 ]);
 
-const Nr = Or.from([ 32, 0 ]);
+const Fr = Ir.from([ 32, 0 ]);
 
-const Fr = 4095;
+const Br = 4095;
 
-const Br = 257;
+const zr = 257;
 
-const zr = 263;
+const Mr = 263;
 
-var Mr = Pr.decodeLongPath = function e(t, r) {
-    return ii(t, 0, t.length, r);
+var Rr = Or.decodeLongPath = function e(t, r) {
+    return ni(t, 0, t.length, r);
 };
 
-var Rr = Pr.encodePax = function e(t) {
+var Wr = Or.encodePax = function e(t) {
     let r = "";
-    if (t.name) r += ni(" path=" + t.name + "\n");
-    if (t.linkname) r += ni(" linkpath=" + t.linkname + "\n");
+    if (t.name) r += si(" path=" + t.name + "\n");
+    if (t.linkname) r += si(" linkpath=" + t.linkname + "\n");
     const i = t.pax;
     if (i) {
         for (const e in i) {
-            r += ni(" " + e + "=" + i[e] + "\n");
+            r += si(" " + e + "=" + i[e] + "\n");
         }
     }
-    return Or.from(r);
+    return Ir.from(r);
 };
 
-var Wr = Pr.decodePax = function e(t) {
+var Ur = Or.decodePax = function e(t) {
     const r = {};
     while (t.length) {
         let e = 0;
         while (e < t.length && t[e] !== 32) e++;
-        const i = parseInt(Or.toString(t.subarray(0, e)), 10);
+        const i = parseInt(Ir.toString(t.subarray(0, e)), 10);
         if (!i) return r;
-        const n = Or.toString(t.subarray(e + 1, i - 1));
+        const n = Ir.toString(t.subarray(e + 1, i - 1));
         const s = n.indexOf("=");
         if (s === -1) return r;
         r[n.slice(0, s)] = n.slice(s + 1);
@@ -1611,59 +1611,59 @@ var Wr = Pr.decodePax = function e(t) {
     return r;
 };
 
-var Ur = Pr.encode = function e(t) {
-    const r = Or.alloc(512);
+var Hr = Or.encode = function e(t) {
+    const r = Ir.alloc(512);
     let i = t.name;
     let n = "";
     if (t.typeflag === 5 && i[i.length - 1] !== "/") i += "/";
-    if (Or.byteLength(i) !== i.length) return null;
-    while (Or.byteLength(i) > 100) {
+    if (Ir.byteLength(i) !== i.length) return null;
+    while (Ir.byteLength(i) > 100) {
         const e = i.indexOf("/");
         if (e === -1) return null;
         n += n ? "/" + i.slice(0, e) : i.slice(0, e);
         i = i.slice(e + 1);
     }
-    if (Or.byteLength(i) > 100 || Or.byteLength(n) > 155) return null;
-    if (t.linkname && Or.byteLength(t.linkname) > 100) return null;
-    Or.write(r, i);
-    Or.write(r, Xr(t.mode & Fr, 6), 100);
-    Or.write(r, Xr(t.uid, 6), 108);
-    Or.write(r, Xr(t.gid, 6), 116);
-    ei(t.size, r, 124);
-    Or.write(r, Xr(t.mtime.getTime() / 1e3 | 0, 11), 136);
-    r[156] = Cr + Vr(t.type);
-    if (t.linkname) Or.write(r, t.linkname, 157);
-    Or.copy(Er, r, Br);
-    Or.copy(Lr, r, zr);
-    if (t.uname) Or.write(r, t.uname, 265);
-    if (t.gname) Or.write(r, t.gname, 297);
-    Or.write(r, Xr(t.devmajor || 0, 6), 329);
-    Or.write(r, Xr(t.devminor || 0, 6), 337);
-    if (n) Or.write(r, n, 345);
-    Or.write(r, Xr(Yr(r), 6), 148);
+    if (Ir.byteLength(i) > 100 || Ir.byteLength(n) > 155) return null;
+    if (t.linkname && Ir.byteLength(t.linkname) > 100) return null;
+    Ir.write(r, i);
+    Ir.write(r, Qr(t.mode & Br, 6), 100);
+    Ir.write(r, Qr(t.uid, 6), 108);
+    Ir.write(r, Qr(t.gid, 6), 116);
+    ti(t.size, r, 124);
+    Ir.write(r, Qr(t.mtime.getTime() / 1e3 | 0, 11), 136);
+    r[156] = Er + Jr(t.type);
+    if (t.linkname) Ir.write(r, t.linkname, 157);
+    Ir.copy(Lr, r, zr);
+    Ir.copy(Ar, r, Mr);
+    if (t.uname) Ir.write(r, t.uname, 265);
+    if (t.gname) Ir.write(r, t.gname, 297);
+    Ir.write(r, Qr(t.devmajor || 0, 6), 329);
+    Ir.write(r, Qr(t.devminor || 0, 6), 337);
+    if (n) Ir.write(r, n, 345);
+    Ir.write(r, Qr(Xr(r), 6), 148);
     return r;
 };
 
-var Hr = Pr.decode = function e(t, r, i) {
-    let n = t[156] === 0 ? 0 : t[156] - Cr;
-    let s = ii(t, 0, 100, r);
-    const a = ri(t, 100, 8);
-    const o = ri(t, 108, 8);
-    const u = ri(t, 116, 8);
-    const l = ri(t, 124, 12);
-    const c = ri(t, 136, 12);
-    const h = Kr(n);
-    const d = t[157] === 0 ? null : ii(t, 157, 100, r);
-    const f = ii(t, 265, 32);
-    const p = ii(t, 297, 32);
-    const _ = ri(t, 329, 8);
-    const m = ri(t, 337, 8);
-    const g = Yr(t);
+var $r = Or.decode = function e(t, r, i) {
+    let n = t[156] === 0 ? 0 : t[156] - Er;
+    let s = ni(t, 0, 100, r);
+    const a = ii(t, 100, 8);
+    const o = ii(t, 108, 8);
+    const u = ii(t, 116, 8);
+    const l = ii(t, 124, 12);
+    const c = ii(t, 136, 12);
+    const h = Vr(n);
+    const d = t[157] === 0 ? null : ni(t, 157, 100, r);
+    const f = ni(t, 265, 32);
+    const p = ni(t, 297, 32);
+    const _ = ii(t, 329, 8);
+    const m = ii(t, 337, 8);
+    const g = Xr(t);
     if (g === 8 * 32) return null;
-    if (g !== ri(t, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
-    if ($r(t)) {
-        if (t[345]) s = ii(t, 345, 155, r) + "/" + s;
-    } else if (Zr(t)) {} else {
+    if (g !== ii(t, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
+    if (Zr(t)) {
+        if (t[345]) s = ni(t, 345, 155, r) + "/" + s;
+    } else if (Gr(t)) {} else {
         if (!i) {
             throw new Error("Invalid tar header: unknown format.");
         }
@@ -1686,15 +1686,15 @@ var Hr = Pr.decode = function e(t, r, i) {
     };
 };
 
-function $r(e) {
-    return Or.equals(Er, e.subarray(Br, Br + 6));
+function Zr(e) {
+    return Ir.equals(Lr, e.subarray(zr, zr + 6));
 }
 
-function Zr(e) {
-    return Or.equals(Ar, e.subarray(Br, Br + 6)) && Or.equals(Nr, e.subarray(zr, zr + 2));
+function Gr(e) {
+    return Ir.equals(Nr, e.subarray(zr, zr + 6)) && Ir.equals(Fr, e.subarray(Mr, Mr + 2));
 }
 
-function Gr(e, t, r) {
+function Kr(e, t, r) {
     if (typeof e !== "number") return r;
     e = ~~e;
     if (e >= t) return t;
@@ -1704,7 +1704,7 @@ function Gr(e, t, r) {
     return 0;
 }
 
-function Kr(e) {
+function Vr(e) {
     switch (e) {
       case 0:
         return "file";
@@ -1746,7 +1746,7 @@ function Kr(e) {
     return null;
 }
 
-function Vr(e) {
+function Jr(e) {
     switch (e) {
       case "file":
         return 0;
@@ -1778,27 +1778,27 @@ function Vr(e) {
     return 0;
 }
 
-function Jr(e, t, r, i) {
+function Yr(e, t, r, i) {
     for (;r < i; r++) {
         if (e[r] === t) return r;
     }
     return i;
 }
 
-function Yr(e) {
+function Xr(e) {
     let t = 8 * 32;
     for (let r = 0; r < 148; r++) t += e[r];
     for (let r = 156; r < 512; r++) t += e[r];
     return t;
 }
 
-function Xr(e, t) {
+function Qr(e, t) {
     e = e.toString(8);
-    if (e.length > t) return Tr.slice(0, t) + " ";
-    return Ir.slice(0, t - e.length) + e + " ";
+    if (e.length > t) return Cr.slice(0, t) + " ";
+    return Tr.slice(0, t - e.length) + e + " ";
 }
 
-function Qr(e, t, r) {
+function ei(e, t, r) {
     t[r] = 128;
     for (let i = 11; i > 0; i--) {
         t[r + i] = e & 255;
@@ -1806,15 +1806,15 @@ function Qr(e, t, r) {
     }
 }
 
-function ei(e, t, r) {
+function ti(e, t, r) {
     if (e.toString(8).length > 11) {
-        Qr(e, t, r);
+        ei(e, t, r);
     } else {
-        Or.write(t, Xr(e, 11), r);
+        Ir.write(t, Qr(e, 11), r);
     }
 }
 
-function ti(e) {
+function ri(e) {
     let t;
     if (e[0] === 128) t = true; else if (e[0] === 255) t = false; else return null;
     const r = [];
@@ -1831,46 +1831,46 @@ function ti(e) {
     return t ? n : -1 * n;
 }
 
-function ri(e, t, r) {
+function ii(e, t, r) {
     e = e.subarray(t, t + r);
     t = 0;
     if (e[t] & 128) {
-        return ti(e);
+        return ri(e);
     } else {
         while (t < e.length && e[t] === 32) t++;
-        const r = Gr(Jr(e, 32, t, e.length), e.length, e.length);
+        const r = Kr(Yr(e, 32, t, e.length), e.length, e.length);
         while (t < r && e[t] === 0) t++;
         if (r === t) return 0;
-        return parseInt(Or.toString(e.subarray(t, r)), 8);
+        return parseInt(Ir.toString(e.subarray(t, r)), 8);
     }
 }
 
-function ii(e, t, r, i) {
-    return Or.toString(e.subarray(t, Jr(e, 0, t, t + r)), i);
+function ni(e, t, r, i) {
+    return Ir.toString(e.subarray(t, Yr(e, 0, t, t + r)), i);
 }
 
-function ni(e) {
-    const t = Or.byteLength(e);
+function si(e) {
+    const t = Ir.byteLength(e);
     let r = Math.floor(Math.log(t) / Math.log(10)) + 1;
     if (t + r >= Math.pow(10, r)) r++;
     return t + r + e;
 }
 
-const {Writable: si, Readable: ai, getStreamError: oi} = Vt;
+const {Writable: ai, Readable: oi, getStreamError: ui} = Jt;
 
-const ui = W;
+const li = U;
 
-const li = vr;
+const ci = Dr;
 
-const ci = Pr;
+const hi = Or;
 
-const hi = li.alloc(0);
+const di = ci.alloc(0);
 
 class BufferList {
     constructor() {
         this.buffered = 0;
         this.shifted = 0;
-        this.queue = new ui;
+        this.queue = new li;
         this._offset = 0;
     }
     push(e) {
@@ -1882,7 +1882,7 @@ class BufferList {
     }
     shift(e) {
         if (e > this.buffered) return null;
-        if (e === 0) return hi;
+        if (e === 0) return di;
         let t = this._next(e);
         if (e === t.byteLength) return t;
         const r = [ t ];
@@ -1890,7 +1890,7 @@ class BufferList {
             t = this._next(e);
             r.push(t);
         }
-        return li.concat(r);
+        return ci.concat(r);
     }
     _next(e) {
         const t = this.queue.peek();
@@ -1909,7 +1909,7 @@ class BufferList {
     }
 }
 
-class Source extends ai {
+class Source extends oi {
     constructor(e, t, r) {
         super();
         this.header = t;
@@ -1926,12 +1926,12 @@ class Source extends ai {
         e(null);
     }
     _predestroy() {
-        this._parent.destroy(oi(this));
+        this._parent.destroy(ui(this));
     }
     _detach() {
         if (this._parent._stream === this) {
             this._parent._stream = null;
-            this._parent._missing = pi(this.header.size);
+            this._parent._missing = _i(this.header.size);
             this._parent._update();
         }
     }
@@ -1941,7 +1941,7 @@ class Source extends ai {
     }
 }
 
-class Extract extends si {
+class Extract extends ai {
     constructor(e) {
         super(e);
         if (!e) e = {};
@@ -1951,7 +1951,7 @@ class Extract extends si {
         this._stream = null;
         this._missing = 0;
         this._longHeader = false;
-        this._callback = fi;
+        this._callback = pi;
         this._locked = false;
         this._finished = false;
         this._pax = null;
@@ -1975,7 +1975,7 @@ class Extract extends si {
         if (this._locked) return false;
         this._offset = this._buffer.shifted;
         try {
-            this._header = ci.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
+            this._header = hi.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
         } catch (e) {
             this._continueWrite(e);
             return false;
@@ -2021,25 +2021,25 @@ class Extract extends si {
     _decodeLongHeader(e) {
         switch (this._header.type) {
           case "gnu-long-path":
-            this._gnuLongPath = ci.decodeLongPath(e, this._filenameEncoding);
+            this._gnuLongPath = hi.decodeLongPath(e, this._filenameEncoding);
             break;
 
           case "gnu-long-link-path":
-            this._gnuLongLinkPath = ci.decodeLongPath(e, this._filenameEncoding);
+            this._gnuLongLinkPath = hi.decodeLongPath(e, this._filenameEncoding);
             break;
 
           case "pax-global-header":
-            this._paxGlobal = ci.decodePax(e);
+            this._paxGlobal = hi.decodePax(e);
             break;
 
           case "pax-header":
-            this._pax = this._paxGlobal === null ? ci.decodePax(e) : Object.assign({}, this._paxGlobal, ci.decodePax(e));
+            this._pax = this._paxGlobal === null ? hi.decodePax(e) : Object.assign({}, this._paxGlobal, hi.decodePax(e));
             break;
         }
     }
     _consumeLongHeader() {
         this._longHeader = false;
-        this._missing = pi(this._header.size);
+        this._missing = _i(this._header.size);
         const e = this._buffer.shift(this._header.size);
         try {
             this._decodeLongHeader(e);
@@ -2087,7 +2087,7 @@ class Extract extends si {
     }
     _continueWrite(e) {
         const t = this._callback;
-        this._callback = fi;
+        this._callback = pi;
         t(e);
     }
     _write(e, t) {
@@ -2103,7 +2103,7 @@ class Extract extends si {
         this._continueWrite(null);
     }
     _destroy(e) {
-        if (this._stream) this._stream.destroy(oi(this));
+        if (this._stream) this._stream.destroy(ui(this));
         e(null);
     }
     [Symbol.asyncIterator]() {
@@ -2163,7 +2163,7 @@ class Extract extends si {
         }
         function u(e, s, a) {
             n = a;
-            s.on("error", fi);
+            s.on("error", pi);
             if (t) {
                 t({
                     value: s,
@@ -2202,26 +2202,26 @@ class Extract extends si {
     }
 }
 
-var di = function e(t) {
+var fi = function e(t) {
     return new Extract(t);
 };
 
-function fi() {}
+function pi() {}
 
-function pi(e) {
+function _i(e) {
     e &= 511;
     return e && 512 - e;
 }
 
-const _i = x.getDefaultExportFromCjs(di);
+const mi = x.getDefaultExportFromCjs(fi);
 
-var mi = {
+var gi = {
     exports: {}
 };
 
-var gi = mi.exports;
+var bi = gi.exports;
 
-const bi = {
+const yi = {
     S_IFMT: 61440,
     S_IFDIR: 16384,
     S_IFCHR: 8192,
@@ -2231,33 +2231,33 @@ const bi = {
 };
 
 try {
-    mi.exports = require("fs").constants || bi;
+    gi.exports = require("fs").constants || yi;
 } catch {
-    mi.exports = bi;
+    gi.exports = yi;
 }
 
-var yi = mi.exports;
+var xi = gi.exports;
 
-const xi = x.getDefaultExportFromCjs(yi);
+const Si = x.getDefaultExportFromCjs(xi);
 
-const {Readable: Si, Writable: wi, getStreamError: ki} = Vt;
+const {Readable: wi, Writable: ki, getStreamError: qi} = Jt;
 
-const qi = vr;
+const ji = Dr;
 
-const ji = yi;
+const vi = xi;
 
-const vi = Pr;
+const Di = Or;
 
-const Di = 493;
+const Pi = 493;
 
-const Pi = 420;
+const Oi = 420;
 
-const Oi = qi.alloc(1024);
+const Ii = ji.alloc(1024);
 
-class Sink extends wi {
+class Sink extends ki {
     constructor(e, t, r) {
         super({
-            mapWritable: Li,
+            mapWritable: Ai,
             eagerOpen: true
         });
         this.written = 0;
@@ -2300,7 +2300,7 @@ class Sink extends wi {
     }
     _write(e, t) {
         if (this._isLinkname) {
-            this._linkname = this._linkname ? qi.concat([ this._linkname, e ]) : e;
+            this._linkname = this._linkname ? ji.concat([ this._linkname, e ]) : e;
             return t(null);
         }
         if (this._isVoid) {
@@ -2317,10 +2317,10 @@ class Sink extends wi {
         if (this._finished) return;
         this._finished = true;
         if (this._isLinkname) {
-            this.header.linkname = this._linkname ? qi.toString(this._linkname, "utf-8") : "";
+            this.header.linkname = this._linkname ? ji.toString(this._linkname, "utf-8") : "";
             this._pack._encode(this.header);
         }
-        Ei(this._pack, this.header.size);
+        Li(this._pack, this.header.size);
         this._pack._done(this);
     }
     _final(e) {
@@ -2331,7 +2331,7 @@ class Sink extends wi {
         e(null);
     }
     _getError() {
-        return ki(this) || new Error("tar entry destroyed");
+        return qi(this) || new Error("tar entry destroyed");
     }
     _predestroy() {
         this._pack.destroy(this._getError());
@@ -2343,10 +2343,10 @@ class Sink extends wi {
     }
 }
 
-class Pack extends Si {
+class Pack extends wi {
     constructor(e) {
         super(e);
-        this._drain = Ci;
+        this._drain = Ei;
         this._finalized = false;
         this._finalizing = false;
         this._pending = [];
@@ -2358,16 +2358,16 @@ class Pack extends Si {
             r = t;
             t = null;
         }
-        if (!r) r = Ci;
+        if (!r) r = Ei;
         if (!e.size || e.type === "symlink") e.size = 0;
-        if (!e.type) e.type = Ti(e.mode);
-        if (!e.mode) e.mode = e.type === "directory" ? Di : Pi;
+        if (!e.type) e.type = Ci(e.mode);
+        if (!e.mode) e.mode = e.type === "directory" ? Pi : Oi;
         if (!e.uid) e.uid = 0;
         if (!e.gid) e.gid = 0;
         if (!e.mtime) e.mtime = new Date;
-        if (typeof t === "string") t = qi.from(t);
+        if (typeof t === "string") t = ji.from(t);
         const i = new Sink(this, e, r);
-        if (qi.isBuffer(t)) {
+        if (ji.isBuffer(t)) {
             e.size = t.byteLength;
             i.write(t);
             i.end();
@@ -2385,7 +2385,7 @@ class Pack extends Si {
         }
         if (this._finalized) return;
         this._finalized = true;
-        this.push(Oi);
+        this.push(Ii);
         this.push(null);
     }
     _done(e) {
@@ -2396,7 +2396,7 @@ class Pack extends Si {
     }
     _encode(e) {
         if (!e.pax) {
-            const t = vi.encode(e);
+            const t = Di.encode(e);
             if (t) {
                 this.push(t);
                 return;
@@ -2405,7 +2405,7 @@ class Pack extends Si {
         this._encodePax(e);
     }
     _encodePax(e) {
-        const t = vi.encodePax({
+        const t = Di.encodePax({
             name: e.name,
             linkname: e.linkname,
             pax: e.pax
@@ -2424,20 +2424,20 @@ class Pack extends Si {
             devmajor: e.devmajor,
             devminor: e.devminor
         };
-        this.push(vi.encode(r));
+        this.push(Di.encode(r));
         this.push(t);
-        Ei(this, t.byteLength);
+        Li(this, t.byteLength);
         r.size = e.size;
         r.type = e.type;
-        this.push(vi.encode(r));
+        this.push(Di.encode(r));
     }
     _doDrain() {
         const e = this._drain;
-        this._drain = Ci;
+        this._drain = Ei;
         e();
     }
     _predestroy() {
-        const e = ki(this);
+        const e = qi(this);
         if (this._stream) this._stream.destroy(e);
         while (this._pending.length) {
             const t = this._pending.shift();
@@ -2452,52 +2452,52 @@ class Pack extends Si {
     }
 }
 
-var Ii = function e(t) {
+var Ti = function e(t) {
     return new Pack(t);
 };
 
-function Ti(e) {
-    switch (e & ji.S_IFMT) {
-      case ji.S_IFBLK:
+function Ci(e) {
+    switch (e & vi.S_IFMT) {
+      case vi.S_IFBLK:
         return "block-device";
 
-      case ji.S_IFCHR:
+      case vi.S_IFCHR:
         return "character-device";
 
-      case ji.S_IFDIR:
+      case vi.S_IFDIR:
         return "directory";
 
-      case ji.S_IFIFO:
+      case vi.S_IFIFO:
         return "fifo";
 
-      case ji.S_IFLNK:
+      case vi.S_IFLNK:
         return "symlink";
     }
     return "file";
 }
 
-function Ci() {}
+function Ei() {}
 
-function Ei(e, t) {
+function Li(e, t) {
     t &= 511;
-    if (t) e.push(Oi.subarray(0, 512 - t));
+    if (t) e.push(Ii.subarray(0, 512 - t));
 }
 
-function Li(e) {
-    return qi.isBuffer(e) ? e : qi.from(e);
+function Ai(e) {
+    return ji.isBuffer(e) ? e : ji.from(e);
 }
 
-const Ai = x.getDefaultExportFromCjs(Ii);
+const Ni = x.getDefaultExportFromCjs(Ti);
 
-var Ni = E.extract = di;
+var Fi = L.extract = fi;
 
-var Fi = E.pack = Ii;
+var Bi = L.pack = Ti;
 
-var Bi = {
+var zi = {
     exports: {}
 };
 
-var zi = Bi.exports;
+var Mi = zi.exports;
 
 (function(e, t) {
     (function(r) {
@@ -2537,28 +2537,28 @@ var zi = Bi.exports;
             r.isBase64 = i;
         }
     })(x.commonjsGlobal);
-})(Bi, Bi.exports);
+})(zi, zi.exports);
 
-var Mi = Bi.exports;
+var Ri = zi.exports;
 
-const Ri = x.getDefaultExportFromCjs(Mi);
+const Wi = x.getDefaultExportFromCjs(Ri);
 
-function Wi({onlyFirst: e = false} = {}) {
+function Ui({onlyFirst: e = false} = {}) {
     const t = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
     const r = [ `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${t})`, "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))" ].join("|");
     return new RegExp(r, e ? undefined : "g");
 }
 
-const Ui = Wi();
+const Hi = Ui();
 
-function Hi(e) {
+function $i(e) {
     if (typeof e !== "string") {
         throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);
     }
-    return e.replace(Ui, "");
+    return e.replace(Hi, "");
 }
 
-function $i(e) {
+function Zi(e) {
     if (typeof e !== "string") {
         throw new TypeError(`Expected a string, got ${typeof e}`);
     }
@@ -2708,31 +2708,38 @@ exports.Docker = class Docker extends t.Component {
                 f.createInterface({
                     input: i
                 }).on("line", (t => {
-                    const r = JSON.parse(t);
-                    if (r.error) s = new g.DockerImageBuildException(r.error);
-                    if (typeof r.aux !== "string") {
-                        if (r.aux) n = r.aux.ID;
-                    } else if (Ri(r.aux) && !r.stream) {
-                        r.stream = Buffer.from(r.aux, "base64").toString();
-                    }
-                    if (r.stream) {
-                        a = `${a}${r.stream}`;
-                    } else if (Ri(r.aux)) {
-                        a = `${a}${Buffer.from(r.aux, "base64").toString("ascii")}`;
+                    try {
+                        const r = JSON.parse(t);
+                        if (r.error) s = new g.DockerImageBuildException(r.error);
+                        if (typeof r.aux !== "string") {
+                            if (r.aux) n = r.aux.ID;
+                        } else if (Wi(r.aux) && !r.stream) {
+                            r.stream = Buffer.from(r.aux, "base64").toString();
+                        }
+                        if (r.stream) {
+                            a = `${a}${r.stream}`;
+                        } else if (Wi(r.aux)) {
+                            a = `${a}${Buffer.from(r.aux, "base64").toString("ascii")}`;
+                        }
+                        const i = Zi($i(a));
+                        i.replace(/[\f\n\r\t\v]/g, "\n").split("\n").forEach((t => {
+                            const i = Buffer.from(t).toString("ascii");
+                            if (i.startsWith(Buffer.from([ 8, 239 ]).toString("ascii"))) return;
+                            let n = t.replace(/[^\u4e00-\u9fa5^a-z^A-Z^0-9^\[^\]^\/^:^\s+^\-^\\^&^\.^@^|^"^*^_\\n]/g, "").trim();
+                            if (!n || n.length < 2) return;
+                            if (n.startsWith("Gsha256")) n = n.substring(72);
+                            if (n.startsWith("r")) n = n.substring(1);
+                            if (n.startsWith("Uwriting")) n = n.substring(1);
+                            if (n.startsWith("Gsha256")) n = n.substring(72);
+                            if (n.substring(1, 2) === "[") n = n.substring(1);
+                            if (/[A-Z]/.test(n.substring(1, 2)) && !/[A-Z]/.test(n.substring(0, 1))) n = n.substring(1);
+                            r.stream = n;
+                            if (e.outputCallback) e.outputCallback(r);
+                        }));
+                        a = "";
+                    } catch (e) {
+                        T.DevNull(e);
                     }
-                    const i = $i(Hi(a));
-                    i.replace(/[\f\n\r\t\v]/g, "\n").split("\n").forEach((t => {
-                        const i = Buffer.from(t).toString("ascii");
-                        if (i.startsWith(Buffer.from([ 8, 239 ]).toString("ascii"))) return;
-                        let n = t.replace(/[^\u4e00-\u9fa5^a-z^A-Z^0-9^\[^\]^\/^:^\s+^\\n]/g, "").trim();
-                        if (!n || n.length < 2) return;
-                        if (n.startsWith("Gsha256")) n = n.substring(72);
-                        if (n.startsWith("r")) n = n.substring(1);
-                        if (n.startsWith("Uwriting")) n = n.substring(1);
-                        if (n.startsWith("Gsha256")) n = n.substring(72);
-                        r.stream = n;
-                        if (e.outputCallback) e.outputCallback(r);
-                    }));
                 })).once("close", (() => {
                     if (s) return r(s);
                     if (!n) return r(new g.DockerImageBuildException("Build image failed"));
@@ -2750,7 +2757,7 @@ exports.Docker = class Docker extends t.Component {
         const i = new k.PassThrough;
         t.pipe(r);
         t.pipe(i);
-        const n = Ni();
+        const n = Fi();
         let s;
         n.on("entry", ((e, t, r) => {
             if (e.name === "manifest.json") {