@drmhse/authos-vue 0.2.4 → 0.2.5

package/dist/tar-A5SPYDDD.mjs

@@ -0,0 +1,3289 @@
+import { __exportAll } from './chunk-VVJVQ4JO.mjs';
+import './chunk-6DZX6EAA.mjs';
+import t from 'fs';
+import n from 'fs/promises';
+import r from 'stream';
+import i, { posix, basename, win32, parse, dirname, join } from 'path';
+import l, { EventEmitter } from 'events';
+import { StringDecoder } from 'string_decoder';
+import ne from 'assert';
+import { Buffer as Buffer$1 } from 'buffer';
+import * as ie from 'zlib';
+import ie__default from 'zlib';
+import { randomBytes } from 'crypto';
+
+var ce = __exportAll({
+  Header: () => I,
+  Pack: () => ni,
+  PackJob: () => Ir,
+  PackSync: () => ri,
+  Parser: () => Jn,
+  Pax: () => hn,
+  ReadEntry: () => yn,
+  Unpack: () => _a,
+  UnpackSync: () => ya,
+  WriteEntry: () => Dr,
+  WriteEntrySync: () => Or,
+  WriteEntryTar: () => kr,
+  c: () => ci,
+  create: () => ci,
+  extract: () => ba,
+  filesFilter: () => Zn,
+  list: () => Qn,
+  r: () => Ea,
+  replace: () => Ea,
+  t: () => Qn,
+  types: () => Xt,
+  x: () => ba
+});
+var le = Object.defineProperty;
+var ue = (e3, t2) => {
+  for (var n2 in t2) le(e3, n2, {
+    get: t2[n2],
+    enumerable: true
+  });
+};
+var de = typeof process == `object` && process ? process : {
+  stdout: null,
+  stderr: null
+};
+var fe = (e3) => !!e3 && typeof e3 == `object` && (e3 instanceof Ue || e3 instanceof r || pe(e3) || me(e3));
+var pe = (e3) => !!e3 && typeof e3 == `object` && e3 instanceof EventEmitter && typeof e3.pipe == `function` && e3.pipe !== r.Writable.prototype.pipe;
+var me = (e3) => !!e3 && typeof e3 == `object` && e3 instanceof EventEmitter && typeof e3.write == `function` && typeof e3.end == `function`;
+var h = /* @__PURE__ */ Symbol(`EOF`);
+var g = /* @__PURE__ */ Symbol(`maybeEmitEnd`);
+var _ = /* @__PURE__ */ Symbol(`emittedEnd`);
+var he = /* @__PURE__ */ Symbol(`emittingEnd`);
+var ge = /* @__PURE__ */ Symbol(`emittedError`);
+var _e = /* @__PURE__ */ Symbol(`closed`);
+var ve = /* @__PURE__ */ Symbol(`read`);
+var ye = /* @__PURE__ */ Symbol(`flush`);
+var be = /* @__PURE__ */ Symbol(`flushChunk`);
+var v = /* @__PURE__ */ Symbol(`encoding`);
+var xe = /* @__PURE__ */ Symbol(`decoder`);
+var y = /* @__PURE__ */ Symbol(`flowing`);
+var Se = /* @__PURE__ */ Symbol(`paused`);
+var Ce = /* @__PURE__ */ Symbol(`resume`);
+var b = /* @__PURE__ */ Symbol(`buffer`);
+var x = /* @__PURE__ */ Symbol(`pipes`);
+var S = /* @__PURE__ */ Symbol(`bufferLength`);
+var we = /* @__PURE__ */ Symbol(`bufferPush`);
+var Te = /* @__PURE__ */ Symbol(`bufferShift`);
+var C = /* @__PURE__ */ Symbol(`objectMode`);
+var w = /* @__PURE__ */ Symbol(`destroyed`);
+var Ee = /* @__PURE__ */ Symbol(`error`);
+var De = /* @__PURE__ */ Symbol(`emitData`);
+var Oe = /* @__PURE__ */ Symbol(`emitEnd`);
+var ke = /* @__PURE__ */ Symbol(`emitEnd2`);
+var T = /* @__PURE__ */ Symbol(`async`);
+var Ae = /* @__PURE__ */ Symbol(`abort`);
+var je = /* @__PURE__ */ Symbol(`aborted`);
+var Me = /* @__PURE__ */ Symbol(`signal`);
+var Ne = /* @__PURE__ */ Symbol(`dataListeners`);
+var E = /* @__PURE__ */ Symbol(`discarded`);
+var Pe = (e3) => Promise.resolve().then(e3);
+var Fe = (e3) => e3();
+var Ie = (e3) => e3 === `end` || e3 === `finish` || e3 === `prefinish`;
+var Le = (e3) => e3 instanceof ArrayBuffer || !!e3 && typeof e3 == `object` && e3.constructor && e3.constructor.name === `ArrayBuffer` && e3.byteLength >= 0;
+var Re = (e3) => !Buffer.isBuffer(e3) && ArrayBuffer.isView(e3);
+var ze = class {
+  src;
+  dest;
+  opts;
+  ondrain;
+  constructor(e3, t2, n2) {
+    this.src = e3, this.dest = t2, this.opts = n2, this.ondrain = () => e3[Ce](), this.dest.on(`drain`, this.ondrain);
+  }
+  unpipe() {
+    this.dest.removeListener(`drain`, this.ondrain);
+  }
+  proxyErrors(e3) {
+  }
+  end() {
+    this.unpipe(), this.opts.end && this.dest.end();
+  }
+};
+var Be = class extends ze {
+  unpipe() {
+    this.src.removeListener(`error`, this.proxyErrors), super.unpipe();
+  }
+  constructor(e3, t2, n2) {
+    super(e3, t2, n2), this.proxyErrors = (e4) => this.dest.emit(`error`, e4), e3.on(`error`, this.proxyErrors);
+  }
+};
+var Ve = (e3) => !!e3.objectMode;
+var He = (e3) => !e3.objectMode && !!e3.encoding && e3.encoding !== `buffer`;
+var Ue = class extends EventEmitter {
+  [y] = false;
+  [Se] = false;
+  [x] = [];
+  [b] = [];
+  [C];
+  [v];
+  [T];
+  [xe];
+  [h] = false;
+  [_] = false;
+  [he] = false;
+  [_e] = false;
+  [ge] = null;
+  [S] = 0;
+  [w] = false;
+  [Me];
+  [je] = false;
+  [Ne] = 0;
+  [E] = false;
+  writable = true;
+  readable = true;
+  constructor(...e3) {
+    let t2 = e3[0] || {};
+    if (super(), t2.objectMode && typeof t2.encoding == `string`) throw TypeError(`Encoding and objectMode may not be used together`);
+    Ve(t2) ? (this[C] = true, this[v] = null) : He(t2) ? (this[v] = t2.encoding, this[C] = false) : (this[C] = false, this[v] = null), this[T] = !!t2.async, this[xe] = this[v] ? new StringDecoder(this[v]) : null, t2 && t2.debugExposeBuffer === true && Object.defineProperty(this, `buffer`, { get: () => this[b] }), t2 && t2.debugExposePipes === true && Object.defineProperty(this, `pipes`, { get: () => this[x] });
+    let { signal: n2 } = t2;
+    n2 && (this[Me] = n2, n2.aborted ? this[Ae]() : n2.addEventListener(`abort`, () => this[Ae]()));
+  }
+  get bufferLength() {
+    return this[S];
+  }
+  get encoding() {
+    return this[v];
+  }
+  set encoding(e3) {
+    throw Error(`Encoding must be set at instantiation time`);
+  }
+  setEncoding(e3) {
+    throw Error(`Encoding must be set at instantiation time`);
+  }
+  get objectMode() {
+    return this[C];
+  }
+  set objectMode(e3) {
+    throw Error(`objectMode must be set at instantiation time`);
+  }
+  get async() {
+    return this[T];
+  }
+  set async(e3) {
+    this[T] = this[T] || !!e3;
+  }
+  [Ae]() {
+    this[je] = true, this.emit(`abort`, this[Me]?.reason), this.destroy(this[Me]?.reason);
+  }
+  get aborted() {
+    return this[je];
+  }
+  set aborted(e3) {
+  }
+  write(e3, t2, n2) {
+    if (this[je]) return false;
+    if (this[h]) throw Error(`write after end`);
+    if (this[w]) return this.emit(`error`, Object.assign(Error(`Cannot call write after a stream was destroyed`), { code: `ERR_STREAM_DESTROYED` })), true;
+    typeof t2 == `function` && (n2 = t2, t2 = `utf8`), t2 ||= `utf8`;
+    let r2 = this[T] ? Pe : Fe;
+    if (!this[C] && !Buffer.isBuffer(e3)) {
+      if (Re(e3)) e3 = Buffer.from(e3.buffer, e3.byteOffset, e3.byteLength);
+      else if (Le(e3)) e3 = Buffer.from(e3);
+      else if (typeof e3 != `string`) throw Error(`Non-contiguous data written to non-objectMode stream`);
+    }
+    return this[C] ? (this[y] && this[S] !== 0 && this[ye](true), this[y] ? this.emit(`data`, e3) : this[we](e3), this[S] !== 0 && this.emit(`readable`), n2 && r2(n2), this[y]) : e3.length ? (typeof e3 == `string` && !(t2 === this[v] && !this[xe]?.lastNeed) && (e3 = Buffer.from(e3, t2)), Buffer.isBuffer(e3) && this[v] && (e3 = this[xe].write(e3)), this[y] && this[S] !== 0 && this[ye](true), this[y] ? this.emit(`data`, e3) : this[we](e3), this[S] !== 0 && this.emit(`readable`), n2 && r2(n2), this[y]) : (this[S] !== 0 && this.emit(`readable`), n2 && r2(n2), this[y]);
+  }
+  read(e3) {
+    if (this[w]) return null;
+    if (this[E] = false, this[S] === 0 || e3 === 0 || e3 && e3 > this[S]) return this[g](), null;
+    this[C] && (e3 = null), this[b].length > 1 && !this[C] && (this[b] = [this[v] ? this[b].join(``) : Buffer.concat(this[b], this[S])]);
+    let t2 = this[ve](e3 || null, this[b][0]);
+    return this[g](), t2;
+  }
+  [ve](e3, t2) {
+    if (this[C]) this[Te]();
+    else {
+      let n2 = t2;
+      e3 === n2.length || e3 === null ? this[Te]() : typeof n2 == `string` ? (this[b][0] = n2.slice(e3), t2 = n2.slice(0, e3), this[S] -= e3) : (this[b][0] = n2.subarray(e3), t2 = n2.subarray(0, e3), this[S] -= e3);
+    }
+    return this.emit(`data`, t2), !this[b].length && !this[h] && this.emit(`drain`), t2;
+  }
+  end(e3, t2, n2) {
+    return typeof e3 == `function` && (n2 = e3, e3 = void 0), typeof t2 == `function` && (n2 = t2, t2 = `utf8`), e3 !== void 0 && this.write(e3, t2), n2 && this.once(`end`, n2), this[h] = true, this.writable = false, (this[y] || !this[Se]) && this[g](), this;
+  }
+  [Ce]() {
+    this[w] || (!this[Ne] && !this[x].length && (this[E] = true), this[Se] = false, this[y] = true, this.emit(`resume`), this[b].length ? this[ye]() : this[h] ? this[g]() : this.emit(`drain`));
+  }
+  resume() {
+    return this[Ce]();
+  }
+  pause() {
+    this[y] = false, this[Se] = true, this[E] = false;
+  }
+  get destroyed() {
+    return this[w];
+  }
+  get flowing() {
+    return this[y];
+  }
+  get paused() {
+    return this[Se];
+  }
+  [we](e3) {
+    this[C] ? this[S] += 1 : this[S] += e3.length, this[b].push(e3);
+  }
+  [Te]() {
+    return this[C] ? --this[S] : this[S] -= this[b][0].length, this[b].shift();
+  }
+  [ye](e3 = false) {
+    do
+      ;
+    while (this[be](this[Te]()) && this[b].length);
+    !e3 && !this[b].length && !this[h] && this.emit(`drain`);
+  }
+  [be](e3) {
+    return this.emit(`data`, e3), this[y];
+  }
+  pipe(e3, t2) {
+    if (this[w]) return e3;
+    this[E] = false;
+    let n2 = this[_];
+    return t2 ||= {}, e3 === de.stdout || e3 === de.stderr ? t2.end = false : t2.end = t2.end !== false, t2.proxyErrors = !!t2.proxyErrors, n2 ? t2.end && e3.end() : (this[x].push(t2.proxyErrors ? new Be(this, e3, t2) : new ze(this, e3, t2)), this[T] ? Pe(() => this[Ce]()) : this[Ce]()), e3;
+  }
+  unpipe(e3) {
+    let t2 = this[x].find((t3) => t3.dest === e3);
+    t2 && (this[x].length === 1 ? (this[y] && this[Ne] === 0 && (this[y] = false), this[x] = []) : this[x].splice(this[x].indexOf(t2), 1), t2.unpipe());
+  }
+  addListener(e3, t2) {
+    return this.on(e3, t2);
+  }
+  on(e3, t2) {
+    let n2 = super.on(e3, t2);
+    if (e3 === `data`) this[E] = false, this[Ne]++, !this[x].length && !this[y] && this[Ce]();
+    else if (e3 === `readable` && this[S] !== 0) super.emit(`readable`);
+    else if (Ie(e3) && this[_]) super.emit(e3), this.removeAllListeners(e3);
+    else if (e3 === `error` && this[ge]) {
+      let e4 = t2;
+      this[T] ? Pe(() => e4.call(this, this[ge])) : e4.call(this, this[ge]);
+    }
+    return n2;
+  }
+  removeListener(e3, t2) {
+    return this.off(e3, t2);
+  }
+  off(e3, t2) {
+    let n2 = super.off(e3, t2);
+    return e3 === `data` && (this[Ne] = this.listeners(`data`).length, this[Ne] === 0 && !this[E] && !this[x].length && (this[y] = false)), n2;
+  }
+  removeAllListeners(e3) {
+    let t2 = super.removeAllListeners(e3);
+    return (e3 === `data` || e3 === void 0) && (this[Ne] = 0, !this[E] && !this[x].length && (this[y] = false)), t2;
+  }
+  get emittedEnd() {
+    return this[_];
+  }
+  [g]() {
+    !this[he] && !this[_] && !this[w] && this[b].length === 0 && this[h] && (this[he] = true, this.emit(`end`), this.emit(`prefinish`), this.emit(`finish`), this[_e] && this.emit(`close`), this[he] = false);
+  }
+  emit(e3, ...t2) {
+    let n2 = t2[0];
+    if (e3 !== `error` && e3 !== `close` && e3 !== w && this[w]) return false;
+    if (e3 === `data`) return !this[C] && !n2 ? false : this[T] ? (Pe(() => this[De](n2)), true) : this[De](n2);
+    if (e3 === `end`) return this[Oe]();
+    if (e3 === `close`) {
+      if (this[_e] = true, !this[_] && !this[w]) return false;
+      let e4 = super.emit(`close`);
+      return this.removeAllListeners(`close`), e4;
+    } else if (e3 === `error`) {
+      this[ge] = n2, super.emit(Ee, n2);
+      let e4 = !this[Me] || this.listeners(`error`).length ? super.emit(`error`, n2) : false;
+      return this[g](), e4;
+    } else if (e3 === `resume`) {
+      let e4 = super.emit(`resume`);
+      return this[g](), e4;
+    } else if (e3 === `finish` || e3 === `prefinish`) {
+      let t3 = super.emit(e3);
+      return this.removeAllListeners(e3), t3;
+    }
+    let r2 = super.emit(e3, ...t2);
+    return this[g](), r2;
+  }
+  [De](e3) {
+    for (let t3 of this[x]) t3.dest.write(e3) === false && this.pause();
+    let t2 = this[E] ? false : super.emit(`data`, e3);
+    return this[g](), t2;
+  }
+  [Oe]() {
+    return this[_] ? false : (this[_] = true, this.readable = false, this[T] ? (Pe(() => this[ke]()), true) : this[ke]());
+  }
+  [ke]() {
+    if (this[xe]) {
+      let e4 = this[xe].end();
+      if (e4) {
+        for (let t2 of this[x]) t2.dest.write(e4);
+        this[E] || super.emit(`data`, e4);
+      }
+    }
+    for (let e4 of this[x]) e4.end();
+    let e3 = super.emit(`end`);
+    return this.removeAllListeners(`end`), e3;
+  }
+  async collect() {
+    let e3 = Object.assign([], { dataLength: 0 });
+    this[C] || (e3.dataLength = 0);
+    let t2 = this.promise();
+    return this.on(`data`, (t3) => {
+      e3.push(t3), this[C] || (e3.dataLength += t3.length);
+    }), await t2, e3;
+  }
+  async concat() {
+    if (this[C]) throw Error(`cannot concat in objectMode`);
+    let e3 = await this.collect();
+    return this[v] ? e3.join(``) : Buffer.concat(e3, e3.dataLength);
+  }
+  async promise() {
+    return new Promise((e3, t2) => {
+      this.on(w, () => t2(Error(`stream destroyed`))), this.on(`error`, (e4) => t2(e4)), this.on(`end`, () => e3());
+    });
+  }
+  [Symbol.asyncIterator]() {
+    this[E] = false;
+    let e3 = false, t2 = async () => (this.pause(), e3 = true, {
+      value: void 0,
+      done: true
+    });
+    return {
+      next: () => {
+        if (e3) return t2();
+        let n2 = this.read();
+        if (n2 !== null) return Promise.resolve({
+          done: false,
+          value: n2
+        });
+        if (this[h]) return t2();
+        let r2, i2, a2 = (e4) => {
+          this.off(`data`, o2), this.off(`end`, s2), this.off(w, c2), t2(), i2(e4);
+        }, o2 = (e4) => {
+          this.off(`error`, a2), this.off(`end`, s2), this.off(w, c2), this.pause(), r2({
+            value: e4,
+            done: !!this[h]
+          });
+        }, s2 = () => {
+          this.off(`error`, a2), this.off(`data`, o2), this.off(w, c2), t2(), r2({
+            done: true,
+            value: void 0
+          });
+        }, c2 = () => a2(Error(`stream destroyed`));
+        return new Promise((e4, t3) => {
+          i2 = t3, r2 = e4, this.once(w, c2), this.once(`error`, a2), this.once(`end`, s2), this.once(`data`, o2);
+        });
+      },
+      throw: t2,
+      return: t2,
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      [Symbol.asyncDispose]: async () => {
+      }
+    };
+  }
+  [Symbol.iterator]() {
+    this[E] = false;
+    let e3 = false, t2 = () => (this.pause(), this.off(Ee, t2), this.off(w, t2), this.off(`end`, t2), e3 = true, {
+      done: true,
+      value: void 0
+    });
+    return this.once(`end`, t2), this.once(Ee, t2), this.once(w, t2), {
+      next: () => {
+        if (e3) return t2();
+        let n2 = this.read();
+        return n2 === null ? t2() : {
+          done: false,
+          value: n2
+        };
+      },
+      throw: t2,
+      return: t2,
+      [Symbol.iterator]() {
+        return this;
+      },
+      [Symbol.dispose]: () => {
+      }
+    };
+  }
+  destroy(e3) {
+    if (this[w]) return e3 ? this.emit(`error`, e3) : this.emit(w), this;
+    this[w] = true, this[E] = true, this[b].length = 0, this[S] = 0;
+    let t2 = this;
+    return typeof t2.close == `function` && !this[_e] && t2.close(), e3 ? this.emit(`error`, e3) : this.emit(w), this;
+  }
+  static get isStream() {
+    return fe;
+  }
+};
+var We = t.writev;
+var D = /* @__PURE__ */ Symbol(`_autoClose`);
+var O = /* @__PURE__ */ Symbol(`_close`);
+var Ge = /* @__PURE__ */ Symbol(`_ended`);
+var k = /* @__PURE__ */ Symbol(`_fd`);
+var Ke = /* @__PURE__ */ Symbol(`_finished`);
+var A = /* @__PURE__ */ Symbol(`_flags`);
+var qe = /* @__PURE__ */ Symbol(`_flush`);
+var Je = /* @__PURE__ */ Symbol(`_handleChunk`);
+var Ye = /* @__PURE__ */ Symbol(`_makeBuf`);
+var Xe = /* @__PURE__ */ Symbol(`_mode`);
+var Ze = /* @__PURE__ */ Symbol(`_needDrain`);
+var Qe = /* @__PURE__ */ Symbol(`_onerror`);
+var $e = /* @__PURE__ */ Symbol(`_onopen`);
+var et = /* @__PURE__ */ Symbol(`_onread`);
+var tt = /* @__PURE__ */ Symbol(`_onwrite`);
+var j = /* @__PURE__ */ Symbol(`_open`);
+var M = /* @__PURE__ */ Symbol(`_path`);
+var nt = /* @__PURE__ */ Symbol(`_pos`);
+var N = /* @__PURE__ */ Symbol(`_queue`);
+var rt = /* @__PURE__ */ Symbol(`_read`);
+var it = /* @__PURE__ */ Symbol(`_readSize`);
+var P = /* @__PURE__ */ Symbol(`_reading`);
+var at = /* @__PURE__ */ Symbol(`_remain`);
+var ot = /* @__PURE__ */ Symbol(`_size`);
+var st = /* @__PURE__ */ Symbol(`_write`);
+var ct = /* @__PURE__ */ Symbol(`_writing`);
+var lt = /* @__PURE__ */ Symbol(`_defaultFlag`);
+var ut = /* @__PURE__ */ Symbol(`_errored`);
+var dt = class extends Ue {
+  [ut] = false;
+  [k];
+  [M];
+  [it];
+  [P] = false;
+  [ot];
+  [at];
+  [D];
+  constructor(e3, t2) {
+    if (t2 ||= {}, super(t2), this.readable = true, this.writable = false, typeof e3 != `string`) throw TypeError(`path must be a string`);
+    this[ut] = false, this[k] = typeof t2.fd == `number` ? t2.fd : void 0, this[M] = e3, this[it] = t2.readSize || 16 * 1024 * 1024, this[P] = false, this[ot] = typeof t2.size == `number` ? t2.size : Infinity, this[at] = this[ot], this[D] = typeof t2.autoClose == `boolean` ? t2.autoClose : true, typeof this[k] == `number` ? this[rt]() : this[j]();
+  }
+  get fd() {
+    return this[k];
+  }
+  get path() {
+    return this[M];
+  }
+  write() {
+    throw TypeError(`this is a readable stream`);
+  }
+  end() {
+    throw TypeError(`this is a readable stream`);
+  }
+  [j]() {
+    t.open(this[M], `r`, (e3, t2) => this[$e](e3, t2));
+  }
+  [$e](e3, t2) {
+    e3 ? this[Qe](e3) : (this[k] = t2, this.emit(`open`, t2), this[rt]());
+  }
+  [Ye]() {
+    return Buffer.allocUnsafe(Math.min(this[it], this[at]));
+  }
+  [rt]() {
+    if (!this[P]) {
+      this[P] = true;
+      let e3 = this[Ye]();
+      if (e3.length === 0) return process.nextTick(() => this[et](null, 0, e3));
+      t.read(this[k], e3, 0, e3.length, null, (e4, t2, n2) => this[et](e4, t2, n2));
+    }
+  }
+  [et](e3, t2, n2) {
+    this[P] = false, e3 ? this[Qe](e3) : this[Je](t2, n2) && this[rt]();
+  }
+  [O]() {
+    if (this[D] && typeof this[k] == `number`) {
+      let e3 = this[k];
+      this[k] = void 0, t.close(e3, (e4) => e4 ? this.emit(`error`, e4) : this.emit(`close`));
+    }
+  }
+  [Qe](e3) {
+    this[P] = true, this[O](), this.emit(`error`, e3);
+  }
+  [Je](e3, t2) {
+    let n2 = false;
+    return this[at] -= e3, e3 > 0 && (n2 = super.write(e3 < t2.length ? t2.subarray(0, e3) : t2)), (e3 === 0 || this[at] <= 0) && (n2 = false, this[O](), super.end()), n2;
+  }
+  emit(e3, ...t2) {
+    switch (e3) {
+      case `prefinish`:
+      case `finish`:
+        return false;
+      case `drain`:
+        return typeof this[k] == `number` && this[rt](), false;
+      case `error`:
+        return this[ut] ? false : (this[ut] = true, super.emit(e3, ...t2));
+      default:
+        return super.emit(e3, ...t2);
+    }
+  }
+};
+var ft = class extends dt {
+  [j]() {
+    let e3 = true;
+    try {
+      this[$e](null, t.openSync(this[M], `r`)), e3 = false;
+    } finally {
+      e3 && this[O]();
+    }
+  }
+  [rt]() {
+    let e3 = true;
+    try {
+      if (!this[P]) {
+        this[P] = true;
+        do {
+          let e4 = this[Ye](), t2 = e4.length === 0 ? 0 : t.readSync(this[k], e4, 0, e4.length, null);
+          if (!this[Je](t2, e4)) break;
+        } while (true);
+        this[P] = false;
+      }
+      e3 = false;
+    } finally {
+      e3 && this[O]();
+    }
+  }
+  [O]() {
+    if (this[D] && typeof this[k] == `number`) {
+      let e3 = this[k];
+      this[k] = void 0, t.closeSync(e3), this.emit(`close`);
+    }
+  }
+};
+var pt = class extends l {
+  readable = false;
+  writable = true;
+  [ut] = false;
+  [ct] = false;
+  [Ge] = false;
+  [N] = [];
+  [Ze] = false;
+  [M];
+  [Xe];
+  [D];
+  [k];
+  [lt];
+  [A];
+  [Ke] = false;
+  [nt];
+  constructor(e3, t2) {
+    t2 ||= {}, super(t2), this[M] = e3, this[k] = typeof t2.fd == `number` ? t2.fd : void 0, this[Xe] = t2.mode === void 0 ? 438 : t2.mode, this[nt] = typeof t2.start == `number` ? t2.start : void 0, this[D] = typeof t2.autoClose == `boolean` ? t2.autoClose : true;
+    let n2 = this[nt] === void 0 ? `w` : `r+`;
+    this[lt] = t2.flags === void 0, this[A] = t2.flags === void 0 ? n2 : t2.flags, this[k] === void 0 && this[j]();
+  }
+  emit(e3, ...t2) {
+    if (e3 === `error`) {
+      if (this[ut]) return false;
+      this[ut] = true;
+    }
+    return super.emit(e3, ...t2);
+  }
+  get fd() {
+    return this[k];
+  }
+  get path() {
+    return this[M];
+  }
+  [Qe](e3) {
+    this[O](), this[ct] = true, this.emit(`error`, e3);
+  }
+  [j]() {
+    t.open(this[M], this[A], this[Xe], (e3, t2) => this[$e](e3, t2));
+  }
+  [$e](e3, t2) {
+    this[lt] && this[A] === `r+` && e3 && e3.code === `ENOENT` ? (this[A] = `w`, this[j]()) : e3 ? this[Qe](e3) : (this[k] = t2, this.emit(`open`, t2), this[ct] || this[qe]());
+  }
+  end(e3, t2) {
+    return e3 && this.write(e3, t2), this[Ge] = true, !this[ct] && !this[N].length && typeof this[k] == `number` && this[tt](null, 0), this;
+  }
+  write(e3, t2) {
+    return typeof e3 == `string` && (e3 = Buffer.from(e3, t2)), this[Ge] ? (this.emit(`error`, Error(`write() after end()`)), false) : this[k] === void 0 || this[ct] || this[N].length ? (this[N].push(e3), this[Ze] = true, false) : (this[ct] = true, this[st](e3), true);
+  }
+  [st](e3) {
+    t.write(this[k], e3, 0, e3.length, this[nt], (e4, t2) => this[tt](e4, t2));
+  }
+  [tt](e3, t2) {
+    e3 ? this[Qe](e3) : (this[nt] !== void 0 && typeof t2 == `number` && (this[nt] += t2), this[N].length ? this[qe]() : (this[ct] = false, this[Ge] && !this[Ke] ? (this[Ke] = true, this[O](), this.emit(`finish`)) : this[Ze] && (this[Ze] = false, this.emit(`drain`))));
+  }
+  [qe]() {
+    if (this[N].length === 0) this[Ge] && this[tt](null, 0);
+    else if (this[N].length === 1) this[st](this[N].pop());
+    else {
+      let e3 = this[N];
+      this[N] = [], We(this[k], e3, this[nt], (e4, t2) => this[tt](e4, t2));
+    }
+  }
+  [O]() {
+    if (this[D] && typeof this[k] == `number`) {
+      let e3 = this[k];
+      this[k] = void 0, t.close(e3, (e4) => e4 ? this.emit(`error`, e4) : this.emit(`close`));
+    }
+  }
+};
+var mt = class extends pt {
+  [j]() {
+    let e3;
+    if (this[lt] && this[A] === `r+`) try {
+      e3 = t.openSync(this[M], this[A], this[Xe]);
+    } catch (e4) {
+      if (e4?.code === `ENOENT`) return this[A] = `w`, this[j]();
+      throw e4;
+    }
+    else e3 = t.openSync(this[M], this[A], this[Xe]);
+    this[$e](null, e3);
+  }
+  [O]() {
+    if (this[D] && typeof this[k] == `number`) {
+      let e3 = this[k];
+      this[k] = void 0, t.closeSync(e3), this.emit(`close`);
+    }
+  }
+  [st](e3) {
+    let t2 = true;
+    try {
+      this[tt](null, t.writeSync(this[k], e3, 0, e3.length, this[nt])), t2 = false;
+    } finally {
+      if (t2) try {
+        this[O]();
+      } catch {
+      }
+    }
+  }
+};
+var ht = /* @__PURE__ */ new Map([
+  [`C`, `cwd`],
+  [`f`, `file`],
+  [`z`, `gzip`],
+  [`P`, `preservePaths`],
+  [`U`, `unlink`],
+  [`strip-components`, `strip`],
+  [`stripComponents`, `strip`],
+  [`keep-newer`, `newer`],
+  [`keepNewer`, `newer`],
+  [`keep-newer-files`, `newer`],
+  [`keepNewerFiles`, `newer`],
+  [`k`, `keep`],
+  [`keep-existing`, `keep`],
+  [`keepExisting`, `keep`],
+  [`m`, `noMtime`],
+  [`no-mtime`, `noMtime`],
+  [`p`, `preserveOwner`],
+  [`L`, `follow`],
+  [`h`, `follow`],
+  [`onentry`, `onReadEntry`]
+]);
+var gt = (e3) => !!e3.sync && !!e3.file;
+var _t = (e3) => !e3.sync && !!e3.file;
+var vt = (e3) => !!e3.sync && !e3.file;
+var yt = (e3) => !e3.sync && !e3.file;
+var bt = (e3) => !!e3.file;
+var xt = (e3) => ht.get(e3) || e3;
+var St = (e3 = {}) => {
+  if (!e3) return {};
+  let t2 = {};
+  for (let [n2, r2] of Object.entries(e3)) {
+    let e4 = xt(n2);
+    t2[e4] = r2;
+  }
+  return t2.chmod === void 0 && t2.noChmod === false && (t2.chmod = true), delete t2.noChmod, t2;
+};
+var Ct = (e3, t2, n2, r2, i2) => Object.assign((a2 = [], o2, s2) => {
+  Array.isArray(a2) && (o2 = a2, a2 = {}), typeof o2 == `function` && (s2 = o2, o2 = void 0), o2 = o2 ? Array.from(o2) : [];
+  let c2 = St(a2);
+  if (i2?.(c2, o2), gt(c2)) {
+    if (typeof s2 == `function`) throw TypeError(`callback not supported for sync tar functions`);
+    return e3(c2, o2);
+  } else if (_t(c2)) {
+    let e4 = t2(c2, o2);
+    return s2 ? e4.then(() => s2(), s2) : e4;
+  } else if (vt(c2)) {
+    if (typeof s2 == `function`) throw TypeError(`callback not supported for sync tar functions`);
+    return n2(c2, o2);
+  } else if (yt(c2)) {
+    if (typeof s2 == `function`) throw TypeError(`callback only supported with file option`);
+    return r2(c2, o2);
+  }
+  throw Error(`impossible options??`);
+}, {
+  syncFile: e3,
+  asyncFile: t2,
+  syncNoFile: n2,
+  asyncNoFile: r2,
+  validate: i2
+});
+var wt = ie__default.constants || { ZLIB_VERNUM: 4736 };
+var F = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  Z_VERSION_ERROR: -6,
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  DEFLATE: 1,
+  INFLATE: 2,
+  GZIP: 3,
+  GUNZIP: 4,
+  DEFLATERAW: 5,
+  INFLATERAW: 6,
+  UNZIP: 7,
+  BROTLI_DECODE: 8,
+  BROTLI_ENCODE: 9,
+  Z_MIN_WINDOWBITS: 8,
+  Z_MAX_WINDOWBITS: 15,
+  Z_DEFAULT_WINDOWBITS: 15,
+  Z_MIN_CHUNK: 64,
+  Z_MAX_CHUNK: Infinity,
+  Z_DEFAULT_CHUNK: 16384,
+  Z_MIN_MEMLEVEL: 1,
+  Z_MAX_MEMLEVEL: 9,
+  Z_DEFAULT_MEMLEVEL: 8,
+  Z_MIN_LEVEL: -1,
+  Z_MAX_LEVEL: 9,
+  Z_DEFAULT_LEVEL: -1,
+  BROTLI_OPERATION_PROCESS: 0,
+  BROTLI_OPERATION_FLUSH: 1,
+  BROTLI_OPERATION_FINISH: 2,
+  BROTLI_OPERATION_EMIT_METADATA: 3,
+  BROTLI_MODE_GENERIC: 0,
+  BROTLI_MODE_TEXT: 1,
+  BROTLI_MODE_FONT: 2,
+  BROTLI_DEFAULT_MODE: 0,
+  BROTLI_MIN_QUALITY: 0,
+  BROTLI_MAX_QUALITY: 11,
+  BROTLI_DEFAULT_QUALITY: 11,
+  BROTLI_MIN_WINDOW_BITS: 10,
+  BROTLI_MAX_WINDOW_BITS: 24,
+  BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+  BROTLI_DEFAULT_WINDOW: 22,
+  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+  BROTLI_PARAM_MODE: 0,
+  BROTLI_PARAM_QUALITY: 1,
+  BROTLI_PARAM_LGWIN: 2,
+  BROTLI_PARAM_LGBLOCK: 3,
+  BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+  BROTLI_PARAM_SIZE_HINT: 5,
+  BROTLI_PARAM_LARGE_WINDOW: 6,
+  BROTLI_PARAM_NPOSTFIX: 7,
+  BROTLI_PARAM_NDIRECT: 8,
+  BROTLI_DECODER_RESULT_ERROR: 0,
+  BROTLI_DECODER_RESULT_SUCCESS: 1,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+  BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+  BROTLI_DECODER_NO_ERROR: 0,
+  BROTLI_DECODER_SUCCESS: 1,
+  BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+  BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+  BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+  BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+  BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+  BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+  BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+  BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+  BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+  BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+  BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+  BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+  BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+  BROTLI_DECODER_ERROR_UNREACHABLE: -31
+}, wt));
+var Tt = Buffer$1.concat;
+var Et = Object.getOwnPropertyDescriptor(Buffer$1, `concat`);
+var Dt = (e3) => e3;
+var Ot = Et?.writable === true || Et?.set !== void 0 ? (e3) => {
+  Buffer$1.concat = e3 ? Dt : Tt;
+} : (e3) => {
+};
+var kt = /* @__PURE__ */ Symbol(`_superWrite`);
+var At = class extends Error {
+  code;
+  errno;
+  constructor(e3, t2) {
+    super(`zlib: ` + e3.message, { cause: e3 }), this.code = e3.code, this.errno = e3.errno, this.code ||= `ZLIB_ERROR`, this.message = `zlib: ` + e3.message, Error.captureStackTrace(this, t2 ?? this.constructor);
+  }
+  get name() {
+    return `ZlibError`;
+  }
+};
+var jt = /* @__PURE__ */ Symbol(`flushFlag`);
+var Mt = class extends Ue {
+  #t = false;
+  #i = false;
+  #s;
+  #n;
+  #r;
+  #e;
+  #o;
+  get sawError() {
+    return this.#t;
+  }
+  get handle() {
+    return this.#e;
+  }
+  get flushFlag() {
+    return this.#s;
+  }
+  constructor(e3, t2) {
+    if (!e3 || typeof e3 != `object`) throw TypeError(`invalid options for ZlibBase constructor`);
+    if (super(e3), this.#s = e3.flush ?? 0, this.#n = e3.finishFlush ?? 0, this.#r = e3.fullFlushFlag ?? 0, typeof ie[t2] != `function`) throw TypeError(`Compression method not supported: ` + t2);
+    try {
+      this.#e = new ie[t2](e3);
+    } catch (e4) {
+      throw new At(e4, this.constructor);
+    }
+    this.#o = (e4) => {
+      this.#t || (this.#t = true, this.close(), this.emit(`error`, e4));
+    }, this.#e?.on(`error`, (e4) => this.#o(new At(e4))), this.once(`end`, () => this.close);
+  }
+  close() {
+    this.#e && (this.#e.close(), this.#e = void 0, this.emit(`close`));
+  }
+  reset() {
+    if (!this.#t) return ne(this.#e, `zlib binding closed`), this.#e.reset?.();
+  }
+  flush(e3) {
+    this.ended || (typeof e3 != `number` && (e3 = this.#r), this.write(Object.assign(Buffer$1.alloc(0), { [jt]: e3 })));
+  }
+  end(e3, t2, n2) {
+    return typeof e3 == `function` && (n2 = e3, t2 = void 0, e3 = void 0), typeof t2 == `function` && (n2 = t2, t2 = void 0), e3 && (t2 ? this.write(e3, t2) : this.write(e3)), this.flush(this.#n), this.#i = true, super.end(n2);
+  }
+  get ended() {
+    return this.#i;
+  }
+  [kt](e3) {
+    return super.write(e3);
+  }
+  write(e3, t2, n2) {
+    if (typeof t2 == `function` && (n2 = t2, t2 = `utf8`), typeof e3 == `string` && (e3 = Buffer$1.from(e3, t2)), this.#t) return;
+    ne(this.#e, `zlib binding closed`);
+    let r2 = this.#e._handle, i2 = r2.close;
+    r2.close = () => {
+    };
+    let a2 = this.#e.close;
+    this.#e.close = () => {
+    }, Ot(true);
+    let o2;
+    try {
+      let t3 = typeof e3[jt] == `number` ? e3[jt] : this.#s;
+      o2 = this.#e._processChunk(e3, t3), Ot(false);
+    } catch (e4) {
+      Ot(false), this.#o(new At(e4, this.write));
+    } finally {
+      this.#e && (this.#e._handle = r2, r2.close = i2, this.#e.close = a2, this.#e.removeAllListeners(`error`));
+    }
+    this.#e && this.#e.on(`error`, (e4) => this.#o(new At(e4, this.write)));
+    let s2;
+    if (o2) if (Array.isArray(o2) && o2.length > 0) {
+      let e4 = o2[0];
+      s2 = this[kt](Buffer$1.from(e4));
+      for (let e5 = 1; e5 < o2.length; e5++) s2 = this[kt](o2[e5]);
+    } else s2 = this[kt](Buffer$1.from(o2));
+    return n2 && n2(), s2;
+  }
+};
+var Nt = class extends Mt {
+  #t;
+  #i;
+  constructor(e3, t2) {
+    e3 ||= {}, e3.flush = e3.flush || F.Z_NO_FLUSH, e3.finishFlush = e3.finishFlush || F.Z_FINISH, e3.fullFlushFlag = F.Z_FULL_FLUSH, super(e3, t2), this.#t = e3.level, this.#i = e3.strategy;
+  }
+  params(e3, t2) {
+    if (!this.sawError) {
+      if (!this.handle) throw Error(`cannot switch params when binding is closed`);
+      if (!this.handle.params) throw Error(`not supported in this implementation`);
+      if (this.#t !== e3 || this.#i !== t2) {
+        this.flush(F.Z_SYNC_FLUSH), ne(this.handle, `zlib binding closed`);
+        let n2 = this.handle.flush;
+        this.handle.flush = (e4, t3) => {
+          typeof e4 == `function` && (t3 = e4, e4 = this.flushFlag), this.flush(e4), t3?.();
+        };
+        try {
+          this.handle.params(e3, t2);
+        } finally {
+          this.handle.flush = n2;
+        }
+        this.handle && (this.#t = e3, this.#i = t2);
+      }
+    }
+  }
+};
+var Pt = class extends Nt {
+  #t;
+  constructor(e3) {
+    super(e3, `Gzip`), this.#t = e3 && !!e3.portable;
+  }
+  [kt](e3) {
+    return this.#t ? (this.#t = false, e3[9] = 255, super[kt](e3)) : super[kt](e3);
+  }
+};
+var Ft = class extends Nt {
+  constructor(e3) {
+    super(e3, `Unzip`);
+  }
+};
+var It = class extends Mt {
+  constructor(e3, t2) {
+    e3 ||= {}, e3.flush = e3.flush || F.BROTLI_OPERATION_PROCESS, e3.finishFlush = e3.finishFlush || F.BROTLI_OPERATION_FINISH, e3.fullFlushFlag = F.BROTLI_OPERATION_FLUSH, super(e3, t2);
+  }
+};
+var Lt = class extends It {
+  constructor(e3) {
+    super(e3, `BrotliCompress`);
+  }
+};
+var Rt = class extends It {
+  constructor(e3) {
+    super(e3, `BrotliDecompress`);
+  }
+};
+var zt = class extends Mt {
+  constructor(e3, t2) {
+    e3 ||= {}, e3.flush = e3.flush || F.ZSTD_e_continue, e3.finishFlush = e3.finishFlush || F.ZSTD_e_end, e3.fullFlushFlag = F.ZSTD_e_flush, super(e3, t2);
+  }
+};
+var Bt = class extends zt {
+  constructor(e3) {
+    super(e3, `ZstdCompress`);
+  }
+};
+var Vt = class extends zt {
+  constructor(e3) {
+    super(e3, `ZstdDecompress`);
+  }
+};
+var Ht = (e3, t2) => {
+  if (Number.isSafeInteger(e3)) e3 < 0 ? Wt(e3, t2) : Ut(e3, t2);
+  else throw Error(`cannot encode number outside of javascript safe integer range`);
+  return t2;
+};
+var Ut = (e3, t2) => {
+  t2[0] = 128;
+  for (var n2 = t2.length; n2 > 1; n2--) t2[n2 - 1] = e3 & 255, e3 = Math.floor(e3 / 256);
+};
+var Wt = (e3, t2) => {
+  t2[0] = 255;
+  var n2 = false;
+  e3 *= -1;
+  for (var r2 = t2.length; r2 > 1; r2--) {
+    var i2 = e3 & 255;
+    e3 = Math.floor(e3 / 256), n2 ? t2[r2 - 1] = Jt(i2) : i2 === 0 ? t2[r2 - 1] = 0 : (n2 = true, t2[r2 - 1] = Yt(i2));
+  }
+};
+var Gt = (e3) => {
+  let t2 = e3[0], n2 = t2 === 128 ? qt(e3.subarray(1, e3.length)) : t2 === 255 ? Kt(e3) : null;
+  if (n2 === null) throw Error(`invalid base256 encoding`);
+  if (!Number.isSafeInteger(n2)) throw Error(`parsed number outside of javascript safe integer range`);
+  return n2;
+};
+var Kt = (e3) => {
+  for (var t2 = e3.length, n2 = 0, r2 = false, i2 = t2 - 1; i2 > -1; i2--) {
+    var a2 = Number(e3[i2]), o2;
+    r2 ? o2 = Jt(a2) : a2 === 0 ? o2 = a2 : (r2 = true, o2 = Yt(a2)), o2 !== 0 && (n2 -= o2 * 256 ** (t2 - i2 - 1));
+  }
+  return n2;
+};
+var qt = (e3) => {
+  for (var t2 = e3.length, n2 = 0, r2 = t2 - 1; r2 > -1; r2--) {
+    var i2 = Number(e3[r2]);
+    i2 !== 0 && (n2 += i2 * 256 ** (t2 - r2 - 1));
+  }
+  return n2;
+};
+var Jt = (e3) => (255 ^ e3) & 255;
+var Yt = (e3) => (255 ^ e3) + 1 & 255;
+var Xt = {};
+ue(Xt, {
+  code: () => en,
+  isCode: () => Zt,
+  isName: () => Qt,
+  name: () => $t
+});
+var Zt = (e3) => $t.has(e3);
+var Qt = (e3) => en.has(e3);
+var $t = /* @__PURE__ */ new Map([
+  [`0`, `File`],
+  [``, `OldFile`],
+  [`1`, `Link`],
+  [`2`, `SymbolicLink`],
+  [`3`, `CharacterDevice`],
+  [`4`, `BlockDevice`],
+  [`5`, `Directory`],
+  [`6`, `FIFO`],
+  [`7`, `ContiguousFile`],
+  [`g`, `GlobalExtendedHeader`],
+  [`x`, `ExtendedHeader`],
+  [`A`, `SolarisACL`],
+  [`D`, `GNUDumpDir`],
+  [`I`, `Inode`],
+  [`K`, `NextFileHasLongLinkpath`],
+  [`L`, `NextFileHasLongPath`],
+  [`M`, `ContinuationFile`],
+  [`N`, `OldGnuLongPath`],
+  [`S`, `SparseFile`],
+  [`V`, `TapeVolumeHeader`],
+  [`X`, `OldExtendedHeader`]
+]);
+var en = new Map(Array.from($t).map((e3) => [e3[1], e3[0]]));
+var I = class {
+  cksumValid = false;
+  needPax = false;
+  nullBlock = false;
+  block;
+  path;
+  mode;
+  uid;
+  gid;
+  size;
+  cksum;
+  #t = `Unsupported`;
+  linkpath;
+  uname;
+  gname;
+  devmaj = 0;
+  devmin = 0;
+  atime;
+  ctime;
+  mtime;
+  charset;
+  comment;
+  constructor(e3, t2 = 0, n2, r2) {
+    Buffer.isBuffer(e3) ? this.decode(e3, t2 || 0, n2, r2) : e3 && this.#i(e3);
+  }
+  decode(e3, t2, n2, r2) {
+    if (t2 ||= 0, !e3 || !(e3.length >= t2 + 512)) throw Error(`need 512 bytes for header`);
+    this.path = n2?.path ?? nn(e3, t2, 100), this.mode = n2?.mode ?? r2?.mode ?? L(e3, t2 + 100, 8), this.uid = n2?.uid ?? r2?.uid ?? L(e3, t2 + 108, 8), this.gid = n2?.gid ?? r2?.gid ?? L(e3, t2 + 116, 8), this.size = n2?.size ?? r2?.size ?? L(e3, t2 + 124, 12), this.mtime = n2?.mtime ?? r2?.mtime ?? rn(e3, t2 + 136, 12), this.cksum = L(e3, t2 + 148, 12), r2 && this.#i(r2, true), n2 && this.#i(n2);
+    let i2 = nn(e3, t2 + 156, 1);
+    if (Zt(i2) && (this.#t = i2 || `0`), this.#t === `0` && this.path.slice(-1) === `/` && (this.#t = `5`), this.#t === `5` && (this.size = 0), this.linkpath = nn(e3, t2 + 157, 100), e3.subarray(t2 + 257, t2 + 265).toString() === `ustar\x0000`) if (this.uname = n2?.uname ?? r2?.uname ?? nn(e3, t2 + 265, 32), this.gname = n2?.gname ?? r2?.gname ?? nn(e3, t2 + 297, 32), this.devmaj = n2?.devmaj ?? r2?.devmaj ?? L(e3, t2 + 329, 8) ?? 0, this.devmin = n2?.devmin ?? r2?.devmin ?? L(e3, t2 + 337, 8) ?? 0, e3[t2 + 475] !== 0) this.path = nn(e3, t2 + 345, 155) + `/` + this.path;
+    else {
+      let i3 = nn(e3, t2 + 345, 130);
+      i3 && (this.path = i3 + `/` + this.path), this.atime = n2?.atime ?? r2?.atime ?? rn(e3, t2 + 476, 12), this.ctime = n2?.ctime ?? r2?.ctime ?? rn(e3, t2 + 488, 12);
+    }
+    let a2 = 256;
+    for (let n3 = t2; n3 < t2 + 148; n3++) a2 += e3[n3];
+    for (let n3 = t2 + 156; n3 < t2 + 512; n3++) a2 += e3[n3];
+    this.cksumValid = a2 === this.cksum, this.cksum === void 0 && a2 === 256 && (this.nullBlock = true);
+  }
+  #i(e3, t2 = false) {
+    Object.assign(this, Object.fromEntries(Object.entries(e3).filter(([e4, n2]) => !(n2 == null || e4 === `path` && t2 || e4 === `linkpath` && t2 || e4 === `global`))));
+  }
+  encode(e3, t2 = 0) {
+    if (e3 ||= this.block = Buffer.alloc(512), this.#t === `Unsupported` && (this.#t = `0`), !(e3.length >= t2 + 512)) throw Error(`need 512 bytes for header`);
+    let n2 = this.ctime || this.atime ? 130 : 155, r2 = tn(this.path || ``, n2), i2 = r2[0], a2 = r2[1];
+    this.needPax = !!r2[2], this.needPax = mn(e3, t2, 100, i2) || this.needPax, this.needPax = R(e3, t2 + 100, 8, this.mode) || this.needPax, this.needPax = R(e3, t2 + 108, 8, this.uid) || this.needPax, this.needPax = R(e3, t2 + 116, 8, this.gid) || this.needPax, this.needPax = R(e3, t2 + 124, 12, this.size) || this.needPax, this.needPax = fn(e3, t2 + 136, 12, this.mtime) || this.needPax, e3[t2 + 156] = Number(this.#t.codePointAt(0)), this.needPax = mn(e3, t2 + 157, 100, this.linkpath) || this.needPax, e3.write(`ustar\x0000`, t2 + 257, 8), this.needPax = mn(e3, t2 + 265, 32, this.uname) || this.needPax, this.needPax = mn(e3, t2 + 297, 32, this.gname) || this.needPax, this.needPax = R(e3, t2 + 329, 8, this.devmaj) || this.needPax, this.needPax = R(e3, t2 + 337, 8, this.devmin) || this.needPax, this.needPax = mn(e3, t2 + 345, n2, a2) || this.needPax, e3[t2 + 475] === 0 ? (this.needPax = mn(e3, t2 + 345, 130, a2) || this.needPax, this.needPax = fn(e3, t2 + 476, 12, this.atime) || this.needPax, this.needPax = fn(e3, t2 + 488, 12, this.ctime) || this.needPax) : this.needPax = mn(e3, t2 + 345, 155, a2) || this.needPax;
+    let o2 = 256;
+    for (let n3 = t2; n3 < t2 + 148; n3++) o2 += e3[n3];
+    for (let n3 = t2 + 156; n3 < t2 + 512; n3++) o2 += e3[n3];
+    return this.cksum = o2, R(e3, t2 + 148, 8, this.cksum), this.cksumValid = true, this.needPax;
+  }
+  get type() {
+    return this.#t === `Unsupported` ? this.#t : $t.get(this.#t);
+  }
+  get typeKey() {
+    return this.#t;
+  }
+  set type(e3) {
+    let t2 = String(en.get(e3));
+    if (Zt(t2) || t2 === `Unsupported`) this.#t = t2;
+    else if (Zt(e3)) this.#t = e3;
+    else throw TypeError(`invalid entry type: ` + e3);
+  }
+};
+var tn = (e3, t2) => {
+  let n2 = e3, r2 = ``, i2, a2 = posix.parse(e3).root || `.`;
+  if (Buffer.byteLength(n2) < 100) i2 = [
+    n2,
+    r2,
+    false
+  ];
+  else {
+    r2 = posix.dirname(n2), n2 = posix.basename(n2);
+    do
+      Buffer.byteLength(n2) <= 100 && Buffer.byteLength(r2) <= t2 ? i2 = [
+        n2,
+        r2,
+        false
+      ] : Buffer.byteLength(n2) > 100 && Buffer.byteLength(r2) <= t2 ? i2 = [
+        n2.slice(0, 99),
+        r2,
+        true
+      ] : (n2 = posix.join(posix.basename(r2), n2), r2 = posix.dirname(r2));
+    while (r2 !== a2 && i2 === void 0);
+    i2 ||= [
+      e3.slice(0, 99),
+      ``,
+      true
+    ];
+  }
+  return i2;
+};
+var nn = (e3, t2, n2) => e3.subarray(t2, t2 + n2).toString(`utf8`).replace(/\0.*/, ``);
+var rn = (e3, t2, n2) => an(L(e3, t2, n2));
+var an = (e3) => e3 === void 0 ? void 0 : /* @__PURE__ */ new Date(e3 * 1e3);
+var L = (e3, t2, n2) => Number(e3[t2]) & 128 ? Gt(e3.subarray(t2, t2 + n2)) : sn(e3, t2, n2);
+var on = (e3) => isNaN(e3) ? void 0 : e3;
+var sn = (e3, t2, n2) => on(parseInt(e3.subarray(t2, t2 + n2).toString(`utf8`).replace(/\0.*$/, ``).trim(), 8));
+var cn = {
+  12: 8589934591,
+  8: 2097151
+};
+var R = (e3, t2, n2, r2) => r2 === void 0 ? false : r2 > cn[n2] || r2 < 0 ? (Ht(r2, e3.subarray(t2, t2 + n2)), true) : (ln(e3, t2, n2, r2), false);
+var ln = (e3, t2, n2, r2) => e3.write(un(r2, n2), t2, n2, `ascii`);
+var un = (e3, t2) => dn(Math.floor(e3).toString(8), t2);
+var dn = (e3, t2) => (e3.length === t2 - 1 ? e3 : Array(t2 - e3.length - 1).join(`0`) + e3 + ` `) + `\0`;
+var fn = (e3, t2, n2, r2) => r2 === void 0 ? false : R(e3, t2, n2, r2.getTime() / 1e3);
+var pn = Array(156).join(`\0`);
+var mn = (e3, t2, n2, r2) => r2 === void 0 ? false : (e3.write(r2 + pn, t2, n2, `utf8`), r2.length !== Buffer.byteLength(r2) || r2.length > n2);
+var hn = class e {
+  atime;
+  mtime;
+  ctime;
+  charset;
+  comment;
+  gid;
+  uid;
+  gname;
+  uname;
+  linkpath;
+  dev;
+  ino;
+  nlink;
+  path;
+  size;
+  mode;
+  global;
+  constructor(e3, t2 = false) {
+    this.atime = e3.atime, this.charset = e3.charset, this.comment = e3.comment, this.ctime = e3.ctime, this.dev = e3.dev, this.gid = e3.gid, this.global = t2, this.gname = e3.gname, this.ino = e3.ino, this.linkpath = e3.linkpath, this.mtime = e3.mtime, this.nlink = e3.nlink, this.path = e3.path, this.size = e3.size, this.uid = e3.uid, this.uname = e3.uname;
+  }
+  encode() {
+    let e3 = this.encodeBody();
+    if (e3 === ``) return Buffer.allocUnsafe(0);
+    let t2 = Buffer.byteLength(e3), n2 = 512 * Math.ceil(1 + t2 / 512), r2 = Buffer.allocUnsafe(n2);
+    for (let e4 = 0; e4 < 512; e4++) r2[e4] = 0;
+    new I({
+      path: (`PaxHeader/` + basename(this.path ?? ``)).slice(0, 99),
+      mode: this.mode || 420,
+      uid: this.uid,
+      gid: this.gid,
+      size: t2,
+      mtime: this.mtime,
+      type: this.global ? `GlobalExtendedHeader` : `ExtendedHeader`,
+      linkpath: ``,
+      uname: this.uname || ``,
+      gname: this.gname || ``,
+      devmaj: 0,
+      devmin: 0,
+      atime: this.atime,
+      ctime: this.ctime
+    }).encode(r2), r2.write(e3, 512, t2, `utf8`);
+    for (let e4 = t2 + 512; e4 < r2.length; e4++) r2[e4] = 0;
+    return r2;
+  }
+  encodeBody() {
+    return this.encodeField(`path`) + this.encodeField(`ctime`) + this.encodeField(`atime`) + this.encodeField(`dev`) + this.encodeField(`ino`) + this.encodeField(`nlink`) + this.encodeField(`charset`) + this.encodeField(`comment`) + this.encodeField(`gid`) + this.encodeField(`gname`) + this.encodeField(`linkpath`) + this.encodeField(`mtime`) + this.encodeField(`size`) + this.encodeField(`uid`) + this.encodeField(`uname`);
+  }
+  encodeField(e3) {
+    if (this[e3] === void 0) return ``;
+    let t2 = this[e3], n2 = t2 instanceof Date ? t2.getTime() / 1e3 : t2, r2 = ` ` + (e3 === `dev` || e3 === `ino` || e3 === `nlink` ? `SCHILY.` : ``) + e3 + `=` + n2 + `
+`, i2 = Buffer.byteLength(r2), a2 = Math.floor(Math.log(i2) / Math.log(10)) + 1;
+    return i2 + a2 >= 10 ** a2 && (a2 += 1), a2 + i2 + r2;
+  }
+  static parse(t2, n2, r2 = false) {
+    return new e(gn(_n(t2), n2), r2);
+  }
+};
+var gn = (e3, t2) => t2 ? Object.assign({}, t2, e3) : e3;
+var _n = (e3) => e3.replace(/\n$/, ``).split(`
+`).reduce(vn, /* @__PURE__ */ Object.create(null));
+var vn = (e3, t2) => {
+  let n2 = parseInt(t2, 10);
+  if (n2 !== Buffer.byteLength(t2) + 1) return e3;
+  t2 = t2.slice((n2 + ` `).length);
+  let r2 = t2.split(`=`), i2 = r2.shift();
+  if (!i2) return e3;
+  let a2 = i2.replace(/^SCHILY\.(dev|ino|nlink)/, `$1`), o2 = r2.join(`=`);
+  return e3[a2] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(a2) ? /* @__PURE__ */ new Date(Number(o2) * 1e3) : /^[0-9]+$/.test(o2) ? +o2 : o2, e3;
+};
+var z = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === `win32` ? (e3) => e3 && e3.replaceAll(/\\/g, `/`) : (e3) => e3;
+var yn = class extends Ue {
+  extended;
+  globalExtended;
+  header;
+  startBlockSize;
+  blockRemain;
+  remain;
+  type;
+  meta = false;
+  ignore = false;
+  path;
+  mode;
+  uid;
+  gid;
+  uname;
+  gname;
+  size = 0;
+  mtime;
+  atime;
+  ctime;
+  linkpath;
+  dev;
+  ino;
+  nlink;
+  invalid = false;
+  absolute;
+  unsupported = false;
+  constructor(e3, t2, n2) {
+    switch (super({}), this.pause(), this.extended = t2, this.globalExtended = n2, this.header = e3, this.remain = e3.size ?? 0, this.startBlockSize = 512 * Math.ceil(this.remain / 512), this.blockRemain = this.startBlockSize, this.type = e3.type, this.type) {
+      case `File`:
+      case `OldFile`:
+      case `Link`:
+      case `SymbolicLink`:
+      case `CharacterDevice`:
+      case `BlockDevice`:
+      case `Directory`:
+      case `FIFO`:
+      case `ContiguousFile`:
+      case `GNUDumpDir`:
+        break;
+      case `NextFileHasLongLinkpath`:
+      case `NextFileHasLongPath`:
+      case `OldGnuLongPath`:
+      case `GlobalExtendedHeader`:
+      case `ExtendedHeader`:
+      case `OldExtendedHeader`:
+        this.meta = true;
+        break;
+      default:
+        this.ignore = true;
+    }
+    if (!e3.path) throw Error(`no path provided for tar.ReadEntry`);
+    this.path = z(e3.path), this.mode = e3.mode, this.mode && (this.mode &= 4095), this.uid = e3.uid, this.gid = e3.gid, this.uname = e3.uname, this.gname = e3.gname, this.size = this.remain, this.mtime = e3.mtime, this.atime = e3.atime, this.ctime = e3.ctime, this.linkpath = e3.linkpath ? z(e3.linkpath) : void 0, this.uname = e3.uname, this.gname = e3.gname, t2 && this.#t(t2), n2 && this.#t(n2, true);
+  }
+  write(e3) {
+    let t2 = e3.length;
+    if (t2 > this.blockRemain) throw Error(`writing more to entry than is appropriate`);
+    let n2 = this.remain, r2 = this.blockRemain;
+    return this.remain = Math.max(0, n2 - t2), this.blockRemain = Math.max(0, r2 - t2), this.ignore ? true : n2 >= t2 ? super.write(e3) : super.write(e3.subarray(0, n2));
+  }
+  #t(e3, t2 = false) {
+    e3.path &&= z(e3.path), e3.linkpath &&= z(e3.linkpath), Object.assign(this, Object.fromEntries(Object.entries(e3).filter(([e4, n2]) => !(n2 == null || e4 === `path` && t2))));
+  }
+};
+var bn = (e3, t2, n2, r2 = {}) => {
+  e3.file && (r2.file = e3.file), e3.cwd && (r2.cwd = e3.cwd), r2.code = n2 instanceof Error && n2.code || t2, r2.tarCode = t2, !e3.strict && r2.recoverable !== false ? (n2 instanceof Error && (r2 = Object.assign(n2, r2), n2 = n2.message), e3.emit(`warn`, t2, n2, r2)) : n2 instanceof Error ? e3.emit(`error`, Object.assign(n2, r2)) : e3.emit(`error`, Object.assign(Error(`${t2}: ${n2}`), r2));
+};
+var xn = 1024 * 1024;
+var Sn = Buffer.from([31, 139]);
+var Cn = Buffer.from([
+  40,
+  181,
+  47,
+  253
+]);
+var wn = Math.max(Sn.length, Cn.length);
+var B = /* @__PURE__ */ Symbol(`state`);
+var Tn = /* @__PURE__ */ Symbol(`writeEntry`);
+var V = /* @__PURE__ */ Symbol(`readEntry`);
+var En = /* @__PURE__ */ Symbol(`nextEntry`);
+var Dn = /* @__PURE__ */ Symbol(`processEntry`);
+var H = /* @__PURE__ */ Symbol(`extendedHeader`);
+var On = /* @__PURE__ */ Symbol(`globalExtendedHeader`);
+var kn = /* @__PURE__ */ Symbol(`meta`);
+var An = /* @__PURE__ */ Symbol(`emitMeta`);
+var U = /* @__PURE__ */ Symbol(`buffer`);
+var W = /* @__PURE__ */ Symbol(`queue`);
+var G = /* @__PURE__ */ Symbol(`ended`);
+var jn = /* @__PURE__ */ Symbol(`emittedEnd`);
+var Mn = /* @__PURE__ */ Symbol(`emit`);
+var K = /* @__PURE__ */ Symbol(`unzip`);
+var Nn = /* @__PURE__ */ Symbol(`consumeChunk`);
+var Pn = /* @__PURE__ */ Symbol(`consumeChunkSub`);
+var Fn = /* @__PURE__ */ Symbol(`consumeBody`);
+var In = /* @__PURE__ */ Symbol(`consumeMeta`);
+var Ln = /* @__PURE__ */ Symbol(`consumeHeader`);
+var Rn = /* @__PURE__ */ Symbol(`consuming`);
+var zn = /* @__PURE__ */ Symbol(`bufferConcat`);
+var Bn = /* @__PURE__ */ Symbol(`maybeEnd`);
+var Vn = /* @__PURE__ */ Symbol(`writing`);
+var q = /* @__PURE__ */ Symbol(`aborted`);
+var Hn = /* @__PURE__ */ Symbol(`onDone`);
+var Un = /* @__PURE__ */ Symbol(`sawValidEntry`);
+var Wn = /* @__PURE__ */ Symbol(`sawNullBlock`);
+var Gn = /* @__PURE__ */ Symbol(`sawEOF`);
+var Kn = /* @__PURE__ */ Symbol(`closeStream`);
+var qn = () => true;
+var Jn = class extends EventEmitter {
+  file;
+  strict;
+  maxMetaEntrySize;
+  filter;
+  brotli;
+  zstd;
+  writable = true;
+  readable = false;
+  [W] = [];
+  [U];
+  [V];
+  [Tn];
+  [B] = `begin`;
+  [kn] = ``;
+  [H];
+  [On];
+  [G] = false;
+  [K];
+  [q] = false;
+  [Un];
+  [Wn] = false;
+  [Gn] = false;
+  [Vn] = false;
+  [Rn] = false;
+  [jn] = false;
+  constructor(e3 = {}) {
+    super(), this.file = e3.file || ``, this.on(Hn, () => {
+      (this[B] === `begin` || this[Un] === false) && this.warn(`TAR_BAD_ARCHIVE`, `Unrecognized archive format`);
+    }), e3.ondone ? this.on(Hn, e3.ondone) : this.on(Hn, () => {
+      this.emit(`prefinish`), this.emit(`finish`), this.emit(`end`);
+    }), this.strict = !!e3.strict, this.maxMetaEntrySize = e3.maxMetaEntrySize || xn, this.filter = typeof e3.filter == `function` ? e3.filter : qn;
+    let t2 = e3.file && (e3.file.endsWith(`.tar.br`) || e3.file.endsWith(`.tbr`));
+    this.brotli = !(e3.gzip || e3.zstd) && e3.brotli !== void 0 ? e3.brotli : t2 ? void 0 : false;
+    let n2 = e3.file && (e3.file.endsWith(`.tar.zst`) || e3.file.endsWith(`.tzst`));
+    this.zstd = !(e3.gzip || e3.brotli) && e3.zstd !== void 0 ? e3.zstd : n2 ? true : void 0, this.on(`end`, () => this[Kn]()), typeof e3.onwarn == `function` && this.on(`warn`, e3.onwarn), typeof e3.onReadEntry == `function` && this.on(`entry`, e3.onReadEntry);
+  }
+  warn(e3, t2, n2 = {}) {
+    bn(this, e3, t2, n2);
+  }
+  [Ln](e3, t2) {
+    this[Un] === void 0 && (this[Un] = false);
+    let n2;
+    try {
+      n2 = new I(e3, t2, this[H], this[On]);
+    } catch (e4) {
+      return this.warn(`TAR_ENTRY_INVALID`, e4);
+    }
+    if (n2.nullBlock) this[Wn] ? (this[Gn] = true, this[B] === `begin` && (this[B] = `header`), this[Mn](`eof`)) : (this[Wn] = true, this[Mn](`nullBlock`));
+    else if (this[Wn] = false, !n2.cksumValid) this.warn(`TAR_ENTRY_INVALID`, `checksum failure`, { header: n2 });
+    else if (!n2.path) this.warn(`TAR_ENTRY_INVALID`, `path is required`, { header: n2 });
+    else {
+      let e4 = n2.type;
+      if (/^(Symbolic)?Link$/.test(e4) && !n2.linkpath) this.warn(`TAR_ENTRY_INVALID`, `linkpath required`, { header: n2 });
+      else if (!/^(Symbolic)?Link$/.test(e4) && !/^(Global)?ExtendedHeader$/.test(e4) && n2.linkpath) this.warn(`TAR_ENTRY_INVALID`, `linkpath forbidden`, { header: n2 });
+      else {
+        let e5 = this[Tn] = new yn(n2, this[H], this[On]);
+        this[Un] || (e5.remain ? e5.on(`end`, () => {
+          e5.invalid || (this[Un] = true);
+        }) : this[Un] = true), e5.meta ? e5.size > this.maxMetaEntrySize ? (e5.ignore = true, this[Mn](`ignoredEntry`, e5), this[B] = `ignore`, e5.resume()) : e5.size > 0 && (this[kn] = ``, e5.on(`data`, (e6) => this[kn] += e6), this[B] = `meta`) : (this[H] = void 0, e5.ignore = e5.ignore || !this.filter(e5.path, e5), e5.ignore ? (this[Mn](`ignoredEntry`, e5), this[B] = e5.remain ? `ignore` : `header`, e5.resume()) : (e5.remain ? this[B] = `body` : (this[B] = `header`, e5.end()), this[V] ? this[W].push(e5) : (this[W].push(e5), this[En]())));
+      }
+    }
+  }
+  [Kn]() {
+    queueMicrotask(() => this.emit(`close`));
+  }
+  [Dn](e3) {
+    let t2 = true;
+    if (!e3) this[V] = void 0, t2 = false;
+    else if (Array.isArray(e3)) {
+      let [t3, ...n2] = e3;
+      this.emit(t3, ...n2);
+    } else this[V] = e3, this.emit(`entry`, e3), e3.emittedEnd || (e3.on(`end`, () => this[En]()), t2 = false);
+    return t2;
+  }
+  [En]() {
+    do
+      ;
+    while (this[Dn](this[W].shift()));
+    if (this[W].length === 0) {
+      let e3 = this[V];
+      !e3 || e3.flowing || e3.size === e3.remain ? this[Vn] || this.emit(`drain`) : e3.once(`drain`, () => this.emit(`drain`));
+    }
+  }
+  [Fn](e3, t2) {
+    let n2 = this[Tn];
+    if (!n2) throw Error(`attempt to consume body without entry??`);
+    let r2 = n2.blockRemain ?? 0, i2 = r2 >= e3.length && t2 === 0 ? e3 : e3.subarray(t2, t2 + r2);
+    return n2.write(i2), n2.blockRemain || (this[B] = `header`, this[Tn] = void 0, n2.end()), i2.length;
+  }
+  [In](e3, t2) {
+    let n2 = this[Tn], r2 = this[Fn](e3, t2);
+    return !this[Tn] && n2 && this[An](n2), r2;
+  }
+  [Mn](e3, t2, n2) {
+    this[W].length === 0 && !this[V] ? this.emit(e3, t2, n2) : this[W].push([
+      e3,
+      t2,
+      n2
+    ]);
+  }
+  [An](e3) {
+    switch (this[Mn](`meta`, this[kn]), e3.type) {
+      case `ExtendedHeader`:
+      case `OldExtendedHeader`:
+        this[H] = hn.parse(this[kn], this[H], false);
+        break;
+      case `GlobalExtendedHeader`:
+        this[On] = hn.parse(this[kn], this[On], true);
+        break;
+      case `NextFileHasLongPath`:
+      case `OldGnuLongPath`: {
+        let e4 = this[H] ?? /* @__PURE__ */ Object.create(null);
+        this[H] = e4, e4.path = this[kn].replace(/\0.*/, ``);
+        break;
+      }
+      case `NextFileHasLongLinkpath`: {
+        let e4 = this[H] || /* @__PURE__ */ Object.create(null);
+        this[H] = e4, e4.linkpath = this[kn].replace(/\0.*/, ``);
+        break;
+      }
+      default:
+        throw Error(`unknown meta: ` + e3.type);
+    }
+  }
+  abort(e3) {
+    this[q] = true, this.emit(`abort`, e3), this.warn(`TAR_ABORT`, e3, { recoverable: false });
+  }
+  write(e3, t2, n2) {
+    if (typeof t2 == `function` && (n2 = t2, t2 = void 0), typeof e3 == `string` && (e3 = Buffer.from(e3, typeof t2 == `string` ? t2 : `utf8`)), this[q]) return n2?.(), false;
+    if ((this[K] === void 0 || this.brotli === void 0 && this[K] === false) && e3) {
+      if (this[U] && (e3 = Buffer.concat([this[U], e3]), this[U] = void 0), e3.length < wn) return this[U] = e3, n2?.(), true;
+      for (let t4 = 0; this[K] === void 0 && t4 < Sn.length; t4++) e3[t4] !== Sn[t4] && (this[K] = false);
+      let t3 = false;
+      if (this[K] === false && this.zstd !== false) {
+        t3 = true;
+        for (let n3 = 0; n3 < Cn.length; n3++) if (e3[n3] !== Cn[n3]) {
+          t3 = false;
+          break;
+        }
+      }
+      let r3 = this.brotli === void 0 && !t3;
+      if (this[K] === false && r3) if (e3.length < 512) if (this[G]) this.brotli = true;
+      else return this[U] = e3, n2?.(), true;
+      else try {
+        new I(e3.subarray(0, 512)), this.brotli = false;
+      } catch {
+        this.brotli = true;
+      }
+      if (this[K] === void 0 || this[K] === false && (this.brotli || t3)) {
+        let r4 = this[G];
+        this[G] = false, this[K] = this[K] === void 0 ? new Ft({}) : t3 ? new Vt({}) : new Rt({}), this[K].on(`data`, (e4) => this[Nn](e4)), this[K].on(`error`, (e4) => this.abort(e4)), this[K].on(`end`, () => {
+          this[G] = true, this[Nn]();
+        }), this[Vn] = true;
+        let i2 = !!this[K][r4 ? `end` : `write`](e3);
+        return this[Vn] = false, n2?.(), i2;
+      }
+    }
+    this[Vn] = true, this[K] ? this[K].write(e3) : this[Nn](e3), this[Vn] = false;
+    let r2 = this[W].length > 0 ? false : this[V] ? this[V].flowing : true;
+    return !r2 && this[W].length === 0 && this[V]?.once(`drain`, () => this.emit(`drain`)), n2?.(), r2;
+  }
+  [zn](e3) {
+    e3 && !this[q] && (this[U] = this[U] ? Buffer.concat([this[U], e3]) : e3);
+  }
+  [Bn]() {
+    if (this[G] && !this[jn] && !this[q] && !this[Rn]) {
+      this[jn] = true;
+      let e3 = this[Tn];
+      if (e3 && e3.blockRemain) {
+        let t2 = this[U] ? this[U].length : 0;
+        this.warn(`TAR_BAD_ARCHIVE`, `Truncated input (needed ${e3.blockRemain} more bytes, only ${t2} available)`, { entry: e3 }), this[U] && e3.write(this[U]), e3.end();
+      }
+      this[Mn](Hn);
+    }
+  }
+  [Nn](e3) {
+    if (this[Rn] && e3) this[zn](e3);
+    else if (!e3 && !this[U]) this[Bn]();
+    else if (e3) {
+      if (this[Rn] = true, this[U]) {
+        this[zn](e3);
+        let t2 = this[U];
+        this[U] = void 0, this[Pn](t2);
+      } else this[Pn](e3);
+      for (; this[U] && this[U]?.length >= 512 && !this[q] && !this[Gn]; ) {
+        let e4 = this[U];
+        this[U] = void 0, this[Pn](e4);
+      }
+      this[Rn] = false;
+    }
+    (!this[U] || this[G]) && this[Bn]();
+  }
+  [Pn](e3) {
+    let t2 = 0, n2 = e3.length;
+    for (; t2 + 512 <= n2 && !this[q] && !this[Gn]; ) switch (this[B]) {
+      case `begin`:
+      case `header`:
+        this[Ln](e3, t2), t2 += 512;
+        break;
+      case `ignore`:
+      case `body`:
+        t2 += this[Fn](e3, t2);
+        break;
+      case `meta`:
+        t2 += this[In](e3, t2);
+        break;
+      default:
+        throw Error(`invalid state: ` + this[B]);
+    }
+    t2 < n2 && (this[U] = this[U] ? Buffer.concat([e3.subarray(t2), this[U]]) : e3.subarray(t2));
+  }
+  end(e3, t2, n2) {
+    return typeof e3 == `function` && (n2 = e3, t2 = void 0, e3 = void 0), typeof t2 == `function` && (n2 = t2, t2 = void 0), typeof e3 == `string` && (e3 = Buffer.from(e3, t2)), n2 && this.once(`finish`, n2), this[q] || (this[K] ? (e3 && this[K].write(e3), this[K].end()) : (this[G] = true, (this.brotli === void 0 || this.zstd === void 0) && (e3 ||= Buffer.alloc(0)), e3 && this.write(e3), this[Bn]())), this;
+  }
+};
+var Yn = (e3) => {
+  let t2 = e3.length - 1, n2 = -1;
+  for (; t2 > -1 && e3.charAt(t2) === `/`; ) n2 = t2, t2--;
+  return n2 === -1 ? e3 : e3.slice(0, n2);
+};
+var Xn = (e3) => {
+  let t2 = e3.onReadEntry;
+  e3.onReadEntry = t2 ? (e4) => {
+    t2(e4), e4.resume();
+  } : (e4) => e4.resume();
+};
+var Zn = (e3, t2) => {
+  let n2 = new Map(t2.map((e4) => [Yn(e4), true])), r2 = e3.filter, i2 = (e4, t3 = ``) => {
+    let r3 = t3 || parse(e4).root || `.`, a2;
+    if (e4 === r3) a2 = false;
+    else {
+      let t4 = n2.get(e4);
+      a2 = t4 === void 0 ? i2(dirname(e4), r3) : t4;
+    }
+    return n2.set(e4, a2), a2;
+  };
+  e3.filter = r2 ? (e4, t3) => r2(e4, t3) && i2(Yn(e4)) : (e4) => i2(Yn(e4));
+};
+var Qn = Ct((e3) => {
+  let n2 = new Jn(e3), r2 = e3.file, i2;
+  try {
+    i2 = t.openSync(r2, `r`);
+    let a2 = t.fstatSync(i2), o2 = e3.maxReadSize || 16 * 1024 * 1024;
+    if (a2.size < o2) {
+      let e4 = Buffer.allocUnsafe(a2.size), r3 = t.readSync(i2, e4, 0, a2.size, 0);
+      n2.end(r3 === e4.byteLength ? e4 : e4.subarray(0, r3));
+    } else {
+      let e4 = 0, r3 = Buffer.allocUnsafe(o2);
+      for (; e4 < a2.size; ) {
+        let a3 = t.readSync(i2, r3, 0, o2, e4);
+        if (a3 === 0) break;
+        e4 += a3, n2.write(r3.subarray(0, a3));
+      }
+      n2.end();
+    }
+  } finally {
+    if (typeof i2 == `number`) try {
+      t.closeSync(i2);
+    } catch {
+    }
+  }
+}, (e3, n2) => {
+  let r2 = new Jn(e3), i2 = e3.maxReadSize || 16 * 1024 * 1024, a2 = e3.file;
+  return new Promise((e4, n3) => {
+    r2.on(`error`, n3), r2.on(`end`, e4), t.stat(a2, (e5, t2) => {
+      if (e5) n3(e5);
+      else {
+        let e6 = new dt(a2, {
+          readSize: i2,
+          size: t2.size
+        });
+        e6.on(`error`, n3), e6.pipe(r2);
+      }
+    });
+  });
+}, (e3) => new Jn(e3), (e3) => new Jn(e3), (e3, t2) => {
+  t2?.length && Zn(e3, t2), e3.noResume || Xn(e3);
+});
+var $n = (e3, t2, n2) => (e3 &= 4095, n2 && (e3 = (e3 | 384) & -19), t2 && (e3 & 256 && (e3 |= 64), e3 & 32 && (e3 |= 8), e3 & 4 && (e3 |= 1)), e3);
+var { isAbsolute: er, parse: tr } = win32;
+var nr = (e3) => {
+  let t2 = ``, n2 = tr(e3);
+  for (; er(e3) || n2.root; ) {
+    let r2 = e3.charAt(0) === `/` && e3.slice(0, 4) !== `//?/` ? `/` : n2.root;
+    e3 = e3.slice(r2.length), t2 += r2, n2 = tr(e3);
+  }
+  return [t2, e3];
+};
+var rr = [
+  `|`,
+  `<`,
+  `>`,
+  `?`,
+  `:`
+];
+var ir = rr.map((e3) => String.fromCodePoint(61440 + Number(e3.codePointAt(0))));
+var ar = new Map(rr.map((e3, t2) => [e3, ir[t2]]));
+var or = new Map(ir.map((e3, t2) => [e3, rr[t2]]));
+var sr = (e3) => rr.reduce((e4, t2) => e4.split(t2).join(ar.get(t2)), e3);
+var cr = (e3) => ir.reduce((e4, t2) => e4.split(t2).join(or.get(t2)), e3);
+var lr = (e3, t2) => t2 ? (e3 = z(e3).replace(/^\.(\/|$)/, ``), Yn(t2) + `/` + e3) : z(e3);
+var ur = 16 * 1024 * 1024;
+var dr = /* @__PURE__ */ Symbol(`process`);
+var fr = /* @__PURE__ */ Symbol(`file`);
+var pr = /* @__PURE__ */ Symbol(`directory`);
+var mr = /* @__PURE__ */ Symbol(`symlink`);
+var hr = /* @__PURE__ */ Symbol(`hardlink`);
+var gr = /* @__PURE__ */ Symbol(`header`);
+var _r = /* @__PURE__ */ Symbol(`read`);
+var vr = /* @__PURE__ */ Symbol(`lstat`);
+var yr = /* @__PURE__ */ Symbol(`onlstat`);
+var br = /* @__PURE__ */ Symbol(`onread`);
+var xr = /* @__PURE__ */ Symbol(`onreadlink`);
+var Sr = /* @__PURE__ */ Symbol(`openfile`);
+var Cr = /* @__PURE__ */ Symbol(`onopenfile`);
+var J = /* @__PURE__ */ Symbol(`close`);
+var wr = /* @__PURE__ */ Symbol(`mode`);
+var Tr = /* @__PURE__ */ Symbol(`awaitDrain`);
+var Er = /* @__PURE__ */ Symbol(`ondrain`);
+var Y = /* @__PURE__ */ Symbol(`prefix`);
+var Dr = class extends Ue {
+  path;
+  portable;
+  myuid = process.getuid && process.getuid() || 0;
+  myuser = process.env.USER || ``;
+  maxReadSize;
+  linkCache;
+  statCache;
+  preservePaths;
+  cwd;
+  strict;
+  mtime;
+  noPax;
+  noMtime;
+  prefix;
+  fd;
+  blockLen = 0;
+  blockRemain = 0;
+  buf;
+  pos = 0;
+  remain = 0;
+  length = 0;
+  offset = 0;
+  win32;
+  absolute;
+  header;
+  type;
+  linkpath;
+  stat;
+  onWriteEntry;
+  #t = false;
+  constructor(e3, t2 = {}) {
+    let n2 = St(t2);
+    super(), this.path = z(e3), this.portable = !!n2.portable, this.maxReadSize = n2.maxReadSize || ur, this.linkCache = n2.linkCache || /* @__PURE__ */ new Map(), this.statCache = n2.statCache || /* @__PURE__ */ new Map(), this.preservePaths = !!n2.preservePaths, this.cwd = z(n2.cwd || process.cwd()), this.strict = !!n2.strict, this.noPax = !!n2.noPax, this.noMtime = !!n2.noMtime, this.mtime = n2.mtime, this.prefix = n2.prefix ? z(n2.prefix) : void 0, this.onWriteEntry = n2.onWriteEntry, typeof n2.onwarn == `function` && this.on(`warn`, n2.onwarn);
+    let r2 = false;
+    if (!this.preservePaths) {
+      let [e4, t3] = nr(this.path);
+      e4 && typeof t3 == `string` && (this.path = t3, r2 = e4);
+    }
+    this.win32 = !!n2.win32 || process.platform === `win32`, this.win32 && (this.path = cr(this.path.replaceAll(/\\/g, `/`)), e3 = e3.replaceAll(/\\/g, `/`)), this.absolute = z(n2.absolute || i.resolve(this.cwd, e3)), this.path === `` && (this.path = `./`), r2 && this.warn(`TAR_ENTRY_INFO`, `stripping ${r2} from absolute path`, {
+      entry: this,
+      path: r2 + this.path
+    });
+    let i2 = this.statCache.get(this.absolute);
+    i2 ? this[yr](i2) : this[vr]();
+  }
+  warn(e3, t2, n2 = {}) {
+    return bn(this, e3, t2, n2);
+  }
+  emit(e3, ...t2) {
+    return e3 === `error` && (this.#t = true), super.emit(e3, ...t2);
+  }
+  [vr]() {
+    t.lstat(this.absolute, (e3, t2) => {
+      if (e3) return this.emit(`error`, e3);
+      this[yr](t2);
+    });
+  }
+  [yr](e3) {
+    this.statCache.set(this.absolute, e3), this.stat = e3, e3.isFile() || (e3.size = 0), this.type = Ar(e3), this.emit(`stat`, e3), this[dr]();
+  }
+  [dr]() {
+    switch (this.type) {
+      case `File`:
+        return this[fr]();
+      case `Directory`:
+        return this[pr]();
+      case `SymbolicLink`:
+        return this[mr]();
+      default:
+        return this.end();
+    }
+  }
+  [wr](e3) {
+    return $n(e3, this.type === `Directory`, this.portable);
+  }
+  [Y](e3) {
+    return lr(e3, this.prefix);
+  }
+  [gr]() {
+    if (!this.stat) throw Error(`cannot write header before stat`);
+    this.type === `Directory` && this.portable && (this.noMtime = true), this.onWriteEntry?.(this), this.header = new I({
+      path: this[Y](this.path),
+      linkpath: this.type === `Link` && this.linkpath !== void 0 ? this[Y](this.linkpath) : this.linkpath,
+      mode: this[wr](this.stat.mode),
+      uid: this.portable ? void 0 : this.stat.uid,
+      gid: this.portable ? void 0 : this.stat.gid,
+      size: this.stat.size,
+      mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
+      type: this.type === `Unsupported` ? void 0 : this.type,
+      uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : ``,
+      atime: this.portable ? void 0 : this.stat.atime,
+      ctime: this.portable ? void 0 : this.stat.ctime
+    }), this.header.encode() && !this.noPax && super.write(new hn({
+      atime: this.portable ? void 0 : this.header.atime,
+      ctime: this.portable ? void 0 : this.header.ctime,
+      gid: this.portable ? void 0 : this.header.gid,
+      mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
+      path: this[Y](this.path),
+      linkpath: this.type === `Link` && this.linkpath !== void 0 ? this[Y](this.linkpath) : this.linkpath,
+      size: this.header.size,
+      uid: this.portable ? void 0 : this.header.uid,
+      uname: this.portable ? void 0 : this.header.uname,
+      dev: this.portable ? void 0 : this.stat.dev,
+      ino: this.portable ? void 0 : this.stat.ino,
+      nlink: this.portable ? void 0 : this.stat.nlink
+    }).encode());
+    let e3 = this.header?.block;
+    if (!e3) throw Error(`failed to encode header`);
+    super.write(e3);
+  }
+  [pr]() {
+    if (!this.stat) throw Error(`cannot create directory entry without stat`);
+    this.path.slice(-1) !== `/` && (this.path += `/`), this.stat.size = 0, this[gr](), this.end();
+  }
+  [mr]() {
+    t.readlink(this.absolute, (e3, t2) => {
+      if (e3) return this.emit(`error`, e3);
+      this[xr](t2);
+    });
+  }
+  [xr](e3) {
+    this.linkpath = z(e3), this[gr](), this.end();
+  }
+  [hr](e3) {
+    if (!this.stat) throw Error(`cannot create link entry without stat`);
+    this.type = `Link`, this.linkpath = z(i.relative(this.cwd, e3)), this.stat.size = 0, this[gr](), this.end();
+  }
+  [fr]() {
+    if (!this.stat) throw Error(`cannot create file entry without stat`);
+    if (this.stat.nlink > 1) {
+      let e3 = `${this.stat.dev}:${this.stat.ino}`, t2 = this.linkCache.get(e3);
+      if (t2?.indexOf(this.cwd) === 0) return this[hr](t2);
+      this.linkCache.set(e3, this.absolute);
+    }
+    if (this[gr](), this.stat.size === 0) return this.end();
+    this[Sr]();
+  }
+  [Sr]() {
+    t.open(this.absolute, `r`, (e3, t2) => {
+      if (e3) return this.emit(`error`, e3);
+      this[Cr](t2);
+    });
+  }
+  [Cr](e3) {
+    if (this.fd = e3, this.#t) return this[J]();
+    if (!this.stat) throw Error(`should stat before calling onopenfile`);
+    this.blockLen = 512 * Math.ceil(this.stat.size / 512), this.blockRemain = this.blockLen;
+    let t2 = Math.min(this.blockLen, this.maxReadSize);
+    this.buf = Buffer.allocUnsafe(t2), this.offset = 0, this.pos = 0, this.remain = this.stat.size, this.length = this.buf.length, this[_r]();
+  }
+  [_r]() {
+    let { fd: e3, buf: t2, offset: n2, length: r2, pos: i2 } = this;
+    if (e3 === void 0 || t2 === void 0) throw Error(`cannot read file without first opening`);
+    t.read(e3, t2, n2, r2, i2, (e4, t3) => {
+      if (e4) return this[J](() => this.emit(`error`, e4));
+      this[br](t3);
+    });
+  }
+  [J](e3 = () => {
+  }) {
+    this.fd !== void 0 && t.close(this.fd, e3);
+  }
+  [br](e3) {
+    if (e3 <= 0 && this.remain > 0) {
+      let e4 = Object.assign(Error(`encountered unexpected EOF`), {
+        path: this.absolute,
+        syscall: `read`,
+        code: `EOF`
+      });
+      return this[J](() => this.emit(`error`, e4));
+    }
+    if (e3 > this.remain) {
+      let e4 = Object.assign(Error(`did not encounter expected EOF`), {
+        path: this.absolute,
+        syscall: `read`,
+        code: `EOF`
+      });
+      return this[J](() => this.emit(`error`, e4));
+    }
+    if (!this.buf) throw Error(`should have created buffer prior to reading`);
+    if (e3 === this.remain) for (let t3 = e3; t3 < this.length && e3 < this.blockRemain; t3++) this.buf[t3 + this.offset] = 0, e3++, this.remain++;
+    let t2 = this.offset === 0 && e3 === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + e3);
+    this.write(t2) ? this[Er]() : this[Tr](() => this[Er]());
+  }
+  [Tr](e3) {
+    this.once(`drain`, e3);
+  }
+  write(e3, t2, n2) {
+    if (typeof t2 == `function` && (n2 = t2, t2 = void 0), typeof e3 == `string` && (e3 = Buffer.from(e3, typeof t2 == `string` ? t2 : `utf8`)), this.blockRemain < e3.length) {
+      let e4 = Object.assign(Error(`writing more data than expected`), { path: this.absolute });
+      return this.emit(`error`, e4);
+    }
+    return this.remain -= e3.length, this.blockRemain -= e3.length, this.pos += e3.length, this.offset += e3.length, super.write(e3, null, n2);
+  }
+  [Er]() {
+    if (!this.remain) return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), this[J]((e3) => e3 ? this.emit(`error`, e3) : this.end());
+    if (!this.buf) throw Error(`buffer lost somehow in ONDRAIN`);
+    this.offset >= this.length && (this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length)), this.offset = 0), this.length = this.buf.length - this.offset, this[_r]();
+  }
+};
+var Or = class extends Dr {
+  sync = true;
+  [vr]() {
+    this[yr](t.lstatSync(this.absolute));
+  }
+  [mr]() {
+    this[xr](t.readlinkSync(this.absolute));
+  }
+  [Sr]() {
+    this[Cr](t.openSync(this.absolute, `r`));
+  }
+  [_r]() {
+    let e3 = true;
+    try {
+      let { fd: t2, buf: n2, offset: r2, length: i2, pos: a2 } = this;
+      if (t2 === void 0 || n2 === void 0) throw Error(`fd and buf must be set in READ method`);
+      let o2 = t.readSync(t2, n2, r2, i2, a2);
+      this[br](o2), e3 = false;
+    } finally {
+      if (e3) try {
+        this[J](() => {
+        });
+      } catch {
+      }
+    }
+  }
+  [Tr](e3) {
+    e3();
+  }
+  [J](e3 = () => {
+  }) {
+    this.fd !== void 0 && t.closeSync(this.fd), e3();
+  }
+};
+var kr = class extends Ue {
+  blockLen = 0;
+  blockRemain = 0;
+  buf = 0;
+  pos = 0;
+  remain = 0;
+  length = 0;
+  preservePaths;
+  portable;
+  strict;
+  noPax;
+  noMtime;
+  readEntry;
+  type;
+  prefix;
+  path;
+  mode;
+  uid;
+  gid;
+  uname;
+  gname;
+  header;
+  mtime;
+  atime;
+  ctime;
+  linkpath;
+  size;
+  onWriteEntry;
+  warn(e3, t2, n2 = {}) {
+    return bn(this, e3, t2, n2);
+  }
+  constructor(e3, t2 = {}) {
+    let n2 = St(t2);
+    super(), this.preservePaths = !!n2.preservePaths, this.portable = !!n2.portable, this.strict = !!n2.strict, this.noPax = !!n2.noPax, this.noMtime = !!n2.noMtime, this.onWriteEntry = n2.onWriteEntry, this.readEntry = e3;
+    let { type: r2 } = e3;
+    if (r2 === `Unsupported`) throw Error(`writing entry that should be ignored`);
+    this.type = r2, this.type === `Directory` && this.portable && (this.noMtime = true), this.prefix = n2.prefix, this.path = z(e3.path), this.mode = e3.mode === void 0 ? void 0 : this[wr](e3.mode), this.uid = this.portable ? void 0 : e3.uid, this.gid = this.portable ? void 0 : e3.gid, this.uname = this.portable ? void 0 : e3.uname, this.gname = this.portable ? void 0 : e3.gname, this.size = e3.size, this.mtime = this.noMtime ? void 0 : n2.mtime || e3.mtime, this.atime = this.portable ? void 0 : e3.atime, this.ctime = this.portable ? void 0 : e3.ctime, this.linkpath = e3.linkpath === void 0 ? void 0 : z(e3.linkpath), typeof n2.onwarn == `function` && this.on(`warn`, n2.onwarn);
+    let i2 = false;
+    if (!this.preservePaths) {
+      let [e4, t3] = nr(this.path);
+      e4 && typeof t3 == `string` && (this.path = t3, i2 = e4);
+    }
+    this.remain = e3.size, this.blockRemain = e3.startBlockSize, this.onWriteEntry?.(this), this.header = new I({
+      path: this[Y](this.path),
+      linkpath: this.type === `Link` && this.linkpath !== void 0 ? this[Y](this.linkpath) : this.linkpath,
+      mode: this.mode,
+      uid: this.portable ? void 0 : this.uid,
+      gid: this.portable ? void 0 : this.gid,
+      size: this.size,
+      mtime: this.noMtime ? void 0 : this.mtime,
+      type: this.type,
+      uname: this.portable ? void 0 : this.uname,
+      atime: this.portable ? void 0 : this.atime,
+      ctime: this.portable ? void 0 : this.ctime
+    }), i2 && this.warn(`TAR_ENTRY_INFO`, `stripping ${i2} from absolute path`, {
+      entry: this,
+      path: i2 + this.path
+    }), this.header.encode() && !this.noPax && super.write(new hn({
+      atime: this.portable ? void 0 : this.atime,
+      ctime: this.portable ? void 0 : this.ctime,
+      gid: this.portable ? void 0 : this.gid,
+      mtime: this.noMtime ? void 0 : this.mtime,
+      path: this[Y](this.path),
+      linkpath: this.type === `Link` && this.linkpath !== void 0 ? this[Y](this.linkpath) : this.linkpath,
+      size: this.size,
+      uid: this.portable ? void 0 : this.uid,
+      uname: this.portable ? void 0 : this.uname,
+      dev: this.portable ? void 0 : this.readEntry.dev,
+      ino: this.portable ? void 0 : this.readEntry.ino,
+      nlink: this.portable ? void 0 : this.readEntry.nlink
+    }).encode());
+    let a2 = this.header?.block;
+    if (!a2) throw Error(`failed to encode header`);
+    super.write(a2), e3.pipe(this);
+  }
+  [Y](e3) {
+    return lr(e3, this.prefix);
+  }
+  [wr](e3) {
+    return $n(e3, this.type === `Directory`, this.portable);
+  }
+  write(e3, t2, n2) {
+    typeof t2 == `function` && (n2 = t2, t2 = void 0), typeof e3 == `string` && (e3 = Buffer.from(e3, typeof t2 == `string` ? t2 : `utf8`));
+    let r2 = e3.length;
+    if (r2 > this.blockRemain) throw Error(`writing more to entry than is appropriate`);
+    return this.blockRemain -= r2, super.write(e3, n2);
+  }
+  end(e3, t2, n2) {
+    return this.blockRemain && super.write(Buffer.alloc(this.blockRemain)), typeof e3 == `function` && (n2 = e3, t2 = void 0, e3 = void 0), typeof t2 == `function` && (n2 = t2, t2 = void 0), typeof e3 == `string` && (e3 = Buffer.from(e3, t2 ?? `utf8`)), n2 && this.once(`finish`, n2), e3 ? super.end(e3, n2) : super.end(n2), this;
+  }
+};
+var Ar = (e3) => e3.isFile() ? `File` : e3.isDirectory() ? `Directory` : e3.isSymbolicLink() ? `SymbolicLink` : `Unsupported`;
+var jr = class e2 {
+  tail;
+  head;
+  length = 0;
+  static create(t2 = []) {
+    return new e2(t2);
+  }
+  constructor(e3 = []) {
+    for (let t2 of e3) this.push(t2);
+  }
+  *[Symbol.iterator]() {
+    for (let e3 = this.head; e3; e3 = e3.next) yield e3.value;
+  }
+  removeNode(e3) {
+    if (e3.list !== this) throw Error(`removing node which does not belong to this list`);
+    let t2 = e3.next, n2 = e3.prev;
+    return t2 && (t2.prev = n2), n2 && (n2.next = t2), e3 === this.head && (this.head = t2), e3 === this.tail && (this.tail = n2), this.length--, e3.next = void 0, e3.prev = void 0, e3.list = void 0, t2;
+  }
+  unshiftNode(e3) {
+    if (e3 === this.head) return;
+    e3.list && e3.list.removeNode(e3);
+    let t2 = this.head;
+    e3.list = this, e3.next = t2, t2 && (t2.prev = e3), this.head = e3, this.tail ||= e3, this.length++;
+  }
+  pushNode(e3) {
+    if (e3 === this.tail) return;
+    e3.list && e3.list.removeNode(e3);
+    let t2 = this.tail;
+    e3.list = this, e3.prev = t2, t2 && (t2.next = e3), this.tail = e3, this.head ||= e3, this.length++;
+  }
+  push(...e3) {
+    for (let t2 = 0, n2 = e3.length; t2 < n2; t2++) Nr(this, e3[t2]);
+    return this.length;
+  }
+  unshift(...e3) {
+    for (var t2 = 0, n2 = e3.length; t2 < n2; t2++) Pr(this, e3[t2]);
+    return this.length;
+  }
+  pop() {
+    if (!this.tail) return;
+    let e3 = this.tail.value, t2 = this.tail;
+    return this.tail = this.tail.prev, this.tail ? this.tail.next = void 0 : this.head = void 0, t2.list = void 0, this.length--, e3;
+  }
+  shift() {
+    if (!this.head) return;
+    let e3 = this.head.value, t2 = this.head;
+    return this.head = this.head.next, this.head ? this.head.prev = void 0 : this.tail = void 0, t2.list = void 0, this.length--, e3;
+  }
+  forEach(e3, t2) {
+    t2 ||= this;
+    for (let n2 = this.head, r2 = 0; n2; r2++) e3.call(t2, n2.value, r2, this), n2 = n2.next;
+  }
+  forEachReverse(e3, t2) {
+    t2 ||= this;
+    for (let n2 = this.tail, r2 = this.length - 1; n2; r2--) e3.call(t2, n2.value, r2, this), n2 = n2.prev;
+  }
+  get(e3) {
+    let t2 = 0, n2 = this.head;
+    for (; n2 && t2 < e3; t2++) n2 = n2.next;
+    if (t2 === e3 && n2) return n2.value;
+  }
+  getReverse(e3) {
+    let t2 = 0, n2 = this.tail;
+    for (; n2 && t2 < e3; t2++) n2 = n2.prev;
+    if (t2 === e3 && n2) return n2.value;
+  }
+  map(t2, n2) {
+    n2 ||= this;
+    let r2 = new e2();
+    for (let e3 = this.head; e3; ) r2.push(t2.call(n2, e3.value, this)), e3 = e3.next;
+    return r2;
+  }
+  mapReverse(t2, n2) {
+    n2 ||= this;
+    var r2 = new e2();
+    for (let e3 = this.tail; e3; ) r2.push(t2.call(n2, e3.value, this)), e3 = e3.prev;
+    return r2;
+  }
+  reduce(e3, t2) {
+    let n2, r2 = this.head;
+    if (arguments.length > 1) n2 = t2;
+    else if (this.head) r2 = this.head.next, n2 = this.head.value;
+    else throw TypeError(`Reduce of empty list with no initial value`);
+    for (var i2 = 0; r2; i2++) n2 = e3(n2, r2.value, i2), r2 = r2.next;
+    return n2;
+  }
+  reduceReverse(e3, t2) {
+    let n2, r2 = this.tail;
+    if (arguments.length > 1) n2 = t2;
+    else if (this.tail) r2 = this.tail.prev, n2 = this.tail.value;
+    else throw TypeError(`Reduce of empty list with no initial value`);
+    for (let t3 = this.length - 1; r2; t3--) n2 = e3(n2, r2.value, t3), r2 = r2.prev;
+    return n2;
+  }
+  toArray() {
+    let e3 = Array(this.length);
+    for (let t2 = 0, n2 = this.head; n2; t2++) e3[t2] = n2.value, n2 = n2.next;
+    return e3;
+  }
+  toArrayReverse() {
+    let e3 = Array(this.length);
+    for (let t2 = 0, n2 = this.tail; n2; t2++) e3[t2] = n2.value, n2 = n2.prev;
+    return e3;
+  }
+  slice(t2 = 0, n2 = this.length) {
+    n2 < 0 && (n2 += this.length), t2 < 0 && (t2 += this.length);
+    let r2 = new e2();
+    if (n2 < t2 || n2 < 0) return r2;
+    t2 < 0 && (t2 = 0), n2 > this.length && (n2 = this.length);
+    let i2 = this.head, a2 = 0;
+    for (a2 = 0; i2 && a2 < t2; a2++) i2 = i2.next;
+    for (; i2 && a2 < n2; a2++, i2 = i2.next) r2.push(i2.value);
+    return r2;
+  }
+  sliceReverse(t2 = 0, n2 = this.length) {
+    n2 < 0 && (n2 += this.length), t2 < 0 && (t2 += this.length);
+    let r2 = new e2();
+    if (n2 < t2 || n2 < 0) return r2;
+    t2 < 0 && (t2 = 0), n2 > this.length && (n2 = this.length);
+    let i2 = this.length, a2 = this.tail;
+    for (; a2 && i2 > n2; i2--) a2 = a2.prev;
+    for (; a2 && i2 > t2; i2--, a2 = a2.prev) r2.push(a2.value);
+    return r2;
+  }
+  splice(e3, t2 = 0, ...n2) {
+    e3 > this.length && (e3 = this.length - 1), e3 < 0 && (e3 = this.length + e3);
+    let r2 = this.head;
+    for (let t3 = 0; r2 && t3 < e3; t3++) r2 = r2.next;
+    let i2 = [];
+    for (let e4 = 0; r2 && e4 < t2; e4++) i2.push(r2.value), r2 = this.removeNode(r2);
+    r2 ? r2 !== this.tail && (r2 = r2.prev) : r2 = this.tail;
+    for (let e4 of n2) r2 = Mr(this, r2, e4);
+    return i2;
+  }
+  reverse() {
+    let e3 = this.head, t2 = this.tail;
+    for (let t3 = e3; t3; t3 = t3.prev) {
+      let e4 = t3.prev;
+      t3.prev = t3.next, t3.next = e4;
+    }
+    return this.head = t2, this.tail = e3, this;
+  }
+};
+function Mr(e3, t2, n2) {
+  let r2 = new Fr(n2, t2, t2 ? t2.next : e3.head, e3);
+  return r2.next === void 0 && (e3.tail = r2), r2.prev === void 0 && (e3.head = r2), e3.length++, r2;
+}
+function Nr(e3, t2) {
+  e3.tail = new Fr(t2, e3.tail, void 0, e3), e3.head ||= e3.tail, e3.length++;
+}
+function Pr(e3, t2) {
+  e3.head = new Fr(t2, void 0, e3.head, e3), e3.tail ||= e3.head, e3.length++;
+}
+var Fr = class {
+  list;
+  next;
+  prev;
+  value;
+  constructor(e3, t2, n2, r2) {
+    this.list = r2, this.value = e3, t2 ? (t2.next = this, this.prev = t2) : this.prev = void 0, n2 ? (n2.prev = this, this.next = n2) : this.next = void 0;
+  }
+};
+var Ir = class {
+  path;
+  absolute;
+  entry;
+  stat;
+  readdir;
+  pending = false;
+  ignore = false;
+  piped = false;
+  constructor(e3, t2) {
+    this.path = e3 || `./`, this.absolute = t2;
+  }
+};
+var Lr = Buffer.alloc(1024);
+var Rr = /* @__PURE__ */ Symbol(`onStat`);
+var zr = /* @__PURE__ */ Symbol(`ended`);
+var X = /* @__PURE__ */ Symbol(`queue`);
+var Br = /* @__PURE__ */ Symbol(`current`);
+var Vr = /* @__PURE__ */ Symbol(`process`);
+var Hr = /* @__PURE__ */ Symbol(`processing`);
+var Ur = /* @__PURE__ */ Symbol(`processJob`);
+var Z = /* @__PURE__ */ Symbol(`jobs`);
+var Wr = /* @__PURE__ */ Symbol(`jobDone`);
+var Gr = /* @__PURE__ */ Symbol(`addFSEntry`);
+var Kr = /* @__PURE__ */ Symbol(`addTarEntry`);
+var qr = /* @__PURE__ */ Symbol(`stat`);
+var Jr = /* @__PURE__ */ Symbol(`readdir`);
+var Yr = /* @__PURE__ */ Symbol(`onreaddir`);
+var Xr = /* @__PURE__ */ Symbol(`pipe`);
+var Zr = /* @__PURE__ */ Symbol(`entry`);
+var Qr = /* @__PURE__ */ Symbol(`entryOpt`);
+var $r = /* @__PURE__ */ Symbol(`writeEntryClass`);
+var ei = /* @__PURE__ */ Symbol(`write`);
+var ti = /* @__PURE__ */ Symbol(`ondrain`);
+var ni = class extends Ue {
+  sync = false;
+  opt;
+  cwd;
+  maxReadSize;
+  preservePaths;
+  strict;
+  noPax;
+  prefix;
+  linkCache;
+  statCache;
+  file;
+  portable;
+  zip;
+  readdirCache;
+  noDirRecurse;
+  follow;
+  noMtime;
+  mtime;
+  filter;
+  jobs;
+  [$r];
+  onWriteEntry;
+  [X];
+  [Z] = 0;
+  [Hr] = false;
+  [zr] = false;
+  constructor(e3 = {}) {
+    if (super(), this.opt = e3, this.file = e3.file || ``, this.cwd = e3.cwd || process.cwd(), this.maxReadSize = e3.maxReadSize, this.preservePaths = !!e3.preservePaths, this.strict = !!e3.strict, this.noPax = !!e3.noPax, this.prefix = z(e3.prefix || ``), this.linkCache = e3.linkCache || /* @__PURE__ */ new Map(), this.statCache = e3.statCache || /* @__PURE__ */ new Map(), this.readdirCache = e3.readdirCache || /* @__PURE__ */ new Map(), this.onWriteEntry = e3.onWriteEntry, this[$r] = Dr, typeof e3.onwarn == `function` && this.on(`warn`, e3.onwarn), this.portable = !!e3.portable, e3.gzip || e3.brotli || e3.zstd) {
+      if ((e3.gzip ? 1 : 0) + (e3.brotli ? 1 : 0) + (e3.zstd ? 1 : 0) > 1) throw TypeError(`gzip, brotli, zstd are mutually exclusive`);
+      if (e3.gzip && (typeof e3.gzip != `object` && (e3.gzip = {}), this.portable && (e3.gzip.portable = true), this.zip = new Pt(e3.gzip)), e3.brotli && (typeof e3.brotli != `object` && (e3.brotli = {}), this.zip = new Lt(e3.brotli)), e3.zstd && (typeof e3.zstd != `object` && (e3.zstd = {}), this.zip = new Bt(e3.zstd)), !this.zip) throw Error(`impossible`);
+      let t2 = this.zip;
+      t2.on(`data`, (e4) => super.write(e4)), t2.on(`end`, () => super.end()), t2.on(`drain`, () => this[ti]()), this.on(`resume`, () => t2.resume());
+    } else this.on(`drain`, this[ti]);
+    this.noDirRecurse = !!e3.noDirRecurse, this.follow = !!e3.follow, this.noMtime = !!e3.noMtime, e3.mtime && (this.mtime = e3.mtime), this.filter = typeof e3.filter == `function` ? e3.filter : () => true, this[X] = new jr(), this[Z] = 0, this.jobs = Number(e3.jobs) || 4, this[Hr] = false, this[zr] = false;
+  }
+  [ei](e3) {
+    return super.write(e3);
+  }
+  add(e3) {
+    return this.write(e3), this;
+  }
+  end(e3, t2, n2) {
+    return typeof e3 == `function` && (n2 = e3, e3 = void 0), typeof t2 == `function` && (n2 = t2, t2 = void 0), e3 && this.add(e3), this[zr] = true, this[Vr](), n2 && n2(), this;
+  }
+  write(e3) {
+    if (this[zr]) throw Error(`write after end`);
+    return e3 instanceof yn ? this[Kr](e3) : this[Gr](e3), this.flowing;
+  }
+  [Kr](e3) {
+    let t2 = z(i.resolve(this.cwd, e3.path));
+    if (!this.filter(e3.path, e3)) e3.resume();
+    else {
+      let n2 = new Ir(e3.path, t2);
+      n2.entry = new kr(e3, this[Qr](n2)), n2.entry.on(`end`, () => this[Wr](n2)), this[Z] += 1, this[X].push(n2);
+    }
+    this[Vr]();
+  }
+  [Gr](e3) {
+    let t2 = z(i.resolve(this.cwd, e3));
+    this[X].push(new Ir(e3, t2)), this[Vr]();
+  }
+  [qr](e3) {
+    e3.pending = true, this[Z] += 1, t[this.follow ? `stat` : `lstat`](e3.absolute, (t2, n2) => {
+      e3.pending = false, --this[Z], t2 ? this.emit(`error`, t2) : this[Rr](e3, n2);
+    });
+  }
+  [Rr](e3, t2) {
+    this.statCache.set(e3.absolute, t2), e3.stat = t2, this.filter(e3.path, t2) ? t2.isFile() && t2.nlink > 1 && e3 === this[Br] && !this.linkCache.get(`${t2.dev}:${t2.ino}`) && !this.sync && this[Ur](e3) : e3.ignore = true, this[Vr]();
+  }
+  [Jr](e3) {
+    e3.pending = true, this[Z] += 1, t.readdir(e3.absolute, (t2, n2) => {
+      if (e3.pending = false, --this[Z], t2) return this.emit(`error`, t2);
+      this[Yr](e3, n2);
+    });
+  }
+  [Yr](e3, t2) {
+    this.readdirCache.set(e3.absolute, t2), e3.readdir = t2, this[Vr]();
+  }
+  [Vr]() {
+    if (!this[Hr]) {
+      this[Hr] = true;
+      for (let e3 = this[X].head; e3 && this[Z] < this.jobs; e3 = e3.next) if (this[Ur](e3.value), e3.value.ignore) {
+        let t2 = e3.next;
+        this[X].removeNode(e3), e3.next = t2;
+      }
+      this[Hr] = false, this[zr] && this[X].length === 0 && this[Z] === 0 && (this.zip ? this.zip.end(Lr) : (super.write(Lr), super.end()));
+    }
+  }
+  get [Br]() {
+    return this[X] && this[X].head && this[X].head.value;
+  }
+  [Wr](e3) {
+    this[X].shift(), --this[Z], this[Vr]();
+  }
+  [Ur](e3) {
+    if (!e3.pending) {
+      if (e3.entry) {
+        e3 === this[Br] && !e3.piped && this[Xr](e3);
+        return;
+      }
+      if (!e3.stat) {
+        let t2 = this.statCache.get(e3.absolute);
+        t2 ? this[Rr](e3, t2) : this[qr](e3);
+      }
+      if (e3.stat && !e3.ignore) {
+        if (!this.noDirRecurse && e3.stat.isDirectory() && !e3.readdir) {
+          let t2 = this.readdirCache.get(e3.absolute);
+          if (t2 ? this[Yr](e3, t2) : this[Jr](e3), !e3.readdir) return;
+        }
+        if (e3.entry = this[Zr](e3), !e3.entry) {
+          e3.ignore = true;
+          return;
+        }
+        e3 === this[Br] && !e3.piped && this[Xr](e3);
+      }
+    }
+  }
+  [Qr](e3) {
+    return {
+      onwarn: (e4, t2, n2) => this.warn(e4, t2, n2),
+      noPax: this.noPax,
+      cwd: this.cwd,
+      absolute: e3.absolute,
+      preservePaths: this.preservePaths,
+      maxReadSize: this.maxReadSize,
+      strict: this.strict,
+      portable: this.portable,
+      linkCache: this.linkCache,
+      statCache: this.statCache,
+      noMtime: this.noMtime,
+      mtime: this.mtime,
+      prefix: this.prefix,
+      onWriteEntry: this.onWriteEntry
+    };
+  }
+  [Zr](e3) {
+    this[Z] += 1;
+    try {
+      return new this[$r](e3.path, this[Qr](e3)).on(`end`, () => this[Wr](e3)).on(`error`, (e4) => this.emit(`error`, e4));
+    } catch (e4) {
+      this.emit(`error`, e4);
+    }
+  }
+  [ti]() {
+    this[Br] && this[Br].entry && this[Br].entry.resume();
+  }
+  [Xr](e3) {
+    e3.piped = true, e3.readdir && e3.readdir.forEach((t3) => {
+      let n3 = e3.path, r2 = n3 === `./` ? `` : n3.replace(/\/*$/, `/`);
+      this[Gr](r2 + t3);
+    });
+    let t2 = e3.entry, n2 = this.zip;
+    if (!t2) throw Error(`cannot pipe without source`);
+    n2 ? t2.on(`data`, (e4) => {
+      n2.write(e4) || t2.pause();
+    }) : t2.on(`data`, (e4) => {
+      super.write(e4) || t2.pause();
+    });
+  }
+  pause() {
+    return this.zip && this.zip.pause(), super.pause();
+  }
+  warn(e3, t2, n2 = {}) {
+    bn(this, e3, t2, n2);
+  }
+};
+var ri = class extends ni {
+  sync = true;
+  constructor(e3) {
+    super(e3), this[$r] = Or;
+  }
+  pause() {
+  }
+  resume() {
+  }
+  [qr](e3) {
+    let t2 = this.follow ? `statSync` : `lstatSync`;
+    this[Rr](e3, t[t2](e3.absolute));
+  }
+  [Jr](e3) {
+    this[Yr](e3, t.readdirSync(e3.absolute));
+  }
+  [Xr](e3) {
+    let t2 = e3.entry, n2 = this.zip;
+    if (e3.readdir && e3.readdir.forEach((t3) => {
+      let n3 = e3.path, r2 = n3 === `./` ? `` : n3.replace(/\/*$/, `/`);
+      this[Gr](r2 + t3);
+    }), !t2) throw Error(`Cannot pipe without source`);
+    n2 ? t2.on(`data`, (e4) => {
+      n2.write(e4);
+    }) : t2.on(`data`, (e4) => {
+      super[ei](e4);
+    });
+  }
+};
+var ii = (e3, t2) => {
+  let n2 = new ri(e3), r2 = new mt(e3.file, { mode: e3.mode || 438 });
+  n2.pipe(r2), oi(n2, t2);
+};
+var ai = (e3, t2) => {
+  let n2 = new ni(e3), r2 = new pt(e3.file, { mode: e3.mode || 438 });
+  n2.pipe(r2);
+  let i2 = new Promise((e4, t3) => {
+    r2.on(`error`, t3), r2.on(`close`, e4), n2.on(`error`, t3);
+  });
+  return si(n2, t2).catch((e4) => n2.emit(`error`, e4)), i2;
+};
+var oi = (e3, t2) => {
+  t2.forEach((t3) => {
+    t3.charAt(0) === `@` ? Qn({
+      file: i.resolve(e3.cwd, t3.slice(1)),
+      sync: true,
+      noResume: true,
+      onReadEntry: (t4) => e3.add(t4)
+    }) : e3.add(t3);
+  }), e3.end();
+};
+var si = async (e3, t2) => {
+  for (let n2 of t2) n2.charAt(0) === `@` ? await Qn({
+    file: i.resolve(String(e3.cwd), n2.slice(1)),
+    noResume: true,
+    onReadEntry: (t3) => {
+      e3.add(t3);
+    }
+  }) : e3.add(n2);
+  e3.end();
+};
+var ci = Ct(ii, ai, (e3, t2) => {
+  let n2 = new ri(e3);
+  return oi(n2, t2), n2;
+}, (e3, t2) => {
+  let n2 = new ni(e3);
+  return si(n2, t2).catch((e4) => n2.emit(`error`, e4)), n2;
+}, (e3, t2) => {
+  if (!t2?.length) throw TypeError(`no paths specified to add to archive`);
+});
+var li = (process.env.__FAKE_PLATFORM__ || process.platform) === `win32`;
+var { O_CREAT: ui, O_NOFOLLOW: di, O_TRUNC: fi, O_WRONLY: pi } = t.constants;
+var mi = Number(process.env.__FAKE_FS_O_FILENAME__) || t.constants.UV_FS_O_FILEMAP || 0;
+var hi = li && !!mi;
+var gi = 512 * 1024;
+var _i = mi | fi | ui | pi;
+var vi = !li && typeof di == `number` ? di | fi | ui | pi : null;
+var yi = vi === null ? hi ? (e3) => e3 < gi ? _i : `w` : () => `w` : () => vi;
+var bi = (e3, n2, r2) => {
+  try {
+    return t.lchownSync(e3, n2, r2);
+  } catch (e4) {
+    if (e4?.code !== `ENOENT`) throw e4;
+  }
+};
+var xi = (e3, n2, r2, i2) => {
+  t.lchown(e3, n2, r2, (e4) => {
+    i2(e4 && e4?.code !== `ENOENT` ? e4 : null);
+  });
+};
+var Si = (e3, t2, n2, r2, a2) => {
+  t2.isDirectory() ? Ci(i.resolve(e3, t2.name), n2, r2, (o2) => {
+    if (o2) return a2(o2);
+    xi(i.resolve(e3, t2.name), n2, r2, a2);
+  }) : xi(i.resolve(e3, t2.name), n2, r2, a2);
+};
+var Ci = (e3, n2, r2, i2) => {
+  t.readdir(e3, { withFileTypes: true }, (t2, a2) => {
+    if (t2) {
+      if (t2.code === `ENOENT`) return i2();
+      if (t2.code !== `ENOTDIR` && t2.code !== `ENOTSUP`) return i2(t2);
+    }
+    if (t2 || !a2.length) return xi(e3, n2, r2, i2);
+    let o2 = a2.length, s2 = null, c2 = (t3) => {
+      if (!s2) {
+        if (t3) return i2(s2 = t3);
+        if (--o2 === 0) return xi(e3, n2, r2, i2);
+      }
+    };
+    for (let t3 of a2) Si(e3, t3, n2, r2, c2);
+  });
+};
+var wi = (e3, t2, n2, r2) => {
+  t2.isDirectory() && Ti(i.resolve(e3, t2.name), n2, r2), bi(i.resolve(e3, t2.name), n2, r2);
+};
+var Ti = (e3, n2, r2) => {
+  let i2;
+  try {
+    i2 = t.readdirSync(e3, { withFileTypes: true });
+  } catch (t2) {
+    let i3 = t2;
+    if (i3?.code === `ENOENT`) return;
+    if (i3?.code === `ENOTDIR` || i3?.code === `ENOTSUP`) return bi(e3, n2, r2);
+    throw i3;
+  }
+  for (let t2 of i2) wi(e3, t2, n2, r2);
+  return bi(e3, n2, r2);
+};
+var Ei = class extends Error {
+  path;
+  code;
+  syscall = `chdir`;
+  constructor(e3, t2) {
+    super(`${t2}: Cannot cd into '${e3}'`), this.path = e3, this.code = t2;
+  }
+  get name() {
+    return `CwdError`;
+  }
+};
+var Di = class extends Error {
+  path;
+  symlink;
+  syscall = `symlink`;
+  code = `TAR_SYMLINK_ERROR`;
+  constructor(e3, t2) {
+    super(`TAR_SYMLINK_ERROR: Cannot extract through symbolic link`), this.symlink = e3, this.path = t2;
+  }
+  get name() {
+    return `SymlinkError`;
+  }
+};
+var Oi = (e3, n2) => {
+  t.stat(e3, (t2, r2) => {
+    (t2 || !r2.isDirectory()) && (t2 = new Ei(e3, t2?.code || `ENOTDIR`)), n2(t2);
+  });
+};
+var ki = (e3, r2, a2) => {
+  e3 = z(e3);
+  let o2 = r2.umask ?? 18, s2 = r2.mode | 448, c2 = (s2 & o2) !== 0, l2 = r2.uid, u2 = r2.gid, d2 = typeof l2 == `number` && typeof u2 == `number` && (l2 !== r2.processUid || u2 !== r2.processGid), f2 = r2.preserve, ee2 = r2.unlink, p2 = z(r2.cwd), m2 = (n2, r3) => {
+    n2 ? a2(n2) : r3 && d2 ? Ci(r3, l2, u2, (e4) => m2(e4)) : c2 ? t.chmod(e3, s2, a2) : a2();
+  };
+  if (e3 === p2) return Oi(e3, m2);
+  if (f2) return n.mkdir(e3, {
+    mode: s2,
+    recursive: true
+  }).then((e4) => m2(null, e4 ?? void 0), m2);
+  Ai(p2, z(i.relative(p2, e3)).split(`/`), s2, ee2, p2, void 0, m2);
+};
+var Ai = (e3, n2, r2, a2, o2, s2, c2) => {
+  if (n2.length === 0) return c2(null, s2);
+  let l2 = n2.shift(), u2 = z(i.resolve(e3 + `/` + l2));
+  t.mkdir(u2, r2, ji(u2, n2, r2, a2, o2, s2, c2));
+};
+var ji = (e3, n2, r2, i2, a2, o2, s2) => (c2) => {
+  c2 ? t.lstat(e3, (l2, u2) => {
+    if (l2) l2.path = l2.path && z(l2.path), s2(l2);
+    else if (u2.isDirectory()) Ai(e3, n2, r2, i2, a2, o2, s2);
+    else if (i2) t.unlink(e3, (c3) => {
+      if (c3) return s2(c3);
+      t.mkdir(e3, r2, ji(e3, n2, r2, i2, a2, o2, s2));
+    });
+    else {
+      if (u2.isSymbolicLink()) return s2(new Di(e3, e3 + `/` + n2.join(`/`)));
+      s2(c2);
+    }
+  }) : (o2 ||= e3, Ai(e3, n2, r2, i2, a2, o2, s2));
+};
+var Mi = (e3) => {
+  let n2 = false, r2;
+  try {
+    n2 = t.statSync(e3).isDirectory();
+  } catch (e4) {
+    r2 = e4?.code;
+  } finally {
+    if (!n2) throw new Ei(e3, r2 ?? `ENOTDIR`);
+  }
+};
+var Ni = (e3, n2) => {
+  e3 = z(e3);
+  let r2 = n2.umask ?? 18, a2 = n2.mode | 448, o2 = (a2 & r2) !== 0, s2 = n2.uid, c2 = n2.gid, l2 = typeof s2 == `number` && typeof c2 == `number` && (s2 !== n2.processUid || c2 !== n2.processGid), u2 = n2.preserve, d2 = n2.unlink, f2 = z(n2.cwd), ee2 = (n3) => {
+    n3 && l2 && Ti(n3, s2, c2), o2 && t.chmodSync(e3, a2);
+  };
+  if (e3 === f2) return Mi(f2), ee2();
+  if (u2) return ee2(t.mkdirSync(e3, {
+    mode: a2,
+    recursive: true
+  }) ?? void 0);
+  let p2 = z(i.relative(f2, e3)).split(`/`), m2;
+  for (let e4 = p2.shift(), n3 = f2; e4 && (n3 += `/` + e4); e4 = p2.shift()) {
+    n3 = z(i.resolve(n3));
+    try {
+      t.mkdirSync(n3, a2), m2 ||= n3;
+    } catch {
+      let e5 = t.lstatSync(n3);
+      if (e5.isDirectory()) continue;
+      if (d2) {
+        t.unlinkSync(n3), t.mkdirSync(n3, a2), m2 ||= n3;
+        continue;
+      } else if (e5.isSymbolicLink()) return new Di(n3, n3 + `/` + p2.join(`/`));
+    }
+  }
+  return ee2(m2);
+};
+var Pi = /* @__PURE__ */ Object.create(null);
+var Fi = 1e4;
+var Ii = /* @__PURE__ */ new Set();
+var Li = (e3) => {
+  Ii.has(e3) ? Ii.delete(e3) : Pi[e3] = e3.normalize(`NFD`).toLocaleLowerCase(`en`).toLocaleUpperCase(`en`), Ii.add(e3);
+  let t2 = Pi[e3], n2 = Ii.size - Fi;
+  if (n2 > Fi / 10) {
+    for (let e4 of Ii) if (Ii.delete(e4), delete Pi[e4], --n2 <= 0) break;
+  }
+  return t2;
+};
+var Ri = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === `win32`;
+var zi = (e3) => e3.split(`/`).slice(0, -1).reduce((e4, t2) => {
+  let n2 = e4.at(-1);
+  return n2 !== void 0 && (t2 = join(n2, t2)), e4.push(t2 || `/`), e4;
+}, []);
+var Bi = class {
+  #t = /* @__PURE__ */ new Map();
+  #i = /* @__PURE__ */ new Map();
+  #s = /* @__PURE__ */ new Set();
+  reserve(e3, t2) {
+    e3 = Ri ? [`win32 parallelization disabled`] : e3.map((e4) => Yn(join(Li(e4))));
+    let n2 = new Set(e3.map((e4) => zi(e4)).reduce((e4, t3) => e4.concat(t3)));
+    this.#i.set(t2, {
+      dirs: n2,
+      paths: e3
+    });
+    for (let n3 of e3) {
+      let e4 = this.#t.get(n3);
+      e4 ? e4.push(t2) : this.#t.set(n3, [t2]);
+    }
+    for (let e4 of n2) {
+      let n3 = this.#t.get(e4);
+      if (!n3) this.#t.set(e4, [/* @__PURE__ */ new Set([t2])]);
+      else {
+        let e5 = n3.at(-1);
+        e5 instanceof Set ? e5.add(t2) : n3.push(/* @__PURE__ */ new Set([t2]));
+      }
+    }
+    return this.#r(t2);
+  }
+  #n(e3) {
+    let t2 = this.#i.get(e3);
+    if (!t2) throw Error(`function does not have any path reservations`);
+    return {
+      paths: t2.paths.map((e4) => this.#t.get(e4)),
+      dirs: [...t2.dirs].map((e4) => this.#t.get(e4))
+    };
+  }
+  check(e3) {
+    let { paths: t2, dirs: n2 } = this.#n(e3);
+    return t2.every((t3) => t3 && t3[0] === e3) && n2.every((t3) => t3 && t3[0] instanceof Set && t3[0].has(e3));
+  }
+  #r(e3) {
+    return this.#s.has(e3) || !this.check(e3) ? false : (this.#s.add(e3), e3(() => this.#e(e3)), true);
+  }
+  #e(e3) {
+    if (!this.#s.has(e3)) return false;
+    let t2 = this.#i.get(e3);
+    if (!t2) throw Error(`invalid reservation`);
+    let { paths: n2, dirs: r2 } = t2, i2 = /* @__PURE__ */ new Set();
+    for (let t3 of n2) {
+      let n3 = this.#t.get(t3);
+      if (!n3 || n3?.[0] !== e3) continue;
+      let r3 = n3[1];
+      if (!r3) {
+        this.#t.delete(t3);
+        continue;
+      }
+      if (n3.shift(), typeof r3 == `function`) i2.add(r3);
+      else for (let e4 of r3) i2.add(e4);
+    }
+    for (let t3 of r2) {
+      let n3 = this.#t.get(t3), r3 = n3?.[0];
+      if (!(!n3 || !(r3 instanceof Set))) if (r3.size === 1 && n3.length === 1) {
+        this.#t.delete(t3);
+        continue;
+      } else if (r3.size === 1) {
+        n3.shift();
+        let e4 = n3[0];
+        typeof e4 == `function` && i2.add(e4);
+      } else r3.delete(e3);
+    }
+    return this.#s.delete(e3), i2.forEach((e4) => this.#r(e4)), true;
+  }
+};
+var Vi = () => process.umask();
+var Hi = /* @__PURE__ */ Symbol(`onEntry`);
+var Ui = /* @__PURE__ */ Symbol(`checkFs`);
+var Wi = /* @__PURE__ */ Symbol(`checkFs2`);
+var Gi = /* @__PURE__ */ Symbol(`isReusable`);
+var Q = /* @__PURE__ */ Symbol(`makeFs`);
+var Ki = /* @__PURE__ */ Symbol(`file`);
+var qi = /* @__PURE__ */ Symbol(`directory`);
+var Ji = /* @__PURE__ */ Symbol(`link`);
+var Yi = /* @__PURE__ */ Symbol(`symlink`);
+var Xi = /* @__PURE__ */ Symbol(`hardlink`);
+var Zi = /* @__PURE__ */ Symbol(`ensureNoSymlink`);
+var Qi = /* @__PURE__ */ Symbol(`unsupported`);
+var $i = /* @__PURE__ */ Symbol(`checkPath`);
+var ea = /* @__PURE__ */ Symbol(`stripAbsolutePath`);
+var ta = /* @__PURE__ */ Symbol(`mkdir`);
+var $ = /* @__PURE__ */ Symbol(`onError`);
+var na = /* @__PURE__ */ Symbol(`pending`);
+var ra = /* @__PURE__ */ Symbol(`pend`);
+var ia = /* @__PURE__ */ Symbol(`unpend`);
+var aa = /* @__PURE__ */ Symbol(`ended`);
+var oa = /* @__PURE__ */ Symbol(`maybeClose`);
+var sa = /* @__PURE__ */ Symbol(`skip`);
+var ca = /* @__PURE__ */ Symbol(`doChown`);
+var la = /* @__PURE__ */ Symbol(`uid`);
+var ua = /* @__PURE__ */ Symbol(`gid`);
+var da = /* @__PURE__ */ Symbol(`checkedCwd`);
+var fa = (process.env.TESTING_TAR_FAKE_PLATFORM || process.platform) === `win32`;
+var pa = 1024;
+var ma = (e3, n2) => {
+  if (!fa) return t.unlink(e3, n2);
+  let r2 = e3 + `.DELETE.` + randomBytes(16).toString(`hex`);
+  t.rename(e3, r2, (e4) => {
+    if (e4) return n2(e4);
+    t.unlink(r2, n2);
+  });
+};
+var ha = (e3) => {
+  if (!fa) return t.unlinkSync(e3);
+  let n2 = e3 + `.DELETE.` + randomBytes(16).toString(`hex`);
+  t.renameSync(e3, n2), t.unlinkSync(n2);
+};
+var ga = (e3, t2, n2) => e3 !== void 0 && e3 === e3 >>> 0 ? e3 : t2 !== void 0 && t2 === t2 >>> 0 ? t2 : n2;
+var _a = class extends Jn {
+  [aa] = false;
+  [da] = false;
+  [na] = 0;
+  reservations = new Bi();
+  transform;
+  writable = true;
+  readable = false;
+  uid;
+  gid;
+  setOwner;
+  preserveOwner;
+  processGid;
+  processUid;
+  maxDepth;
+  forceChown;
+  win32;
+  newer;
+  keep;
+  noMtime;
+  preservePaths;
+  unlink;
+  cwd;
+  strip;
+  processUmask;
+  umask;
+  dmode;
+  fmode;
+  chmod;
+  constructor(e3 = {}) {
+    if (e3.ondone = () => {
+      this[aa] = true, this[oa]();
+    }, super(e3), this.transform = e3.transform, this.chmod = !!e3.chmod, typeof e3.uid == `number` || typeof e3.gid == `number`) {
+      if (typeof e3.uid != `number` || typeof e3.gid != `number`) throw TypeError(`cannot set owner without number uid and gid`);
+      if (e3.preserveOwner) throw TypeError(`cannot preserve owner in archive and also set owner explicitly`);
+      this.uid = e3.uid, this.gid = e3.gid, this.setOwner = true;
+    } else this.uid = void 0, this.gid = void 0, this.setOwner = false;
+    this.preserveOwner = e3.preserveOwner === void 0 && typeof e3.uid != `number` ? !!(process.getuid && process.getuid() === 0) : !!e3.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof e3.maxDepth == `number` ? e3.maxDepth : pa, this.forceChown = e3.forceChown === true, this.win32 = !!e3.win32 || fa, this.newer = !!e3.newer, this.keep = !!e3.keep, this.noMtime = !!e3.noMtime, this.preservePaths = !!e3.preservePaths, this.unlink = !!e3.unlink, this.cwd = z(i.resolve(e3.cwd || process.cwd())), this.strip = Number(e3.strip) || 0, this.processUmask = this.chmod ? typeof e3.processUmask == `number` ? e3.processUmask : Vi() : 0, this.umask = typeof e3.umask == `number` ? e3.umask : this.processUmask, this.dmode = e3.dmode || 511 & ~this.umask, this.fmode = e3.fmode || 438 & ~this.umask, this.on(`entry`, (e4) => this[Hi](e4));
+  }
+  warn(e3, t2, n2 = {}) {
+    return (e3 === `TAR_BAD_ARCHIVE` || e3 === `TAR_ABORT`) && (n2.recoverable = false), super.warn(e3, t2, n2);
+  }
+  [oa]() {
+    this[aa] && this[na] === 0 && (this.emit(`prefinish`), this.emit(`finish`), this.emit(`end`));
+  }
+  [ea](e3, t2) {
+    let n2 = e3[t2], { type: r2 } = e3;
+    if (!n2 || this.preservePaths) return true;
+    let [a2, o2] = nr(n2), s2 = o2.replaceAll(/\\/g, `/`).split(`/`);
+    if (s2.includes(`..`) || fa && /^[a-z]:\.\.$/i.test(s2[0] ?? ``)) {
+      if (t2 === `path` || r2 === `Link`) return this.warn(`TAR_ENTRY_ERROR`, `${t2} contains '..'`, {
+        entry: e3,
+        [t2]: n2
+      }), false;
+      let a3 = i.posix.dirname(e3.path), o3 = i.posix.normalize(i.posix.join(a3, s2.join(`/`)));
+      if (o3.startsWith(`../`) || o3 === `..`) return this.warn(`TAR_ENTRY_ERROR`, `${t2} escapes extraction directory`, {
+        entry: e3,
+        [t2]: n2
+      }), false;
+    }
+    return a2 && (e3[t2] = String(o2), this.warn(`TAR_ENTRY_INFO`, `stripping ${a2} from absolute ${t2}`, {
+      entry: e3,
+      [t2]: n2
+    })), true;
+  }
+  [$i](e3) {
+    let t2 = z(e3.path), n2 = t2.split(`/`);
+    if (this.strip) {
+      if (n2.length < this.strip) return false;
+      if (e3.type === `Link`) {
+        let t3 = z(String(e3.linkpath)).split(`/`);
+        if (t3.length >= this.strip) e3.linkpath = t3.slice(this.strip).join(`/`);
+        else return false;
+      }
+      n2.splice(0, this.strip), e3.path = n2.join(`/`);
+    }
+    if (isFinite(this.maxDepth) && n2.length > this.maxDepth) return this.warn(`TAR_ENTRY_ERROR`, `path excessively deep`, {
+      entry: e3,
+      path: t2,
+      depth: n2.length,
+      maxDepth: this.maxDepth
+    }), false;
+    if (!this[ea](e3, `path`) || !this[ea](e3, `linkpath`)) return false;
+    if (e3.absolute = i.isAbsolute(e3.path) ? z(i.resolve(e3.path)) : z(i.resolve(this.cwd, e3.path)), !this.preservePaths && typeof e3.absolute == `string` && e3.absolute.indexOf(this.cwd + `/`) !== 0 && e3.absolute !== this.cwd) return this.warn(`TAR_ENTRY_ERROR`, `path escaped extraction target`, {
+      entry: e3,
+      path: z(e3.path),
+      resolvedPath: e3.absolute,
+      cwd: this.cwd
+    }), false;
+    if (e3.absolute === this.cwd && e3.type !== `Directory` && e3.type !== `GNUDumpDir`) return false;
+    if (this.win32) {
+      let { root: t3 } = i.win32.parse(String(e3.absolute));
+      e3.absolute = t3 + sr(String(e3.absolute).slice(t3.length));
+      let { root: n3 } = i.win32.parse(e3.path);
+      e3.path = n3 + sr(e3.path.slice(n3.length));
+    }
+    return true;
+  }
+  [Hi](e3) {
+    if (!this[$i](e3)) return e3.resume();
+    switch (ne.equal(typeof e3.absolute, `string`), e3.type) {
+      case `Directory`:
+      case `GNUDumpDir`:
+        e3.mode && (e3.mode |= 448);
+      case `File`:
+      case `OldFile`:
+      case `ContiguousFile`:
+      case `Link`:
+      case `SymbolicLink`:
+        return this[Ui](e3);
+      default:
+        return this[Qi](e3);
+    }
+  }
+  [$](e3, t2) {
+    e3.name === `CwdError` ? this.emit(`error`, e3) : (this.warn(`TAR_ENTRY_ERROR`, e3, { entry: t2 }), this[ia](), t2.resume());
+  }
+  [ta](e3, t2, n2) {
+    ki(z(e3), {
+      uid: this.uid,
+      gid: this.gid,
+      processUid: this.processUid,
+      processGid: this.processGid,
+      umask: this.processUmask,
+      preserve: this.preservePaths,
+      unlink: this.unlink,
+      cwd: this.cwd,
+      mode: t2
+    }, n2);
+  }
+  [ca](e3) {
+    return this.forceChown || this.preserveOwner && (typeof e3.uid == `number` && e3.uid !== this.processUid || typeof e3.gid == `number` && e3.gid !== this.processGid) || typeof this.uid == `number` && this.uid !== this.processUid || typeof this.gid == `number` && this.gid !== this.processGid;
+  }
+  [la](e3) {
+    return ga(this.uid, e3.uid, this.processUid);
+  }
+  [ua](e3) {
+    return ga(this.gid, e3.gid, this.processGid);
+  }
+  [Ki](e3, n2) {
+    let r2 = typeof e3.mode == `number` ? e3.mode & 4095 : this.fmode, i2 = new pt(String(e3.absolute), {
+      flags: yi(e3.size),
+      mode: r2,
+      autoClose: false
+    });
+    i2.on(`error`, (r3) => {
+      i2.fd && t.close(i2.fd, () => {
+      }), i2.write = () => true, this[$](r3, e3), n2();
+    });
+    let a2 = 1, o2 = (r3) => {
+      if (r3) {
+        i2.fd && t.close(i2.fd, () => {
+        }), this[$](r3, e3), n2();
+        return;
+      }
+      --a2 === 0 && i2.fd !== void 0 && t.close(i2.fd, (t2) => {
+        t2 ? this[$](t2, e3) : this[ia](), n2();
+      });
+    };
+    i2.on(`finish`, () => {
+      let n3 = String(e3.absolute), r3 = i2.fd;
+      if (typeof r3 == `number` && e3.mtime && !this.noMtime) {
+        a2++;
+        let i3 = e3.atime || /* @__PURE__ */ new Date(), s3 = e3.mtime;
+        t.futimes(r3, i3, s3, (e4) => e4 ? t.utimes(n3, i3, s3, (t2) => o2(t2 && e4)) : o2());
+      }
+      if (typeof r3 == `number` && this[ca](e3)) {
+        a2++;
+        let i3 = this[la](e3), s3 = this[ua](e3);
+        typeof i3 == `number` && typeof s3 == `number` && t.fchown(r3, i3, s3, (e4) => e4 ? t.chown(n3, i3, s3, (t2) => o2(t2 && e4)) : o2());
+      }
+      o2();
+    });
+    let s2 = this.transform && this.transform(e3) || e3;
+    s2 !== e3 && (s2.on(`error`, (t2) => {
+      this[$](t2, e3), n2();
+    }), e3.pipe(s2)), s2.pipe(i2);
+  }
+  [qi](e3, n2) {
+    let r2 = typeof e3.mode == `number` ? e3.mode & 4095 : this.dmode;
+    this[ta](String(e3.absolute), r2, (r3) => {
+      if (r3) {
+        this[$](r3, e3), n2();
+        return;
+      }
+      let i2 = 1, a2 = () => {
+        --i2 === 0 && (n2(), this[ia](), e3.resume());
+      };
+      e3.mtime && !this.noMtime && (i2++, t.utimes(String(e3.absolute), e3.atime || /* @__PURE__ */ new Date(), e3.mtime, a2)), this[ca](e3) && (i2++, t.chown(String(e3.absolute), Number(this[la](e3)), Number(this[ua](e3)), a2)), a2();
+    });
+  }
+  [Qi](e3) {
+    e3.unsupported = true, this.warn(`TAR_ENTRY_UNSUPPORTED`, `unsupported entry type: ${e3.type}`, { entry: e3 }), e3.resume();
+  }
+  [Yi](e3, t2) {
+    let n2 = z(i.relative(this.cwd, i.resolve(i.dirname(String(e3.absolute)), String(e3.linkpath)))).split(`/`);
+    this[Zi](e3, this.cwd, n2, () => this[Ji](e3, String(e3.linkpath), `symlink`, t2), (n3) => {
+      this[$](n3, e3), t2();
+    });
+  }
+  [Xi](e3, t2) {
+    let n2 = z(i.resolve(this.cwd, String(e3.linkpath))), r2 = z(String(e3.linkpath)).split(`/`);
+    this[Zi](e3, this.cwd, r2, () => this[Ji](e3, n2, `link`, t2), (n3) => {
+      this[$](n3, e3), t2();
+    });
+  }
+  [Zi](e3, n2, r2, a2, o2) {
+    let s2 = r2.shift();
+    if (this.preservePaths || s2 === void 0) return a2();
+    let c2 = i.resolve(n2, s2);
+    t.lstat(c2, (t2, n3) => {
+      if (t2) return a2();
+      if (n3?.isSymbolicLink()) return o2(new Di(c2, i.resolve(c2, r2.join(`/`))));
+      this[Zi](e3, c2, r2, a2, o2);
+    });
+  }
+  [ra]() {
+    this[na]++;
+  }
+  [ia]() {
+    this[na]--, this[oa]();
+  }
+  [sa](e3) {
+    this[ia](), e3.resume();
+  }
+  [Gi](e3, t2) {
+    return e3.type === `File` && !this.unlink && t2.isFile() && t2.nlink <= 1 && !fa;
+  }
+  [Ui](e3) {
+    this[ra]();
+    let t2 = [e3.path];
+    e3.linkpath && t2.push(e3.linkpath), this.reservations.reserve(t2, (t3) => this[Wi](e3, t3));
+  }
+  [Wi](e3, n2) {
+    let r2 = (e4) => {
+      n2(e4);
+    }, a2 = () => {
+      this[ta](this.cwd, this.dmode, (t2) => {
+        if (t2) {
+          this[$](t2, e3), r2();
+          return;
+        }
+        this[da] = true, o2();
+      });
+    }, o2 = () => {
+      if (e3.absolute !== this.cwd) {
+        let t2 = z(i.dirname(String(e3.absolute)));
+        if (t2 !== this.cwd) return this[ta](t2, this.dmode, (t3) => {
+          if (t3) {
+            this[$](t3, e3), r2();
+            return;
+          }
+          s2();
+        });
+      }
+      s2();
+    }, s2 = () => {
+      t.lstat(String(e3.absolute), (n3, i2) => {
+        if (i2 && (this.keep || this.newer && i2.mtime > (e3.mtime ?? i2.mtime))) {
+          this[sa](e3), r2();
+          return;
+        }
+        if (n3 || this[Gi](e3, i2)) return this[Q](null, e3, r2);
+        if (i2.isDirectory()) {
+          if (e3.type === `Directory`) {
+            let n4 = this.chmod && e3.mode && (i2.mode & 4095) !== e3.mode, a3 = (t2) => this[Q](t2 ?? null, e3, r2);
+            return n4 ? t.chmod(String(e3.absolute), Number(e3.mode), a3) : a3();
+          }
+          if (e3.absolute !== this.cwd) return t.rmdir(String(e3.absolute), (t2) => this[Q](t2 ?? null, e3, r2));
+        }
+        if (e3.absolute === this.cwd) return this[Q](null, e3, r2);
+        ma(String(e3.absolute), (t2) => this[Q](t2 ?? null, e3, r2));
+      });
+    };
+    this[da] ? o2() : a2();
+  }
+  [Q](e3, t2, n2) {
+    if (e3) {
+      this[$](e3, t2), n2();
+      return;
+    }
+    switch (t2.type) {
+      case `File`:
+      case `OldFile`:
+      case `ContiguousFile`:
+        return this[Ki](t2, n2);
+      case `Link`:
+        return this[Xi](t2, n2);
+      case `SymbolicLink`:
+        return this[Yi](t2, n2);
+      case `Directory`:
+      case `GNUDumpDir`:
+        return this[qi](t2, n2);
+    }
+  }
+  [Ji](e3, n2, r2, i2) {
+    t[r2](n2, String(e3.absolute), (t2) => {
+      t2 ? this[$](t2, e3) : (this[ia](), e3.resume()), i2();
+    });
+  }
+};
+var va = (e3) => {
+  try {
+    return [null, e3()];
+  } catch (e4) {
+    return [e4, null];
+  }
+};
+var ya = class extends _a {
+  sync = true;
+  [Q](e3, t2) {
+    return super[Q](e3, t2, () => {
+    });
+  }
+  [Ui](e3) {
+    if (!this[da]) {
+      let t2 = this[ta](this.cwd, this.dmode);
+      if (t2) return this[$](t2, e3);
+      this[da] = true;
+    }
+    if (e3.absolute !== this.cwd) {
+      let t2 = z(i.dirname(String(e3.absolute)));
+      if (t2 !== this.cwd) {
+        let n3 = this[ta](t2, this.dmode);
+        if (n3) return this[$](n3, e3);
+      }
+    }
+    let [n2, r2] = va(() => t.lstatSync(String(e3.absolute)));
+    if (r2 && (this.keep || this.newer && r2.mtime > (e3.mtime ?? r2.mtime))) return this[sa](e3);
+    if (n2 || this[Gi](e3, r2)) return this[Q](null, e3);
+    if (r2.isDirectory()) {
+      if (e3.type === `Directory`) {
+        let [n4] = this.chmod && e3.mode && (r2.mode & 4095) !== e3.mode ? va(() => {
+          t.chmodSync(String(e3.absolute), Number(e3.mode));
+        }) : [];
+        return this[Q](n4, e3);
+      }
+      let [n3] = va(() => t.rmdirSync(String(e3.absolute)));
+      this[Q](n3, e3);
+    }
+    let [a2] = e3.absolute === this.cwd ? [] : va(() => ha(String(e3.absolute)));
+    this[Q](a2, e3);
+  }
+  [Ki](e3, n2) {
+    let r2 = typeof e3.mode == `number` ? e3.mode & 4095 : this.fmode, i2 = (r3) => {
+      let i3;
+      try {
+        t.closeSync(a2);
+      } catch (e4) {
+        i3 = e4;
+      }
+      (r3 || i3) && this[$](r3 || i3, e3), n2();
+    }, a2;
+    try {
+      a2 = t.openSync(String(e3.absolute), yi(e3.size), r2);
+    } catch (e4) {
+      return i2(e4);
+    }
+    let o2 = this.transform && this.transform(e3) || e3;
+    o2 !== e3 && (o2.on(`error`, (t2) => this[$](t2, e3)), e3.pipe(o2)), o2.on(`data`, (e4) => {
+      try {
+        t.writeSync(a2, e4, 0, e4.length);
+      } catch (e5) {
+        i2(e5);
+      }
+    }), o2.on(`end`, () => {
+      let n3 = null;
+      if (e3.mtime && !this.noMtime) {
+        let r3 = e3.atime || /* @__PURE__ */ new Date(), i3 = e3.mtime;
+        try {
+          t.futimesSync(a2, r3, i3);
+        } catch (a3) {
+          try {
+            t.utimesSync(String(e3.absolute), r3, i3);
+          } catch {
+            n3 = a3;
+          }
+        }
+      }
+      if (this[ca](e3)) {
+        let r3 = this[la](e3), i3 = this[ua](e3);
+        try {
+          t.fchownSync(a2, Number(r3), Number(i3));
+        } catch (a3) {
+          try {
+            t.chownSync(String(e3.absolute), Number(r3), Number(i3));
+          } catch {
+            n3 ||= a3;
+          }
+        }
+      }
+      i2(n3);
+    });
+  }
+  [qi](e3, n2) {
+    let r2 = typeof e3.mode == `number` ? e3.mode & 4095 : this.dmode, i2 = this[ta](String(e3.absolute), r2);
+    if (i2) {
+      this[$](i2, e3), n2();
+      return;
+    }
+    if (e3.mtime && !this.noMtime) try {
+      t.utimesSync(String(e3.absolute), e3.atime || /* @__PURE__ */ new Date(), e3.mtime);
+    } catch {
+    }
+    if (this[ca](e3)) try {
+      t.chownSync(String(e3.absolute), Number(this[la](e3)), Number(this[ua](e3)));
+    } catch {
+    }
+    n2(), e3.resume();
+  }
+  [ta](e3, t2) {
+    try {
+      return Ni(z(e3), {
+        uid: this.uid,
+        gid: this.gid,
+        processUid: this.processUid,
+        processGid: this.processGid,
+        umask: this.processUmask,
+        preserve: this.preservePaths,
+        unlink: this.unlink,
+        cwd: this.cwd,
+        mode: t2
+      });
+    } catch (e4) {
+      return e4;
+    }
+  }
+  [Zi](e3, n2, r2, a2, o2) {
+    if (this.preservePaths || r2.length === 0) return a2();
+    let s2 = n2;
+    for (let e4 of r2) {
+      s2 = i.resolve(s2, e4);
+      let [c2, l2] = va(() => t.lstatSync(s2));
+      if (c2) return a2();
+      if (l2.isSymbolicLink()) return o2(new Di(s2, i.resolve(n2, r2.join(`/`))));
+    }
+    a2();
+  }
+  [Ji](e3, n2, r2, i2) {
+    let a2 = `${r2}Sync`;
+    try {
+      t[a2](n2, String(e3.absolute)), i2(), e3.resume();
+    } catch (t2) {
+      return this[$](t2, e3);
+    }
+  }
+};
+var ba = Ct((e3) => {
+  let n2 = new ya(e3), r2 = e3.file, i2 = t.statSync(r2);
+  new ft(r2, {
+    readSize: e3.maxReadSize || 16 * 1024 * 1024,
+    size: i2.size
+  }).pipe(n2);
+}, (e3, n2) => {
+  let r2 = new _a(e3), i2 = e3.maxReadSize || 16 * 1024 * 1024, a2 = e3.file;
+  return new Promise((e4, n3) => {
+    r2.on(`error`, n3), r2.on(`close`, e4), t.stat(a2, (e5, t2) => {
+      if (e5) n3(e5);
+      else {
+        let e6 = new dt(a2, {
+          readSize: i2,
+          size: t2.size
+        });
+        e6.on(`error`, n3), e6.pipe(r2);
+      }
+    });
+  });
+}, (e3) => new ya(e3), (e3) => new _a(e3), (e3, t2) => {
+  t2?.length && Zn(e3, t2);
+});
+var xa = (e3, n2) => {
+  let r2 = new ri(e3), i2 = true, a2, o2;
+  try {
+    try {
+      a2 = t.openSync(e3.file, `r+`);
+    } catch (n3) {
+      if (n3?.code === `ENOENT`) a2 = t.openSync(e3.file, `w+`);
+      else throw n3;
+    }
+    let s2 = t.fstatSync(a2), c2 = Buffer.alloc(512);
+    t: for (o2 = 0; o2 < s2.size; o2 += 512) {
+      for (let e4 = 0, n4 = 0; e4 < 512; e4 += n4) {
+        if (n4 = t.readSync(a2, c2, e4, c2.length - e4, o2 + e4), o2 === 0 && c2[0] === 31 && c2[1] === 139) throw Error(`cannot append to compressed archives`);
+        if (!n4) break t;
+      }
+      let n3 = new I(c2);
+      if (!n3.cksumValid) break;
+      let r3 = 512 * Math.ceil((n3.size || 0) / 512);
+      if (o2 + r3 + 512 > s2.size) break;
+      o2 += r3, e3.mtimeCache && n3.mtime && e3.mtimeCache.set(String(n3.path), n3.mtime);
+    }
+    i2 = false, Sa(e3, r2, o2, a2, n2);
+  } finally {
+    if (i2) try {
+      t.closeSync(a2);
+    } catch {
+    }
+  }
+};
+var Sa = (e3, t2, n2, r2, i2) => {
+  let a2 = new mt(e3.file, {
+    fd: r2,
+    start: n2
+  });
+  t2.pipe(a2), wa(t2, i2);
+};
+var Ca = (e3, n2) => {
+  n2 = Array.from(n2);
+  let r2 = new ni(e3), i2 = (n3, r3, i3) => {
+    let a2 = (e4, r4) => {
+      e4 ? t.close(n3, (t2) => i3(e4)) : i3(null, r4);
+    }, o2 = 0;
+    if (r3 === 0) return a2(null, 0);
+    let s2 = 0, c2 = Buffer.alloc(512), l2 = (i4, u2) => {
+      if (i4 || u2 === void 0) return a2(i4);
+      if (s2 += u2, s2 < 512 && u2) return t.read(n3, c2, s2, c2.length - s2, o2 + s2, l2);
+      if (o2 === 0 && c2[0] === 31 && c2[1] === 139) return a2(Error(`cannot append to compressed archives`));
+      if (s2 < 512) return a2(null, o2);
+      let d2 = new I(c2);
+      if (!d2.cksumValid) return a2(null, o2);
+      let f2 = 512 * Math.ceil((d2.size ?? 0) / 512);
+      if (o2 + f2 + 512 > r3 || (o2 += f2 + 512, o2 >= r3)) return a2(null, o2);
+      e3.mtimeCache && d2.mtime && e3.mtimeCache.set(String(d2.path), d2.mtime), s2 = 0, t.read(n3, c2, 0, 512, o2, l2);
+    };
+    t.read(n3, c2, 0, 512, o2, l2);
+  };
+  return new Promise((a2, o2) => {
+    r2.on(`error`, o2);
+    let s2 = `r+`, c2 = (l2, u2) => {
+      if (l2 && l2.code === `ENOENT` && s2 === `r+`) return s2 = `w+`, t.open(e3.file, s2, c2);
+      if (l2 || !u2) return o2(l2);
+      t.fstat(u2, (s3, c3) => {
+        if (s3) return t.close(u2, () => o2(s3));
+        i2(u2, c3.size, (t2, i3) => {
+          if (t2) return o2(t2);
+          let s4 = new pt(e3.file, {
+            fd: u2,
+            start: i3
+          });
+          r2.pipe(s4), s4.on(`error`, o2), s4.on(`close`, a2), Ta(r2, n2);
+        });
+      });
+    };
+    t.open(e3.file, s2, c2);
+  });
+};
+var wa = (e3, t2) => {
+  t2.forEach((t3) => {
+    t3.charAt(0) === `@` ? Qn({
+      file: i.resolve(e3.cwd, t3.slice(1)),
+      sync: true,
+      noResume: true,
+      onReadEntry: (t4) => e3.add(t4)
+    }) : e3.add(t3);
+  }), e3.end();
+};
+var Ta = async (e3, t2) => {
+  for (let n2 of t2) n2.charAt(0) === `@` ? await Qn({
+    file: i.resolve(String(e3.cwd), n2.slice(1)),
+    noResume: true,
+    onReadEntry: (t3) => e3.add(t3)
+  }) : e3.add(n2);
+  e3.end();
+};
+var Ea = Ct(xa, Ca, () => {
+  throw TypeError(`file is required`);
+}, () => {
+  throw TypeError(`file is required`);
+}, (e3, t2) => {
+  if (!bt(e3)) throw TypeError(`file is required`);
+  if (e3.gzip || e3.brotli || e3.zstd || e3.file.endsWith(`.br`) || e3.file.endsWith(`.tbr`)) throw TypeError(`cannot append to compressed archives`);
+  if (!t2?.length) throw TypeError(`no paths specified to add/replace`);
+});
+Ct(Ea.syncFile, Ea.asyncFile, Ea.syncNoFile, Ea.asyncNoFile, (e3, t2 = []) => {
+  Ea.validate?.(e3, t2), Da(e3);
+});
+var Da = (e3) => {
+  let t2 = e3.filter;
+  e3.mtimeCache ||= /* @__PURE__ */ new Map(), e3.filter = t2 ? (n2, r2) => t2(n2, r2) && !((e3.mtimeCache?.get(n2) ?? r2.mtime ?? 0) > (r2.mtime ?? 0)) : (t3, n2) => !((e3.mtimeCache?.get(t3) ?? n2.mtime ?? 0) > (n2.mtime ?? 0));
+};
+
+export { ce as t };