first commit

62 files changed, 5989 insertions, 0 deletions

diff --git a/node_modules/tar/dist/esm/create.d.ts b/node_modules/tar/dist/esm/create.d.ts
new file mode 100644
index 0000000..867c5e9
--- /dev/null
+++ b/node_modules/tar/dist/esm/create.d.ts
@@ -0,0 +1,3 @@
+import { Pack, PackSync } from './pack.js';
+export declare const create: import("./make-command.js").TarCommand<Pack, PackSync>;
+//# sourceMappingURL=create.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/create.js b/node_modules/tar/dist/esm/create.js
new file mode 100644
index 0000000..4e88751
--- /dev/null
+++ b/node_modules/tar/dist/esm/create.js
@@ -0,0 +1,76 @@
+import { WriteStream, WriteStreamSync } from '@isaacs/fs-minipass';
+import path from 'node:path';
+import { list } from './list.js';
+import { makeCommand } from './make-command.js';
+import { Pack, PackSync } from './pack.js';
+const createFileSync = (opt, files) => {
+    const p = new PackSync(opt);
+    const stream = new WriteStreamSync(opt.file, {
+        mode: opt.mode || 0o666,
+    });
+    p.pipe(stream);
+    addFilesSync(p, files);
+};
+const createFile = (opt, files) => {
+    const p = new Pack(opt);
+    const stream = new WriteStream(opt.file, {
+        mode: opt.mode || 0o666,
+    });
+    p.pipe(stream);
+    const promise = new Promise((res, rej) => {
+        stream.on('error', rej);
+        stream.on('close', res);
+        p.on('error', rej);
+    });
+    addFilesAsync(p, files).catch(er => p.emit('error', er));
+    return promise;
+};
+const addFilesSync = (p, files) => {
+    files.forEach(file => {
+        if (file.charAt(0) === '@') {
+            list({
+                file: path.resolve(p.cwd, file.slice(1)),
+                sync: true,
+                noResume: true,
+                onReadEntry: entry => p.add(entry),
+            });
+        }
+        else {
+            p.add(file);
+        }
+    });
+    p.end();
+};
+const addFilesAsync = async (p, files) => {
+    for (const file of files) {
+        if (file.charAt(0) === '@') {
+            await list({
+                file: path.resolve(String(p.cwd), file.slice(1)),
+                noResume: true,
+                onReadEntry: entry => {
+                    p.add(entry);
+                },
+            });
+        }
+        else {
+            p.add(file);
+        }
+    }
+    p.end();
+};
+const createSync = (opt, files) => {
+    const p = new PackSync(opt);
+    addFilesSync(p, files);
+    return p;
+};
+const createAsync = (opt, files) => {
+    const p = new Pack(opt);
+    addFilesAsync(p, files).catch(er => p.emit('error', er));
+    return p;
+};
+export const create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => {
+    if (!files?.length) {
+        throw new TypeError('no paths specified to add to archive');
+    }
+});
+//# sourceMappingURL=create.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/cwd-error.d.ts b/node_modules/tar/dist/esm/cwd-error.d.ts
new file mode 100644
index 0000000..394da16
--- /dev/null
+++ b/node_modules/tar/dist/esm/cwd-error.d.ts
@@ -0,0 +1,8 @@
+export declare class CwdError extends Error {
+    path: string;
+    code: string;
+    syscall: "chdir";
+    constructor(path: string, code: string);
+    get name(): string;
+}
+//# sourceMappingURL=cwd-error.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/cwd-error.js b/node_modules/tar/dist/esm/cwd-error.js
new file mode 100644
index 0000000..289a066
--- /dev/null
+++ b/node_modules/tar/dist/esm/cwd-error.js
@@ -0,0 +1,14 @@
+export class CwdError extends Error {
+    path;
+    code;
+    syscall = 'chdir';
+    constructor(path, code) {
+        super(`${code}: Cannot cd into '${path}'`);
+        this.path = path;
+        this.code = code;
+    }
+    get name() {
+        return 'CwdError';
+    }
+}
+//# sourceMappingURL=cwd-error.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/extract.d.ts b/node_modules/tar/dist/esm/extract.d.ts
new file mode 100644
index 0000000..9cbb18c
--- /dev/null
+++ b/node_modules/tar/dist/esm/extract.d.ts
@@ -0,0 +1,3 @@
+import { Unpack, UnpackSync } from './unpack.js';
+export declare const extract: import("./make-command.js").TarCommand<Unpack, UnpackSync>;
+//# sourceMappingURL=extract.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/extract.js b/node_modules/tar/dist/esm/extract.js
new file mode 100644
index 0000000..2274fee
--- /dev/null
+++ b/node_modules/tar/dist/esm/extract.js
@@ -0,0 +1,49 @@
+// tar -x
+import * as fsm from '@isaacs/fs-minipass';
+import fs from 'node:fs';
+import { filesFilter } from './list.js';
+import { makeCommand } from './make-command.js';
+import { Unpack, UnpackSync } from './unpack.js';
+const extractFileSync = (opt) => {
+    const u = new UnpackSync(opt);
+    const file = opt.file;
+    const stat = fs.statSync(file);
+    // This trades a zero-byte read() syscall for a stat
+    // However, it will usually result in less memory allocation
+    const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+    const stream = new fsm.ReadStreamSync(file, {
+        readSize: readSize,
+        size: stat.size,
+    });
+    stream.pipe(u);
+};
+const extractFile = (opt, _) => {
+    const u = new Unpack(opt);
+    const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+    const file = opt.file;
+    const p = new Promise((resolve, reject) => {
+        u.on('error', reject);
+        u.on('close', resolve);
+        // This trades a zero-byte read() syscall for a stat
+        // However, it will usually result in less memory allocation
+        fs.stat(file, (er, stat) => {
+            if (er) {
+                reject(er);
+            }
+            else {
+                const stream = new fsm.ReadStream(file, {
+                    readSize: readSize,
+                    size: stat.size,
+                });
+                stream.on('error', reject);
+                stream.pipe(u);
+            }
+        });
+    });
+    return p;
+};
+export const extract = makeCommand(extractFileSync, extractFile, opt => new UnpackSync(opt), opt => new Unpack(opt), (opt, files) => {
+    if (files?.length)
+        filesFilter(opt, files);
+});
+//# sourceMappingURL=extract.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/get-write-flag.d.ts b/node_modules/tar/dist/esm/get-write-flag.d.ts
new file mode 100644
index 0000000..d35ec71
--- /dev/null
+++ b/node_modules/tar/dist/esm/get-write-flag.d.ts
@@ -0,0 +1,2 @@
+export declare const getWriteFlag: (() => string) | ((size: number) => number | "w");
+//# sourceMappingURL=get-write-flag.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/get-write-flag.js b/node_modules/tar/dist/esm/get-write-flag.js
new file mode 100644
index 0000000..73d5745
--- /dev/null
+++ b/node_modules/tar/dist/esm/get-write-flag.js
@@ -0,0 +1,26 @@
+// Get the appropriate flag to use for creating files
+// We use fmap on Windows platforms for files less than
+// 512kb.  This is a fairly low limit, but avoids making
+// things slower in some cases.  Since most of what this
+// library is used for is extracting tarballs of many
+// relatively small files in npm packages and the like,
+// it can be a big boost on Windows platforms.
+import fs from 'fs';
+const platform = process.env.__FAKE_PLATFORM__ || process.platform;
+const isWindows = platform === 'win32';
+/* c8 ignore start */
+const { O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = fs.constants;
+const UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) ||
+    fs.constants.UV_FS_O_FILEMAP ||
+    0;
+/* c8 ignore stop */
+const fMapEnabled = isWindows && !!UV_FS_O_FILEMAP;
+const fMapLimit = 512 * 1024;
+const fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
+const noFollowFlag = !isWindows && typeof O_NOFOLLOW === 'number' ?
+    O_NOFOLLOW | O_TRUNC | O_CREAT | O_WRONLY
+    : null;
+export const getWriteFlag = noFollowFlag !== null ? () => noFollowFlag
+    : !fMapEnabled ? () => 'w'
+        : (size) => (size < fMapLimit ? fMapFlag : 'w');
+//# sourceMappingURL=get-write-flag.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/header.d.ts b/node_modules/tar/dist/esm/header.d.ts
new file mode 100644
index 0000000..58f1b43
--- /dev/null
+++ b/node_modules/tar/dist/esm/header.d.ts
@@ -0,0 +1,53 @@
+import type { EntryTypeCode, EntryTypeName } from './types.js';
+export type HeaderData = {
+    path?: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    size?: number;
+    cksum?: number;
+    type?: EntryTypeName | 'Unsupported';
+    linkpath?: string;
+    uname?: string;
+    gname?: string;
+    devmaj?: number;
+    devmin?: number;
+    atime?: Date;
+    ctime?: Date;
+    mtime?: Date;
+    charset?: string;
+    comment?: string;
+    dev?: number;
+    ino?: number;
+    nlink?: number;
+};
+export declare class Header implements HeaderData {
+    #private;
+    cksumValid: boolean;
+    needPax: boolean;
+    nullBlock: boolean;
+    block?: Buffer;
+    path?: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    size?: number;
+    cksum?: number;
+    linkpath?: string;
+    uname?: string;
+    gname?: string;
+    devmaj: number;
+    devmin: number;
+    atime?: Date;
+    ctime?: Date;
+    mtime?: Date;
+    charset?: string;
+    comment?: string;
+    constructor(data?: Buffer | HeaderData, off?: number, ex?: HeaderData, gex?: HeaderData);
+    decode(buf: Buffer, off: number, ex?: HeaderData, gex?: HeaderData): void;
+    encode(buf?: Buffer, off?: number): boolean;
+    get type(): EntryTypeName;
+    get typeKey(): EntryTypeCode | 'Unsupported';
+    set type(type: EntryTypeCode | EntryTypeName | 'Unsupported');
+}
+//# sourceMappingURL=header.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/header.js b/node_modules/tar/dist/esm/header.js
new file mode 100644
index 0000000..068c4ea
--- /dev/null
+++ b/node_modules/tar/dist/esm/header.js
@@ -0,0 +1,311 @@
+// parse a 512-byte header block to a data object, or vice-versa
+// encode returns `true` if a pax extended header is needed, because
+// the data could not be faithfully encoded in a simple header.
+// (Also, check header.needPax to see if it needs a pax header.)
+import { posix as pathModule } from 'node:path';
+import * as large from './large-numbers.js';
+import * as types from './types.js';
+const notNegative = (n) => n === undefined || n < 0 ? undefined : n;
+export class Header {
+    cksumValid = false;
+    needPax = false;
+    nullBlock = false;
+    block;
+    path;
+    mode;
+    uid;
+    gid;
+    size;
+    cksum;
+    #type = 'Unsupported';
+    linkpath;
+    uname;
+    gname;
+    devmaj = 0;
+    devmin = 0;
+    atime;
+    ctime;
+    mtime;
+    charset;
+    comment;
+    constructor(data, off = 0, ex, gex) {
+        if (Buffer.isBuffer(data)) {
+            this.decode(data, off || 0, ex, gex);
+        }
+        else if (data) {
+            this.#slurp(data);
+        }
+    }
+    decode(buf, off, ex, gex) {
+        if (!off) {
+            off = 0;
+        }
+        if (!buf || !(buf.length >= off + 512)) {
+            throw new Error('need 512 bytes for header');
+        }
+        // Decode the typeflag (independent of any pending PAX/GNU extended header)
+        // up front so we can tell whether THIS block is itself an intermediary
+        // extension header (PAX `x`/`g`, GNU long-name `L`, GNU long-link `K`).
+        // Per POSIX pax, a PAX extended header describes the *next file entry*, not
+        // the extension headers that may sit between it and that file. Applying the
+        // pending PAX overrides (notably `size`) to an intervening `L`/`K`/`x`/`g`
+        // header desynchronizes the stream relative to other tar implementations
+        // and enables tar interpretation-conflict / file-smuggling attacks.
+        const t = decString(buf, off + 156, 1);
+        const isNormalFS = types.normalFsTypes.has(t);
+        const exForFields = isNormalFS ? ex : undefined;
+        const gexForFields = isNormalFS ? gex : undefined;
+        this.path = exForFields?.path ?? decString(buf, off, 100);
+        this.mode =
+            exForFields?.mode ??
+                gexForFields?.mode ??
+                decNumber(buf, off + 100, 8);
+        this.uid =
+            exForFields?.uid ?? gexForFields?.uid ?? decNumber(buf, off + 108, 8);
+        this.gid =
+            exForFields?.gid ?? gexForFields?.gid ?? decNumber(buf, off + 116, 8);
+        this.size = notNegative(exForFields?.size ??
+            gexForFields?.size ??
+            decNumber(buf, off + 124, 12));
+        this.mtime =
+            exForFields?.mtime ??
+                gexForFields?.mtime ??
+                decDate(buf, off + 136, 12);
+        this.cksum = decNumber(buf, off + 148, 12);
+        // if we have extended or global extended headers, apply them now
+        // See https://github.com/npm/node-tar/pull/187
+        // Apply global before local, so it overrides. Never slurp the pending
+        // extended-header fields onto an intermediary extension header.
+        if (gexForFields)
+            this.#slurp(gexForFields, true);
+        if (exForFields)
+            this.#slurp(exForFields);
+        // old tar versions marked dirs as a file with a trailing /
+        if (types.isCode(t)) {
+            this.#type = t || '0';
+        }
+        if (this.#type === '0' && this.path.slice(-1) === '/') {
+            this.#type = '5';
+        }
+        // tar implementations sometimes incorrectly put the stat(dir).size
+        // as the size in the tarball, even though Directory entries are
+        // not able to have any body at all.  In the very rare chance that
+        // it actually DOES have a body, we weren't going to do anything with
+        // it anyway, and it'll just be a warning about an invalid header.
+        if (this.#type === '5') {
+            this.size = 0;
+        }
+        this.linkpath = decString(buf, off + 157, 100);
+        if (buf.subarray(off + 257, off + 265).toString() === 'ustar\u000000') {
+            /* c8 ignore start */
+            this.uname =
+                exForFields?.uname ??
+                    gexForFields?.uname ??
+                    decString(buf, off + 265, 32);
+            this.gname =
+                exForFields?.gname ??
+                    gexForFields?.gname ??
+                    decString(buf, off + 297, 32);
+            this.devmaj =
+                exForFields?.devmaj ??
+                    gexForFields?.devmaj ??
+                    decNumber(buf, off + 329, 8) ??
+                    0;
+            this.devmin =
+                exForFields?.devmin ??
+                    gexForFields?.devmin ??
+                    decNumber(buf, off + 337, 8) ??
+                    0;
+            /* c8 ignore stop */
+            if (buf[off + 475] !== 0) {
+                // definitely a prefix, definitely >130 chars.
+                const prefix = decString(buf, off + 345, 155);
+                this.path = prefix + '/' + this.path;
+            }
+            else {
+                const prefix = decString(buf, off + 345, 130);
+                if (prefix) {
+                    this.path = prefix + '/' + this.path;
+                }
+                /* c8 ignore start */
+                this.atime = ex?.atime ?? gex?.atime ?? decDate(buf, off + 476, 12);
+                this.ctime = ex?.ctime ?? gex?.ctime ?? decDate(buf, off + 488, 12);
+                /* c8 ignore stop */
+            }
+        }
+        let sum = 8 * 0x20;
+        for (let i = off; i < off + 148; i++) {
+            sum += buf[i];
+        }
+        for (let i = off + 156; i < off + 512; i++) {
+            sum += buf[i];
+        }
+        this.cksumValid = sum === this.cksum;
+        if (this.cksum === undefined && sum === 8 * 0x20) {
+            this.nullBlock = true;
+        }
+    }
+    #slurp(ex, gex = false) {
+        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+            // we slurp in everything except for the path attribute in
+            // a global extended header, because that's weird. Also, any
+            // null/undefined values are ignored.
+            return !(v === null ||
+                v === undefined ||
+                (k === 'size' && Number(v) < 0) ||
+                (k === 'path' && gex) ||
+                (k === 'linkpath' && gex) ||
+                k === 'global');
+        })));
+    }
+    encode(buf, off = 0) {
+        if (!buf) {
+            buf = this.block = Buffer.alloc(512);
+        }
+        if (this.#type === 'Unsupported') {
+            this.#type = '0';
+        }
+        if (!(buf.length >= off + 512)) {
+            throw new Error('need 512 bytes for header');
+        }
+        const prefixSize = this.ctime || this.atime ? 130 : 155;
+        const split = splitPrefix(this.path || '', prefixSize);
+        const path = split[0];
+        const prefix = split[1];
+        this.needPax = !!split[2];
+        this.needPax = encString(buf, off, 100, path) || this.needPax;
+        this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
+        this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
+        this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
+        this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
+        this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
+        buf[off + 156] = Number(this.#type.codePointAt(0));
+        this.needPax =
+            encString(buf, off + 157, 100, this.linkpath) || this.needPax;
+        buf.write('ustar\u000000', off + 257, 8);
+        this.needPax =
+            encString(buf, off + 265, 32, this.uname) || this.needPax;
+        this.needPax =
+            encString(buf, off + 297, 32, this.gname) || this.needPax;
+        this.needPax =
+            encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
+        this.needPax =
+            encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
+        this.needPax =
+            encString(buf, off + 345, prefixSize, prefix) || this.needPax;
+        if (buf[off + 475] !== 0) {
+            this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax;
+        }
+        else {
+            this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax;
+            this.needPax =
+                encDate(buf, off + 476, 12, this.atime) || this.needPax;
+            this.needPax =
+                encDate(buf, off + 488, 12, this.ctime) || this.needPax;
+        }
+        let sum = 8 * 0x20;
+        for (let i = off; i < off + 148; i++) {
+            sum += buf[i];
+        }
+        for (let i = off + 156; i < off + 512; i++) {
+            sum += buf[i];
+        }
+        this.cksum = sum;
+        encNumber(buf, off + 148, 8, this.cksum);
+        this.cksumValid = true;
+        return this.needPax;
+    }
+    get type() {
+        return (this.#type === 'Unsupported' ?
+            this.#type
+            : types.name.get(this.#type));
+    }
+    get typeKey() {
+        return this.#type;
+    }
+    set type(type) {
+        const c = String(types.code.get(type));
+        if (types.isCode(c) || c === 'Unsupported') {
+            this.#type = c;
+        }
+        else if (types.isCode(type)) {
+            this.#type = type;
+        }
+        else {
+            throw new TypeError('invalid entry type: ' + type);
+        }
+    }
+}
+const splitPrefix = (p, prefixSize) => {
+    const pathSize = 100;
+    let pp = p;
+    let prefix = '';
+    let ret = undefined;
+    const root = pathModule.parse(p).root || '.';
+    if (Buffer.byteLength(pp) < pathSize) {
+        ret = [pp, prefix, false];
+    }
+    else {
+        // first set prefix to the dir, and path to the base
+        prefix = pathModule.dirname(pp);
+        pp = pathModule.basename(pp);
+        do {
+            if (Buffer.byteLength(pp) <= pathSize &&
+                Buffer.byteLength(prefix) <= prefixSize) {
+                // both fit!
+                ret = [pp, prefix, false];
+            }
+            else if (Buffer.byteLength(pp) > pathSize &&
+                Buffer.byteLength(prefix) <= prefixSize) {
+                // prefix fits in prefix, but path doesn't fit in path
+                ret = [pp.slice(0, pathSize - 1), prefix, true];
+            }
+            else {
+                // make path take a bit from prefix
+                pp = pathModule.join(pathModule.basename(prefix), pp);
+                prefix = pathModule.dirname(prefix);
+            }
+        } while (prefix !== root && ret === undefined);
+        // at this point, found no resolution, just truncate
+        if (!ret) {
+            ret = [p.slice(0, pathSize - 1), '', true];
+        }
+    }
+    return ret;
+};
+const decString = (buf, off, size) => buf
+    .subarray(off, off + size)
+    .toString('utf8')
+    .replace(/\0.*/, '');
+const decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+const numToDate = (num) => num === undefined ? undefined : new Date(num * 1000);
+const decNumber = (buf, off, size) => Number(buf[off]) & 0x80 ?
+    large.parse(buf.subarray(off, off + size))
+    : decSmallNumber(buf, off, size);
+const nanUndef = (value) => (isNaN(value) ? undefined : value);
+const decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf
+    .subarray(off, off + size)
+    .toString('utf8')
+    .replace(/\0.*$/, '')
+    .trim(), 8));
+// the maximum encodable as a null-terminated octal, by field size
+const MAXNUM = {
+    12: 0o77777777777,
+    8: 0o7777777,
+};
+const encNumber = (buf, off, size, num) => num === undefined ? false
+    : num > MAXNUM[size] || num < 0 ?
+        (large.encode(num, buf.subarray(off, off + size)), true)
+        : (encSmallNumber(buf, off, size, num), false);
+const encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, 'ascii');
+const octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+const padOctal = (str, size) => (str.length === size - 1 ?
+    str
+    : new Array(size - str.length - 1).join('0') + str + ' ') + '\0';
+const encDate = (buf, off, size, date) => date === undefined ? false : (encNumber(buf, off, size, date.getTime() / 1000));
+// enough to fill the longest string we've got
+const NULLS = new Array(156).join('\0');
+// pad with nulls, return true if it's longer or non-ascii
+const encString = (buf, off, size, str) => str === undefined ? false : ((buf.write(str + NULLS, off, size, 'utf8'),
+    str.length !== Buffer.byteLength(str) || str.length > size));
+//# sourceMappingURL=header.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/index.d.ts b/node_modules/tar/dist/esm/index.d.ts
new file mode 100644
index 0000000..a582123
--- /dev/null
+++ b/node_modules/tar/dist/esm/index.d.ts
@@ -0,0 +1,20 @@
+export { type TarOptionsWithAliasesAsync, type TarOptionsWithAliasesAsyncFile, type TarOptionsWithAliasesAsyncNoFile, type TarOptionsWithAliasesSyncNoFile, type TarOptionsWithAliases, type TarOptionsWithAliasesFile, type TarOptionsWithAliasesSync, type TarOptionsWithAliasesSyncFile, } from './options.js';
+export * from './create.js';
+export { create as c } from './create.js';
+export * from './extract.js';
+export { extract as x } from './extract.js';
+export * from './header.js';
+export * from './list.js';
+export { list as t } from './list.js';
+export * from './pack.js';
+export * from './parse.js';
+export * from './pax.js';
+export * from './read-entry.js';
+export * from './replace.js';
+export { replace as r } from './replace.js';
+export * as types from './types.js';
+export * from './unpack.js';
+export * from './update.js';
+export { update as u } from './update.js';
+export * from './write-entry.js';
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/index.js b/node_modules/tar/dist/esm/index.js
new file mode 100644
index 0000000..1bac641
--- /dev/null
+++ b/node_modules/tar/dist/esm/index.js
@@ -0,0 +1,20 @@
+export * from './create.js';
+export { create as c } from './create.js';
+export * from './extract.js';
+export { extract as x } from './extract.js';
+export * from './header.js';
+export * from './list.js';
+export { list as t } from './list.js';
+// classes
+export * from './pack.js';
+export * from './parse.js';
+export * from './pax.js';
+export * from './read-entry.js';
+export * from './replace.js';
+export { replace as r } from './replace.js';
+export * as types from './types.js';
+export * from './unpack.js';
+export * from './update.js';
+export { update as u } from './update.js';
+export * from './write-entry.js';
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/index.min.js b/node_modules/tar/dist/esm/index.min.js
new file mode 100644
index 0000000..9d9044c
--- /dev/null
+++ b/node_modules/tar/dist/esm/index.min.js
@@ -0,0 +1,4 @@
+var zr=Object.defineProperty;var Ur=(s,t)=>{for(var e in t)zr(s,e,{get:t[e],enumerable:!0})};import Qr from"events";import I from"fs";import{EventEmitter as Di}from"node:events";import Cs from"node:stream";import{StringDecoder as Hr}from"node:string_decoder";var Ds=typeof process=="object"&&process?process:{stdout:null,stderr:null},Wr=s=>!!s&&typeof s=="object"&&(s instanceof A||s instanceof Cs||Gr(s)||Zr(s)),Gr=s=>!!s&&typeof s=="object"&&s instanceof Di&&typeof s.pipe=="function"&&s.pipe!==Cs.Writable.prototype.pipe,Zr=s=>!!s&&typeof s=="object"&&s instanceof Di&&typeof s.write=="function"&&typeof s.end=="function",Q=Symbol("EOF"),J=Symbol("maybeEmitEnd"),nt=Symbol("emittedEnd"),De=Symbol("emittingEnd"),qt=Symbol("emittedError"),Ne=Symbol("closed"),Ns=Symbol("read"),Ae=Symbol("flush"),As=Symbol("flushChunk"),z=Symbol("encoding"),Mt=Symbol("decoder"),g=Symbol("flowing"),Qt=Symbol("paused"),Bt=Symbol("resume"),b=Symbol("buffer"),N=Symbol("pipes"),_=Symbol("bufferLength"),bi=Symbol("bufferPush"),Ie=Symbol("bufferShift"),L=Symbol("objectMode"),S=Symbol("destroyed"),_i=Symbol("error"),Oi=Symbol("emitData"),Is=Symbol("emitEnd"),Ti=Symbol("emitEnd2"),Z=Symbol("async"),xi=Symbol("abort"),Ce=Symbol("aborted"),Jt=Symbol("signal"),Rt=Symbol("dataListeners"),C=Symbol("discarded"),jt=s=>Promise.resolve().then(s),Yr=s=>s(),Kr=s=>s==="end"||s==="finish"||s==="prefinish",Vr=s=>s instanceof ArrayBuffer||!!s&&typeof s=="object"&&s.constructor&&s.constructor.name==="ArrayBuffer"&&s.byteLength>=0,$r=s=>!Buffer.isBuffer(s)&&ArrayBuffer.isView(s),Fe=class{src;dest;opts;ondrain;constructor(t,e,i){this.src=t,this.dest=e,this.opts=i,this.ondrain=()=>t[Bt](),this.dest.on("drain",this.ondrain)}unpipe(){this.dest.removeListener("drain",this.ondrain)}proxyErrors(t){}end(){this.unpipe(),this.opts.end&&this.dest.end()}},Li=class extends Fe{unpipe(){this.src.removeListener("error",this.proxyErrors),super.unpipe()}constructor(t,e,i){super(t,e,i),this.proxyErrors=r=>this.dest.emit("error",r),t.on("error",this.proxyErrors)}},Xr=s=>!!s.objectMode,qr=s=>!s.objectMode&&!!s.encoding&&s.encoding!=="buffer",A=class extends Di{[g]=!1;[Qt]=!1;[N]=[];[b]=[];[L];[z];[Z];[Mt];[Q]=!1;[nt]=!1;[De]=!1;[Ne]=!1;[qt]=null;[_]=0;[S]=!1;[Jt];[Ce]=!1;[Rt]=0;[C]=!1;writable=!0;readable=!0;constructor(...t){let e=t[0]||{};if(super(),e.objectMode&&typeof e.encoding=="string")throw new TypeError("Encoding and objectMode may not be used together");Xr(e)?(this[L]=!0,this[z]=null):qr(e)?(this[z]=e.encoding,this[L]=!1):(this[L]=!1,this[z]=null),this[Z]=!!e.async,this[Mt]=this[z]?new Hr(this[z]):null,e&&e.debugExposeBuffer===!0&&Object.defineProperty(this,"buffer",{get:()=>this[b]}),e&&e.debugExposePipes===!0&&Object.defineProperty(this,"pipes",{get:()=>this[N]});let{signal:i}=e;i&&(this[Jt]=i,i.aborted?this[xi]():i.addEventListener("abort",()=>this[xi]()))}get bufferLength(){return this[_]}get encoding(){return this[z]}set encoding(t){throw new Error("Encoding must be set at instantiation time")}setEncoding(t){throw new Error("Encoding must be set at instantiation time")}get objectMode(){return this[L]}set objectMode(t){throw new Error("objectMode must be set at instantiation time")}get async(){return this[Z]}set async(t){this[Z]=this[Z]||!!t}[xi](){this[Ce]=!0,this.emit("abort",this[Jt]?.reason),this.destroy(this[Jt]?.reason)}get aborted(){return this[Ce]}set aborted(t){}write(t,e,i){if(this[Ce])return!1;if(this[Q])throw new Error("write after end");if(this[S])return this.emit("error",Object.assign(new Error("Cannot call write after a stream was destroyed"),{code:"ERR_STREAM_DESTROYED"})),!0;typeof e=="function"&&(i=e,e="utf8"),e||(e="utf8");let r=this[Z]?jt:Yr;if(!this[L]&&!Buffer.isBuffer(t)){if($r(t))t=Buffer.from(t.buffer,t.byteOffset,t.byteLength);else if(Vr(t))t=Buffer.from(t);else if(typeof t!="string")throw new Error("Non-contiguous data written to non-objectMode stream")}return this[L]?(this[g]&&this[_]!==0&&this[Ae](!0),this[g]?this.emit("data",t):this[bi](t),this[_]!==0&&this.emit("readable"),i&&r(i),this[g]):t.length?(typeof t=="string"&&!(e===this[z]&&!this[Mt]?.lastNeed)&&(t=Buffer.from(t,e)),Buffer.isBuffer(t)&&this[z]&&(t=this[Mt].write(t)),this[g]&&this[_]!==0&&this[Ae](!0),this[g]?this.emit("data",t):this[bi](t),this[_]!==0&&this.emit("readable"),i&&r(i),this[g]):(this[_]!==0&&this.emit("readable"),i&&r(i),this[g])}read(t){if(this[S])return null;if(this[C]=!1,this[_]===0||t===0||t&&t>this[_])return this[J](),null;this[L]&&(t=null),this[b].length>1&&!this[L]&&(this[b]=[this[z]?this[b].join(""):Buffer.concat(this[b],this[_])]);let e=this[Ns](t||null,this[b][0]);return this[J](),e}[Ns](t,e){if(this[L])this[Ie]();else{let i=e;t===i.length||t===null?this[Ie]():typeof i=="string"?(this[b][0]=i.slice(t),e=i.slice(0,t),this[_]-=t):(this[b][0]=i.subarray(t),e=i.subarray(0,t),this[_]-=t)}return this.emit("data",e),!this[b].length&&!this[Q]&&this.emit("drain"),e}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e="utf8"),t!==void 0&&this.write(t,e),i&&this.once("end",i),this[Q]=!0,this.writable=!1,(this[g]||!this[Qt])&&this[J](),this}[Bt](){this[S]||(!this[Rt]&&!this[N].length&&(this[C]=!0),this[Qt]=!1,this[g]=!0,this.emit("resume"),this[b].length?this[Ae]():this[Q]?this[J]():this.emit("drain"))}resume(){return this[Bt]()}pause(){this[g]=!1,this[Qt]=!0,this[C]=!1}get destroyed(){return this[S]}get flowing(){return this[g]}get paused(){return this[Qt]}[bi](t){this[L]?this[_]+=1:this[_]+=t.length,this[b].push(t)}[Ie](){return this[L]?this[_]-=1:this[_]-=this[b][0].length,this[b].shift()}[Ae](t=!1){do;while(this[As](this[Ie]())&&this[b].length);!t&&!this[b].length&&!this[Q]&&this.emit("drain")}[As](t){return this.emit("data",t),this[g]}pipe(t,e){if(this[S])return t;this[C]=!1;let i=this[nt];return e=e||{},t===Ds.stdout||t===Ds.stderr?e.end=!1:e.end=e.end!==!1,e.proxyErrors=!!e.proxyErrors,i?e.end&&t.end():(this[N].push(e.proxyErrors?new Li(this,t,e):new Fe(this,t,e)),this[Z]?jt(()=>this[Bt]()):this[Bt]()),t}unpipe(t){let e=this[N].find(i=>i.dest===t);e&&(this[N].length===1?(this[g]&&this[Rt]===0&&(this[g]=!1),this[N]=[]):this[N].splice(this[N].indexOf(e),1),e.unpipe())}addListener(t,e){return this.on(t,e)}on(t,e){let i=super.on(t,e);if(t==="data")this[C]=!1,this[Rt]++,!this[N].length&&!this[g]&&this[Bt]();else if(t==="readable"&&this[_]!==0)super.emit("readable");else if(Kr(t)&&this[nt])super.emit(t),this.removeAllListeners(t);else if(t==="error"&&this[qt]){let r=e;this[Z]?jt(()=>r.call(this,this[qt])):r.call(this,this[qt])}return i}removeListener(t,e){return this.off(t,e)}off(t,e){let i=super.off(t,e);return t==="data"&&(this[Rt]=this.listeners("data").length,this[Rt]===0&&!this[C]&&!this[N].length&&(this[g]=!1)),i}removeAllListeners(t){let e=super.removeAllListeners(t);return(t==="data"||t===void 0)&&(this[Rt]=0,!this[C]&&!this[N].length&&(this[g]=!1)),e}get emittedEnd(){return this[nt]}[J](){!this[De]&&!this[nt]&&!this[S]&&this[b].length===0&&this[Q]&&(this[De]=!0,this.emit("end"),this.emit("prefinish"),this.emit("finish"),this[Ne]&&this.emit("close"),this[De]=!1)}emit(t,...e){let i=e[0];if(t!=="error"&&t!=="close"&&t!==S&&this[S])return!1;if(t==="data")return!this[L]&&!i?!1:this[Z]?(jt(()=>this[Oi](i)),!0):this[Oi](i);if(t==="end")return this[Is]();if(t==="close"){if(this[Ne]=!0,!this[nt]&&!this[S])return!1;let n=super.emit("close");return this.removeAllListeners("close"),n}else if(t==="error"){this[qt]=i,super.emit(_i,i);let n=!this[Jt]||this.listeners("error").length?super.emit("error",i):!1;return this[J](),n}else if(t==="resume"){let n=super.emit("resume");return this[J](),n}else if(t==="finish"||t==="prefinish"){let n=super.emit(t);return this.removeAllListeners(t),n}let r=super.emit(t,...e);return this[J](),r}[Oi](t){for(let i of this[N])i.dest.write(t)===!1&&this.pause();let e=this[C]?!1:super.emit("data",t);return this[J](),e}[Is](){return this[nt]?!1:(this[nt]=!0,this.readable=!1,this[Z]?(jt(()=>this[Ti]()),!0):this[Ti]())}[Ti](){if(this[Mt]){let e=this[Mt].end();if(e){for(let i of this[N])i.dest.write(e);this[C]||super.emit("data",e)}}for(let e of this[N])e.end();let t=super.emit("end");return this.removeAllListeners("end"),t}async collect(){let t=Object.assign([],{dataLength:0});this[L]||(t.dataLength=0);let e=this.promise();return this.on("data",i=>{t.push(i),this[L]||(t.dataLength+=i.length)}),await e,t}async concat(){if(this[L])throw new Error("cannot concat in objectMode");let t=await this.collect();return this[z]?t.join(""):Buffer.concat(t,t.dataLength)}async promise(){return new Promise((t,e)=>{this.on(S,()=>e(new Error("stream destroyed"))),this.on("error",i=>e(i)),this.on("end",()=>t())})}[Symbol.asyncIterator](){this[C]=!1;let t=!1,e=async()=>(this.pause(),t=!0,{value:void 0,done:!0});return{next:()=>{if(t)return e();let r=this.read();if(r!==null)return Promise.resolve({done:!1,value:r});if(this[Q])return e();let n,o,h=d=>{this.off("data",a),this.off("end",l),this.off(S,c),e(),o(d)},a=d=>{this.off("error",h),this.off("end",l),this.off(S,c),this.pause(),n({value:d,done:!!this[Q]})},l=()=>{this.off("error",h),this.off("data",a),this.off(S,c),e(),n({done:!0,value:void 0})},c=()=>h(new Error("stream destroyed"));return new Promise((d,y)=>{o=y,n=d,this.once(S,c),this.once("error",h),this.once("end",l),this.once("data",a)})},throw:e,return:e,[Symbol.asyncIterator](){return this},[Symbol.asyncDispose]:async()=>{}}}[Symbol.iterator](){this[C]=!1;let t=!1,e=()=>(this.pause(),this.off(_i,e),this.off(S,e),this.off("end",e),t=!0,{done:!0,value:void 0}),i=()=>{if(t)return e();let r=this.read();return r===null?e():{done:!1,value:r}};return this.once("end",e),this.once(_i,e),this.once(S,e),{next:i,throw:e,return:e,[Symbol.iterator](){return this},[Symbol.dispose]:()=>{}}}destroy(t){if(this[S])return t?this.emit("error",t):this.emit(S),this;this[S]=!0,this[C]=!0,this[b].length=0,this[_]=0;let e=this;return typeof e.close=="function"&&!this[Ne]&&e.close(),t?this.emit("error",t):this.emit(S),this}static get isStream(){return Wr}};var Jr=I.writev,ht=Symbol("_autoClose"),H=Symbol("_close"),te=Symbol("_ended"),m=Symbol("_fd"),Ni=Symbol("_finished"),tt=Symbol("_flags"),Ai=Symbol("_flush"),ki=Symbol("_handleChunk"),vi=Symbol("_makeBuf"),ie=Symbol("_mode"),ke=Symbol("_needDrain"),Ut=Symbol("_onerror"),Ht=Symbol("_onopen"),Ii=Symbol("_onread"),Pt=Symbol("_onwrite"),at=Symbol("_open"),U=Symbol("_path"),ot=Symbol("_pos"),Y=Symbol("_queue"),zt=Symbol("_read"),Ci=Symbol("_readSize"),j=Symbol("_reading"),ee=Symbol("_remain"),Fi=Symbol("_size"),ve=Symbol("_write"),gt=Symbol("_writing"),Me=Symbol("_defaultFlag"),bt=Symbol("_errored"),_t=class extends A{[bt]=!1;[m];[U];[Ci];[j]=!1;[Fi];[ee];[ht];constructor(t,e){if(e=e||{},super(e),this.readable=!0,this.writable=!1,typeof t!="string")throw new TypeError("path must be a string");this[bt]=!1,this[m]=typeof e.fd=="number"?e.fd:void 0,this[U]=t,this[Ci]=e.readSize||16*1024*1024,this[j]=!1,this[Fi]=typeof e.size=="number"?e.size:1/0,this[ee]=this[Fi],this[ht]=typeof e.autoClose=="boolean"?e.autoClose:!0,typeof this[m]=="number"?this[zt]():this[at]()}get fd(){return this[m]}get path(){return this[U]}write(){throw new TypeError("this is a readable stream")}end(){throw new TypeError("this is a readable stream")}[at](){I.open(this[U],"r",(t,e)=>this[Ht](t,e))}[Ht](t,e){t?this[Ut](t):(this[m]=e,this.emit("open",e),this[zt]())}[vi](){return Buffer.allocUnsafe(Math.min(this[Ci],this[ee]))}[zt](){if(!this[j]){this[j]=!0;let t=this[vi]();if(t.length===0)return process.nextTick(()=>this[Ii](null,0,t));I.read(this[m],t,0,t.length,null,(e,i,r)=>this[Ii](e,i,r))}}[Ii](t,e,i){this[j]=!1,t?this[Ut](t):this[ki](e,i)&&this[zt]()}[H](){if(this[ht]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}[Ut](t){this[j]=!0,this[H](),this.emit("error",t)}[ki](t,e){let i=!1;return this[ee]-=t,t>0&&(i=super.write(t<e.length?e.subarray(0,t):e)),(t===0||this[ee]<=0)&&(i=!1,this[H](),super.end()),i}emit(t,...e){switch(t){case"prefinish":case"finish":return!1;case"drain":return typeof this[m]=="number"&&this[zt](),!1;case"error":return this[bt]?!1:(this[bt]=!0,super.emit(t,...e));default:return super.emit(t,...e)}}},Be=class extends _t{[at](){let t=!0;try{this[Ht](null,I.openSync(this[U],"r")),t=!1}finally{t&&this[H]()}}[zt](){let t=!0;try{if(!this[j]){this[j]=!0;do{let e=this[vi](),i=e.length===0?0:I.readSync(this[m],e,0,e.length,null);if(!this[ki](i,e))break}while(!0);this[j]=!1}t=!1}finally{t&&this[H]()}}[H](){if(this[ht]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}},et=class extends Qr{readable=!1;writable=!0;[bt]=!1;[gt]=!1;[te]=!1;[Y]=[];[ke]=!1;[U];[ie];[ht];[m];[Me];[tt];[Ni]=!1;[ot];constructor(t,e){e=e||{},super(e),this[U]=t,this[m]=typeof e.fd=="number"?e.fd:void 0,this[ie]=e.mode===void 0?438:e.mode,this[ot]=typeof e.start=="number"?e.start:void 0,this[ht]=typeof e.autoClose=="boolean"?e.autoClose:!0;let i=this[ot]!==void 0?"r+":"w";this[Me]=e.flags===void 0,this[tt]=e.flags===void 0?i:e.flags,this[m]===void 0&&this[at]()}emit(t,...e){if(t==="error"){if(this[bt])return!1;this[bt]=!0}return super.emit(t,...e)}get fd(){return this[m]}get path(){return this[U]}[Ut](t){this[H](),this[gt]=!0,this.emit("error",t)}[at](){I.open(this[U],this[tt],this[ie],(t,e)=>this[Ht](t,e))}[Ht](t,e){this[Me]&&this[tt]==="r+"&&t&&t.code==="ENOENT"?(this[tt]="w",this[at]()):t?this[Ut](t):(this[m]=e,this.emit("open",e),this[gt]||this[Ai]())}end(t,e){return t&&this.write(t,e),this[te]=!0,!this[gt]&&!this[Y].length&&typeof this[m]=="number"&&this[Pt](null,0),this}write(t,e){return typeof t=="string"&&(t=Buffer.from(t,e)),this[te]?(this.emit("error",new Error("write() after end()")),!1):this[m]===void 0||this[gt]||this[Y].length?(this[Y].push(t),this[ke]=!0,!1):(this[gt]=!0,this[ve](t),!0)}[ve](t){I.write(this[m],t,0,t.length,this[ot],(e,i)=>this[Pt](e,i))}[Pt](t,e){t?this[Ut](t):(this[ot]!==void 0&&typeof e=="number"&&(this[ot]+=e),this[Y].length?this[Ai]():(this[gt]=!1,this[te]&&!this[Ni]?(this[Ni]=!0,this[H](),this.emit("finish")):this[ke]&&(this[ke]=!1,this.emit("drain"))))}[Ai](){if(this[Y].length===0)this[te]&&this[Pt](null,0);else if(this[Y].length===1)this[ve](this[Y].pop());else{let t=this[Y];this[Y]=[],Jr(this[m],t,this[ot],(e,i)=>this[Pt](e,i))}}[H](){if(this[ht]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}},Wt=class extends et{[at](){let t;if(this[Me]&&this[tt]==="r+")try{t=I.openSync(this[U],this[tt],this[ie])}catch(e){if(e?.code==="ENOENT")return this[tt]="w",this[at]();throw e}else t=I.openSync(this[U],this[tt],this[ie]);this[Ht](null,t)}[H](){if(this[ht]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}[ve](t){let e=!0;try{this[Pt](null,I.writeSync(this[m],t,0,t.length,this[ot])),e=!1}finally{if(e)try{this[H]()}catch{}}}};import cr from"node:path";import Kt from"node:fs";import{dirname as Fn,parse as kn}from"path";var jr=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"]]),Fs=s=>!!s.sync&&!!s.file,ks=s=>!s.sync&&!!s.file,vs=s=>!!s.sync&&!s.file,Ms=s=>!s.sync&&!s.file;var Bs=s=>!!s.file;var tn=s=>{let t=jr.get(s);return t||s},se=(s={})=>{if(!s)return{};let t={};for(let[e,i]of Object.entries(s)){let r=tn(e);t[r]=i}return t.chmod===void 0&&t.noChmod===!1&&(t.chmod=!0),delete t.noChmod,t};var K=(s,t,e,i,r)=>Object.assign((n=[],o,h)=>{Array.isArray(n)&&(o=n,n={}),typeof o=="function"&&(h=o,o=void 0),o=o?Array.from(o):[];let a=se(n);if(r?.(a,o),Fs(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return s(a,o)}else if(ks(a)){let l=t(a,o);return h?l.then(()=>h(),h):l}else if(vs(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return e(a,o)}else if(Ms(a)){if(typeof h=="function")throw new TypeError("callback only supported with file option");return i(a,o)}throw new Error("impossible options??")},{syncFile:s,asyncFile:t,syncNoFile:e,asyncNoFile:i,validate:r});import{EventEmitter as Dn}from"events";import zi from"assert";import{Buffer as Ot}from"buffer";import*as Ps from"zlib";import en from"zlib";var sn=en.constants||{ZLIB_VERNUM:4736},M=Object.freeze(Object.assign(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:1/0,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},sn));var rn=Ot.concat,zs=Object.getOwnPropertyDescriptor(Ot,"concat"),nn=s=>s,Bi=zs?.writable===!0||zs?.set!==void 0?s=>{Ot.concat=s?nn:rn}:s=>{},Tt=Symbol("_superWrite"),Gt=class extends Error{code;errno;constructor(t,e){super("zlib: "+t.message,{cause:t}),this.code=t.code,this.errno=t.errno,this.code||(this.code="ZLIB_ERROR"),this.message="zlib: "+t.message,Error.captureStackTrace(this,e??this.constructor)}get name(){return"ZlibError"}},Pi=Symbol("flushFlag"),re=class extends A{#t=!1;#i=!1;#s;#n;#r;#e;#o;get sawError(){return this.#t}get handle(){return this.#e}get flushFlag(){return this.#s}constructor(t,e){if(!t||typeof t!="object")throw new TypeError("invalid options for ZlibBase constructor");if(super(t),this.#s=t.flush??0,this.#n=t.finishFlush??0,this.#r=t.fullFlushFlag??0,typeof Ps[e]!="function")throw new TypeError("Compression method not supported: "+e);try{this.#e=new Ps[e](t)}catch(i){throw new Gt(i,this.constructor)}this.#o=i=>{this.#t||(this.#t=!0,this.close(),this.emit("error",i))},this.#e?.on("error",i=>this.#o(new Gt(i))),this.once("end",()=>this.close)}close(){this.#e&&(this.#e.close(),this.#e=void 0,this.emit("close"))}reset(){if(!this.#t)return zi(this.#e,"zlib binding closed"),this.#e.reset?.()}flush(t){this.ended||(typeof t!="number"&&(t=this.#r),this.write(Object.assign(Ot.alloc(0),{[Pi]:t})))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&(e?this.write(t,e):this.write(t)),this.flush(this.#n),this.#i=!0,super.end(i)}get ended(){return this.#i}[Tt](t){return super.write(t)}write(t,e,i){if(typeof e=="function"&&(i=e,e="utf8"),typeof t=="string"&&(t=Ot.from(t,e)),this.#t)return;zi(this.#e,"zlib binding closed");let r=this.#e._handle,n=r.close;r.close=()=>{};let o=this.#e.close;this.#e.close=()=>{},Bi(!0);let h;try{let l=typeof t[Pi]=="number"?t[Pi]:this.#s;h=this.#e._processChunk(t,l),Bi(!1)}catch(l){Bi(!1),this.#o(new Gt(l,this.write))}finally{this.#e&&(this.#e._handle=r,r.close=n,this.#e.close=o,this.#e.removeAllListeners("error"))}this.#e&&this.#e.on("error",l=>this.#o(new Gt(l,this.write)));let a;if(h)if(Array.isArray(h)&&h.length>0){let l=h[0];a=this[Tt](Ot.from(l));for(let c=1;c<h.length;c++)a=this[Tt](h[c])}else a=this[Tt](Ot.from(h));return i&&i(),a}},Pe=class extends re{#t;#i;constructor(t,e){t=t||{},t.flush=t.flush||M.Z_NO_FLUSH,t.finishFlush=t.finishFlush||M.Z_FINISH,t.fullFlushFlag=M.Z_FULL_FLUSH,super(t,e),this.#t=t.level,this.#i=t.strategy}params(t,e){if(!this.sawError){if(!this.handle)throw new Error("cannot switch params when binding is closed");if(!this.handle.params)throw new Error("not supported in this implementation");if(this.#t!==t||this.#i!==e){this.flush(M.Z_SYNC_FLUSH),zi(this.handle,"zlib binding closed");let i=this.handle.flush;this.handle.flush=(r,n)=>{typeof r=="function"&&(n=r,r=this.flushFlag),this.flush(r),n?.()};try{this.handle.params(t,e)}finally{this.handle.flush=i}this.handle&&(this.#t=t,this.#i=e)}}}};var ze=class extends Pe{#t;constructor(t){super(t,"Gzip"),this.#t=t&&!!t.portable}[Tt](t){return this.#t?(this.#t=!1,t[9]=255,super[Tt](t)):super[Tt](t)}};var Ue=class extends Pe{constructor(t){super(t,"Unzip")}},He=class extends re{constructor(t,e){t=t||{},t.flush=t.flush||M.BROTLI_OPERATION_PROCESS,t.finishFlush=t.finishFlush||M.BROTLI_OPERATION_FINISH,t.fullFlushFlag=M.BROTLI_OPERATION_FLUSH,super(t,e)}},We=class extends He{constructor(t){super(t,"BrotliCompress")}},Ge=class extends He{constructor(t){super(t,"BrotliDecompress")}},Ze=class extends re{constructor(t,e){t=t||{},t.flush=t.flush||M.ZSTD_e_continue,t.finishFlush=t.finishFlush||M.ZSTD_e_end,t.fullFlushFlag=M.ZSTD_e_flush,super(t,e)}},Ye=class extends Ze{constructor(t){super(t,"ZstdCompress")}},Ke=class extends Ze{constructor(t){super(t,"ZstdDecompress")}};import{posix as Zt}from"node:path";var Us=(s,t)=>{if(Number.isSafeInteger(s))s<0?an(s,t):hn(s,t);else throw Error("cannot encode number outside of javascript safe integer range");return t},hn=(s,t)=>{t[0]=128;for(var e=t.length;e>1;e--)t[e-1]=s&255,s=Math.floor(s/256)},an=(s,t)=>{t[0]=255;var e=!1;s=s*-1;for(var i=t.length;i>1;i--){var r=s&255;s=Math.floor(s/256),e?t[i-1]=Ws(r):r===0?t[i-1]=0:(e=!0,t[i-1]=Gs(r))}},Hs=s=>{let t=s[0],e=t===128?cn(s.subarray(1,s.length)):t===255?ln(s):null;if(e===null)throw Error("invalid base256 encoding");if(!Number.isSafeInteger(e))throw Error("parsed number outside of javascript safe integer range");return e},ln=s=>{for(var t=s.length,e=0,i=!1,r=t-1;r>-1;r--){var n=Number(s[r]),o;i?o=Ws(n):n===0?o=n:(i=!0,o=Gs(n)),o!==0&&(e-=o*Math.pow(256,t-r-1))}return e},cn=s=>{for(var t=s.length,e=0,i=t-1;i>-1;i--){var r=Number(s[i]);r!==0&&(e+=r*Math.pow(256,t-i-1))}return e},Ws=s=>(255^s)&255,Gs=s=>(255^s)+1&255;var Hi={};Ur(Hi,{code:()=>Ve,isCode:()=>ne,isName:()=>dn,name:()=>oe,normalFsTypes:()=>Ui});var ne=s=>oe.has(s),dn=s=>Ve.has(s),Ui=new Set(["0","","1","2","3","4","5","6","7","D"]),oe=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"]]),Ve=new Map(Array.from(oe).map(s=>[s[1],s[0]]));var un=s=>s===void 0||s<0?void 0:s,F=class{cksumValid=!1;needPax=!1;nullBlock=!1;block;path;mode;uid;gid;size;cksum;#t="Unsupported";linkpath;uname;gname;devmaj=0;devmin=0;atime;ctime;mtime;charset;comment;constructor(t,e=0,i,r){Buffer.isBuffer(t)?this.decode(t,e||0,i,r):t&&this.#i(t)}decode(t,e,i,r){if(e||(e=0),!t||!(t.length>=e+512))throw new Error("need 512 bytes for header");let n=xt(t,e+156,1),o=Ui.has(n),h=o?i:void 0,a=o?r:void 0;if(this.path=h?.path??xt(t,e,100),this.mode=h?.mode??a?.mode??lt(t,e+100,8),this.uid=h?.uid??a?.uid??lt(t,e+108,8),this.gid=h?.gid??a?.gid??lt(t,e+116,8),this.size=un(h?.size??a?.size??lt(t,e+124,12)),this.mtime=h?.mtime??a?.mtime??Wi(t,e+136,12),this.cksum=lt(t,e+148,12),a&&this.#i(a,!0),h&&this.#i(h),ne(n)&&(this.#t=n||"0"),this.#t==="0"&&this.path.slice(-1)==="/"&&(this.#t="5"),this.#t==="5"&&(this.size=0),this.linkpath=xt(t,e+157,100),t.subarray(e+257,e+265).toString()==="ustar\x0000")if(this.uname=h?.uname??a?.uname??xt(t,e+265,32),this.gname=h?.gname??a?.gname??xt(t,e+297,32),this.devmaj=h?.devmaj??a?.devmaj??lt(t,e+329,8)??0,this.devmin=h?.devmin??a?.devmin??lt(t,e+337,8)??0,t[e+475]!==0){let c=xt(t,e+345,155);this.path=c+"/"+this.path}else{let c=xt(t,e+345,130);c&&(this.path=c+"/"+this.path),this.atime=i?.atime??r?.atime??Wi(t,e+476,12),this.ctime=i?.ctime??r?.ctime??Wi(t,e+488,12)}let l=256;for(let c=e;c<e+148;c++)l+=t[c];for(let c=e+156;c<e+512;c++)l+=t[c];this.cksumValid=l===this.cksum,this.cksum===void 0&&l===256&&(this.nullBlock=!0)}#i(t,e=!1){Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="size"&&Number(r)<0||i==="path"&&e||i==="linkpath"&&e||i==="global"))))}encode(t,e=0){if(t||(t=this.block=Buffer.alloc(512)),this.#t==="Unsupported"&&(this.#t="0"),!(t.length>=e+512))throw new Error("need 512 bytes for header");let i=this.ctime||this.atime?130:155,r=mn(this.path||"",i),n=r[0],o=r[1];this.needPax=!!r[2],this.needPax=Lt(t,e,100,n)||this.needPax,this.needPax=ct(t,e+100,8,this.mode)||this.needPax,this.needPax=ct(t,e+108,8,this.uid)||this.needPax,this.needPax=ct(t,e+116,8,this.gid)||this.needPax,this.needPax=ct(t,e+124,12,this.size)||this.needPax,this.needPax=Gi(t,e+136,12,this.mtime)||this.needPax,t[e+156]=Number(this.#t.codePointAt(0)),this.needPax=Lt(t,e+157,100,this.linkpath)||this.needPax,t.write("ustar\x0000",e+257,8),this.needPax=Lt(t,e+265,32,this.uname)||this.needPax,this.needPax=Lt(t,e+297,32,this.gname)||this.needPax,this.needPax=ct(t,e+329,8,this.devmaj)||this.needPax,this.needPax=ct(t,e+337,8,this.devmin)||this.needPax,this.needPax=Lt(t,e+345,i,o)||this.needPax,t[e+475]!==0?this.needPax=Lt(t,e+345,155,o)||this.needPax:(this.needPax=Lt(t,e+345,130,o)||this.needPax,this.needPax=Gi(t,e+476,12,this.atime)||this.needPax,this.needPax=Gi(t,e+488,12,this.ctime)||this.needPax);let h=256;for(let a=e;a<e+148;a++)h+=t[a];for(let a=e+156;a<e+512;a++)h+=t[a];return this.cksum=h,ct(t,e+148,8,this.cksum),this.cksumValid=!0,this.needPax}get type(){return this.#t==="Unsupported"?this.#t:oe.get(this.#t)}get typeKey(){return this.#t}set type(t){let e=String(Ve.get(t));if(ne(e)||e==="Unsupported")this.#t=e;else if(ne(t))this.#t=t;else throw new TypeError("invalid entry type: "+t)}},mn=(s,t)=>{let i=s,r="",n,o=Zt.parse(s).root||".";if(Buffer.byteLength(i)<100)n=[i,r,!1];else{r=Zt.dirname(i),i=Zt.basename(i);do Buffer.byteLength(i)<=100&&Buffer.byteLength(r)<=t?n=[i,r,!1]:Buffer.byteLength(i)>100&&Buffer.byteLength(r)<=t?n=[i.slice(0,99),r,!0]:(i=Zt.join(Zt.basename(r),i),r=Zt.dirname(r));while(r!==o&&n===void 0);n||(n=[s.slice(0,99),"",!0])}return n},xt=(s,t,e)=>s.subarray(t,t+e).toString("utf8").replace(/\0.*/,""),Wi=(s,t,e)=>pn(lt(s,t,e)),pn=s=>s===void 0?void 0:new Date(s*1e3),lt=(s,t,e)=>Number(s[t])&128?Hs(s.subarray(t,t+e)):wn(s,t,e),En=s=>isNaN(s)?void 0:s,wn=(s,t,e)=>En(parseInt(s.subarray(t,t+e).toString("utf8").replace(/\0.*$/,"").trim(),8)),Sn={12:8589934591,8:2097151},ct=(s,t,e,i)=>i===void 0?!1:i>Sn[e]||i<0?(Us(i,s.subarray(t,t+e)),!0):(yn(s,t,e,i),!1),yn=(s,t,e,i)=>s.write(Rn(i,e),t,e,"ascii"),Rn=(s,t)=>gn(Math.floor(s).toString(8),t),gn=(s,t)=>(s.length===t-1?s:new Array(t-s.length-1).join("0")+s+" ")+"\0",Gi=(s,t,e,i)=>i===void 0?!1:ct(s,t,e,i.getTime()/1e3),bn=new Array(156).join("\0"),Lt=(s,t,e,i)=>i===void 0?!1:(s.write(i+bn,t,e,"utf8"),i.length!==Buffer.byteLength(i)||i.length>e);import{basename as _n}from"node:path";var ft=class s{atime;mtime;ctime;charset;comment;gid;uid;gname;uname;linkpath;dev;ino;nlink;path;size;mode;global;constructor(t,e=!1){this.atime=t.atime,this.charset=t.charset,this.comment=t.comment,this.ctime=t.ctime,this.dev=t.dev,this.gid=t.gid,this.global=e,this.gname=t.gname,this.ino=t.ino,this.linkpath=t.linkpath,this.mtime=t.mtime,this.nlink=t.nlink,this.path=t.path,this.size=t.size,this.uid=t.uid,this.uname=t.uname}encode(){let t=this.encodeBody();if(t==="")return Buffer.allocUnsafe(0);let e=Buffer.byteLength(t),i=512*Math.ceil(1+e/512),r=Buffer.allocUnsafe(i);for(let n=0;n<512;n++)r[n]=0;new F({path:("PaxHeader/"+_n(this.path??"")).slice(0,99),mode:this.mode||420,uid:this.uid,gid:this.gid,size:e,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(r),r.write(t,512,e,"utf8");for(let n=e+512;n<r.length;n++)r[n]=0;return r}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(t){if(this[t]===void 0)return"";let e=this[t],i=e instanceof Date?e.getTime()/1e3:e,r=" "+(t==="dev"||t==="ino"||t==="nlink"?"SCHILY.":"")+t+"="+i+`
+`,n=Buffer.byteLength(r),o=Math.floor(Math.log(n)/Math.log(10))+1;return n+o>=Math.pow(10,o)&&(o+=1),o+n+r}static parse(t,e,i=!1){return new s(On(Tn(t),e),i)}},On=(s,t)=>t?Object.assign({},t,s):s,Tn=s=>s.replace(/\n$/,"").split(`
+`).reduce(xn,Object.create(null)),xn=(s,t)=>{let e=parseInt(t,10);if(e!==Buffer.byteLength(t)+1)return s;t=t.slice((e+" ").length);let i=t.split("="),r=i.shift();if(!r)return s;let n=r.replace(/^SCHILY\.(dev|ino|nlink)/,"$1"),o=i.join("=").replace(/\0.*/,"");switch(n){case"path":case"linkpath":case"type":case"charset":case"comment":case"gname":case"uname":s[n]=o;break;case"ctime":case"atime":case"mtime":s[n]=new Date(Number(o)*1e3);break;case"size":let h=+o;h>=0&&(s[n]=h);break;case"gid":case"uid":case"dev":case"ino":case"nlink":case"mode":s[n]=+o;break}return s};var Ln=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,f=Ln!=="win32"?s=>String(s):s=>String(s).replaceAll(/\\/g,"/");var $e=class extends A{extended;globalExtended;header;startBlockSize;blockRemain;remain;type;meta=!1;ignore=!1;path;mode;uid;gid;uname;gname;size=0;mtime;atime;ctime;linkpath;dev;ino;nlink;invalid=!1;absolute;unsupported=!1;constructor(t,e,i){switch(super({}),this.pause(),this.extended=e,this.globalExtended=i,this.header=t,this.remain=t.size??0,this.startBlockSize=512*Math.ceil(this.remain/512),this.blockRemain=this.startBlockSize,this.type=t.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=!0;break;default:this.ignore=!0}if(!t.path)throw new Error("no path provided for tar.ReadEntry");this.path=f(t.path),this.mode=t.mode,this.mode&&(this.mode=this.mode&4095),this.uid=t.uid,this.gid=t.gid,this.uname=t.uname,this.gname=t.gname,this.size=this.remain,this.mtime=t.mtime,this.atime=t.atime,this.ctime=t.ctime,this.linkpath=t.linkpath?f(t.linkpath):void 0,this.uname=t.uname,this.gname=t.gname,e&&this.#t(e),i&&this.#t(i,!0)}write(t){let e=t.length;if(e>this.blockRemain)throw new Error("writing more to entry than is appropriate");let i=this.remain,r=this.blockRemain;return this.remain=Math.max(0,i-e),this.blockRemain=Math.max(0,r-e),this.ignore?!0:i>=e?super.write(t):super.write(t.subarray(0,i))}#t(t,e=!1){t.path&&(t.path=f(t.path)),t.linkpath&&(t.linkpath=f(t.linkpath)),Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="path"&&e))))}};var Dt=(s,t,e,i={})=>{s.file&&(i.file=s.file),s.cwd&&(i.cwd=s.cwd),i.code=e instanceof Error&&e.code||t,i.tarCode=t,!s.strict&&i.recoverable!==!1?(e instanceof Error&&(i=Object.assign(e,i),e=e.message),s.emit("warn",t,e,i)):e instanceof Error?s.emit("error",Object.assign(e,i)):s.emit("error",Object.assign(new Error(`${t}: ${e}`),i))};var Nn=1024*1024,Xi=Buffer.from([31,139]),qi=Buffer.from([40,181,47,253]),An=Math.max(Xi.length,qi.length),B=Symbol("state"),Nt=Symbol("writeEntry"),it=Symbol("readEntry"),Zi=Symbol("nextEntry"),Zs=Symbol("processEntry"),V=Symbol("extendedHeader"),he=Symbol("globalExtendedHeader"),dt=Symbol("meta"),Ys=Symbol("emitMeta"),p=Symbol("buffer"),st=Symbol("queue"),ut=Symbol("ended"),Yi=Symbol("emittedEnd"),At=Symbol("emit"),w=Symbol("unzip"),Xe=Symbol("consumeChunk"),qe=Symbol("consumeChunkSub"),Ki=Symbol("consumeBody"),Ks=Symbol("consumeMeta"),Vs=Symbol("consumeHeader"),ae=Symbol("consuming"),Vi=Symbol("bufferConcat"),Qe=Symbol("maybeEnd"),Yt=Symbol("writing"),$=Symbol("aborted"),Je=Symbol("onDone"),It=Symbol("sawValidEntry"),je=Symbol("sawNullBlock"),ti=Symbol("sawEOF"),$s=Symbol("closeStream"),In=1e3,le=Symbol("compressedBytesRead"),$i=Symbol("decompressedBytesRead"),Xs=Symbol("checkDecompressionRatio"),Cn=()=>!0,rt=class extends Dn{file;strict;maxMetaEntrySize;filter;brotli;zstd;maxDecompressionRatio;writable=!0;readable=!1;[st]=[];[p];[it];[Nt];[B]="begin";[dt]="";[V];[he];[ut]=!1;[w];[$]=!1;[It];[je]=!1;[ti]=!1;[Yt]=!1;[ae]=!1;[Yi]=!1;[le]=0;[$i]=0;constructor(t={}){super(),this.file=t.file||"",this.on(Je,()=>{(this[B]==="begin"||this[It]===!1)&&this.warn("TAR_BAD_ARCHIVE","Unrecognized archive format")}),t.ondone?this.on(Je,t.ondone):this.on(Je,()=>{this.emit("prefinish"),this.emit("finish"),this.emit("end")}),this.strict=!!t.strict,this.maxDecompressionRatio=typeof t.maxDecompressionRatio=="number"?t.maxDecompressionRatio:In,this.maxMetaEntrySize=t.maxMetaEntrySize||Nn,this.filter=typeof t.filter=="function"?t.filter:Cn;let e=t.file&&(t.file.endsWith(".tar.br")||t.file.endsWith(".tbr"));this.brotli=!(t.gzip||t.zstd)&&t.brotli!==void 0?t.brotli:e?void 0:!1;let i=t.file&&(t.file.endsWith(".tar.zst")||t.file.endsWith(".tzst"));this.zstd=!(t.gzip||t.brotli)&&t.zstd!==void 0?t.zstd:i?!0:void 0,this.on("end",()=>this[$s]()),typeof t.onwarn=="function"&&this.on("warn",t.onwarn),typeof t.onReadEntry=="function"&&this.on("entry",t.onReadEntry)}warn(t,e,i={}){Dt(this,t,e,i)}[Vs](t,e){this[It]===void 0&&(this[It]=!1);let i;try{i=new F(t,e,this[V],this[he])}catch(r){return this.warn("TAR_ENTRY_INVALID",r)}if(i.nullBlock)this[je]?(this[ti]=!0,this[B]==="begin"&&(this[B]="header"),this[At]("eof")):(this[je]=!0,this[At]("nullBlock"));else if(this[je]=!1,!i.cksumValid)this.warn("TAR_ENTRY_INVALID","checksum failure",{header:i});else if(!i.path)this.warn("TAR_ENTRY_INVALID","path is required",{header:i});else{let r=i.type;if(/^(Symbolic)?Link$/.test(r)&&!i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath required",{header:i});else if(!/^(Symbolic)?Link$/.test(r)&&!/^(Global)?ExtendedHeader$/.test(r)&&i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath forbidden",{header:i});else{let n=this[Nt]=new $e(i,this[V],this[he]);if(!this[It])if(n.remain){let o=()=>{n.invalid||(this[It]=!0)};n.on("end",o)}else this[It]=!0;n.meta?n.size>this.maxMetaEntrySize?(n.ignore=!0,this[At]("ignoredEntry",n),this[B]="ignore",n.resume()):n.size>0&&(this[dt]="",n.on("data",o=>this[dt]+=o),this[B]="meta"):(this[V]=void 0,n.ignore=n.ignore||!this.filter(n.path,n),n.ignore?(this[At]("ignoredEntry",n),this[B]=n.remain?"ignore":"header",n.resume()):(n.remain?this[B]="body":(this[B]="header",n.end()),this[it]?this[st].push(n):(this[st].push(n),this[Zi]())))}}}[$s](){queueMicrotask(()=>this.emit("close"))}[Zs](t){let e=!0;if(!t)this[it]=void 0,e=!1;else if(Array.isArray(t)){let[i,...r]=t;this.emit(i,...r)}else this[it]=t,this.emit("entry",t),t.emittedEnd||(t.on("end",()=>this[Zi]()),e=!1);return e}[Zi](){do;while(this[Zs](this[st].shift()));if(this[st].length===0){let t=this[it];!t||t.flowing||t.size===t.remain?this[Yt]||this.emit("drain"):t.once("drain",()=>this.emit("drain"))}}[Ki](t,e){let i=this[Nt];if(!i)throw new Error("attempt to consume body without entry??");let r=i.blockRemain??0,n=r>=t.length&&e===0?t:t.subarray(e,e+r);return i.write(n),i.blockRemain||(this[B]="header",this[Nt]=void 0,i.end()),n.length}[Ks](t,e){let i=this[Nt],r=this[Ki](t,e);return!this[Nt]&&i&&this[Ys](i),r}[At](t,e,i){this[st].length===0&&!this[it]?this.emit(t,e,i):this[st].push([t,e,i])}[Ys](t){switch(this[At]("meta",this[dt]),t.type){case"ExtendedHeader":case"OldExtendedHeader":this[V]=ft.parse(this[dt],this[V],!1);break;case"GlobalExtendedHeader":this[he]=ft.parse(this[dt],this[he],!0);break;case"NextFileHasLongPath":case"OldGnuLongPath":{let e=this[V]??Object.create(null);this[V]=e,e.path=this[dt].replace(/\0.*/,"");break}case"NextFileHasLongLinkpath":{let e=this[V]||Object.create(null);this[V]=e,e.linkpath=this[dt].replace(/\0.*/,"");break}default:throw new Error("unknown meta: "+t.type)}}abort(t){if(!this[$]){if(this[w]){let e=this[w];e.write=()=>!0,e.end=()=>e,e.emit=()=>!1,e.destroy?.()}this[$]=!0,this.emit("abort",t),this.warn("TAR_ABORT",t,{recoverable:!1})}}[Xs](t){this[$i]+=t.length;let e=this[$i]/this[le];return e>this.maxDecompressionRatio?(this.abort(new Error(`max decompression ratio exceeded: ${e.toFixed(2)} > ${this.maxDecompressionRatio}`)),!1):!0}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this[$])return i?.(),!1;if((this[w]===void 0||this.brotli===void 0&&this[w]===!1)&&t){if(this[p]&&(t=Buffer.concat([this[p],t]),this[p]=void 0),t.length<An)return this[p]=t,i?.(),!0;for(let a=0;this[w]===void 0&&a<Xi.length;a++)t[a]!==Xi[a]&&(this[w]=!1);let o=!1;if(this[w]===!1&&this.zstd!==!1){o=!0;for(let a=0;a<qi.length;a++)if(t[a]!==qi[a]){o=!1;break}}let h=this.brotli===void 0&&!o;if(this[w]===!1&&h)if(t.length<512)if(this[ut])this.brotli=!0;else return this[p]=t,i?.(),!0;else try{new F(t.subarray(0,512)),this.brotli=!1}catch{this.brotli=!0}if(this[w]===void 0||this[w]===!1&&(this.brotli||o)){let a=this[ut];this[ut]=!1,this[w]=this[w]===void 0?new Ue({}):o?new Ke({}):new Ge({}),this[w].on("data",c=>{this[Xs](c)&&this[Xe](c)}),this[w].on("error",c=>{this[$]||this.abort(c)}),this[w].on("end",()=>{this[ut]=!0,this[Xe]()}),this[Yt]=!0,this[le]+=t.length;let l=!!this[w][a?"end":"write"](t);return this[Yt]=!1,i?.(),l}}this[Yt]=!0,this[w]?(this[le]+=t.length,this[w].write(t)):this[Xe](t),this[Yt]=!1;let n=this[st].length>0?!1:this[it]?this[it].flowing:!0;return!n&&this[st].length===0&&this[it]?.once("drain",()=>this.emit("drain")),i?.(),n}[Vi](t){t&&!this[$]&&(this[p]=this[p]?Buffer.concat([this[p],t]):t)}[Qe](){if(this[ut]&&!this[Yi]&&!this[$]&&!this[ae]){this[Yi]=!0;let t=this[Nt];if(t?.blockRemain){let e=this[p]?this[p].length:0;this.warn("TAR_BAD_ARCHIVE",`Truncated input (needed ${t.blockRemain} more bytes, only ${e} available)`,{entry:t}),this[p]&&t.write(this[p]),t.end()}this[At](Je)}}[Xe](t){if(this[ae]&&t)this[Vi](t);else if(!t&&!this[p])this[Qe]();else if(t){if(this[ae]=!0,this[p]){this[Vi](t);let e=this[p];this[p]=void 0,this[qe](e)}else this[qe](t);for(;this[p]&&this[p]?.length>=512&&!this[$]&&!this[ti];){let e=this[p];this[p]=void 0,this[qe](e)}this[ae]=!1}(!this[p]||this[ut])&&this[Qe]()}[qe](t){let e=0,i=t.length;for(;e+512<=i&&!this[$]&&!this[ti];)switch(this[B]){case"begin":case"header":this[Vs](t,e),e+=512;break;case"ignore":case"body":e+=this[Ki](t,e);break;case"meta":e+=this[Ks](t,e);break;default:throw new Error("invalid state: "+this[B])}e<i&&(this[p]=this[p]?Buffer.concat([t.subarray(e),this[p]]):t.subarray(e))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e)),i&&this.once("finish",i),this[$]||(this[w]?(t&&(this[le]+=t.length,this[w].write(t)),this[w].end()):(this[ut]=!0,(this.brotli===void 0||this.zstd===void 0)&&(t=t||Buffer.alloc(0)),t&&this.write(t),this[Qe]())),this}};var mt=s=>{let t=s.length-1,e=-1;for(;t>-1&&s.charAt(t)==="/";)e=t,t--;return e===-1?s:s.slice(0,e)};var vn=s=>{let t=s.onReadEntry;s.onReadEntry=t?e=>{t(e),e.resume()}:e=>e.resume()},Qi=(s,t)=>{let e=new Map(t.map(o=>[mt(o),!0])),i=s.filter,r=100,n=(o,h="",a=0)=>{if(a>=r)return e.set(o,!1),!1;let l=h||kn(o).root||".",c;if(o===l)c=!1;else{let d=e.get(o);c=d!==void 0?d:n(Fn(o),l,a+1)}return e.set(o,c),c};s.filter=i?(o,h)=>i(o,h)&&n(mt(o)):o=>n(mt(o))},Mn=s=>{let t=new rt(s),e=s.file,i;try{i=Kt.openSync(e,"r");let r=Kt.fstatSync(i),n=s.maxReadSize||16*1024*1024;if(r.size<n){let o=Buffer.allocUnsafe(r.size),h=Kt.readSync(i,o,0,r.size,0);t.end(h===o.byteLength?o:o.subarray(0,h))}else{let o=0,h=Buffer.allocUnsafe(n);for(;o<r.size;){let a=Kt.readSync(i,h,0,n,o);if(a===0)break;o+=a,t.write(h.subarray(0,a))}t.end()}}finally{if(typeof i=="number")try{Kt.closeSync(i)}catch{}}},Bn=(s,t)=>{let e=new rt(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("end",o),Kt.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},Ct=K(Mn,Bn,s=>new rt(s),s=>new rt(s),(s,t)=>{t?.length&&Qi(s,t),s.noResume||vn(s)});import mi from"fs";import X from"fs";import js from"path";var Ji=(s,t,e)=>(s&=4095,e&&(s=(s|384)&-19),t&&(s&256&&(s|=64),s&32&&(s|=8),s&4&&(s|=1)),s);import{win32 as Pn}from"node:path";var{isAbsolute:zn,parse:qs}=Pn,ce=s=>{let t="",e=qs(s);for(;zn(s)||e.root;){let i=s.charAt(0)==="/"&&s.slice(0,4)!=="//?/"?"/":e.root;s=s.slice(i.length),t+=i,e=qs(s)}return[t,s]};var ei=["|","<",">","?",":"],ji=ei.map(s=>String.fromCodePoint(61440+Number(s.codePointAt(0)))),Un=new Map(ei.map((s,t)=>[s,ji[t]])),Hn=new Map(ji.map((s,t)=>[s,ei[t]])),ts=s=>ei.reduce((t,e)=>t.split(e).join(Un.get(e)),s),Qs=s=>ji.reduce((t,e)=>t.split(e).join(Hn.get(e)),s);var rr=(s,t)=>t?(s=f(s).replace(/^\.(\/|$)/,""),mt(t)+"/"+s):f(s),Wn=16*1024*1024,tr=Symbol("process"),er=Symbol("file"),ir=Symbol("directory"),is=Symbol("symlink"),sr=Symbol("hardlink"),fe=Symbol("header"),ii=Symbol("read"),ss=Symbol("lstat"),si=Symbol("onlstat"),rs=Symbol("onread"),ns=Symbol("onreadlink"),os=Symbol("openfile"),hs=Symbol("onopenfile"),pt=Symbol("close"),ri=Symbol("mode"),as=Symbol("awaitDrain"),es=Symbol("ondrain"),q=Symbol("prefix"),de=class extends A{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=!1;constructor(t,e={}){let i=se(e);super(),this.path=f(t),this.portable=!!i.portable,this.maxReadSize=i.maxReadSize||Wn,this.linkCache=i.linkCache||new Map,this.statCache=i.statCache||new Map,this.preservePaths=!!i.preservePaths,this.cwd=f(i.cwd||process.cwd()),this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.mtime=i.mtime,this.prefix=i.prefix?f(i.prefix):void 0,this.onWriteEntry=i.onWriteEntry,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let r=!1;if(!this.preservePaths){let[o,h]=ce(this.path);o&&typeof h=="string"&&(this.path=h,r=o)}this.win32=!!i.win32||process.platform==="win32",this.win32&&(this.path=Qs(this.path.replaceAll(/\\/g,"/")),t=t.replaceAll(/\\/g,"/")),this.absolute=f(i.absolute||js.resolve(this.cwd,t)),this.path===""&&(this.path="./"),r&&this.warn("TAR_ENTRY_INFO",`stripping ${r} from absolute path`,{entry:this,path:r+this.path});let n=this.statCache.get(this.absolute);n?this[si](n):this[ss]()}warn(t,e,i={}){return Dt(this,t,e,i)}emit(t,...e){return t==="error"&&(this.#t=!0),super.emit(t,...e)}[ss](){X.lstat(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[si](e)})}[si](t){this.statCache.set(this.absolute,t),this.stat=t,t.isFile()||(t.size=0),this.type=Gn(t),this.emit("stat",t),this[tr]()}[tr](){switch(this.type){case"File":return this[er]();case"Directory":return this[ir]();case"SymbolicLink":return this[is]();default:return this.end()}}[ri](t){return Ji(t,this.type==="Directory",this.portable)}[q](t){return rr(t,this.prefix)}[fe](){if(!this.stat)throw new Error("cannot write header before stat");this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.onWriteEntry?.(this),this.header=new F({path:this[q](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[q](this.linkpath):this.linkpath,mode:this[ri](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 ft({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[q](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[q](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 t=this.header?.block;if(!t)throw new Error("failed to encode header");super.write(t)}[ir](){if(!this.stat)throw new Error("cannot create directory entry without stat");this.path.slice(-1)!=="/"&&(this.path+="/"),this.stat.size=0,this[fe](),this.end()}[is](){X.readlink(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[ns](e)})}[ns](t){this.linkpath=f(t),this[fe](),this.end()}[sr](t){if(!this.stat)throw new Error("cannot create link entry without stat");this.type="Link",this.linkpath=f(js.relative(this.cwd,t)),this.stat.size=0,this[fe](),this.end()}[er](){if(!this.stat)throw new Error("cannot create file entry without stat");if(this.stat.nlink>1){let t=`${this.stat.dev}:${this.stat.ino}`,e=this.linkCache.get(t);if(e?.indexOf(this.cwd)===0)return this[sr](e);this.linkCache.set(t,this.absolute)}if(this[fe](),this.stat.size===0)return this.end();this[os]()}[os](){X.open(this.absolute,"r",(t,e)=>{if(t)return this.emit("error",t);this[hs](e)})}[hs](t){if(this.fd=t,this.#t)return this[pt]();if(!this.stat)throw new Error("should stat before calling onopenfile");this.blockLen=512*Math.ceil(this.stat.size/512),this.blockRemain=this.blockLen;let e=Math.min(this.blockLen,this.maxReadSize);this.buf=Buffer.allocUnsafe(e),this.offset=0,this.pos=0,this.remain=this.stat.size,this.length=this.buf.length,this[ii]()}[ii](){let{fd:t,buf:e,offset:i,length:r,pos:n}=this;if(t===void 0||e===void 0)throw new Error("cannot read file without first opening");X.read(t,e,i,r,n,(o,h)=>{if(o)return this[pt](()=>this.emit("error",o));this[rs](h)})}[pt](t=()=>{}){this.fd!==void 0&&X.close(this.fd,t)}[rs](t){if(t<=0&&this.remain>0){let r=Object.assign(new Error("encountered unexpected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(t>this.remain){let r=Object.assign(new Error("did not encounter expected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(!this.buf)throw new Error("should have created buffer prior to reading");if(t===this.remain)for(let r=t;r<this.length&&t<this.blockRemain;r++)this.buf[r+this.offset]=0,t++,this.remain++;let e=this.offset===0&&t===this.buf.length?this.buf:this.buf.subarray(this.offset,this.offset+t);this.write(e)?this[es]():this[as](()=>this[es]())}[as](t){this.once("drain",t)}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this.blockRemain<t.length){let r=Object.assign(new Error("writing more data than expected"),{path:this.absolute});return this.emit("error",r)}return this.remain-=t.length,this.blockRemain-=t.length,this.pos+=t.length,this.offset+=t.length,super.write(t,null,i)}[es](){if(!this.remain)return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),this[pt](t=>t?this.emit("error",t):this.end());if(!this.buf)throw new 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[ii]()}},ni=class extends de{sync=!0;[ss](){this[si](X.lstatSync(this.absolute))}[is](){this[ns](X.readlinkSync(this.absolute))}[os](){this[hs](X.openSync(this.absolute,"r"))}[ii](){let t=!0;try{let{fd:e,buf:i,offset:r,length:n,pos:o}=this;if(e===void 0||i===void 0)throw new Error("fd and buf must be set in READ method");let h=X.readSync(e,i,r,n,o);this[rs](h),t=!1}finally{if(t)try{this[pt](()=>{})}catch{}}}[as](t){t()}[pt](t=()=>{}){this.fd!==void 0&&X.closeSync(this.fd),t()}},oi=class extends A{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(t,e,i={}){return Dt(this,t,e,i)}constructor(t,e={}){let i=se(e);super(),this.preservePaths=!!i.preservePaths,this.portable=!!i.portable,this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.onWriteEntry=i.onWriteEntry,this.readEntry=t;let{type:r}=t;if(r==="Unsupported")throw new Error("writing entry that should be ignored");this.type=r,this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.prefix=i.prefix,this.path=f(t.path),this.mode=t.mode!==void 0?this[ri](t.mode):void 0,this.uid=this.portable?void 0:t.uid,this.gid=this.portable?void 0:t.gid,this.uname=this.portable?void 0:t.uname,this.gname=this.portable?void 0:t.gname,this.size=t.size,this.mtime=this.noMtime?void 0:i.mtime||t.mtime,this.atime=this.portable?void 0:t.atime,this.ctime=this.portable?void 0:t.ctime,this.linkpath=t.linkpath!==void 0?f(t.linkpath):void 0,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let n=!1;if(!this.preservePaths){let[h,a]=ce(this.path);h&&typeof a=="string"&&(this.path=a,n=h)}this.remain=t.size,this.blockRemain=t.startBlockSize,this.onWriteEntry?.(this),this.header=new F({path:this[q](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[q](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}),n&&this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute path`,{entry:this,path:n+this.path}),this.header.encode()&&!this.noPax&&super.write(new ft({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[q](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[q](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 o=this.header?.block;if(!o)throw new Error("failed to encode header");super.write(o),t.pipe(this)}[q](t){return rr(t,this.prefix)}[ri](t){return Ji(t,this.type==="Directory",this.portable)}write(t,e,i){typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8"));let r=t.length;if(r>this.blockRemain)throw new Error("writing more to entry than is appropriate");return this.blockRemain-=r,super.write(t,i)}end(t,e,i){return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e??"utf8")),i&&this.once("finish",i),t?super.end(t,i):super.end(i),this}},Gn=s=>s.isFile()?"File":s.isDirectory()?"Directory":s.isSymbolicLink()?"SymbolicLink":"Unsupported";var hi=class s{tail;head;length=0;static create(t=[]){return new s(t)}constructor(t=[]){for(let e of t)this.push(e)}*[Symbol.iterator](){for(let t=this.head;t;t=t.next)yield t.value}removeNode(t){if(t.list!==this)throw new Error("removing node which does not belong to this list");let e=t.next,i=t.prev;return e&&(e.prev=i),i&&(i.next=e),t===this.head&&(this.head=e),t===this.tail&&(this.tail=i),this.length--,t.next=void 0,t.prev=void 0,t.list=void 0,e}unshiftNode(t){if(t===this.head)return;t.list&&t.list.removeNode(t);let e=this.head;t.list=this,t.next=e,e&&(e.prev=t),this.head=t,this.tail||(this.tail=t),this.length++}pushNode(t){if(t===this.tail)return;t.list&&t.list.removeNode(t);let e=this.tail;t.list=this,t.prev=e,e&&(e.next=t),this.tail=t,this.head||(this.head=t),this.length++}push(...t){for(let e=0,i=t.length;e<i;e++)Yn(this,t[e]);return this.length}unshift(...t){for(var e=0,i=t.length;e<i;e++)Kn(this,t[e]);return this.length}pop(){if(!this.tail)return;let t=this.tail.value,e=this.tail;return this.tail=this.tail.prev,this.tail?this.tail.next=void 0:this.head=void 0,e.list=void 0,this.length--,t}shift(){if(!this.head)return;let t=this.head.value,e=this.head;return this.head=this.head.next,this.head?this.head.prev=void 0:this.tail=void 0,e.list=void 0,this.length--,t}forEach(t,e){e=e||this;for(let i=this.head,r=0;i;r++)t.call(e,i.value,r,this),i=i.next}forEachReverse(t,e){e=e||this;for(let i=this.tail,r=this.length-1;i;r--)t.call(e,i.value,r,this),i=i.prev}get(t){let e=0,i=this.head;for(;i&&e<t;e++)i=i.next;if(e===t&&i)return i.value}getReverse(t){let e=0,i=this.tail;for(;i&&e<t;e++)i=i.prev;if(e===t&&i)return i.value}map(t,e){e=e||this;let i=new s;for(let r=this.head;r;)i.push(t.call(e,r.value,this)),r=r.next;return i}mapReverse(t,e){e=e||this;var i=new s;for(let r=this.tail;r;)i.push(t.call(e,r.value,this)),r=r.prev;return i}reduce(t,e){let i,r=this.head;if(arguments.length>1)i=e;else if(this.head)r=this.head.next,i=this.head.value;else throw new TypeError("Reduce of empty list with no initial value");for(var n=0;r;n++)i=t(i,r.value,n),r=r.next;return i}reduceReverse(t,e){let i,r=this.tail;if(arguments.length>1)i=e;else if(this.tail)r=this.tail.prev,i=this.tail.value;else throw new TypeError("Reduce of empty list with no initial value");for(let n=this.length-1;r;n--)i=t(i,r.value,n),r=r.prev;return i}toArray(){let t=new Array(this.length);for(let e=0,i=this.head;i;e++)t[e]=i.value,i=i.next;return t}toArrayReverse(){let t=new Array(this.length);for(let e=0,i=this.tail;i;e++)t[e]=i.value,i=i.prev;return t}slice(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.head,n=0;for(n=0;r&&n<t;n++)r=r.next;for(;r&&n<e;n++,r=r.next)i.push(r.value);return i}sliceReverse(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.length,n=this.tail;for(;n&&r>e;r--)n=n.prev;for(;n&&r>t;r--,n=n.prev)i.push(n.value);return i}splice(t,e=0,...i){t>this.length&&(t=this.length-1),t<0&&(t=this.length+t);let r=this.head;for(let o=0;r&&o<t;o++)r=r.next;let n=[];for(let o=0;r&&o<e;o++)n.push(r.value),r=this.removeNode(r);r?r!==this.tail&&(r=r.prev):r=this.tail;for(let o of i)r=Zn(this,r,o);return n}reverse(){let t=this.head,e=this.tail;for(let i=t;i;i=i.prev){let r=i.prev;i.prev=i.next,i.next=r}return this.head=e,this.tail=t,this}};function Zn(s,t,e){let i=t,r=t?t.next:s.head,n=new ue(e,i,r,s);return n.next===void 0&&(s.tail=n),n.prev===void 0&&(s.head=n),s.length++,n}function Yn(s,t){s.tail=new ue(t,s.tail,void 0,s),s.head||(s.head=s.tail),s.length++}function Kn(s,t){s.head=new ue(t,void 0,s.head,s),s.tail||(s.tail=s.head),s.length++}var ue=class{list;next;prev;value;constructor(t,e,i,r){this.list=r,this.value=t,e?(e.next=this,this.prev=e):this.prev=void 0,i?(i.prev=this,this.next=i):this.next=void 0}};import ar from"path";var pi=class{path;absolute;entry;stat;readdir;pending=!1;pendingLink=!1;ignore=!1;piped=!1;constructor(t,e){this.path=t||"./",this.absolute=e}},nr=Buffer.alloc(1024),li=Symbol("onStat"),me=Symbol("ended"),W=Symbol("queue"),pe=Symbol("pendingLinks"),Et=Symbol("current"),Ft=Symbol("process"),Ee=Symbol("processing"),ai=Symbol("processJob"),G=Symbol("jobs"),ls=Symbol("jobDone"),ci=Symbol("addFSEntry"),or=Symbol("addTarEntry"),ds=Symbol("stat"),us=Symbol("readdir"),fi=Symbol("onreaddir"),di=Symbol("pipe"),hr=Symbol("entry"),cs=Symbol("entryOpt"),ui=Symbol("writeEntryClass"),lr=Symbol("write"),fs=Symbol("ondrain"),wt=class extends A{sync=!1;opt;cwd;maxReadSize;preservePaths;strict;noPax;prefix;linkCache;statCache;file;portable;zip;readdirCache;noDirRecurse;follow;noMtime;mtime;filter;jobs;[ui];onWriteEntry;[W];[pe]=new Map;[G]=0;[Ee]=!1;[me]=!1;constructor(t={}){if(super(),this.opt=t,this.file=t.file||"",this.cwd=t.cwd||process.cwd(),this.maxReadSize=t.maxReadSize,this.preservePaths=!!t.preservePaths,this.strict=!!t.strict,this.noPax=!!t.noPax,this.prefix=f(t.prefix||""),this.linkCache=t.linkCache||new Map,this.statCache=t.statCache||new Map,this.readdirCache=t.readdirCache||new Map,this.onWriteEntry=t.onWriteEntry,this[ui]=de,typeof t.onwarn=="function"&&this.on("warn",t.onwarn),this.portable=!!t.portable,t.gzip||t.brotli||t.zstd){if((t.gzip?1:0)+(t.brotli?1:0)+(t.zstd?1:0)>1)throw new TypeError("gzip, brotli, zstd are mutually exclusive");if(t.gzip&&(typeof t.gzip!="object"&&(t.gzip={}),this.portable&&(t.gzip.portable=!0),this.zip=new ze(t.gzip)),t.brotli&&(typeof t.brotli!="object"&&(t.brotli={}),this.zip=new We(t.brotli)),t.zstd&&(typeof t.zstd!="object"&&(t.zstd={}),this.zip=new Ye(t.zstd)),!this.zip)throw new Error("impossible");let e=this.zip;e.on("data",i=>super.write(i)),e.on("end",()=>super.end()),e.on("drain",()=>this[fs]()),this.on("resume",()=>e.resume())}else this.on("drain",this[fs]);this.noDirRecurse=!!t.noDirRecurse,this.follow=!!t.follow,this.noMtime=!!t.noMtime,t.mtime&&(this.mtime=t.mtime),this.filter=typeof t.filter=="function"?t.filter:()=>!0,this[W]=new hi,this[G]=0,this.jobs=Number(t.jobs)||4,this[Ee]=!1,this[me]=!1}[lr](t){return super.write(t)}add(t){return this.write(t),this}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&this.add(t),this[me]=!0,this[Ft](),i&&i(),this}write(t){if(this[me])throw new Error("write after end");return typeof t=="string"?this[ci](t):this[or](t),this.flowing}[or](t){let e=f(ar.resolve(this.cwd,t.path));if(!this.filter(t.path,t))t.resume();else{let i=new pi(t.path,e);i.entry=new oi(t,this[cs](i)),i.entry.on("end",()=>this[ls](i)),this[G]+=1,this[W].push(i)}this[Ft]()}[ci](t){let e=f(ar.resolve(this.cwd,t));this[W].push(new pi(t,e)),this[Ft]()}[ds](t){t.pending=!0,this[G]+=1;let e=this.follow?"stat":"lstat";mi[e](t.absolute,(i,r)=>{t.pending=!1,this[G]-=1,i?this.emit("error",i):this[li](t,r)})}[li](t,e){if(this.statCache.set(t.absolute,e),t.stat=e,!this.filter(t.path,e))t.ignore=!0;else if(e.isFile()&&e.nlink>1&&!this.linkCache.get(`${e.dev}:${e.ino}`)&&!this.sync)if(t===this[Et])this[ai](t);else{let i=`${e.dev}:${e.ino}`,r=this[pe].get(i);r?r.push(t):this[pe].set(i,[t]),t.pendingLink=!0,t.pending=!0}this[Ft]()}[us](t){t.pending=!0,this[G]+=1,mi.readdir(t.absolute,(e,i)=>{if(t.pending=!1,this[G]-=1,e)return this.emit("error",e);this[fi](t,i)})}[fi](t,e){this.readdirCache.set(t.absolute,e),t.readdir=e,this[Ft]()}[Ft](){if(!this[Ee]){this[Ee]=!0;for(let t=this[W].head;t&&this[G]<this.jobs;t=t.next)if(this[ai](t.value),t.value.ignore){let e=t.next;this[W].removeNode(t),t.next=e}this[Ee]=!1,this[me]&&this[W].length===0&&this[G]===0&&(this.zip?this.zip.end(nr):(super.write(nr),super.end()))}}get[Et](){return this[W]&&this[W].head&&this[W].head.value}[ls](t){this[W].shift(),this[G]-=1;let{stat:e}=t;if(e&&e.isFile()&&e.nlink>1){let i=`${e.dev}:${e.ino}`,r=this[pe].get(i);if(r){this[pe].delete(i);for(let n of r)n.pending=!1,this[ai](n)}}this[Ft]()}[ai](t){if(t.pending&&t.pendingLink&&t===this[Et]&&(t.pending=!1,t.pendingLink=!1),!t.pending){if(t.entry){t===this[Et]&&!t.piped&&this[di](t);return}if(!t.stat){let e=this.statCache.get(t.absolute);e?this[li](t,e):this[ds](t)}if(t.stat&&!t.ignore){if(!this.noDirRecurse&&t.stat.isDirectory()&&!t.readdir){let e=this.readdirCache.get(t.absolute);if(e?this[fi](t,e):this[us](t),!t.readdir)return}if(t.entry=this[hr](t),!t.entry){t.ignore=!0;return}t===this[Et]&&!t.piped&&this[di](t)}}}[cs](t){return{onwarn:(e,i,r)=>this.warn(e,i,r),noPax:this.noPax,cwd:this.cwd,absolute:t.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}}[hr](t){this[G]+=1;try{return new this[ui](t.path,this[cs](t)).on("end",()=>this[ls](t)).on("error",i=>this.emit("error",i))}catch(e){this.emit("error",e)}}[fs](){this[Et]&&this[Et].entry&&this[Et].entry.resume()}[di](t){t.piped=!0,t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[ci](o+r)});let e=t.entry,i=this.zip;if(!e)throw new Error("cannot pipe without source");i?e.on("data",r=>{i.write(r)||e.pause()}):e.on("data",r=>{super.write(r)||e.pause()})}pause(){return this.zip&&this.zip.pause(),super.pause()}warn(t,e,i={}){Dt(this,t,e,i)}},kt=class extends wt{sync=!0;constructor(t){super(t),this[ui]=ni}pause(){}resume(){}[ds](t){let e=this.follow?"statSync":"lstatSync";this[li](t,mi[e](t.absolute))}[us](t){this[fi](t,mi.readdirSync(t.absolute))}[di](t){let e=t.entry,i=this.zip;if(t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[ci](o+r)}),!e)throw new Error("Cannot pipe without source");i?e.on("data",r=>{i.write(r)}):e.on("data",r=>{super[lr](r)})}};var Vn=(s,t)=>{let e=new kt(s),i=new Wt(s.file,{mode:s.mode||438});e.pipe(i),fr(e,t)},$n=(s,t)=>{let e=new wt(s),i=new et(s.file,{mode:s.mode||438});e.pipe(i);let r=new Promise((n,o)=>{i.on("error",o),i.on("close",n),e.on("error",o)});return dr(e,t).catch(n=>e.emit("error",n)),r},fr=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?Ct({file:cr.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},dr=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await Ct({file:cr.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>{s.add(i)}}):s.add(e);s.end()},Xn=(s,t)=>{let e=new kt(s);return fr(e,t),e},qn=(s,t)=>{let e=new wt(s);return dr(e,t).catch(i=>e.emit("error",i)),e},Qn=K(Vn,$n,Xn,qn,(s,t)=>{if(!t?.length)throw new TypeError("no paths specified to add to archive")});import Br from"node:fs";import co from"node:assert";import{randomBytes as Mr}from"node:crypto";import u from"node:fs";import R from"node:path";import pr from"fs";var Jn=process.env.__FAKE_PLATFORM__||process.platform,Er=Jn==="win32",{O_CREAT:wr,O_NOFOLLOW:ur,O_TRUNC:Sr,O_WRONLY:yr}=pr.constants,Rr=Number(process.env.__FAKE_FS_O_FILENAME__)||pr.constants.UV_FS_O_FILEMAP||0,jn=Er&&!!Rr,to=512*1024,eo=Rr|Sr|wr|yr,mr=!Er&&typeof ur=="number"?ur|Sr|wr|yr:null,ms=mr!==null?()=>mr:jn?s=>s<to?eo:"w":()=>"w";import wi from"node:fs";import we from"node:path";var ps=(s,t,e)=>{try{return wi.lchownSync(s,t,e)}catch(i){if(i?.code!=="ENOENT")throw i}},Ei=(s,t,e,i)=>{wi.lchown(s,t,e,r=>{i(r&&r?.code!=="ENOENT"?r:null)})},io=(s,t,e,i,r)=>{if(t.isDirectory())Es(we.resolve(s,t.name),e,i,n=>{if(n)return r(n);let o=we.resolve(s,t.name);Ei(o,e,i,r)});else{let n=we.resolve(s,t.name);Ei(n,e,i,r)}},Es=(s,t,e,i)=>{wi.readdir(s,{withFileTypes:!0},(r,n)=>{if(r){if(r.code==="ENOENT")return i();if(r.code!=="ENOTDIR"&&r.code!=="ENOTSUP")return i(r)}if(r||!n.length)return Ei(s,t,e,i);let o=n.length,h=null,a=l=>{if(!h){if(l)return i(h=l);if(--o===0)return Ei(s,t,e,i)}};for(let l of n)io(s,l,t,e,a)})},so=(s,t,e,i)=>{t.isDirectory()&&ws(we.resolve(s,t.name),e,i),ps(we.resolve(s,t.name),e,i)},ws=(s,t,e)=>{let i;try{i=wi.readdirSync(s,{withFileTypes:!0})}catch(r){let n=r;if(n?.code==="ENOENT")return;if(n?.code==="ENOTDIR"||n?.code==="ENOTSUP")return ps(s,t,e);throw n}for(let r of i)so(s,r,t,e);return ps(s,t,e)};import k from"node:fs";import ro from"node:fs/promises";import Si from"node:path";var Se=class extends Error{path;code;syscall="chdir";constructor(t,e){super(`${e}: Cannot cd into '${t}'`),this.path=t,this.code=e}get name(){return"CwdError"}};var St=class extends Error{path;symlink;syscall="symlink";code="TAR_SYMLINK_ERROR";constructor(t,e){super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"),this.symlink=t,this.path=e}get name(){return"SymlinkError"}};var no=(s,t)=>{k.stat(s,(e,i)=>{(e||!i.isDirectory())&&(e=new Se(s,e?.code||"ENOTDIR")),t(e)})},gr=(s,t,e)=>{s=f(s);let i=t.umask??18,r=t.mode|448,n=(r&i)!==0,o=t.uid,h=t.gid,a=typeof o=="number"&&typeof h=="number"&&(o!==t.processUid||h!==t.processGid),l=t.preserve,c=t.unlink,d=f(t.cwd),y=(E,x)=>{E?e(E):x&&a?Es(x,o,h,Le=>y(Le)):n?k.chmod(s,r,e):e()};if(s===d)return no(s,y);if(l)return ro.mkdir(s,{mode:r,recursive:!0}).then(E=>y(null,E??void 0),y);let D=f(Si.relative(d,s)).split("/");Ss(d,D,r,c,d,void 0,y)},Ss=(s,t,e,i,r,n,o)=>{if(t.length===0)return o(null,n);let h=t.shift(),a=f(Si.resolve(s+"/"+h));k.mkdir(a,e,br(a,t,e,i,r,n,o))},br=(s,t,e,i,r,n,o)=>h=>{h?k.lstat(s,(a,l)=>{if(a)a.path=a.path&&f(a.path),o(a);else if(l.isDirectory())Ss(s,t,e,i,r,n,o);else if(i)k.unlink(s,c=>{if(c)return o(c);k.mkdir(s,e,br(s,t,e,i,r,n,o))});else{if(l.isSymbolicLink())return o(new St(s,s+"/"+t.join("/")));o(h)}}):(n=n||s,Ss(s,t,e,i,r,n,o))},oo=s=>{let t=!1,e;try{t=k.statSync(s).isDirectory()}catch(i){e=i?.code}finally{if(!t)throw new Se(s,e??"ENOTDIR")}},_r=(s,t)=>{s=f(s);let e=t.umask??18,i=t.mode|448,r=(i&e)!==0,n=t.uid,o=t.gid,h=typeof n=="number"&&typeof o=="number"&&(n!==t.processUid||o!==t.processGid),a=t.preserve,l=t.unlink,c=f(t.cwd),d=E=>{E&&h&&ws(E,n,o),r&&k.chmodSync(s,i)};if(s===c)return oo(c),d();if(a)return d(k.mkdirSync(s,{mode:i,recursive:!0})??void 0);let T=f(Si.relative(c,s)).split("/"),D;for(let E=T.shift(),x=c;E&&(x+="/"+E);E=T.shift()){x=f(Si.resolve(x));try{k.mkdirSync(x,i),D=D||x}catch{let Le=k.lstatSync(x);if(Le.isDirectory())continue;if(l){k.unlinkSync(x),k.mkdirSync(x,i),D=D||x;continue}else if(Le.isSymbolicLink())return new St(x,x+"/"+T.join("/"))}}return d(D)};import{join as xr}from"node:path";var ys=Object.create(null),Or=1e4,Vt=new Set,Tr=s=>{Vt.has(s)?Vt.delete(s):ys[s]=s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"),Vt.add(s);let t=ys[s],e=Vt.size-Or;if(e>Or/10){for(let i of Vt)if(Vt.delete(i),delete ys[i],--e<=0)break}return t};var ho=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,ao=ho==="win32",lo=s=>s.split("/").slice(0,-1).reduce((e,i)=>{let r=e.at(-1);return r!==void 0&&(i=xr(r,i)),e.push(i||"/"),e},[]),yi=class{#t=new Map;#i=new Map;#s=new Set;reserve(t,e){t=ao?["win32 parallelization disabled"]:t.map(r=>mt(xr(Tr(r))));let i=new Set(t.map(r=>lo(r)).reduce((r,n)=>r.concat(n)));this.#i.set(e,{dirs:i,paths:t});for(let r of t){let n=this.#t.get(r);n?n.push(e):this.#t.set(r,[e])}for(let r of i){let n=this.#t.get(r);if(!n)this.#t.set(r,[new Set([e])]);else{let o=n.at(-1);o instanceof Set?o.add(e):n.push(new Set([e]))}}return this.#r(e)}#n(t){let e=this.#i.get(t);if(!e)throw new Error("function does not have any path reservations");return{paths:e.paths.map(i=>this.#t.get(i)),dirs:[...e.dirs].map(i=>this.#t.get(i))}}check(t){let{paths:e,dirs:i}=this.#n(t);return e.every(r=>r&&r[0]===t)&&i.every(r=>r&&r[0]instanceof Set&&r[0].has(t))}#r(t){return this.#s.has(t)||!this.check(t)?!1:(this.#s.add(t),t(()=>this.#e(t)),!0)}#e(t){if(!this.#s.has(t))return!1;let e=this.#i.get(t);if(!e)throw new Error("invalid reservation");let{paths:i,dirs:r}=e,n=new Set;for(let o of i){let h=this.#t.get(o);if(!h||h?.[0]!==t)continue;let a=h[1];if(!a){this.#t.delete(o);continue}if(h.shift(),typeof a=="function")n.add(a);else for(let l of a)n.add(l)}for(let o of r){let h=this.#t.get(o),a=h?.[0];if(!(!h||!(a instanceof Set)))if(a.size===1&&h.length===1){this.#t.delete(o);continue}else if(a.size===1){h.shift();let l=h[0];typeof l=="function"&&n.add(l)}else a.delete(t)}return this.#s.delete(t),n.forEach(o=>this.#r(o)),!0}};var Lr=()=>process.umask();var Dr=Symbol("onEntry"),_s=Symbol("checkFs"),Nr=Symbol("checkFs2"),Os=Symbol("isReusable"),P=Symbol("makeFs"),Ts=Symbol("file"),xs=Symbol("directory"),gi=Symbol("link"),Ar=Symbol("symlink"),Ir=Symbol("hardlink"),Re=Symbol("ensureNoSymlink"),Cr=Symbol("unsupported"),Fr=Symbol("checkPath"),Rs=Symbol("stripAbsolutePath"),yt=Symbol("mkdir"),O=Symbol("onError"),Ri=Symbol("pending"),kr=Symbol("pend"),$t=Symbol("unpend"),gs=Symbol("ended"),bs=Symbol("maybeClose"),Ls=Symbol("skip"),ge=Symbol("doChown"),be=Symbol("uid"),_e=Symbol("gid"),Oe=Symbol("checkedCwd"),fo=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Te=fo==="win32",uo=1024,mo=(s,t)=>{if(!Te)return u.unlink(s,t);let e=s+".DELETE."+Mr(16).toString("hex");u.rename(s,e,i=>{if(i)return t(i);u.unlink(e,t)})},po=s=>{if(!Te)return u.unlinkSync(s);let t=s+".DELETE."+Mr(16).toString("hex");u.renameSync(s,t),u.unlinkSync(t)},vr=(s,t,e)=>s!==void 0&&s===s>>>0?s:t!==void 0&&t===t>>>0?t:e,Xt=class extends rt{[gs]=!1;[Oe]=!1;[Ri]=0;reservations=new yi;transform;writable=!0;readable=!1;uid;gid;setOwner;preserveOwner;processGid;processUid;maxDepth;forceChown;win32;newer;keep;noMtime;preservePaths;unlink;cwd;strip;processUmask;umask;dmode;fmode;chmod;constructor(t={}){if(t.ondone=()=>{this[gs]=!0,this[bs]()},super(t),this.transform=t.transform,this.chmod=!!t.chmod,typeof t.uid=="number"||typeof t.gid=="number"){if(typeof t.uid!="number"||typeof t.gid!="number")throw new TypeError("cannot set owner without number uid and gid");if(t.preserveOwner)throw new TypeError("cannot preserve owner in archive and also set owner explicitly");this.uid=t.uid,this.gid=t.gid,this.setOwner=!0}else this.uid=void 0,this.gid=void 0,this.setOwner=!1;this.preserveOwner=t.preserveOwner===void 0&&typeof t.uid!="number"?process.getuid?.()===0:!!t.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 t.maxDepth=="number"?t.maxDepth:uo,this.forceChown=t.forceChown===!0,this.win32=!!t.win32||Te,this.newer=!!t.newer,this.keep=!!t.keep,this.noMtime=!!t.noMtime,this.preservePaths=!!t.preservePaths,this.unlink=!!t.unlink,this.cwd=f(R.resolve(t.cwd||process.cwd())),this.strip=Number(t.strip)||0,this.processUmask=this.chmod?typeof t.processUmask=="number"?t.processUmask:Lr():0,this.umask=typeof t.umask=="number"?t.umask:this.processUmask,this.dmode=t.dmode||511&~this.umask,this.fmode=t.fmode||438&~this.umask,this.on("entry",e=>this[Dr](e))}warn(t,e,i={}){return(t==="TAR_BAD_ARCHIVE"||t==="TAR_ABORT")&&(i.recoverable=!1),super.warn(t,e,i)}[bs](){this[gs]&&this[Ri]===0&&(this.emit("prefinish"),this.emit("finish"),this.emit("end"))}[Rs](t,e){let i=t[e],{type:r}=t;if(!i||this.preservePaths)return!0;let[n,o]=ce(i),h=o.replaceAll(/\\/g,"/").split("/");if(h.includes("..")||Te&&/^[a-z]:\.\.$/i.test(h[0]??"")){if(e==="path"||r==="Link")return this.warn("TAR_ENTRY_ERROR",`${e} contains '..'`,{entry:t,[e]:i}),!1;let a=R.posix.dirname(t.path),l=R.posix.normalize(R.posix.join(a,h.join("/")));if(l.startsWith("../")||l==="..")return this.warn("TAR_ENTRY_ERROR",`${e} escapes extraction directory`,{entry:t,[e]:i}),!1}return n&&(t[e]=String(o),this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute ${e}`,{entry:t,[e]:i})),!0}[Fr](t){let e=f(t.path),i=e.split("/");if(this.strip){if(i.length<this.strip)return!1;if(t.type==="Link"){let r=f(String(t.linkpath)).split("/");if(r.length>=this.strip)t.linkpath=r.slice(this.strip).join("/");else return!1}i.splice(0,this.strip),t.path=i.join("/")}if(isFinite(this.maxDepth)&&i.length>this.maxDepth)return this.warn("TAR_ENTRY_ERROR","path excessively deep",{entry:t,path:e,depth:i.length,maxDepth:this.maxDepth}),!1;if(!this[Rs](t,"path")||!this[Rs](t,"linkpath"))return!1;if(t.absolute=R.isAbsolute(t.path)?f(R.resolve(t.path)):f(R.resolve(this.cwd,t.path)),!this.preservePaths&&typeof t.absolute=="string"&&t.absolute.indexOf(this.cwd+"/")!==0&&t.absolute!==this.cwd)return this.warn("TAR_ENTRY_ERROR","path escaped extraction target",{entry:t,path:f(t.path),resolvedPath:t.absolute,cwd:this.cwd}),!1;if(t.absolute===this.cwd&&t.type!=="Directory"&&t.type!=="GNUDumpDir")return!1;if(this.win32){let{root:r}=R.win32.parse(String(t.absolute));t.absolute=r+ts(String(t.absolute).slice(r.length));let{root:n}=R.win32.parse(t.path);t.path=n+ts(t.path.slice(n.length))}return!0}[Dr](t){if(!this[Fr](t))return t.resume();switch(co.equal(typeof t.absolute,"string"),t.type){case"Directory":case"GNUDumpDir":t.mode&&(t.mode=t.mode|448);case"File":case"OldFile":case"ContiguousFile":case"Link":case"SymbolicLink":return this[_s](t);default:return this[Cr](t)}}[O](t,e){t.name==="CwdError"?this.emit("error",t):(this.warn("TAR_ENTRY_ERROR",t,{entry:e}),this[$t](),e.resume())}[yt](t,e,i){gr(f(t),{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:e},i)}[ge](t){return this.forceChown||this.preserveOwner&&(typeof t.uid=="number"&&t.uid!==this.processUid||typeof t.gid=="number"&&t.gid!==this.processGid)||typeof this.uid=="number"&&this.uid!==this.processUid||typeof this.gid=="number"&&this.gid!==this.processGid}[be](t){return vr(this.uid,t.uid,this.processUid)}[_e](t){return vr(this.gid,t.gid,this.processGid)}[Ts](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=new et(String(t.absolute),{flags:ms(t.size),mode:i,autoClose:!1});r.on("error",a=>{r.fd&&u.close(r.fd,()=>{}),r.write=()=>!0,this[O](a,t),e()});let n=1,o=a=>{if(a){r.fd&&u.close(r.fd,()=>{}),this[O](a,t),e();return}--n===0&&r.fd!==void 0&&u.close(r.fd,l=>{l?this[O](l,t):this[$t](),e()})};r.on("finish",()=>{let a=String(t.absolute),l=r.fd;if(typeof l=="number"&&t.mtime&&!this.noMtime){n++;let c=t.atime||new Date,d=t.mtime;u.futimes(l,c,d,y=>y?u.utimes(a,c,d,T=>o(T&&y)):o())}if(typeof l=="number"&&this[ge](t)){n++;let c=this[be](t),d=this[_e](t);typeof c=="number"&&typeof d=="number"&&u.fchown(l,c,d,y=>y?u.chown(a,c,d,T=>o(T&&y)):o())}o()});let h=this.transform&&this.transform(t)||t;h!==t&&(h.on("error",a=>{this[O](a,t),e()}),t.pipe(h)),h.pipe(r)}[xs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode;this[yt](String(t.absolute),i,r=>{if(r){this[O](r,t),e();return}let n=1,o=()=>{--n===0&&(e(),this[$t](),t.resume())};t.mtime&&!this.noMtime&&(n++,u.utimes(String(t.absolute),t.atime||new Date,t.mtime,o)),this[ge](t)&&(n++,u.chown(String(t.absolute),Number(this[be](t)),Number(this[_e](t)),o)),o()})}[Cr](t){t.unsupported=!0,this.warn("TAR_ENTRY_UNSUPPORTED",`unsupported entry type: ${t.type}`,{entry:t}),t.resume()}[Ar](t,e){let i=f(R.relative(this.cwd,R.resolve(R.dirname(String(t.absolute)),String(t.linkpath)))).split("/");this[Re](t,this.cwd,i,()=>this[gi](t,String(t.linkpath),"symlink",e),r=>{this[O](r,t),e()})}[Ir](t,e){let i=f(R.resolve(this.cwd,String(t.linkpath))),r=f(String(t.linkpath)).split("/");this[Re](t,this.cwd,r,()=>this[gi](t,i,"link",e),n=>{this[O](n,t),e()})}[Re](t,e,i,r,n){let o=i.shift();if(this.preservePaths||o===void 0)return r();let h=R.resolve(e,o);u.lstat(h,(a,l)=>{if(a)return r();if(l?.isSymbolicLink())return n(new St(h,R.resolve(h,i.join("/"))));this[Re](t,h,i,r,n)})}[kr](){this[Ri]++}[$t](){this[Ri]--,this[bs]()}[Ls](t){this[$t](),t.resume()}[Os](t,e){return t.type==="File"&&!this.unlink&&e.isFile()&&e.nlink<=1&&!Te}[_s](t){this[kr]();let e=[t.path];t.linkpath&&e.push(t.linkpath),this.reservations.reserve(e,i=>this[Nr](t,i))}[Nr](t,e){let i=h=>{e(h)},r=()=>{this[yt](this.cwd,this.dmode,h=>{if(h){this[O](h,t),i();return}this[Oe]=!0,n()})},n=()=>{if(t.absolute!==this.cwd){let h=f(R.dirname(String(t.absolute)));if(h!==this.cwd)return this[yt](h,this.dmode,a=>{if(a){this[O](a,t),i();return}o()})}o()},o=()=>{u.lstat(String(t.absolute),(h,a)=>{if(a&&(this.keep||this.newer&&a.mtime>(t.mtime??a.mtime))){this[Ls](t),i();return}if(h||this[Os](t,a))return this[P](null,t,i);if(a.isDirectory()){if(t.type==="Directory"){let l=this.chmod&&t.mode&&(a.mode&4095)!==t.mode,c=d=>this[P](d??null,t,i);return l?u.chmod(String(t.absolute),Number(t.mode),c):c()}if(t.absolute!==this.cwd)return u.rmdir(String(t.absolute),l=>this[P](l??null,t,i))}if(t.absolute===this.cwd)return this[P](null,t,i);mo(String(t.absolute),l=>this[P](l??null,t,i))})};this[Oe]?n():r()}[P](t,e,i){if(t){this[O](t,e),i();return}switch(e.type){case"File":case"OldFile":case"ContiguousFile":return this[Ts](e,i);case"Link":return this[Ir](e,i);case"SymbolicLink":return this[Ar](e,i);case"Directory":case"GNUDumpDir":return this[xs](e,i)}}[gi](t,e,i,r){u[i](e,String(t.absolute),n=>{n?this[O](n,t):(this[$t](),t.resume()),r()})}},ye=s=>{try{return[null,s()]}catch(t){return[t,null]}},xe=class extends Xt{sync=!0;[P](t,e){return super[P](t,e,()=>{})}[_s](t){if(!this[Oe]){let n=this[yt](this.cwd,this.dmode);if(n)return this[O](n,t);this[Oe]=!0}if(t.absolute!==this.cwd){let n=f(R.dirname(String(t.absolute)));if(n!==this.cwd){let o=this[yt](n,this.dmode);if(o)return this[O](o,t)}}let[e,i]=ye(()=>u.lstatSync(String(t.absolute)));if(i&&(this.keep||this.newer&&i.mtime>(t.mtime??i.mtime)))return this[Ls](t);if(e||this[Os](t,i))return this[P](null,t);if(i.isDirectory()){if(t.type==="Directory"){let o=this.chmod&&t.mode&&(i.mode&4095)!==t.mode,[h]=o?ye(()=>{u.chmodSync(String(t.absolute),Number(t.mode))}):[];return this[P](h,t)}let[n]=ye(()=>u.rmdirSync(String(t.absolute)));this[P](n,t)}let[r]=t.absolute===this.cwd?[]:ye(()=>po(String(t.absolute)));this[P](r,t)}[Ts](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=h=>{let a;try{u.closeSync(n)}catch(l){a=l}(h||a)&&this[O](h||a,t),e()},n;try{n=u.openSync(String(t.absolute),ms(t.size),i)}catch(h){return r(h)}let o=this.transform&&this.transform(t)||t;o!==t&&(o.on("error",h=>this[O](h,t)),t.pipe(o)),o.on("data",h=>{try{u.writeSync(n,h,0,h.length)}catch(a){r(a)}}),o.on("end",()=>{let h=null;if(t.mtime&&!this.noMtime){let a=t.atime||new Date,l=t.mtime;try{u.futimesSync(n,a,l)}catch(c){try{u.utimesSync(String(t.absolute),a,l)}catch{h=c}}}if(this[ge](t)){let a=this[be](t),l=this[_e](t);try{u.fchownSync(n,Number(a),Number(l))}catch(c){try{u.chownSync(String(t.absolute),Number(a),Number(l))}catch{h=h||c}}}r(h)})}[xs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode,r=this[yt](String(t.absolute),i);if(r){this[O](r,t),e();return}if(t.mtime&&!this.noMtime)try{u.utimesSync(String(t.absolute),t.atime||new Date,t.mtime)}catch{}if(this[ge](t))try{u.chownSync(String(t.absolute),Number(this[be](t)),Number(this[_e](t)))}catch{}e(),t.resume()}[yt](t,e){try{return _r(f(t),{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:e})}catch(i){return i}}[Re](t,e,i,r,n){if(this.preservePaths||i.length===0)return r();let o=e;for(let h of i){o=R.resolve(o,h);let[a,l]=ye(()=>u.lstatSync(o));if(a)return r();if(l.isSymbolicLink())return n(new St(o,R.resolve(e,i.join("/"))))}r()}[gi](t,e,i,r){let n=`${i}Sync`;try{u[n](e,String(t.absolute)),r(),t.resume()}catch(o){return this[O](o,t)}}};var Eo=s=>{let t=new xe(s),e=s.file,i=Br.statSync(e),r=s.maxReadSize||16*1024*1024;new Be(e,{readSize:r,size:i.size}).pipe(t)},wo=(s,t)=>{let e=new Xt(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("close",o),Br.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},So=K(Eo,wo,s=>new xe(s),s=>new Xt(s),(s,t)=>{t?.length&&Qi(s,t)});import v from"node:fs";import Pr from"node:path";var yo=(s,t)=>{let e=new kt(s),i=!0,r,n;try{try{r=v.openSync(s.file,"r+")}catch(a){if(a?.code==="ENOENT")r=v.openSync(s.file,"w+");else throw a}let o=v.fstatSync(r),h=Buffer.alloc(512);t:for(n=0;n<o.size;n+=512){for(let c=0,d=0;c<512;c+=d){if(d=v.readSync(r,h,c,h.length-c,n+c),n===0&&h[0]===31&&h[1]===139)throw new Error("cannot append to compressed archives");if(!d)break t}let a=new F(h);if(!a.cksumValid)break;let l=512*Math.ceil((a.size||0)/512);if(n+l+512>o.size)break;n+=l,s.mtimeCache&&a.mtime&&s.mtimeCache.set(String(a.path),a.mtime)}i=!1,Ro(s,e,n,r,t)}finally{if(i)try{v.closeSync(r)}catch{}}},Ro=(s,t,e,i,r)=>{let n=new Wt(s.file,{fd:i,start:e});t.pipe(n),bo(t,r)},go=(s,t)=>{t=Array.from(t);let e=new wt(s),i=(n,o,h)=>{let a=(T,D)=>{T?v.close(n,E=>h(T)):h(null,D)},l=0;if(o===0)return a(null,0);let c=0,d=Buffer.alloc(512),y=(T,D)=>{if(T||D===void 0)return a(T);if(c+=D,c<512&&D)return v.read(n,d,c,d.length-c,l+c,y);if(l===0&&d[0]===31&&d[1]===139)return a(new Error("cannot append to compressed archives"));if(c<512)return a(null,l);let E=new F(d);if(!E.cksumValid)return a(null,l);let x=512*Math.ceil((E.size??0)/512);if(l+x+512>o||(l+=x+512,l>=o))return a(null,l);s.mtimeCache&&E.mtime&&s.mtimeCache.set(String(E.path),E.mtime),c=0,v.read(n,d,0,512,l,y)};v.read(n,d,0,512,l,y)};return new Promise((n,o)=>{e.on("error",o);let h="r+",a=(l,c)=>{if(l&&l.code==="ENOENT"&&h==="r+")return h="w+",v.open(s.file,h,a);if(l||!c)return o(l);v.fstat(c,(d,y)=>{if(d)return v.close(c,()=>o(d));i(c,y.size,(T,D)=>{if(T)return o(T);let E=new et(s.file,{fd:c,start:D});e.pipe(E),E.on("error",o),E.on("close",n),_o(e,t)})})};v.open(s.file,h,a)})},bo=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?Ct({file:Pr.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},_o=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await Ct({file:Pr.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e);s.end()},vt=K(yo,go,()=>{throw new TypeError("file is required")},()=>{throw new TypeError("file is required")},(s,t)=>{if(!Bs(s))throw new TypeError("file is required");if(s.gzip||s.brotli||s.zstd||s.file.endsWith(".br")||s.file.endsWith(".tbr"))throw new TypeError("cannot append to compressed archives");if(!t?.length)throw new TypeError("no paths specified to add/replace")});var Oo=K(vt.syncFile,vt.asyncFile,vt.syncNoFile,vt.asyncNoFile,(s,t=[])=>{vt.validate?.(s,t),To(s)}),To=s=>{let t=s.filter;s.mtimeCache||(s.mtimeCache=new Map),s.filter=t?(e,i)=>t(e,i)&&!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0)):(e,i)=>!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0))};export{F as Header,wt as Pack,pi as PackJob,kt as PackSync,rt as Parser,ft as Pax,$e as ReadEntry,Xt as Unpack,xe as UnpackSync,de as WriteEntry,ni as WriteEntrySync,oi as WriteEntryTar,Qn as c,Qn as create,So as extract,Qi as filesFilter,Ct as list,vt as r,vt as replace,Ct as t,Hi as types,Oo as u,Oo as update,So as x};
+//# sourceMappingURL=index.min.js.map
diff --git a/node_modules/tar/dist/esm/large-numbers.d.ts b/node_modules/tar/dist/esm/large-numbers.d.ts
new file mode 100644
index 0000000..a1ec25e
--- /dev/null
+++ b/node_modules/tar/dist/esm/large-numbers.d.ts
@@ -0,0 +1,3 @@
+export declare const encode: (num: number, buf: Buffer) => Buffer<ArrayBufferLike>;
+export declare const parse: (buf: Buffer) => number;
+//# sourceMappingURL=large-numbers.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/large-numbers.js b/node_modules/tar/dist/esm/large-numbers.js
new file mode 100644
index 0000000..4f2f7e5
--- /dev/null
+++ b/node_modules/tar/dist/esm/large-numbers.js
@@ -0,0 +1,94 @@
+// Tar can encode large and negative numbers using a leading byte of
+// 0xff for negative, and 0x80 for positive.
+export const encode = (num, buf) => {
+    if (!Number.isSafeInteger(num)) {
+        // The number is so large that javascript cannot represent it with integer
+        // precision.
+        throw Error('cannot encode number outside of javascript safe integer range');
+    }
+    else if (num < 0) {
+        encodeNegative(num, buf);
+    }
+    else {
+        encodePositive(num, buf);
+    }
+    return buf;
+};
+const encodePositive = (num, buf) => {
+    buf[0] = 0x80;
+    for (var i = buf.length; i > 1; i--) {
+        buf[i - 1] = num & 0xff;
+        num = Math.floor(num / 0x100);
+    }
+};
+const encodeNegative = (num, buf) => {
+    buf[0] = 0xff;
+    var flipped = false;
+    num = num * -1;
+    for (var i = buf.length; i > 1; i--) {
+        var byte = num & 0xff;
+        num = Math.floor(num / 0x100);
+        if (flipped) {
+            buf[i - 1] = onesComp(byte);
+        }
+        else if (byte === 0) {
+            buf[i - 1] = 0;
+        }
+        else {
+            flipped = true;
+            buf[i - 1] = twosComp(byte);
+        }
+    }
+};
+export const parse = (buf) => {
+    const pre = buf[0];
+    const value = pre === 0x80 ? pos(buf.subarray(1, buf.length))
+        : pre === 0xff ? twos(buf)
+            : null;
+    if (value === null) {
+        throw Error('invalid base256 encoding');
+    }
+    if (!Number.isSafeInteger(value)) {
+        // The number is so large that javascript cannot represent it with integer
+        // precision.
+        throw Error('parsed number outside of javascript safe integer range');
+    }
+    return value;
+};
+const twos = (buf) => {
+    var len = buf.length;
+    var sum = 0;
+    var flipped = false;
+    for (var i = len - 1; i > -1; i--) {
+        var byte = Number(buf[i]);
+        var f;
+        if (flipped) {
+            f = onesComp(byte);
+        }
+        else if (byte === 0) {
+            f = byte;
+        }
+        else {
+            flipped = true;
+            f = twosComp(byte);
+        }
+        if (f !== 0) {
+            sum -= f * Math.pow(256, len - i - 1);
+        }
+    }
+    return sum;
+};
+const pos = (buf) => {
+    var len = buf.length;
+    var sum = 0;
+    for (var i = len - 1; i > -1; i--) {
+        var byte = Number(buf[i]);
+        if (byte !== 0) {
+            sum += byte * Math.pow(256, len - i - 1);
+        }
+    }
+    return sum;
+};
+const onesComp = (byte) => (0xff ^ byte) & 0xff;
+const twosComp = (byte) => ((0xff ^ byte) + 1) & 0xff;
+//# sourceMappingURL=large-numbers.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/list.d.ts b/node_modules/tar/dist/esm/list.d.ts
new file mode 100644
index 0000000..7f5bb80
--- /dev/null
+++ b/node_modules/tar/dist/esm/list.d.ts
@@ -0,0 +1,7 @@
+import type { TarOptions } from './options.js';
+import { Parser } from './parse.js';
+export declare const filesFilter: (opt: TarOptions, files: string[]) => void;
+export declare const list: import("./make-command.js").TarCommand<Parser, Parser & {
+    sync: true;
+}>;
+//# sourceMappingURL=list.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/list.js b/node_modules/tar/dist/esm/list.js
new file mode 100644
index 0000000..08bdbe4
--- /dev/null
+++ b/node_modules/tar/dist/esm/list.js
@@ -0,0 +1,113 @@
+// tar -t
+import * as fsm from '@isaacs/fs-minipass';
+import fs from 'node:fs';
+import { dirname, parse } from 'path';
+import { makeCommand } from './make-command.js';
+import { Parser } from './parse.js';
+import { stripTrailingSlashes } from './strip-trailing-slashes.js';
+const onReadEntryFunction = (opt) => {
+    const onReadEntry = opt.onReadEntry;
+    opt.onReadEntry =
+        onReadEntry ?
+            e => {
+                onReadEntry(e);
+                e.resume();
+            }
+            : e => e.resume();
+};
+// construct a filter that limits the file entries listed
+// include child entries if a dir is included
+export const filesFilter = (opt, files) => {
+    const map = new Map(files.map(f => [stripTrailingSlashes(f), true]));
+    const filter = opt.filter;
+    // limit recursion to 100 levels
+    const MAX = 100;
+    const mapHas = (file, r = '', depth = 0) => {
+        /* c8 ignore start - excessive caution */
+        if (depth >= MAX) {
+            map.set(file, false);
+            return false;
+        }
+        /* c8 ignore stop */
+        const root = r || parse(file).root || '.';
+        let ret;
+        if (file === root)
+            ret = false;
+        else {
+            const m = map.get(file);
+            ret = m !== undefined ? m : mapHas(dirname(file), root, depth + 1);
+        }
+        map.set(file, ret);
+        return ret;
+    };
+    opt.filter =
+        filter ?
+            (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file))
+            : file => mapHas(stripTrailingSlashes(file));
+};
+const listFileSync = (opt) => {
+    const p = new Parser(opt);
+    const file = opt.file;
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+        const stat = fs.fstatSync(fd);
+        const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+        if (stat.size < readSize) {
+            const buf = Buffer.allocUnsafe(stat.size);
+            const read = fs.readSync(fd, buf, 0, stat.size, 0);
+            p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
+        }
+        else {
+            let pos = 0;
+            const buf = Buffer.allocUnsafe(readSize);
+            while (pos < stat.size) {
+                const bytesRead = fs.readSync(fd, buf, 0, readSize, pos);
+                if (bytesRead === 0)
+                    break;
+                pos += bytesRead;
+                p.write(buf.subarray(0, bytesRead));
+            }
+            p.end();
+        }
+    }
+    finally {
+        if (typeof fd === 'number') {
+            try {
+                fs.closeSync(fd);
+                /* c8 ignore next */
+            }
+            catch { }
+        }
+    }
+};
+const listFile = (opt, _files) => {
+    const parse = new Parser(opt);
+    const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+    const file = opt.file;
+    const p = new Promise((resolve, reject) => {
+        parse.on('error', reject);
+        parse.on('end', resolve);
+        fs.stat(file, (er, stat) => {
+            if (er) {
+                reject(er);
+            }
+            else {
+                const stream = new fsm.ReadStream(file, {
+                    readSize: readSize,
+                    size: stat.size,
+                });
+                stream.on('error', reject);
+                stream.pipe(parse);
+            }
+        });
+    });
+    return p;
+};
+export const list = makeCommand(listFileSync, listFile, opt => new Parser(opt), opt => new Parser(opt), (opt, files) => {
+    if (files?.length)
+        filesFilter(opt, files);
+    if (!opt.noResume)
+        onReadEntryFunction(opt);
+});
+//# sourceMappingURL=list.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/make-command.d.ts b/node_modules/tar/dist/esm/make-command.d.ts
new file mode 100644
index 0000000..107ac52
--- /dev/null
+++ b/node_modules/tar/dist/esm/make-command.d.ts
@@ -0,0 +1,49 @@
+import type { TarOptions, TarOptionsAsyncFile, TarOptionsAsyncNoFile, TarOptionsSyncFile, TarOptionsSyncNoFile, TarOptionsWithAliases, TarOptionsWithAliasesAsync, TarOptionsWithAliasesAsyncFile, TarOptionsWithAliasesAsyncNoFile, TarOptionsWithAliasesFile, TarOptionsWithAliasesNoFile, TarOptionsWithAliasesSync, TarOptionsWithAliasesSyncFile, TarOptionsWithAliasesSyncNoFile } from './options.js';
+export type CB = (er?: Error) => unknown;
+export type TarCommand<AsyncClass, SyncClass extends {
+    sync: true;
+}> = {
+    (): AsyncClass;
+    (opt: TarOptionsWithAliasesAsyncNoFile): AsyncClass;
+    (entries: string[]): AsyncClass;
+    (opt: TarOptionsWithAliasesAsyncNoFile, entries: string[]): AsyncClass;
+} & {
+    (opt: TarOptionsWithAliasesSyncNoFile): SyncClass;
+    (opt: TarOptionsWithAliasesSyncNoFile, entries: string[]): SyncClass;
+} & {
+    (opt: TarOptionsWithAliasesAsyncFile): Promise<void>;
+    (opt: TarOptionsWithAliasesAsyncFile, entries: string[]): Promise<void>;
+    (opt: TarOptionsWithAliasesAsyncFile, cb: CB): Promise<void>;
+    (opt: TarOptionsWithAliasesAsyncFile, entries: string[], cb: CB): Promise<void>;
+} & {
+    (opt: TarOptionsWithAliasesSyncFile): void;
+    (opt: TarOptionsWithAliasesSyncFile, entries: string[]): void;
+} & {
+    (opt: TarOptionsWithAliasesSync): typeof opt extends (TarOptionsWithAliasesFile) ? void : typeof opt extends TarOptionsWithAliasesNoFile ? SyncClass : void | SyncClass;
+    (opt: TarOptionsWithAliasesSync, entries: string[]): typeof opt extends TarOptionsWithAliasesFile ? void : typeof opt extends TarOptionsWithAliasesNoFile ? SyncClass : void | SyncClass;
+} & {
+    (opt: TarOptionsWithAliasesAsync): typeof opt extends (TarOptionsWithAliasesFile) ? Promise<void> : typeof opt extends TarOptionsWithAliasesNoFile ? AsyncClass : Promise<void> | AsyncClass;
+    (opt: TarOptionsWithAliasesAsync, entries: string[]): typeof opt extends TarOptionsWithAliasesFile ? Promise<void> : typeof opt extends TarOptionsWithAliasesNoFile ? AsyncClass : Promise<void> | AsyncClass;
+    (opt: TarOptionsWithAliasesAsync, cb: CB): Promise<void>;
+    (opt: TarOptionsWithAliasesAsync, entries: string[], cb: CB): typeof opt extends TarOptionsWithAliasesFile ? Promise<void> : typeof opt extends TarOptionsWithAliasesNoFile ? never : Promise<void>;
+} & {
+    (opt: TarOptionsWithAliasesFile): Promise<void> | void;
+    (opt: TarOptionsWithAliasesFile, entries: string[]): typeof opt extends TarOptionsWithAliasesSync ? void : typeof opt extends TarOptionsWithAliasesAsync ? Promise<void> : Promise<void> | void;
+    (opt: TarOptionsWithAliasesFile, cb: CB): Promise<void>;
+    (opt: TarOptionsWithAliasesFile, entries: string[], cb: CB): typeof opt extends TarOptionsWithAliasesSync ? never : typeof opt extends TarOptionsWithAliasesAsync ? Promise<void> : Promise<void>;
+} & {
+    (opt: TarOptionsWithAliasesNoFile): typeof opt extends (TarOptionsWithAliasesSync) ? SyncClass : typeof opt extends TarOptionsWithAliasesAsync ? AsyncClass : SyncClass | AsyncClass;
+    (opt: TarOptionsWithAliasesNoFile, entries: string[]): typeof opt extends TarOptionsWithAliasesSync ? SyncClass : typeof opt extends TarOptionsWithAliasesAsync ? AsyncClass : SyncClass | AsyncClass;
+} & {
+    (opt: TarOptionsWithAliases): typeof opt extends (TarOptionsWithAliasesFile) ? typeof opt extends TarOptionsWithAliasesSync ? void : typeof opt extends TarOptionsWithAliasesAsync ? Promise<void> : void | Promise<void> : typeof opt extends TarOptionsWithAliasesNoFile ? typeof opt extends TarOptionsWithAliasesSync ? SyncClass : typeof opt extends TarOptionsWithAliasesAsync ? AsyncClass : SyncClass | AsyncClass : typeof opt extends TarOptionsWithAliasesSync ? SyncClass | void : typeof opt extends TarOptionsWithAliasesAsync ? AsyncClass | Promise<void> : SyncClass | void | AsyncClass | Promise<void>;
+} & {
+    syncFile: (opt: TarOptionsSyncFile, entries: string[]) => void;
+    asyncFile: (opt: TarOptionsAsyncFile, entries: string[], cb?: CB) => Promise<void>;
+    syncNoFile: (opt: TarOptionsSyncNoFile, entries: string[]) => SyncClass;
+    asyncNoFile: (opt: TarOptionsAsyncNoFile, entries: string[]) => AsyncClass;
+    validate?: (opt: TarOptions, entries?: string[]) => void;
+};
+export declare const makeCommand: <AsyncClass, SyncClass extends {
+    sync: true;
+}>(syncFile: (opt: TarOptionsSyncFile, entries: string[]) => void, asyncFile: (opt: TarOptionsAsyncFile, entries: string[], cb?: CB) => Promise<void>, syncNoFile: (opt: TarOptionsSyncNoFile, entries: string[]) => SyncClass, asyncNoFile: (opt: TarOptionsAsyncNoFile, entries: string[]) => AsyncClass, validate?: (opt: TarOptions, entries?: string[]) => void) => TarCommand<AsyncClass, SyncClass>;
+//# sourceMappingURL=make-command.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/make-command.js b/node_modules/tar/dist/esm/make-command.js
new file mode 100644
index 0000000..b915bc0
--- /dev/null
+++ b/node_modules/tar/dist/esm/make-command.js
@@ -0,0 +1,48 @@
+import { dealias, isAsyncFile, isAsyncNoFile, isSyncFile, isSyncNoFile, } from './options.js';
+export const makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => {
+    return Object.assign((opt_ = [], entries, cb) => {
+        if (Array.isArray(opt_)) {
+            entries = opt_;
+            opt_ = {};
+        }
+        if (typeof entries === 'function') {
+            cb = entries;
+            entries = undefined;
+        }
+        entries = !entries ? [] : Array.from(entries);
+        const opt = dealias(opt_);
+        validate?.(opt, entries);
+        if (isSyncFile(opt)) {
+            if (typeof cb === 'function') {
+                throw new TypeError('callback not supported for sync tar functions');
+            }
+            return syncFile(opt, entries);
+        }
+        else if (isAsyncFile(opt)) {
+            const p = asyncFile(opt, entries);
+            return cb ? p.then(() => cb(), cb) : p;
+        }
+        else if (isSyncNoFile(opt)) {
+            if (typeof cb === 'function') {
+                throw new TypeError('callback not supported for sync tar functions');
+            }
+            return syncNoFile(opt, entries);
+        }
+        else if (isAsyncNoFile(opt)) {
+            if (typeof cb === 'function') {
+                throw new TypeError('callback only supported with file option');
+            }
+            return asyncNoFile(opt, entries);
+            /* c8 ignore start */
+        }
+        throw new Error('impossible options??');
+        /* c8 ignore stop */
+    }, {
+        syncFile,
+        asyncFile,
+        syncNoFile,
+        asyncNoFile,
+        validate,
+    });
+};
+//# sourceMappingURL=make-command.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/mkdir.d.ts b/node_modules/tar/dist/esm/mkdir.d.ts
new file mode 100644
index 0000000..dcbea5c
--- /dev/null
+++ b/node_modules/tar/dist/esm/mkdir.d.ts
@@ -0,0 +1,25 @@
+import { CwdError } from './cwd-error.js';
+import { SymlinkError } from './symlink-error.js';
+export type MkdirOptions = {
+    uid?: number;
+    gid?: number;
+    processUid?: number;
+    processGid?: number;
+    umask?: number;
+    preserve: boolean;
+    unlink: boolean;
+    cwd: string;
+    mode: number;
+};
+export type MkdirError = NodeJS.ErrnoException | CwdError | SymlinkError;
+/**
+ * Wrapper around fs/promises.mkdir for tar's needs.
+ *
+ * The main purpose is to avoid creating directories if we know that
+ * they already exist (and track which ones exist for this purpose),
+ * and prevent entries from being extracted into symlinked folders,
+ * if `preservePaths` is not set.
+ */
+export declare const mkdir: (dir: string, opt: MkdirOptions, cb: (er?: null | MkdirError, made?: string) => void) => void | Promise<void>;
+export declare const mkdirSync: (dir: string, opt: MkdirOptions) => void | SymlinkError;
+//# sourceMappingURL=mkdir.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/mkdir.js b/node_modules/tar/dist/esm/mkdir.js
new file mode 100644
index 0000000..7679907
--- /dev/null
+++ b/node_modules/tar/dist/esm/mkdir.js
@@ -0,0 +1,179 @@
+import { chownr, chownrSync } from 'chownr';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { CwdError } from './cwd-error.js';
+import { normalizeWindowsPath } from './normalize-windows-path.js';
+import { SymlinkError } from './symlink-error.js';
+const checkCwd = (dir, cb) => {
+    fs.stat(dir, (er, st) => {
+        if (er || !st.isDirectory()) {
+            er = new CwdError(dir, er?.code || 'ENOTDIR');
+        }
+        cb(er);
+    });
+};
+/**
+ * Wrapper around fs/promises.mkdir for tar's needs.
+ *
+ * The main purpose is to avoid creating directories if we know that
+ * they already exist (and track which ones exist for this purpose),
+ * and prevent entries from being extracted into symlinked folders,
+ * if `preservePaths` is not set.
+ */
+export const mkdir = (dir, opt, cb) => {
+    dir = normalizeWindowsPath(dir);
+    // if there's any overlap between mask and mode,
+    // then we'll need an explicit chmod
+    /* c8 ignore next */
+    const umask = opt.umask ?? 0o22;
+    const mode = opt.mode | 0o0700;
+    const needChmod = (mode & umask) !== 0;
+    const uid = opt.uid;
+    const gid = opt.gid;
+    const doChown = typeof uid === 'number' &&
+        typeof gid === 'number' &&
+        (uid !== opt.processUid || gid !== opt.processGid);
+    const preserve = opt.preserve;
+    const unlink = opt.unlink;
+    const cwd = normalizeWindowsPath(opt.cwd);
+    const done = (er, created) => {
+        if (er) {
+            cb(er);
+        }
+        else {
+            if (created && doChown) {
+                chownr(created, uid, gid, er => done(er));
+            }
+            else if (needChmod) {
+                fs.chmod(dir, mode, cb);
+            }
+            else {
+                cb();
+            }
+        }
+    };
+    if (dir === cwd) {
+        return checkCwd(dir, done);
+    }
+    if (preserve) {
+        return fsp.mkdir(dir, { mode, recursive: true }).then(made => done(null, made ?? undefined), // oh, ts
+        done);
+    }
+    const sub = normalizeWindowsPath(path.relative(cwd, dir));
+    const parts = sub.split('/');
+    mkdir_(cwd, parts, mode, unlink, cwd, undefined, done);
+};
+const mkdir_ = (base, parts, mode, unlink, cwd, created, cb) => {
+    if (parts.length === 0) {
+        return cb(null, created);
+    }
+    const p = parts.shift();
+    const part = normalizeWindowsPath(path.resolve(base + '/' + p));
+    fs.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+};
+const onmkdir = (part, parts, mode, unlink, cwd, created, cb) => (er) => {
+    if (er) {
+        fs.lstat(part, (statEr, st) => {
+            if (statEr) {
+                statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
+                cb(statEr);
+            }
+            else if (st.isDirectory()) {
+                mkdir_(part, parts, mode, unlink, cwd, created, cb);
+            }
+            else if (unlink) {
+                fs.unlink(part, er => {
+                    if (er) {
+                        return cb(er);
+                    }
+                    fs.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+                });
+            }
+            else if (st.isSymbolicLink()) {
+                return cb(new SymlinkError(part, part + '/' + parts.join('/')));
+            }
+            else {
+                cb(er);
+            }
+        });
+    }
+    else {
+        created = created || part;
+        mkdir_(part, parts, mode, unlink, cwd, created, cb);
+    }
+};
+const checkCwdSync = (dir) => {
+    let ok = false;
+    let code;
+    try {
+        ok = fs.statSync(dir).isDirectory();
+    }
+    catch (er) {
+        code = er?.code;
+    }
+    finally {
+        if (!ok) {
+            throw new CwdError(dir, code ?? 'ENOTDIR');
+        }
+    }
+};
+export const mkdirSync = (dir, opt) => {
+    dir = normalizeWindowsPath(dir);
+    // if there's any overlap between mask and mode,
+    // then we'll need an explicit chmod
+    /* c8 ignore next */
+    const umask = opt.umask ?? 0o22;
+    const mode = opt.mode | 0o700;
+    const needChmod = (mode & umask) !== 0;
+    const uid = opt.uid;
+    const gid = opt.gid;
+    const doChown = typeof uid === 'number' &&
+        typeof gid === 'number' &&
+        (uid !== opt.processUid || gid !== opt.processGid);
+    const preserve = opt.preserve;
+    const unlink = opt.unlink;
+    const cwd = normalizeWindowsPath(opt.cwd);
+    const done = (created) => {
+        if (created && doChown) {
+            chownrSync(created, uid, gid);
+        }
+        if (needChmod) {
+            fs.chmodSync(dir, mode);
+        }
+    };
+    if (dir === cwd) {
+        checkCwdSync(cwd);
+        return done();
+    }
+    if (preserve) {
+        return done(fs.mkdirSync(dir, { mode, recursive: true }) ?? undefined);
+    }
+    const sub = normalizeWindowsPath(path.relative(cwd, dir));
+    const parts = sub.split('/');
+    let created;
+    for (let p = parts.shift(), part = cwd; p && (part += '/' + p); p = parts.shift()) {
+        part = normalizeWindowsPath(path.resolve(part));
+        try {
+            fs.mkdirSync(part, mode);
+            created = created || part;
+        }
+        catch {
+            const st = fs.lstatSync(part);
+            if (st.isDirectory()) {
+                continue;
+            }
+            else if (unlink) {
+                fs.unlinkSync(part);
+                fs.mkdirSync(part, mode);
+                created = created || part;
+                continue;
+            }
+            else if (st.isSymbolicLink()) {
+                return new SymlinkError(part, part + '/' + parts.join('/'));
+            }
+        }
+    }
+    return done(created);
+};
+//# sourceMappingURL=mkdir.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/mode-fix.d.ts b/node_modules/tar/dist/esm/mode-fix.d.ts
new file mode 100644
index 0000000..38f3d93
--- /dev/null
+++ b/node_modules/tar/dist/esm/mode-fix.d.ts
@@ -0,0 +1,2 @@
+export declare const modeFix: (mode: number, isDir: boolean, portable: boolean) => number;
+//# sourceMappingURL=mode-fix.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/mode-fix.js b/node_modules/tar/dist/esm/mode-fix.js
new file mode 100644
index 0000000..5fd3bb8
--- /dev/null
+++ b/node_modules/tar/dist/esm/mode-fix.js
@@ -0,0 +1,25 @@
+export const modeFix = (mode, isDir, portable) => {
+    mode &= 0o7777;
+    // in portable mode, use the minimum reasonable umask
+    // if this system creates files with 0o664 by default
+    // (as some linux distros do), then we'll write the
+    // archive with 0o644 instead.  Also, don't ever create
+    // a file that is not readable/writable by the owner.
+    if (portable) {
+        mode = (mode | 0o600) & ~0o22;
+    }
+    // if dirs are readable, then they should be listable
+    if (isDir) {
+        if (mode & 0o400) {
+            mode |= 0o100;
+        }
+        if (mode & 0o40) {
+            mode |= 0o10;
+        }
+        if (mode & 0o4) {
+            mode |= 0o1;
+        }
+    }
+    return mode;
+};
+//# sourceMappingURL=mode-fix.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/normalize-unicode.d.ts b/node_modules/tar/dist/esm/normalize-unicode.d.ts
new file mode 100644
index 0000000..71df092
--- /dev/null
+++ b/node_modules/tar/dist/esm/normalize-unicode.d.ts
@@ -0,0 +1,2 @@
+export declare const normalizeUnicode: (s: string) => string;
+//# sourceMappingURL=normalize-unicode.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/normalize-unicode.js b/node_modules/tar/dist/esm/normalize-unicode.js
new file mode 100644
index 0000000..8fa17f5
--- /dev/null
+++ b/node_modules/tar/dist/esm/normalize-unicode.js
@@ -0,0 +1,34 @@
+// warning: extremely hot code path.
+// This has been meticulously optimized for use
+// within npm install on large package trees.
+// Do not edit without careful benchmarking.
+const normalizeCache = Object.create(null);
+// Limit the size of this. Very low-sophistication LRU cache
+const MAX = 10000;
+const cache = new Set();
+export const normalizeUnicode = (s) => {
+    if (!cache.has(s)) {
+        // shake out identical accents and ligatures
+        normalizeCache[s] = s
+            .normalize('NFD')
+            .toLocaleLowerCase('en')
+            .toLocaleUpperCase('en');
+    }
+    else {
+        cache.delete(s);
+    }
+    cache.add(s);
+    const ret = normalizeCache[s];
+    let i = cache.size - MAX;
+    // only prune when we're 10% over the max
+    if (i > MAX / 10) {
+        for (const s of cache) {
+            cache.delete(s);
+            delete normalizeCache[s];
+            if (--i <= 0)
+                break;
+        }
+    }
+    return ret;
+};
+//# sourceMappingURL=normalize-unicode.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/normalize-windows-path.d.ts b/node_modules/tar/dist/esm/normalize-windows-path.d.ts
new file mode 100644
index 0000000..9041173
--- /dev/null
+++ b/node_modules/tar/dist/esm/normalize-windows-path.d.ts
@@ -0,0 +1,2 @@
+export declare const normalizeWindowsPath: (p: unknown) => string;
+//# sourceMappingURL=normalize-windows-path.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/normalize-windows-path.js b/node_modules/tar/dist/esm/normalize-windows-path.js
new file mode 100644
index 0000000..cc75178
--- /dev/null
+++ b/node_modules/tar/dist/esm/normalize-windows-path.js
@@ -0,0 +1,9 @@
+// on windows, either \ or / are valid directory separators.
+// on unix, \ is a valid character in filenames.
+// so, on windows, and only on windows, we replace all \ chars with /,
+// so that we can use / as our one and only directory separator char.
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+export const normalizeWindowsPath = platform !== 'win32' ?
+    (p) => String(p)
+    : (p) => String(p).replaceAll(/\\/g, '/');
+//# sourceMappingURL=normalize-windows-path.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/options.d.ts b/node_modules/tar/dist/esm/options.d.ts
new file mode 100644
index 0000000..e91bd48
--- /dev/null
+++ b/node_modules/tar/dist/esm/options.d.ts
@@ -0,0 +1,604 @@
+import { type GzipOptions, type ZlibOptions } from 'minizlib';
+import { type Stats } from 'node:fs';
+import { type ReadEntry } from './read-entry.js';
+import { type WarnData } from './warn-method.js';
+import type { WriteEntry } from './write-entry.js';
+/**
+ * The options that can be provided to tar commands.
+ *
+ * Note that some of these are only relevant for certain commands, since
+ * they are specific to reading or writing.
+ *
+ * Aliases are provided in the {@link TarOptionsWithAliases} type.
+ */
+export interface TarOptions {
+    /**
+     * Perform all I/O operations synchronously. If the stream is ended
+     * immediately, then it will be processed entirely synchronously.
+     */
+    sync?: boolean;
+    /**
+     * The tar file to be read and/or written. When this is set, a stream
+     * is not returned. Asynchronous commands will return a promise indicating
+     * when the operation is completed, and synchronous commands will return
+     * immediately.
+     */
+    file?: string;
+    /**
+     * Treat warnings as crash-worthy errors. Defaults false.
+     */
+    strict?: boolean;
+    /**
+     * The effective current working directory for this tar command
+     */
+    cwd?: string;
+    /**
+     * When creating a tar archive, this can be used to compress it as well.
+     * Set to `true` to use the default gzip options, or customize them as
+     * needed.
+     *
+     * When reading, if this is unset, then the compression status will be
+     * inferred from the archive data. This is generally best, unless you are
+     * sure of the compression settings in use to create the archive, and want to
+     * fail if the archive doesn't match expectations.
+     */
+    gzip?: boolean | GzipOptions;
+    /**
+     * When creating archives, preserve absolute and `..` paths in the archive,
+     * rather than sanitizing them under the cwd.
+     *
+     * When extracting, allow absolute paths, paths containing `..`, and
+     * extracting through symbolic links. By default, the root `/` is stripped
+     * from absolute paths (eg, turning `/x/y/z` into `x/y/z`), paths containing
+     * `..` are not extracted, and any file whose location would be modified by a
+     * symbolic link is not extracted.
+     *
+     * **WARNING** This is almost always unsafe, and must NEVER be used on
+     * archives from untrusted sources, such as user input, and every entry must
+     * be validated to ensure it is safe to write. Even if the input is not
+     * malicious, mistakes can cause a lot of damage!
+     */
+    preservePaths?: boolean;
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    noMtime?: boolean;
+    /**
+     * Set to `true` or an object with settings for `zlib.BrotliCompress()` to
+     * create a brotli-compressed archive
+     *
+     * When extracting, this will cause the archive to be treated as a
+     * brotli-compressed file if set to `true` or a ZlibOptions object.
+     *
+     * If set `false`, then brotli options will not be used.
+     *
+     * If this, the `gzip`, and `zstd` options are left `undefined`, then tar
+     * will attempt to infer the brotli compression status, but can only do so
+     * based on the filename. If the filename ends in `.tbr` or `.tar.br`, and
+     * the first 512 bytes are not a valid tar header, then brotli decompression
+     * will be attempted.
+     */
+    brotli?: boolean | ZlibOptions;
+    /**
+     * Set to `true` or an object with settings for `zstd.compress()` to
+     * create a zstd-compressed archive
+     *
+     * When extracting, this will cause the archive to be treated as a
+     * zstd-compressed file if set to `true` or a ZlibOptions object.
+     *
+     * If set `false`, then zstd options will not be used.
+     *
+     * If this, the `gzip`, and `brotli` options are left `undefined`, then tar
+     * will attempt to infer the zstd compression status, but can only do so
+     * based on the filename. If the filename ends in `.tzst` or `.tar.zst`, and
+     * the first 512 bytes are not a valid tar header, then zstd decompression
+     * will be attempted.
+     */
+    zstd?: boolean | ZlibOptions;
+    /**
+     * A function that is called with `(path, stat)` when creating an archive, or
+     * `(path, entry)` when extracting. Return true to process the file/entry, or
+     * false to exclude it.
+     */
+    filter?: (path: string, entry: Stats | ReadEntry) => boolean;
+    /**
+     * A function that gets called for any warning encountered.
+     *
+     * Note: if `strict` is set, then the warning will throw, and this method
+     * will not be called.
+     */
+    onwarn?: (code: string, message: string, data: WarnData) => unknown;
+    /**
+     * The maximum allowed ratio of decompressed bytes to compressed bytes when
+     * reading gzip, brotli, or zstd-compressed archives.
+     *
+     * This defaults to `1000` and aborts extraction or parsing when exceeded.
+     * Set to `Infinity` to disable the limit.
+     */
+    maxDecompressionRatio?: number;
+    /**
+     * When extracting, unlink files before creating them. Without this option,
+     * tar overwrites existing files, which preserves existing hardlinks. With
+     * this option, existing hardlinks will be broken, as will any symlink that
+     * would affect the location of an extracted file.
+     */
+    unlink?: boolean;
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     *
+     * Any entry whose entire path is stripped will be excluded.
+     */
+    strip?: number;
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    newer?: boolean;
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    keep?: boolean;
+    /**
+     * When extracting, set the `uid` and `gid` of extracted entries to the `uid`
+     * and `gid` fields in the archive. Defaults to true when run as root, and
+     * false otherwise.
+     *
+     * If false, then files and directories will be set with the owner and group
+     * of the user running the process. This is similar to `-p` in `tar(1)`, but
+     * ACLs and other system-specific data is never unpacked in this
+     * implementation, and modes are set by default already.
+     */
+    preserveOwner?: boolean;
+    /**
+     * The maximum depth of subfolders to extract into. This defaults to 1024.
+     * Anything deeper than the limit will raise a warning and skip the entry.
+     * Set to `Infinity` to remove the limitation.
+     */
+    maxDepth?: number;
+    /**
+     * When extracting, force all created files and directories, and all
+     * implicitly created directories, to be owned by the specified user id,
+     * regardless of the `uid` field in the archive.
+     *
+     * Cannot be used along with `preserveOwner`. Requires also setting the `gid`
+     * option.
+     */
+    uid?: number;
+    /**
+     * When extracting, force all created files and directories, and all
+     * implicitly created directories, to be owned by the specified group id,
+     * regardless of the `gid` field in the archive.
+     *
+     * Cannot be used along with `preserveOwner`. Requires also setting the `uid`
+     * option.
+     */
+    gid?: number;
+    /**
+     * When extracting, provide a function that takes an `entry` object, and
+     * returns a stream, or any falsey value. If a stream is provided, then that
+     * stream's data will be written instead of the contents of the archive
+     * entry. If a falsey value is provided, then the entry is written to disk as
+     * normal.
+     *
+     * To exclude items from extraction, use the `filter` option.
+     *
+     * Note that using an asynchronous stream type with the `transform` option
+     * will cause undefined behavior in synchronous extractions.
+     * [MiniPass](http://npm.im/minipass)-based streams are designed for this use
+     * case.
+     */
+    transform?: (entry: ReadEntry) => ReadEntry | null | undefined | false | 0 | '';
+    /**
+     * Call `chmod()` to ensure that extracted files match the entry's mode
+     * field. Without this field set, all mode fields in archive entries are a
+     * best effort attempt only.
+     *
+     * Setting this necessitates a call to the deprecated `process.umask()`
+     * method to determine the default umask value, unless a `processUmask`
+     * config is provided as well.
+     *
+     * If not set, tar will attempt to create file system entries with whatever
+     * mode is provided, and let the implicit process `umask` apply normally, but
+     * if a file already exists to be written to, then its existing mode will not
+     * be modified.
+     *
+     * When setting `chmod: true`, it is highly recommend to set the
+     * {@link TarOptions#processUmask} option as well, to avoid the call to the
+     * deprecated (and thread-unsafe) `process.umask()` method.
+     */
+    chmod?: boolean;
+    /**
+     * When setting the {@link TarOptions#chmod} option to `true`, you may
+     * provide a value here to avoid having to call the deprecated and
+     * thread-unsafe `process.umask()` method.
+     *
+     * This has no effect with `chmod` is not set to true, as mode values are not
+     * set explicitly anyway. If `chmod` is set to `true`, and a value is not
+     * provided here, then `process.umask()` must be called, which will result in
+     * deprecation warnings.
+     *
+     * The most common values for this are `0o22` (resulting in directories
+     * created with mode `0o755` and files with `0o644` by default) and `0o2`
+     * (resulting in directores created with mode `0o775` and files `0o664`, so
+     * they are group-writable).
+     */
+    processUmask?: number;
+    /**
+     * When parsing/listing archives, `entry` streams are by default resumed
+     * (set into "flowing" mode) immediately after the call to `onReadEntry()`.
+     * Set `noResume: true` to suppress this behavior.
+     *
+     * Note that when this is set, the stream will never complete until the
+     * data is consumed somehow.
+     *
+     * Set automatically in extract operations, since the entry is piped to
+     * a file system entry right away. Only relevant when parsing.
+     */
+    noResume?: boolean;
+    /**
+     * When creating, updating, or replacing within archives, this method will
+     * be called with each WriteEntry that is created.
+     */
+    onWriteEntry?: (entry: WriteEntry) => unknown;
+    /**
+     * When extracting or listing archives, this method will be called with
+     * each entry that is not excluded by a `filter`.
+     *
+     * Important when listing archives synchronously from a file, because there
+     * is otherwise no way to interact with the data!
+     */
+    onReadEntry?: (entry: ReadEntry) => unknown;
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    follow?: boolean;
+    /**
+     * When creating archives, omit any metadata that is system-specific:
+     * `ctime`, `atime`, `uid`, `gid`, `uname`, `gname`, `dev`, `ino`, and
+     * `nlink`. Note that `mtime` is still included, because this is necessary
+     * for other time-based operations such as `tar.update`. Additionally, `mode`
+     * is set to a "reasonable default" for mose unix systems, based on an
+     * effective `umask` of `0o22`.
+     *
+     * This also defaults the `portable` option in the gzip configs when creating
+     * a compressed archive, in order to produce deterministic archives that are
+     * not operating-system specific.
+     */
+    portable?: boolean;
+    /**
+     * When creating archives, do not recursively archive the contents of
+     * directories. By default, archiving a directory archives all of its
+     * contents as well.
+     */
+    noDirRecurse?: boolean;
+    /**
+     * Suppress Pax extended headers when creating archives. Note that this means
+     * long paths and linkpaths will be truncated, and large or negative numeric
+     * values may be interpreted incorrectly.
+     */
+    noPax?: boolean;
+    /**
+     * Set to a `Date` object to force a specific `mtime` value for everything
+     * written to an archive.
+     *
+     * This is useful when creating archives that are intended to be
+     * deterministic based on their contents, irrespective of the file's last
+     * modification time.
+     *
+     * Overridden by `noMtime`.
+     */
+    mtime?: Date;
+    /**
+     * A path portion to prefix onto the entries added to an archive.
+     */
+    prefix?: string;
+    /**
+     * The mode to set on any created file archive, defaults to 0o666
+     * masked by the process umask, often resulting in 0o644.
+     *
+     * This does *not* affect the mode fields of individual entries, or the
+     * mode status of extracted entries on the filesystem.
+     */
+    mode?: number;
+    /**
+     * A cache of mtime values, to avoid having to stat the same file repeatedly.
+     *
+     * @internal
+     */
+    mtimeCache?: Map<string, Date>;
+    /**
+     * maximum buffer size for `fs.read()` operations.
+     *
+     * @internal
+     */
+    maxReadSize?: number;
+    /**
+     * Filter modes of entries being unpacked, like `process.umask()`
+     *
+     * @internal
+     */
+    umask?: number;
+    /**
+     * Default mode for directories. Used for all implicitly created directories,
+     * and any directories in the archive that do not have a mode field.
+     *
+     * @internal
+     */
+    dmode?: number;
+    /**
+     * default mode for files
+     *
+     * @internal
+     */
+    fmode?: number;
+    /**
+     * Map that tracks which directories already exist, for extraction
+     *
+     * @internal
+     */
+    dirCache?: Map<string, boolean>;
+    /**
+     * maximum supported size of meta entries. Defaults to 1MB
+     *
+     * @internal
+     */
+    maxMetaEntrySize?: number;
+    /**
+     * A Map object containing the device and inode value for any file whose
+     * `nlink` value is greater than 1, to identify hard links when creating
+     * archives.
+     *
+     * @internal
+     */
+    linkCache?: Map<LinkCacheKey, string>;
+    /**
+     * A map object containing the results of `fs.readdir()` calls.
+     *
+     * @internal
+     */
+    readdirCache?: Map<string, string[]>;
+    /**
+     * A cache of all `lstat` results, for use in creating archives.
+     *
+     * @internal
+     */
+    statCache?: Map<string, Stats>;
+    /**
+     * Number of concurrent jobs to run when creating archives.
+     *
+     * Defaults to 4.
+     *
+     * @internal
+     */
+    jobs?: number;
+    /**
+     * Automatically set to true on Windows systems.
+     *
+     * When extracting, causes behavior where filenames containing `<|>?:`
+     * characters are converted to windows-compatible escape sequences in the
+     * created filesystem entries.
+     *
+     * When packing, causes behavior where paths replace `\` with `/`, and
+     * filenames containing the windows-compatible escaped forms of `<|>?:` are
+     * converted to actual `<|>?:` characters in the archive.
+     *
+     * @internal
+     */
+    win32?: boolean;
+    /**
+     * For `WriteEntry` objects, the absolute path to the entry on the
+     * filesystem. By default, this is `resolve(cwd, entry.path)`, but it can be
+     * overridden explicitly.
+     *
+     * @internal
+     */
+    absolute?: string;
+    /**
+     * Used with Parser stream interface, to attach and take over when the
+     * stream is completely parsed. If this is set, then the prefinish,
+     * finish, and end events will not fire, and are the responsibility of
+     * the ondone method to emit properly.
+     *
+     * @internal
+     */
+    ondone?: () => void;
+    /**
+     * Mostly for testing, but potentially useful in some cases.
+     * Forcibly trigger a chown on every entry, no matter what.
+     */
+    forceChown?: boolean;
+    /**
+     * ambiguous deprecated name for {@link onReadEntry}
+     *
+     * @deprecated
+     */
+    onentry?: (entry: ReadEntry) => unknown;
+}
+export type TarOptionsSync = TarOptions & {
+    sync: true;
+};
+export type TarOptionsAsync = TarOptions & {
+    sync?: false;
+};
+export type TarOptionsFile = TarOptions & {
+    file: string;
+};
+export type TarOptionsNoFile = TarOptions & {
+    file?: undefined;
+};
+export type TarOptionsSyncFile = TarOptionsSync & TarOptionsFile;
+export type TarOptionsAsyncFile = TarOptionsAsync & TarOptionsFile;
+export type TarOptionsSyncNoFile = TarOptionsSync & TarOptionsNoFile;
+export type TarOptionsAsyncNoFile = TarOptionsAsync & TarOptionsNoFile;
+export type LinkCacheKey = `${number}:${number}`;
+export interface TarOptionsWithAliases extends TarOptions {
+    /**
+     * The effective current working directory for this tar command
+     */
+    C?: TarOptions['cwd'];
+    /**
+     * The tar file to be read and/or written. When this is set, a stream
+     * is not returned. Asynchronous commands will return a promise indicating
+     * when the operation is completed, and synchronous commands will return
+     * immediately.
+     */
+    f?: TarOptions['file'];
+    /**
+     * When creating a tar archive, this can be used to compress it as well.
+     * Set to `true` to use the default gzip options, or customize them as
+     * needed.
+     *
+     * When reading, if this is unset, then the compression status will be
+     * inferred from the archive data. This is generally best, unless you are
+     * sure of the compression settings in use to create the archive, and want to
+     * fail if the archive doesn't match expectations.
+     */
+    z?: TarOptions['gzip'];
+    /**
+     * When creating archives, preserve absolute and `..` paths in the archive,
+     * rather than sanitizing them under the cwd.
+     *
+     * When extracting, allow absolute paths, paths containing `..`, and
+     * extracting through symbolic links. By default, the root `/` is stripped
+     * from absolute paths (eg, turning `/x/y/z` into `x/y/z`), paths containing
+     * `..` are not extracted, and any file whose location would be modified by a
+     * symbolic link is not extracted.
+     *
+     * **WARNING** This is almost always unsafe, and must NEVER be used on
+     * archives from untrusted sources, such as user input, and every entry must
+     * be validated to ensure it is safe to write. Even if the input is not
+     * malicious, mistakes can cause a lot of damage!
+     */
+    P?: TarOptions['preservePaths'];
+    /**
+     * When extracting, unlink files before creating them. Without this option,
+     * tar overwrites existing files, which preserves existing hardlinks. With
+     * this option, existing hardlinks will be broken, as will any symlink that
+     * would affect the location of an extracted file.
+     */
+    U?: TarOptions['unlink'];
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     */
+    'strip-components'?: TarOptions['strip'];
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     */
+    stripComponents?: TarOptions['strip'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    'keep-newer'?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    keepNewer?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    'keep-newer-files'?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    keepNewerFiles?: TarOptions['newer'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    k?: TarOptions['keep'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    'keep-existing'?: TarOptions['keep'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    keepExisting?: TarOptions['keep'];
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    m?: TarOptions['noMtime'];
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    'no-mtime'?: TarOptions['noMtime'];
+    /**
+     * When extracting, set the `uid` and `gid` of extracted entries to the `uid`
+     * and `gid` fields in the archive. Defaults to true when run as root, and
+     * false otherwise.
+     *
+     * If false, then files and directories will be set with the owner and group
+     * of the user running the process. This is similar to `-p` in `tar(1)`, but
+     * ACLs and other system-specific data is never unpacked in this
+     * implementation, and modes are set by default already.
+     */
+    p?: TarOptions['preserveOwner'];
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    L?: TarOptions['follow'];
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    h?: TarOptions['follow'];
+    /**
+     * Deprecated option. Set explicitly false to set `chmod: true`. Ignored
+     * if {@link TarOptions#chmod} is set to any boolean value.
+     *
+     * @deprecated
+     */
+    noChmod?: boolean;
+}
+export type TarOptionsWithAliasesSync = TarOptionsWithAliases & {
+    sync: true;
+};
+export type TarOptionsWithAliasesAsync = TarOptionsWithAliases & {
+    sync?: false;
+};
+export type TarOptionsWithAliasesFile = (TarOptionsWithAliases & {
+    file: string;
+}) | (TarOptionsWithAliases & {
+    f: string;
+});
+export type TarOptionsWithAliasesSyncFile = TarOptionsWithAliasesSync & TarOptionsWithAliasesFile;
+export type TarOptionsWithAliasesAsyncFile = TarOptionsWithAliasesAsync & TarOptionsWithAliasesFile;
+export type TarOptionsWithAliasesNoFile = TarOptionsWithAliases & {
+    f?: undefined;
+    file?: undefined;
+};
+export type TarOptionsWithAliasesSyncNoFile = TarOptionsWithAliasesSync & TarOptionsWithAliasesNoFile;
+export type TarOptionsWithAliasesAsyncNoFile = TarOptionsWithAliasesAsync & TarOptionsWithAliasesNoFile;
+export declare const isSyncFile: <O extends TarOptions>(o: O) => o is O & TarOptionsSyncFile;
+export declare const isAsyncFile: <O extends TarOptions>(o: O) => o is O & TarOptionsAsyncFile;
+export declare const isSyncNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsSyncNoFile;
+export declare const isAsyncNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsAsyncNoFile;
+export declare const isSync: <O extends TarOptions>(o: O) => o is O & TarOptionsSync;
+export declare const isAsync: <O extends TarOptions>(o: O) => o is O & TarOptionsAsync;
+export declare const isFile: <O extends TarOptions>(o: O) => o is O & TarOptionsFile;
+export declare const isNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsNoFile;
+export declare const dealias: (opt?: TarOptionsWithAliases) => TarOptions;
+//# sourceMappingURL=options.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/options.js b/node_modules/tar/dist/esm/options.js
new file mode 100644
index 0000000..a006d36
--- /dev/null
+++ b/node_modules/tar/dist/esm/options.js
@@ -0,0 +1,54 @@
+// turn tar(1) style args like `C` into the more verbose things like `cwd`
+const argmap = 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'],
+]);
+export const isSyncFile = (o) => !!o.sync && !!o.file;
+export const isAsyncFile = (o) => !o.sync && !!o.file;
+export const isSyncNoFile = (o) => !!o.sync && !o.file;
+export const isAsyncNoFile = (o) => !o.sync && !o.file;
+export const isSync = (o) => !!o.sync;
+export const isAsync = (o) => !o.sync;
+export const isFile = (o) => !!o.file;
+export const isNoFile = (o) => !o.file;
+const dealiasKey = (k) => {
+    const d = argmap.get(k);
+    if (d)
+        return d;
+    return k;
+};
+export const dealias = (opt = {}) => {
+    if (!opt)
+        return {};
+    const result = {};
+    for (const [key, v] of Object.entries(opt)) {
+        // TS doesn't know that aliases are going to always be the same type
+        const k = dealiasKey(key);
+        result[k] = v;
+    }
+    // affordance for deprecated noChmod -> chmod
+    if (result.chmod === undefined && result.noChmod === false) {
+        result.chmod = true;
+    }
+    delete result.noChmod;
+    return result;
+};
+//# sourceMappingURL=options.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/pack.d.ts b/node_modules/tar/dist/esm/pack.d.ts
new file mode 100644
index 0000000..77eda34
--- /dev/null
+++ b/node_modules/tar/dist/esm/pack.d.ts
@@ -0,0 +1,105 @@
+import { type Stats } from 'fs';
+import { WriteEntry, WriteEntrySync, WriteEntryTar } from './write-entry.js';
+export declare class PackJob {
+    path: string;
+    absolute: string;
+    entry?: WriteEntry | WriteEntryTar;
+    stat?: Stats;
+    readdir?: string[];
+    pending: boolean;
+    pendingLink: boolean;
+    ignore: boolean;
+    piped: boolean;
+    constructor(path: string, absolute: string);
+}
+import { Minipass } from 'minipass';
+import * as zlib from 'minizlib';
+import { Yallist } from 'yallist';
+import type { ReadEntry } from './read-entry.js';
+import type { WarnEvent } from './warn-method.js';
+import { type WarnData, type Warner } from './warn-method.js';
+declare const ONSTAT: unique symbol;
+declare const ENDED: unique symbol;
+declare const QUEUE: unique symbol;
+declare const PENDINGLINKS: unique symbol;
+declare const CURRENT: unique symbol;
+declare const PROCESS: unique symbol;
+declare const PROCESSING: unique symbol;
+declare const PROCESSJOB: unique symbol;
+declare const JOBS: unique symbol;
+declare const JOBDONE: unique symbol;
+declare const ADDFSENTRY: unique symbol;
+declare const ADDTARENTRY: unique symbol;
+declare const STAT: unique symbol;
+declare const READDIR: unique symbol;
+declare const ONREADDIR: unique symbol;
+declare const PIPE: unique symbol;
+declare const ENTRY: unique symbol;
+declare const ENTRYOPT: unique symbol;
+declare const WRITEENTRYCLASS: unique symbol;
+declare const WRITE: unique symbol;
+declare const ONDRAIN: unique symbol;
+import type { TarOptions } from './options.js';
+export declare class Pack extends Minipass<Buffer, ReadEntry | string, WarnEvent<Buffer>> implements Warner {
+    sync: boolean;
+    opt: TarOptions;
+    cwd: string;
+    maxReadSize?: number;
+    preservePaths: boolean;
+    strict: boolean;
+    noPax: boolean;
+    prefix: string;
+    linkCache: Exclude<TarOptions['linkCache'], undefined>;
+    statCache: Exclude<TarOptions['statCache'], undefined>;
+    file: string;
+    portable: boolean;
+    zip?: zlib.BrotliCompress | zlib.Gzip | zlib.ZstdCompress;
+    readdirCache: Exclude<TarOptions['readdirCache'], undefined>;
+    noDirRecurse: boolean;
+    follow: boolean;
+    noMtime: boolean;
+    mtime?: Date;
+    filter: Exclude<TarOptions['filter'], undefined>;
+    jobs: number;
+    [WRITEENTRYCLASS]: typeof WriteEntry | typeof WriteEntrySync;
+    onWriteEntry?: (entry: WriteEntry) => void;
+    [QUEUE]: Yallist<PackJob>;
+    [PENDINGLINKS]: Map<`${number}:${number}`, PackJob[]>;
+    [JOBS]: number;
+    [PROCESSING]: boolean;
+    [ENDED]: boolean;
+    constructor(opt?: TarOptions);
+    [WRITE](chunk: Buffer): boolean;
+    add(path: string | ReadEntry): this;
+    end(cb?: () => void): this;
+    end(path: string | ReadEntry, cb?: () => void): this;
+    end(path: string | ReadEntry, encoding?: Minipass.Encoding, cb?: () => void): this;
+    write(path: string | ReadEntry): boolean;
+    [ADDTARENTRY](p: ReadEntry): void;
+    [ADDFSENTRY](p: string): void;
+    [STAT](job: PackJob): void;
+    [ONSTAT](job: PackJob, stat: Stats): void;
+    [READDIR](job: PackJob): void;
+    [ONREADDIR](job: PackJob, entries: string[]): void;
+    [PROCESS](): void;
+    get [CURRENT](): PackJob | undefined;
+    [JOBDONE](job: PackJob): void;
+    [PROCESSJOB](job: PackJob): void;
+    [ENTRYOPT](job: PackJob): TarOptions;
+    [ENTRY](job: PackJob): WriteEntry | undefined;
+    [ONDRAIN](): void;
+    [PIPE](job: PackJob): void;
+    pause(): void;
+    warn(code: string, message: string | Error, data?: WarnData): void;
+}
+export declare class PackSync extends Pack {
+    sync: true;
+    constructor(opt: TarOptions);
+    pause(): void;
+    resume(): void;
+    [STAT](job: PackJob): void;
+    [READDIR](job: PackJob): void;
+    [PIPE](job: PackJob): void;
+}
+export {};
+//# sourceMappingURL=pack.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/pack.js b/node_modules/tar/dist/esm/pack.js
new file mode 100644
index 0000000..ec44113
--- /dev/null
+++ b/node_modules/tar/dist/esm/pack.js
@@ -0,0 +1,502 @@
+// A readable tar stream creator
+// Technically, this is a transform stream that you write paths into,
+// and tar format comes out of.
+// The `add()` method is like `write()` but returns this,
+// and end() return `this` as well, so you can
+// do `new Pack(opt).add('files').add('dir').end().pipe(output)
+// You could also do something like:
+// streamOfPaths().pipe(new Pack()).pipe(new fs.WriteStream('out.tar'))
+import fs from 'fs';
+import { WriteEntry, WriteEntrySync, WriteEntryTar, } from './write-entry.js';
+export class PackJob {
+    path;
+    absolute;
+    entry;
+    stat;
+    readdir;
+    pending = false;
+    pendingLink = false;
+    ignore = false;
+    piped = false;
+    constructor(path, absolute) {
+        this.path = path || './';
+        this.absolute = absolute;
+    }
+}
+import { Minipass } from 'minipass';
+import * as zlib from 'minizlib';
+import { Yallist } from 'yallist';
+import { warnMethod } from './warn-method.js';
+const EOF = Buffer.alloc(1024);
+const ONSTAT = Symbol('onStat');
+const ENDED = Symbol('ended');
+const QUEUE = Symbol('queue');
+const PENDINGLINKS = Symbol('pendingLinks');
+const CURRENT = Symbol('current');
+const PROCESS = Symbol('process');
+const PROCESSING = Symbol('processing');
+const PROCESSJOB = Symbol('processJob');
+const JOBS = Symbol('jobs');
+const JOBDONE = Symbol('jobDone');
+const ADDFSENTRY = Symbol('addFSEntry');
+const ADDTARENTRY = Symbol('addTarEntry');
+const STAT = Symbol('stat');
+const READDIR = Symbol('readdir');
+const ONREADDIR = Symbol('onreaddir');
+const PIPE = Symbol('pipe');
+const ENTRY = Symbol('entry');
+const ENTRYOPT = Symbol('entryOpt');
+const WRITEENTRYCLASS = Symbol('writeEntryClass');
+const WRITE = Symbol('write');
+const ONDRAIN = Symbol('ondrain');
+import path from 'path';
+import { normalizeWindowsPath } from './normalize-windows-path.js';
+export class Pack extends Minipass {
+    sync = false;
+    opt;
+    cwd;
+    maxReadSize;
+    preservePaths;
+    strict;
+    noPax;
+    prefix;
+    linkCache;
+    statCache;
+    file;
+    portable;
+    zip;
+    readdirCache;
+    noDirRecurse;
+    follow;
+    noMtime;
+    mtime;
+    filter;
+    jobs;
+    [WRITEENTRYCLASS];
+    onWriteEntry;
+    // Note: we actually DO need a linked list here, because we
+    // shift() to update the head of the list where we start, but still
+    // while that happens, need to know what the next item in the queue
+    // will be. Since we do multiple jobs in parallel, it's not as simple
+    // as just an Array.shift(), since that would lose the information about
+    // the next job in the list. We could add a .next field on the PackJob
+    // class, but then we'd have to be tracking the tail of the queue the
+    // whole time, and Yallist just does that for us anyway.
+    [QUEUE];
+    [PENDINGLINKS] = new Map();
+    [JOBS] = 0;
+    [PROCESSING] = false;
+    [ENDED] = false;
+    constructor(opt = {}) {
+        super();
+        this.opt = opt;
+        this.file = opt.file || '';
+        this.cwd = opt.cwd || process.cwd();
+        this.maxReadSize = opt.maxReadSize;
+        this.preservePaths = !!opt.preservePaths;
+        this.strict = !!opt.strict;
+        this.noPax = !!opt.noPax;
+        this.prefix = normalizeWindowsPath(opt.prefix || '');
+        this.linkCache = opt.linkCache || new Map();
+        this.statCache = opt.statCache || new Map();
+        this.readdirCache = opt.readdirCache || new Map();
+        this.onWriteEntry = opt.onWriteEntry;
+        this[WRITEENTRYCLASS] = WriteEntry;
+        if (typeof opt.onwarn === 'function') {
+            this.on('warn', opt.onwarn);
+        }
+        this.portable = !!opt.portable;
+        if (opt.gzip || opt.brotli || opt.zstd) {
+            if ((opt.gzip ? 1 : 0) + (opt.brotli ? 1 : 0) + (opt.zstd ? 1 : 0) >
+                1) {
+                throw new TypeError('gzip, brotli, zstd are mutually exclusive');
+            }
+            if (opt.gzip) {
+                if (typeof opt.gzip !== 'object') {
+                    opt.gzip = {};
+                }
+                if (this.portable) {
+                    opt.gzip.portable = true;
+                }
+                this.zip = new zlib.Gzip(opt.gzip);
+            }
+            if (opt.brotli) {
+                if (typeof opt.brotli !== 'object') {
+                    opt.brotli = {};
+                }
+                this.zip = new zlib.BrotliCompress(opt.brotli);
+            }
+            if (opt.zstd) {
+                if (typeof opt.zstd !== 'object') {
+                    opt.zstd = {};
+                }
+                this.zip = new zlib.ZstdCompress(opt.zstd);
+            }
+            /* c8 ignore next */
+            if (!this.zip)
+                throw new Error('impossible');
+            const zip = this.zip;
+            zip.on('data', chunk => super.write(chunk));
+            zip.on('end', () => super.end());
+            zip.on('drain', () => this[ONDRAIN]());
+            this.on('resume', () => zip.resume());
+        }
+        else {
+            this.on('drain', this[ONDRAIN]);
+        }
+        this.noDirRecurse = !!opt.noDirRecurse;
+        this.follow = !!opt.follow;
+        this.noMtime = !!opt.noMtime;
+        if (opt.mtime)
+            this.mtime = opt.mtime;
+        this.filter =
+            typeof opt.filter === 'function' ? opt.filter : () => true;
+        this[QUEUE] = new Yallist();
+        this[JOBS] = 0;
+        this.jobs = Number(opt.jobs) || 4;
+        this[PROCESSING] = false;
+        this[ENDED] = false;
+    }
+    [WRITE](chunk) {
+        return super.write(chunk);
+    }
+    add(path) {
+        this.write(path);
+        return this;
+    }
+    end(path, encoding, cb) {
+        /* c8 ignore start */
+        if (typeof path === 'function') {
+            cb = path;
+            path = undefined;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        /* c8 ignore stop */
+        if (path) {
+            this.add(path);
+        }
+        this[ENDED] = true;
+        this[PROCESS]();
+        /* c8 ignore next */
+        if (cb)
+            cb();
+        return this;
+    }
+    write(path) {
+        if (this[ENDED]) {
+            throw new Error('write after end');
+        }
+        if (typeof path === 'string') {
+            this[ADDFSENTRY](path);
+        }
+        else {
+            this[ADDTARENTRY](path);
+        }
+        return this.flowing;
+    }
+    [ADDTARENTRY](p) {
+        const absolute = normalizeWindowsPath(path.resolve(this.cwd, p.path));
+        // in this case, we don't have to wait for the stat
+        if (!this.filter(p.path, p)) {
+            p.resume();
+        }
+        else {
+            const job = new PackJob(p.path, absolute);
+            job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
+            job.entry.on('end', () => this[JOBDONE](job));
+            this[JOBS] += 1;
+            this[QUEUE].push(job);
+        }
+        this[PROCESS]();
+    }
+    [ADDFSENTRY](p) {
+        const absolute = normalizeWindowsPath(path.resolve(this.cwd, p));
+        this[QUEUE].push(new PackJob(p, absolute));
+        this[PROCESS]();
+    }
+    [STAT](job) {
+        job.pending = true;
+        this[JOBS] += 1;
+        const stat = this.follow ? 'stat' : 'lstat';
+        fs[stat](job.absolute, (er, stat) => {
+            job.pending = false;
+            this[JOBS] -= 1;
+            if (er) {
+                this.emit('error', er);
+            }
+            else {
+                this[ONSTAT](job, stat);
+            }
+        });
+    }
+    [ONSTAT](job, stat) {
+        this.statCache.set(job.absolute, stat);
+        job.stat = stat;
+        // now we have the stat, we can filter it.
+        if (!this.filter(job.path, stat)) {
+            job.ignore = true;
+        }
+        else if (stat.isFile() &&
+            stat.nlink > 1 &&
+            !this.linkCache.get(`${stat.dev}:${stat.ino}`) &&
+            !this.sync) {
+            // if it's not filtered, and it's a new File entry, and next anyway
+            // process right away in case any pending Link entries are about
+            // to try to link to it.
+            if (job === this[CURRENT]) {
+                this[PROCESSJOB](job);
+            }
+            else {
+                // if it's NOT the current entry, it needs to be deferred,
+                // so that the link target can be built first.
+                const key = `${stat.dev}:${stat.ino}`;
+                const pending = this[PENDINGLINKS].get(key);
+                if (pending)
+                    pending.push(job);
+                else
+                    this[PENDINGLINKS].set(key, [job]);
+                job.pendingLink = true;
+                job.pending = true;
+            }
+        }
+        this[PROCESS]();
+    }
+    [READDIR](job) {
+        job.pending = true;
+        this[JOBS] += 1;
+        fs.readdir(job.absolute, (er, entries) => {
+            job.pending = false;
+            this[JOBS] -= 1;
+            if (er) {
+                return this.emit('error', er);
+            }
+            this[ONREADDIR](job, entries);
+        });
+    }
+    [ONREADDIR](job, entries) {
+        this.readdirCache.set(job.absolute, entries);
+        job.readdir = entries;
+        this[PROCESS]();
+    }
+    [PROCESS]() {
+        if (this[PROCESSING]) {
+            return;
+        }
+        this[PROCESSING] = true;
+        for (let w = this[QUEUE].head; !!w && this[JOBS] < this.jobs; w = w.next) {
+            this[PROCESSJOB](w.value);
+            if (w.value.ignore) {
+                const p = w.next;
+                this[QUEUE].removeNode(w);
+                w.next = p;
+            }
+        }
+        this[PROCESSING] = false;
+        if (this[ENDED] && this[QUEUE].length === 0 && this[JOBS] === 0) {
+            if (this.zip) {
+                this.zip.end(EOF);
+            }
+            else {
+                super.write(EOF);
+                super.end();
+            }
+        }
+    }
+    get [CURRENT]() {
+        return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
+    }
+    [JOBDONE](job) {
+        this[QUEUE].shift();
+        this[JOBS] -= 1;
+        const { stat } = job;
+        if (stat && stat.isFile() && stat.nlink > 1) {
+            // might be a file with pending links
+            const key = `${stat.dev}:${stat.ino}`;
+            const pending = this[PENDINGLINKS].get(key);
+            if (pending) {
+                this[PENDINGLINKS].delete(key);
+                for (const job of pending) {
+                    job.pending = false;
+                    this[PROCESSJOB](job);
+                }
+            }
+        }
+        this[PROCESS]();
+    }
+    [PROCESSJOB](job) {
+        if (job.pending && job.pendingLink && job === this[CURRENT]) {
+            // At least one of the links to this file are not being included
+            // in the tarball, so we need to just proceed.
+            job.pending = false;
+            job.pendingLink = false;
+        }
+        if (job.pending) {
+            return;
+        }
+        if (job.entry) {
+            if (job === this[CURRENT] && !job.piped) {
+                this[PIPE](job);
+            }
+            return;
+        }
+        if (!job.stat) {
+            const sc = this.statCache.get(job.absolute);
+            if (sc) {
+                this[ONSTAT](job, sc);
+            }
+            else {
+                this[STAT](job);
+            }
+        }
+        if (!job.stat) {
+            return;
+        }
+        // filtered out!
+        if (job.ignore) {
+            return;
+        }
+        if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
+            const rc = this.readdirCache.get(job.absolute);
+            if (rc) {
+                this[ONREADDIR](job, rc);
+            }
+            else {
+                this[READDIR](job);
+            }
+            if (!job.readdir) {
+                return;
+            }
+        }
+        // we know it doesn't have an entry, because that got checked above
+        job.entry = this[ENTRY](job);
+        if (!job.entry) {
+            job.ignore = true;
+            return;
+        }
+        if (job === this[CURRENT] && !job.piped) {
+            this[PIPE](job);
+        }
+    }
+    [ENTRYOPT](job) {
+        return {
+            onwarn: (code, msg, data) => this.warn(code, msg, data),
+            noPax: this.noPax,
+            cwd: this.cwd,
+            absolute: job.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,
+        };
+    }
+    [ENTRY](job) {
+        this[JOBS] += 1;
+        try {
+            const e = new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job));
+            return e
+                .on('end', () => this[JOBDONE](job))
+                .on('error', er => this.emit('error', er));
+        }
+        catch (er) {
+            this.emit('error', er);
+        }
+    }
+    [ONDRAIN]() {
+        if (this[CURRENT] && this[CURRENT].entry) {
+            this[CURRENT].entry.resume();
+        }
+    }
+    // like .pipe() but using super, because our write() is special
+    [PIPE](job) {
+        job.piped = true;
+        if (job.readdir) {
+            job.readdir.forEach(entry => {
+                const p = job.path;
+                const base = p === './' ? '' : p.replace(/\/*$/, '/');
+                this[ADDFSENTRY](base + entry);
+            });
+        }
+        const source = job.entry;
+        const zip = this.zip;
+        /* c8 ignore start */
+        if (!source)
+            throw new Error('cannot pipe without source');
+        /* c8 ignore stop */
+        if (zip) {
+            source.on('data', chunk => {
+                if (!zip.write(chunk)) {
+                    source.pause();
+                }
+            });
+        }
+        else {
+            source.on('data', chunk => {
+                if (!super.write(chunk)) {
+                    source.pause();
+                }
+            });
+        }
+    }
+    pause() {
+        if (this.zip) {
+            this.zip.pause();
+        }
+        return super.pause();
+    }
+    warn(code, message, data = {}) {
+        warnMethod(this, code, message, data);
+    }
+}
+export class PackSync extends Pack {
+    sync = true;
+    constructor(opt) {
+        super(opt);
+        this[WRITEENTRYCLASS] = WriteEntrySync;
+    }
+    // pause/resume are no-ops in sync streams.
+    pause() { }
+    resume() { }
+    [STAT](job) {
+        const stat = this.follow ? 'statSync' : 'lstatSync';
+        this[ONSTAT](job, fs[stat](job.absolute));
+    }
+    [READDIR](job) {
+        this[ONREADDIR](job, fs.readdirSync(job.absolute));
+    }
+    // gotta get it all in this tick
+    [PIPE](job) {
+        const source = job.entry;
+        const zip = this.zip;
+        if (job.readdir) {
+            job.readdir.forEach(entry => {
+                const p = job.path;
+                const base = p === './' ? '' : p.replace(/\/*$/, '/');
+                this[ADDFSENTRY](base + entry);
+            });
+        }
+        /* c8 ignore start */
+        if (!source)
+            throw new Error('Cannot pipe without source');
+        /* c8 ignore stop */
+        if (zip) {
+            source.on('data', chunk => {
+                zip.write(chunk);
+            });
+        }
+        else {
+            source.on('data', chunk => {
+                super[WRITE](chunk);
+            });
+        }
+    }
+}
+//# sourceMappingURL=pack.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/package.json b/node_modules/tar/dist/esm/package.json
new file mode 100644
index 0000000..3dbc1ca
--- /dev/null
+++ b/node_modules/tar/dist/esm/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
diff --git a/node_modules/tar/dist/esm/parse.d.ts b/node_modules/tar/dist/esm/parse.d.ts
new file mode 100644
index 0000000..bb37d88
--- /dev/null
+++ b/node_modules/tar/dist/esm/parse.d.ts
@@ -0,0 +1,92 @@
+import { EventEmitter as EE } from 'events';
+import { BrotliDecompress, Unzip, ZstdDecompress } from 'minizlib';
+import type { TarOptions } from './options.js';
+import { Pax } from './pax.js';
+import { ReadEntry } from './read-entry.js';
+import { type WarnData, type Warner } from './warn-method.js';
+declare const STATE: unique symbol;
+declare const WRITEENTRY: unique symbol;
+declare const READENTRY: unique symbol;
+declare const NEXTENTRY: unique symbol;
+declare const PROCESSENTRY: unique symbol;
+declare const EX: unique symbol;
+declare const GEX: unique symbol;
+declare const META: unique symbol;
+declare const EMITMETA: unique symbol;
+declare const BUFFER: unique symbol;
+declare const QUEUE: unique symbol;
+declare const ENDED: unique symbol;
+declare const EMITTEDEND: unique symbol;
+declare const EMIT: unique symbol;
+declare const UNZIP: unique symbol;
+declare const CONSUMECHUNK: unique symbol;
+declare const CONSUMECHUNKSUB: unique symbol;
+declare const CONSUMEBODY: unique symbol;
+declare const CONSUMEMETA: unique symbol;
+declare const CONSUMEHEADER: unique symbol;
+declare const CONSUMING: unique symbol;
+declare const BUFFERCONCAT: unique symbol;
+declare const MAYBEEND: unique symbol;
+declare const WRITING: unique symbol;
+declare const ABORTED: unique symbol;
+declare const SAW_VALID_ENTRY: unique symbol;
+declare const SAW_NULL_BLOCK: unique symbol;
+declare const SAW_EOF: unique symbol;
+declare const CLOSESTREAM: unique symbol;
+declare const COMPRESSEDBYTESREAD: unique symbol;
+declare const DECOMPRESSEDBYTESREAD: unique symbol;
+declare const CHECKDECOMPRESSIONRATIO: unique symbol;
+export type State = 'begin' | 'header' | 'ignore' | 'meta' | 'body';
+export declare class Parser extends EE implements Warner {
+    file: string;
+    strict: boolean;
+    maxMetaEntrySize: number;
+    filter: Exclude<TarOptions['filter'], undefined>;
+    brotli?: TarOptions['brotli'];
+    zstd?: TarOptions['zstd'];
+    maxDecompressionRatio: number;
+    writable: true;
+    readable: false;
+    [QUEUE]: (ReadEntry | [string | symbol, unknown, unknown])[];
+    [BUFFER]?: Buffer;
+    [READENTRY]?: ReadEntry;
+    [WRITEENTRY]?: ReadEntry;
+    [STATE]: State;
+    [META]: string;
+    [EX]?: Pax;
+    [GEX]?: Pax;
+    [ENDED]: boolean;
+    [UNZIP]?: false | Unzip | BrotliDecompress | ZstdDecompress;
+    [ABORTED]: boolean;
+    [SAW_VALID_ENTRY]?: boolean;
+    [SAW_NULL_BLOCK]: boolean;
+    [SAW_EOF]: boolean;
+    [WRITING]: boolean;
+    [CONSUMING]: boolean;
+    [EMITTEDEND]: boolean;
+    [COMPRESSEDBYTESREAD]: number;
+    [DECOMPRESSEDBYTESREAD]: number;
+    constructor(opt?: TarOptions);
+    warn(code: string, message: string | Error, data?: WarnData): void;
+    [CONSUMEHEADER](chunk: Buffer, position: number): void;
+    [CLOSESTREAM](): void;
+    [PROCESSENTRY](entry?: ReadEntry | [string | symbol, unknown, unknown]): boolean;
+    [NEXTENTRY](): void;
+    [CONSUMEBODY](chunk: Buffer, position: number): number;
+    [CONSUMEMETA](chunk: Buffer, position: number): number;
+    [EMIT](ev: string | symbol, data?: unknown, extra?: unknown): void;
+    [EMITMETA](entry: ReadEntry): void;
+    abort(error: Error): void;
+    [CHECKDECOMPRESSIONRATIO](chunk: Buffer): boolean;
+    write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+    write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+    [BUFFERCONCAT](c: Buffer): void;
+    [MAYBEEND](): void;
+    [CONSUMECHUNK](chunk?: Buffer): void;
+    [CONSUMECHUNKSUB](chunk: Buffer): void;
+    end(cb?: () => void): this;
+    end(data: string | Buffer, cb?: () => void): this;
+    end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
+}
+export {};
+//# sourceMappingURL=parse.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/parse.js b/node_modules/tar/dist/esm/parse.js
new file mode 100644
index 0000000..95e42dc
--- /dev/null
+++ b/node_modules/tar/dist/esm/parse.js
@@ -0,0 +1,651 @@
+// this[BUFFER] is the remainder of a chunk if we're waiting for
+// the full 512 bytes of a header to come in.  We will Buffer.concat()
+// it to the next write(), which is a mem copy, but a small one.
+//
+// this[QUEUE] is a list of entries that haven't been emitted
+// yet this can only get filled up if the user keeps write()ing after
+// a write() returns false, or does a write() with more than one entry
+//
+// We don't buffer chunks, we always parse them and either create an
+// entry, or push it into the active entry.  The ReadEntry class knows
+// to throw data away if .ignore=true
+//
+// Shift entry off the buffer when it emits 'end', and emit 'entry' for
+// the next one in the list.
+//
+// At any time, we're pushing body chunks into the entry at WRITEENTRY,
+// and waiting for 'end' on the entry at READENTRY
+//
+// ignored entries get .resume() called on them straight away
+import { EventEmitter as EE } from 'events';
+import { BrotliDecompress, Unzip, ZstdDecompress } from 'minizlib';
+import { Header } from './header.js';
+import { Pax } from './pax.js';
+import { ReadEntry } from './read-entry.js';
+import { warnMethod } from './warn-method.js';
+const maxMetaEntrySize = 1024 * 1024;
+const gzipHeader = Buffer.from([0x1f, 0x8b]);
+const zstdHeader = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+const ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length);
+const STATE = Symbol('state');
+const WRITEENTRY = Symbol('writeEntry');
+const READENTRY = Symbol('readEntry');
+const NEXTENTRY = Symbol('nextEntry');
+const PROCESSENTRY = Symbol('processEntry');
+const EX = Symbol('extendedHeader');
+const GEX = Symbol('globalExtendedHeader');
+const META = Symbol('meta');
+const EMITMETA = Symbol('emitMeta');
+const BUFFER = Symbol('buffer');
+const QUEUE = Symbol('queue');
+const ENDED = Symbol('ended');
+const EMITTEDEND = Symbol('emittedEnd');
+const EMIT = Symbol('emit');
+const UNZIP = Symbol('unzip');
+const CONSUMECHUNK = Symbol('consumeChunk');
+const CONSUMECHUNKSUB = Symbol('consumeChunkSub');
+const CONSUMEBODY = Symbol('consumeBody');
+const CONSUMEMETA = Symbol('consumeMeta');
+const CONSUMEHEADER = Symbol('consumeHeader');
+const CONSUMING = Symbol('consuming');
+const BUFFERCONCAT = Symbol('bufferConcat');
+const MAYBEEND = Symbol('maybeEnd');
+const WRITING = Symbol('writing');
+const ABORTED = Symbol('aborted');
+const DONE = Symbol('onDone');
+const SAW_VALID_ENTRY = Symbol('sawValidEntry');
+const SAW_NULL_BLOCK = Symbol('sawNullBlock');
+const SAW_EOF = Symbol('sawEOF');
+const CLOSESTREAM = Symbol('closeStream');
+const MAX_DECOMPRESSION_RATIO = 1000;
+const COMPRESSEDBYTESREAD = Symbol('compressedBytesRead');
+const DECOMPRESSEDBYTESREAD = Symbol('decompressedBytesRead');
+const CHECKDECOMPRESSIONRATIO = Symbol('checkDecompressionRatio');
+const noop = () => true;
+export class Parser extends EE {
+    file;
+    strict;
+    maxMetaEntrySize;
+    filter;
+    brotli;
+    zstd;
+    maxDecompressionRatio;
+    writable = true;
+    readable = false;
+    [QUEUE] = [];
+    [BUFFER];
+    [READENTRY];
+    [WRITEENTRY];
+    [STATE] = 'begin';
+    [META] = '';
+    [EX];
+    [GEX];
+    [ENDED] = false;
+    [UNZIP];
+    [ABORTED] = false;
+    [SAW_VALID_ENTRY];
+    [SAW_NULL_BLOCK] = false;
+    [SAW_EOF] = false;
+    [WRITING] = false;
+    [CONSUMING] = false;
+    [EMITTEDEND] = false;
+    [COMPRESSEDBYTESREAD] = 0;
+    [DECOMPRESSEDBYTESREAD] = 0;
+    constructor(opt = {}) {
+        super();
+        this.file = opt.file || '';
+        // these BADARCHIVE errors can't be detected early. listen on DONE.
+        this.on(DONE, () => {
+            if (this[STATE] === 'begin' || this[SAW_VALID_ENTRY] === false) {
+                // either less than 1 block of data, or all entries were invalid.
+                // Either way, probably not even a tarball.
+                this.warn('TAR_BAD_ARCHIVE', 'Unrecognized archive format');
+            }
+        });
+        if (opt.ondone) {
+            this.on(DONE, opt.ondone);
+        }
+        else {
+            this.on(DONE, () => {
+                this.emit('prefinish');
+                this.emit('finish');
+                this.emit('end');
+            });
+        }
+        this.strict = !!opt.strict;
+        this.maxDecompressionRatio =
+            typeof opt.maxDecompressionRatio === 'number' ?
+                opt.maxDecompressionRatio
+                : MAX_DECOMPRESSION_RATIO;
+        this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
+        this.filter = typeof opt.filter === 'function' ? opt.filter : noop;
+        // Unlike gzip, brotli doesn't have any magic bytes to identify it
+        // Users need to explicitly tell us they're extracting a brotli file
+        // Or we infer from the file extension
+        const isTBR = opt.file &&
+            (opt.file.endsWith('.tar.br') || opt.file.endsWith('.tbr'));
+        // if it's a tbr file it MIGHT be brotli, but we don't know until
+        // we look at it and verify it's not a valid tar file.
+        this.brotli =
+            !(opt.gzip || opt.zstd) && opt.brotli !== undefined ? opt.brotli
+                : isTBR ? undefined
+                    : false;
+        // zstd has magic bytes to identify it, but we also support explicit options
+        // and file extension detection
+        const isTZST = opt.file &&
+            (opt.file.endsWith('.tar.zst') || opt.file.endsWith('.tzst'));
+        this.zstd =
+            !(opt.gzip || opt.brotli) && opt.zstd !== undefined ? opt.zstd
+                : isTZST ? true
+                    : undefined;
+        // have to set this so that streams are ok piping into it
+        this.on('end', () => this[CLOSESTREAM]());
+        if (typeof opt.onwarn === 'function') {
+            this.on('warn', opt.onwarn);
+        }
+        if (typeof opt.onReadEntry === 'function') {
+            this.on('entry', opt.onReadEntry);
+        }
+    }
+    warn(code, message, data = {}) {
+        warnMethod(this, code, message, data);
+    }
+    [CONSUMEHEADER](chunk, position) {
+        if (this[SAW_VALID_ENTRY] === undefined) {
+            this[SAW_VALID_ENTRY] = false;
+        }
+        let header;
+        try {
+            header = new Header(chunk, position, this[EX], this[GEX]);
+        }
+        catch (er) {
+            return this.warn('TAR_ENTRY_INVALID', er);
+        }
+        if (header.nullBlock) {
+            if (this[SAW_NULL_BLOCK]) {
+                this[SAW_EOF] = true;
+                // ending an archive with no entries.  pointless, but legal.
+                if (this[STATE] === 'begin') {
+                    this[STATE] = 'header';
+                }
+                this[EMIT]('eof');
+            }
+            else {
+                this[SAW_NULL_BLOCK] = true;
+                this[EMIT]('nullBlock');
+            }
+        }
+        else {
+            this[SAW_NULL_BLOCK] = false;
+            if (!header.cksumValid) {
+                this.warn('TAR_ENTRY_INVALID', 'checksum failure', { header });
+            }
+            else if (!header.path) {
+                this.warn('TAR_ENTRY_INVALID', 'path is required', { header });
+            }
+            else {
+                const type = header.type;
+                if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) {
+                    this.warn('TAR_ENTRY_INVALID', 'linkpath required', {
+                        header,
+                    });
+                }
+                else if (!/^(Symbolic)?Link$/.test(type) &&
+                    !/^(Global)?ExtendedHeader$/.test(type) &&
+                    header.linkpath) {
+                    this.warn('TAR_ENTRY_INVALID', 'linkpath forbidden', {
+                        header,
+                    });
+                }
+                else {
+                    const entry = (this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]));
+                    // we do this for meta & ignored entries as well, because they
+                    // are still valid tar, or else we wouldn't know to ignore them
+                    if (!this[SAW_VALID_ENTRY]) {
+                        if (entry.remain) {
+                            // this might be the one!
+                            const onend = () => {
+                                if (!entry.invalid) {
+                                    this[SAW_VALID_ENTRY] = true;
+                                }
+                            };
+                            entry.on('end', onend);
+                        }
+                        else {
+                            this[SAW_VALID_ENTRY] = true;
+                        }
+                    }
+                    if (entry.meta) {
+                        if (entry.size > this.maxMetaEntrySize) {
+                            entry.ignore = true;
+                            this[EMIT]('ignoredEntry', entry);
+                            this[STATE] = 'ignore';
+                            entry.resume();
+                        }
+                        else if (entry.size > 0) {
+                            this[META] = '';
+                            entry.on('data', c => (this[META] += c));
+                            this[STATE] = 'meta';
+                        }
+                    }
+                    else {
+                        this[EX] = undefined;
+                        entry.ignore = entry.ignore || !this.filter(entry.path, entry);
+                        if (entry.ignore) {
+                            // probably valid, just not something we care about
+                            this[EMIT]('ignoredEntry', entry);
+                            this[STATE] = entry.remain ? 'ignore' : 'header';
+                            entry.resume();
+                        }
+                        else {
+                            if (entry.remain) {
+                                this[STATE] = 'body';
+                            }
+                            else {
+                                this[STATE] = 'header';
+                                entry.end();
+                            }
+                            if (!this[READENTRY]) {
+                                this[QUEUE].push(entry);
+                                this[NEXTENTRY]();
+                            }
+                            else {
+                                this[QUEUE].push(entry);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    [CLOSESTREAM]() {
+        queueMicrotask(() => this.emit('close'));
+    }
+    [PROCESSENTRY](entry) {
+        let go = true;
+        if (!entry) {
+            this[READENTRY] = undefined;
+            go = false;
+        }
+        else if (Array.isArray(entry)) {
+            const [ev, ...args] = entry;
+            this.emit(ev, ...args);
+        }
+        else {
+            this[READENTRY] = entry;
+            this.emit('entry', entry);
+            if (!entry.emittedEnd) {
+                entry.on('end', () => this[NEXTENTRY]());
+                go = false;
+            }
+        }
+        return go;
+    }
+    [NEXTENTRY]() {
+        do { } while (this[PROCESSENTRY](this[QUEUE].shift()));
+        if (this[QUEUE].length === 0) {
+            // At this point, there's nothing in the queue, but we may have an
+            // entry which is being consumed (readEntry).
+            // If we don't, then we definitely can handle more data.
+            // If we do, and either it's flowing, or it has never had any data
+            // written to it, then it needs more.
+            // The only other possibility is that it has returned false from a
+            // write() call, so we wait for the next drain to continue.
+            const re = this[READENTRY];
+            const drainNow = !re || re.flowing || re.size === re.remain;
+            if (drainNow) {
+                if (!this[WRITING]) {
+                    this.emit('drain');
+                }
+            }
+            else {
+                re.once('drain', () => this.emit('drain'));
+            }
+        }
+    }
+    [CONSUMEBODY](chunk, position) {
+        // write up to but no  more than writeEntry.blockRemain
+        const entry = this[WRITEENTRY];
+        /* c8 ignore start */
+        if (!entry) {
+            throw new Error('attempt to consume body without entry??');
+        }
+        const br = entry.blockRemain ?? 0;
+        /* c8 ignore stop */
+        const c = br >= chunk.length && position === 0 ?
+            chunk
+            : chunk.subarray(position, position + br);
+        entry.write(c);
+        if (!entry.blockRemain) {
+            this[STATE] = 'header';
+            this[WRITEENTRY] = undefined;
+            entry.end();
+        }
+        return c.length;
+    }
+    [CONSUMEMETA](chunk, position) {
+        const entry = this[WRITEENTRY];
+        const ret = this[CONSUMEBODY](chunk, position);
+        // if we finished, then the entry is reset
+        if (!this[WRITEENTRY] && entry) {
+            this[EMITMETA](entry);
+        }
+        return ret;
+    }
+    [EMIT](ev, data, extra) {
+        if (this[QUEUE].length === 0 && !this[READENTRY]) {
+            this.emit(ev, data, extra);
+        }
+        else {
+            this[QUEUE].push([ev, data, extra]);
+        }
+    }
+    [EMITMETA](entry) {
+        this[EMIT]('meta', this[META]);
+        switch (entry.type) {
+            case 'ExtendedHeader':
+            case 'OldExtendedHeader':
+                this[EX] = Pax.parse(this[META], this[EX], false);
+                break;
+            case 'GlobalExtendedHeader':
+                this[GEX] = Pax.parse(this[META], this[GEX], true);
+                break;
+            case 'NextFileHasLongPath':
+            case 'OldGnuLongPath': {
+                const ex = this[EX] ?? Object.create(null);
+                this[EX] = ex;
+                ex.path = this[META].replace(/\0.*/, '');
+                break;
+            }
+            case 'NextFileHasLongLinkpath': {
+                const ex = this[EX] || Object.create(null);
+                this[EX] = ex;
+                ex.linkpath = this[META].replace(/\0.*/, '');
+                break;
+            }
+            /* c8 ignore start */
+            default:
+                throw new Error('unknown meta: ' + entry.type);
+            /* c8 ignore stop */
+        }
+    }
+    abort(error) {
+        if (this[ABORTED]) {
+            return;
+        }
+        if (this[UNZIP]) {
+            // fully nerf the decompressor and close its underlying binding
+            const u = this[UNZIP];
+            /* c8 ignore start */
+            u.write = () => true;
+            u.end = () => u;
+            u.emit = () => false;
+            /* c8 ignore stop */
+            u.destroy?.();
+        }
+        this[ABORTED] = true;
+        this.emit('abort', error);
+        // always throws, even in non-strict mode
+        this.warn('TAR_ABORT', error, { recoverable: false });
+    }
+    [CHECKDECOMPRESSIONRATIO](chunk) {
+        this[DECOMPRESSEDBYTESREAD] += chunk.length;
+        const ratio = this[DECOMPRESSEDBYTESREAD] / this[COMPRESSEDBYTESREAD];
+        if (ratio > this.maxDecompressionRatio) {
+            this.abort(new Error(`max decompression ratio exceeded: ${ratio.toFixed(2)} > ${this.maxDecompressionRatio}`));
+            return false;
+        }
+        return true;
+    }
+    write(chunk, encoding, cb) {
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, 
+            /* c8 ignore next */
+            typeof encoding === 'string' ? encoding : 'utf8');
+        }
+        if (this[ABORTED]) {
+            /* c8 ignore next */
+            cb?.();
+            return false;
+        }
+        // first write, might be gzipped, zstd, or brotli compressed
+        const needSniff = this[UNZIP] === undefined ||
+            (this.brotli === undefined && this[UNZIP] === false);
+        if (needSniff && chunk) {
+            if (this[BUFFER]) {
+                chunk = Buffer.concat([this[BUFFER], chunk]);
+                this[BUFFER] = undefined;
+            }
+            if (chunk.length < ZIP_HEADER_LEN) {
+                this[BUFFER] = chunk;
+                /* c8 ignore next */
+                cb?.();
+                return true;
+            }
+            // look for gzip header
+            for (let i = 0; this[UNZIP] === undefined && i < gzipHeader.length; i++) {
+                if (chunk[i] !== gzipHeader[i]) {
+                    this[UNZIP] = false;
+                }
+            }
+            // look for zstd header if gzip header not found
+            let isZstd = false;
+            if (this[UNZIP] === false && this.zstd !== false) {
+                isZstd = true;
+                for (let i = 0; i < zstdHeader.length; i++) {
+                    if (chunk[i] !== zstdHeader[i]) {
+                        isZstd = false;
+                        break;
+                    }
+                }
+            }
+            const maybeBrotli = this.brotli === undefined && !isZstd;
+            if (this[UNZIP] === false && maybeBrotli) {
+                // read the first header to see if it's a valid tar file. If so,
+                // we can safely assume that it's not actually brotli, despite the
+                // .tbr or .tar.br file extension.
+                // if we ended before getting a full chunk, yes, def brotli
+                if (chunk.length < 512) {
+                    if (this[ENDED]) {
+                        this.brotli = true;
+                    }
+                    else {
+                        this[BUFFER] = chunk;
+                        /* c8 ignore next */
+                        cb?.();
+                        return true;
+                    }
+                }
+                else {
+                    // if it's tar, it's pretty reliably not brotli, chances of
+                    // that happening are astronomical.
+                    try {
+                        new Header(chunk.subarray(0, 512));
+                        this.brotli = false;
+                    }
+                    catch (_) {
+                        this.brotli = true;
+                    }
+                }
+            }
+            if (this[UNZIP] === undefined ||
+                (this[UNZIP] === false && (this.brotli || isZstd))) {
+                const ended = this[ENDED];
+                this[ENDED] = false;
+                this[UNZIP] =
+                    this[UNZIP] === undefined ? new Unzip({})
+                        : isZstd ? new ZstdDecompress({})
+                            : new BrotliDecompress({});
+                this[UNZIP].on('data', chunk => {
+                    if (this[CHECKDECOMPRESSIONRATIO](chunk)) {
+                        this[CONSUMECHUNK](chunk);
+                    }
+                });
+                this[UNZIP].on('error', er => {
+                    if (!this[ABORTED]) {
+                        this.abort(er);
+                    }
+                });
+                this[UNZIP].on('end', () => {
+                    this[ENDED] = true;
+                    this[CONSUMECHUNK]();
+                });
+                this[WRITING] = true;
+                this[COMPRESSEDBYTESREAD] += chunk.length;
+                const ret = !!this[UNZIP][ended ? 'end' : 'write'](chunk);
+                this[WRITING] = false;
+                cb?.();
+                return ret;
+            }
+        }
+        this[WRITING] = true;
+        if (this[UNZIP]) {
+            this[COMPRESSEDBYTESREAD] += chunk.length;
+            this[UNZIP].write(chunk);
+        }
+        else {
+            this[CONSUMECHUNK](chunk);
+        }
+        this[WRITING] = false;
+        // return false if there's a queue, or if the current entry isn't flowing
+        const ret = this[QUEUE].length > 0 ? false
+            : this[READENTRY] ? this[READENTRY].flowing
+                : true;
+        // if we have no queue, then that means a clogged READENTRY
+        if (!ret && this[QUEUE].length === 0) {
+            this[READENTRY]?.once('drain', () => this.emit('drain'));
+        }
+        /* c8 ignore next */
+        cb?.();
+        return ret;
+    }
+    [BUFFERCONCAT](c) {
+        if (c && !this[ABORTED]) {
+            this[BUFFER] = this[BUFFER] ? Buffer.concat([this[BUFFER], c]) : c;
+        }
+    }
+    [MAYBEEND]() {
+        if (this[ENDED] &&
+            !this[EMITTEDEND] &&
+            !this[ABORTED] &&
+            !this[CONSUMING]) {
+            this[EMITTEDEND] = true;
+            const entry = this[WRITEENTRY];
+            if (entry?.blockRemain) {
+                // truncated, likely a damaged file
+                const have = this[BUFFER] ? this[BUFFER].length : 0;
+                this.warn('TAR_BAD_ARCHIVE', `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
+                if (this[BUFFER]) {
+                    entry.write(this[BUFFER]);
+                }
+                entry.end();
+            }
+            this[EMIT](DONE);
+        }
+    }
+    [CONSUMECHUNK](chunk) {
+        if (this[CONSUMING] && chunk) {
+            this[BUFFERCONCAT](chunk);
+        }
+        else if (!chunk && !this[BUFFER]) {
+            this[MAYBEEND]();
+        }
+        else if (chunk) {
+            this[CONSUMING] = true;
+            if (this[BUFFER]) {
+                this[BUFFERCONCAT](chunk);
+                const c = this[BUFFER];
+                this[BUFFER] = undefined;
+                this[CONSUMECHUNKSUB](c);
+            }
+            else {
+                this[CONSUMECHUNKSUB](chunk);
+            }
+            while (this[BUFFER] &&
+                this[BUFFER]?.length >= 512 &&
+                !this[ABORTED] &&
+                !this[SAW_EOF]) {
+                const c = this[BUFFER];
+                this[BUFFER] = undefined;
+                this[CONSUMECHUNKSUB](c);
+            }
+            this[CONSUMING] = false;
+        }
+        if (!this[BUFFER] || this[ENDED]) {
+            this[MAYBEEND]();
+        }
+    }
+    [CONSUMECHUNKSUB](chunk) {
+        // we know that we are in CONSUMING mode, so anything written goes into
+        // the buffer.  Advance the position and put any remainder in the buffer.
+        let position = 0;
+        const length = chunk.length;
+        while (position + 512 <= length && !this[ABORTED] && !this[SAW_EOF]) {
+            switch (this[STATE]) {
+                case 'begin':
+                case 'header':
+                    this[CONSUMEHEADER](chunk, position);
+                    position += 512;
+                    break;
+                case 'ignore':
+                case 'body':
+                    position += this[CONSUMEBODY](chunk, position);
+                    break;
+                case 'meta':
+                    position += this[CONSUMEMETA](chunk, position);
+                    break;
+                /* c8 ignore start */
+                default:
+                    throw new Error('invalid state: ' + this[STATE]);
+                /* c8 ignore stop */
+            }
+        }
+        if (position < length) {
+            this[BUFFER] =
+                this[BUFFER] ?
+                    Buffer.concat([chunk.subarray(position), this[BUFFER]])
+                    : chunk.subarray(position);
+        }
+    }
+    end(chunk, encoding, cb) {
+        if (typeof chunk === 'function') {
+            cb = chunk;
+            encoding = undefined;
+            chunk = undefined;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+        if (cb)
+            this.once('finish', cb);
+        if (!this[ABORTED]) {
+            if (this[UNZIP]) {
+                /* c8 ignore start */
+                if (chunk) {
+                    this[COMPRESSEDBYTESREAD] += chunk.length;
+                    this[UNZIP].write(chunk);
+                }
+                /* c8 ignore stop */
+                this[UNZIP].end();
+            }
+            else {
+                this[ENDED] = true;
+                if (this.brotli === undefined || this.zstd === undefined)
+                    chunk = chunk || Buffer.alloc(0);
+                if (chunk)
+                    this.write(chunk);
+                this[MAYBEEND]();
+            }
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=parse.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/path-reservations.d.ts b/node_modules/tar/dist/esm/path-reservations.d.ts
new file mode 100644
index 0000000..44f0482
--- /dev/null
+++ b/node_modules/tar/dist/esm/path-reservations.d.ts
@@ -0,0 +1,11 @@
+export type Reservation = {
+    paths: string[];
+    dirs: Set<string>;
+};
+export type Handler = (clear: () => void) => void;
+export declare class PathReservations {
+    #private;
+    reserve(paths: string[], fn: Handler): boolean;
+    check(fn: Handler): boolean;
+}
+//# sourceMappingURL=path-reservations.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/path-reservations.js b/node_modules/tar/dist/esm/path-reservations.js
new file mode 100644
index 0000000..117f6be
--- /dev/null
+++ b/node_modules/tar/dist/esm/path-reservations.js
@@ -0,0 +1,166 @@
+// A path exclusive reservation system
+// reserve([list, of, paths], fn)
+// When the fn is first in line for all its paths, it
+// is called with a cb that clears the reservation.
+//
+// Used by async unpack to avoid clobbering paths in use,
+// while still allowing maximal safe parallelization.
+import { join } from 'node:path';
+import { normalizeUnicode } from './normalize-unicode.js';
+import { stripTrailingSlashes } from './strip-trailing-slashes.js';
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+const isWindows = platform === 'win32';
+// return a set of parent dirs for a given path
+// '/a/b/c/d' -> ['/', '/a', '/a/b', '/a/b/c', '/a/b/c/d']
+const getDirs = (path) => {
+    const dirs = path
+        .split('/')
+        .slice(0, -1)
+        .reduce((set, path) => {
+        const s = set.at(-1);
+        if (s !== undefined) {
+            path = join(s, path);
+        }
+        set.push(path || '/');
+        return set;
+    }, []);
+    return dirs;
+};
+export class PathReservations {
+    // path => [function or Set]
+    // A Set object means a directory reservation
+    // A fn is a direct reservation on that path
+    #queues = new Map();
+    // fn => {paths:[path,...], dirs:[path, ...]}
+    #reservations = new Map();
+    // functions currently running
+    #running = new Set();
+    reserve(paths, fn) {
+        paths =
+            isWindows ?
+                ['win32 parallelization disabled']
+                : paths.map(p => {
+                    // don't need normPath, because we skip this entirely for windows
+                    return stripTrailingSlashes(join(normalizeUnicode(p)));
+                });
+        const dirs = new Set(paths.map(path => getDirs(path)).reduce((a, b) => a.concat(b)));
+        this.#reservations.set(fn, { dirs, paths });
+        for (const p of paths) {
+            const q = this.#queues.get(p);
+            if (!q) {
+                this.#queues.set(p, [fn]);
+            }
+            else {
+                q.push(fn);
+            }
+        }
+        for (const dir of dirs) {
+            const q = this.#queues.get(dir);
+            if (!q) {
+                this.#queues.set(dir, [new Set([fn])]);
+            }
+            else {
+                const l = q.at(-1);
+                if (l instanceof Set) {
+                    l.add(fn);
+                }
+                else {
+                    q.push(new Set([fn]));
+                }
+            }
+        }
+        return this.#run(fn);
+    }
+    // return the queues for each path the function cares about
+    // fn => {paths, dirs}
+    #getQueues(fn) {
+        const res = this.#reservations.get(fn);
+        /* c8 ignore start */
+        if (!res) {
+            throw new Error('function does not have any path reservations');
+        }
+        /* c8 ignore stop */
+        return {
+            paths: res.paths.map((path) => this.#queues.get(path)),
+            dirs: [...res.dirs].map(path => this.#queues.get(path)),
+        };
+    }
+    // check if fn is first in line for all its paths, and is
+    // included in the first set for all its dir queues
+    check(fn) {
+        const { paths, dirs } = this.#getQueues(fn);
+        return (paths.every(q => q && q[0] === fn) &&
+            dirs.every(q => q && q[0] instanceof Set && q[0].has(fn)));
+    }
+    // run the function if it's first in line and not already running
+    #run(fn) {
+        if (this.#running.has(fn) || !this.check(fn)) {
+            return false;
+        }
+        this.#running.add(fn);
+        fn(() => this.#clear(fn));
+        return true;
+    }
+    #clear(fn) {
+        if (!this.#running.has(fn)) {
+            return false;
+        }
+        const res = this.#reservations.get(fn);
+        /* c8 ignore start */
+        if (!res) {
+            throw new Error('invalid reservation');
+        }
+        /* c8 ignore stop */
+        const { paths, dirs } = res;
+        const next = new Set();
+        for (const path of paths) {
+            const q = this.#queues.get(path);
+            /* c8 ignore start */
+            if (!q || q?.[0] !== fn) {
+                continue;
+            }
+            /* c8 ignore stop */
+            const q0 = q[1];
+            if (!q0) {
+                this.#queues.delete(path);
+                continue;
+            }
+            q.shift();
+            if (typeof q0 === 'function') {
+                next.add(q0);
+            }
+            else {
+                for (const f of q0) {
+                    next.add(f);
+                }
+            }
+        }
+        for (const dir of dirs) {
+            const q = this.#queues.get(dir);
+            const q0 = q?.[0];
+            /* c8 ignore next - type safety only */
+            if (!q || !(q0 instanceof Set))
+                continue;
+            if (q0.size === 1 && q.length === 1) {
+                this.#queues.delete(dir);
+                continue;
+            }
+            else if (q0.size === 1) {
+                q.shift();
+                // next one must be a function,
+                // or else the Set would've been reused
+                const n = q[0];
+                if (typeof n === 'function') {
+                    next.add(n);
+                }
+            }
+            else {
+                q0.delete(fn);
+            }
+        }
+        this.#running.delete(fn);
+        next.forEach(fn => this.#run(fn));
+        return true;
+    }
+}
+//# sourceMappingURL=path-reservations.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/pax.d.ts b/node_modules/tar/dist/esm/pax.d.ts
new file mode 100644
index 0000000..a4913c7
--- /dev/null
+++ b/node_modules/tar/dist/esm/pax.d.ts
@@ -0,0 +1,26 @@
+import type { HeaderData } from './header.js';
+export declare class Pax implements HeaderData {
+    atime?: Date;
+    mtime?: Date;
+    ctime?: Date;
+    charset?: string;
+    comment?: string;
+    gid?: number;
+    uid?: number;
+    gname?: string;
+    uname?: string;
+    linkpath?: string;
+    dev?: number;
+    ino?: number;
+    nlink?: number;
+    path?: string;
+    size?: number;
+    mode?: number;
+    global: boolean;
+    constructor(obj: HeaderData, global?: boolean);
+    encode(): Buffer<ArrayBuffer>;
+    encodeBody(): string;
+    encodeField(field: keyof Pax): string;
+    static parse(str: string, ex?: HeaderData, g?: boolean): Pax;
+}
+//# sourceMappingURL=pax.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/pax.js b/node_modules/tar/dist/esm/pax.js
new file mode 100644
index 0000000..907193a
--- /dev/null
+++ b/node_modules/tar/dist/esm/pax.js
@@ -0,0 +1,178 @@
+import { basename } from 'node:path';
+import { Header } from './header.js';
+export class Pax {
+    atime;
+    mtime;
+    ctime;
+    charset;
+    comment;
+    gid;
+    uid;
+    gname;
+    uname;
+    linkpath;
+    dev;
+    ino;
+    nlink;
+    path;
+    size;
+    mode;
+    global;
+    constructor(obj, global = false) {
+        this.atime = obj.atime;
+        this.charset = obj.charset;
+        this.comment = obj.comment;
+        this.ctime = obj.ctime;
+        this.dev = obj.dev;
+        this.gid = obj.gid;
+        this.global = global;
+        this.gname = obj.gname;
+        this.ino = obj.ino;
+        this.linkpath = obj.linkpath;
+        this.mtime = obj.mtime;
+        this.nlink = obj.nlink;
+        this.path = obj.path;
+        this.size = obj.size;
+        this.uid = obj.uid;
+        this.uname = obj.uname;
+    }
+    encode() {
+        const body = this.encodeBody();
+        if (body === '') {
+            return Buffer.allocUnsafe(0);
+        }
+        const bodyLen = Buffer.byteLength(body);
+        // round up to 512 bytes
+        // add 512 for header
+        const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+        const buf = Buffer.allocUnsafe(bufLen);
+        // 0-fill the header section, it might not hit every field
+        for (let i = 0; i < 512; i++) {
+            buf[i] = 0;
+        }
+        new Header({
+            // XXX split the path
+            // then the path should be PaxHeader + basename, but less than 99,
+            // prepend with the dirname
+            /* c8 ignore start */
+            path: ('PaxHeader/' + basename(this.path ?? '')).slice(0, 99),
+            /* c8 ignore stop */
+            mode: this.mode || 0o644,
+            uid: this.uid,
+            gid: this.gid,
+            size: bodyLen,
+            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(buf);
+        buf.write(body, 512, bodyLen, 'utf8');
+        // null pad after the body
+        for (let i = bodyLen + 512; i < buf.length; i++) {
+            buf[i] = 0;
+        }
+        return buf;
+    }
+    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(field) {
+        if (this[field] === undefined) {
+            return '';
+        }
+        const r = this[field];
+        const v = r instanceof Date ? r.getTime() / 1000 : r;
+        const s = ' ' +
+            (field === 'dev' || field === 'ino' || field === 'nlink' ?
+                'SCHILY.'
+                : '') +
+            field +
+            '=' +
+            v +
+            '\n';
+        const byteLen = Buffer.byteLength(s);
+        // the digits includes the length of the digits in ascii base-10
+        // so if it's 9 characters, then adding 1 for the 9 makes it 10
+        // which makes it 11 chars.
+        let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+        if (byteLen + digits >= Math.pow(10, digits)) {
+            digits += 1;
+        }
+        const len = digits + byteLen;
+        return len + s;
+    }
+    static parse(str, ex, g = false) {
+        return new Pax(merge(parseKV(str), ex), g);
+    }
+}
+const merge = (a, b) => b ? Object.assign({}, b, a) : a;
+const parseKV = (str) => str
+    .replace(/\n$/, '')
+    .split('\n')
+    .reduce(parseKVLine, Object.create(null));
+const parseKVLine = (set, line) => {
+    const n = parseInt(line, 10);
+    // XXX Values with \n in them will fail this.
+    // Refactor to not be a naive line-by-line parse.
+    if (n !== Buffer.byteLength(line) + 1) {
+        return set;
+    }
+    line = line.slice((n + ' ').length);
+    const kv = line.split('=');
+    const r = kv.shift();
+    if (!r) {
+        return set;
+    }
+    const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, '$1');
+    const v = kv.join('=').replace(/\0.*/, '');
+    switch (k) {
+        case 'path':
+        case 'linkpath':
+        case 'type':
+        case 'charset':
+        case 'comment':
+        case 'gname':
+        case 'uname':
+            set[k] = v;
+            break;
+        case 'ctime':
+        case 'atime':
+        case 'mtime':
+            set[k] = new Date(Number(v) * 1000);
+            break;
+        case 'size':
+            const s = +v;
+            if (s >= 0)
+                set[k] = s;
+            break;
+        case 'gid':
+        case 'uid':
+        case 'dev':
+        case 'ino':
+        case 'nlink':
+        case 'mode':
+            set[k] = +v;
+            break;
+    }
+    return set;
+};
+//# sourceMappingURL=pax.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/process-umask.d.ts b/node_modules/tar/dist/esm/process-umask.d.ts
new file mode 100644
index 0000000..abde1b6
--- /dev/null
+++ b/node_modules/tar/dist/esm/process-umask.d.ts
@@ -0,0 +1,2 @@
+export declare const umask: () => number;
+//# sourceMappingURL=process-umask.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/process-umask.js b/node_modules/tar/dist/esm/process-umask.js
new file mode 100644
index 0000000..c6748e2
--- /dev/null
+++ b/node_modules/tar/dist/esm/process-umask.js
@@ -0,0 +1,3 @@
+// separate file so I stop getting nagged in vim about deprecated API.
+export const umask = () => process.umask();
+//# sourceMappingURL=process-umask.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/read-entry.d.ts b/node_modules/tar/dist/esm/read-entry.d.ts
new file mode 100644
index 0000000..6376739
--- /dev/null
+++ b/node_modules/tar/dist/esm/read-entry.d.ts
@@ -0,0 +1,36 @@
+import { Minipass } from 'minipass';
+import type { Header } from './header.js';
+import type { Pax } from './pax.js';
+import type { EntryTypeName } from './types.js';
+export declare class ReadEntry extends Minipass<Buffer, Buffer> {
+    #private;
+    extended?: Pax;
+    globalExtended?: Pax;
+    header: Header;
+    startBlockSize: number;
+    blockRemain: number;
+    remain: number;
+    type: EntryTypeName;
+    meta: boolean;
+    ignore: boolean;
+    path: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    uname?: string;
+    gname?: string;
+    size: number;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    linkpath?: string;
+    dev?: number;
+    ino?: number;
+    nlink?: number;
+    invalid: boolean;
+    absolute?: string;
+    unsupported: boolean;
+    constructor(header: Header, ex?: Pax, gex?: Pax);
+    write(data: Buffer): boolean;
+}
+//# sourceMappingURL=read-entry.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/read-entry.js b/node_modules/tar/dist/esm/read-entry.js
new file mode 100644
index 0000000..ef11b01
--- /dev/null
+++ b/node_modules/tar/dist/esm/read-entry.js
@@ -0,0 +1,132 @@
+import { Minipass } from 'minipass';
+import { normalizeWindowsPath } from './normalize-windows-path.js';
+export class ReadEntry extends Minipass {
+    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(header, ex, gex) {
+        super({});
+        // read entries always start life paused.  this is to avoid the
+        // situation where Minipass's auto-ending empty streams results
+        // in an entry ending before we're ready for it.
+        this.pause();
+        this.extended = ex;
+        this.globalExtended = gex;
+        this.header = header;
+        /* c8 ignore start */
+        this.remain = header.size ?? 0;
+        /* c8 ignore stop */
+        this.startBlockSize = 512 * Math.ceil(this.remain / 512);
+        this.blockRemain = this.startBlockSize;
+        this.type = header.type;
+        switch (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;
+            // NOTE: gnutar and bsdtar treat unrecognized types as 'File'
+            // it may be worth doing the same, but with a warning.
+            default:
+                this.ignore = true;
+        }
+        /* c8 ignore start */
+        if (!header.path) {
+            throw new Error('no path provided for tar.ReadEntry');
+        }
+        /* c8 ignore stop */
+        this.path = normalizeWindowsPath(header.path);
+        this.mode = header.mode;
+        if (this.mode) {
+            this.mode = this.mode & 0o7777;
+        }
+        this.uid = header.uid;
+        this.gid = header.gid;
+        this.uname = header.uname;
+        this.gname = header.gname;
+        this.size = this.remain;
+        this.mtime = header.mtime;
+        this.atime = header.atime;
+        this.ctime = header.ctime;
+        /* c8 ignore start */
+        this.linkpath =
+            header.linkpath ? normalizeWindowsPath(header.linkpath) : undefined;
+        /* c8 ignore stop */
+        this.uname = header.uname;
+        this.gname = header.gname;
+        if (ex) {
+            this.#slurp(ex);
+        }
+        if (gex) {
+            this.#slurp(gex, true);
+        }
+    }
+    write(data) {
+        const writeLen = data.length;
+        if (writeLen > this.blockRemain) {
+            throw new Error('writing more to entry than is appropriate');
+        }
+        const r = this.remain;
+        const br = this.blockRemain;
+        this.remain = Math.max(0, r - writeLen);
+        this.blockRemain = Math.max(0, br - writeLen);
+        if (this.ignore) {
+            return true;
+        }
+        if (r >= writeLen) {
+            return super.write(data);
+        }
+        // r < writeLen
+        return super.write(data.subarray(0, r));
+    }
+    #slurp(ex, gex = false) {
+        if (ex.path)
+            ex.path = normalizeWindowsPath(ex.path);
+        if (ex.linkpath)
+            ex.linkpath = normalizeWindowsPath(ex.linkpath);
+        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+            // we slurp in everything except for the path attribute in
+            // a global extended header, because that's weird. Also, any
+            // null/undefined values are ignored.
+            return !(v === null || v === undefined || (k === 'path' && gex));
+        })));
+    }
+}
+//# sourceMappingURL=read-entry.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/replace.d.ts b/node_modules/tar/dist/esm/replace.d.ts
new file mode 100644
index 0000000..8ae4035
--- /dev/null
+++ b/node_modules/tar/dist/esm/replace.d.ts
@@ -0,0 +1,2 @@
+export declare const replace: import("./make-command.js").TarCommand<never, never>;
+//# sourceMappingURL=replace.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/replace.js b/node_modules/tar/dist/esm/replace.js
new file mode 100644
index 0000000..77c878a
--- /dev/null
+++ b/node_modules/tar/dist/esm/replace.js
@@ -0,0 +1,221 @@
+// tar -r
+import { WriteStream, WriteStreamSync } from '@isaacs/fs-minipass';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Header } from './header.js';
+import { list } from './list.js';
+import { makeCommand } from './make-command.js';
+import { isFile } from './options.js';
+import { Pack, PackSync } from './pack.js';
+// starting at the head of the file, read a Header
+// If the checksum is invalid, that's our position to start writing
+// If it is, jump forward by the specified size (round up to 512)
+// and try again.
+// Write the new Pack stream starting there.
+const replaceSync = (opt, files) => {
+    const p = new PackSync(opt);
+    let threw = true;
+    let fd;
+    let position;
+    try {
+        try {
+            fd = fs.openSync(opt.file, 'r+');
+        }
+        catch (er) {
+            if (er?.code === 'ENOENT') {
+                fd = fs.openSync(opt.file, 'w+');
+            }
+            else {
+                throw er;
+            }
+        }
+        const st = fs.fstatSync(fd);
+        const headBuf = Buffer.alloc(512);
+        POSITION: for (position = 0; position < st.size; position += 512) {
+            for (let bufPos = 0, bytes = 0; bufPos < 512; bufPos += bytes) {
+                bytes = fs.readSync(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos);
+                if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) {
+                    throw new Error('cannot append to compressed archives');
+                }
+                if (!bytes) {
+                    break POSITION;
+                }
+            }
+            const h = new Header(headBuf);
+            if (!h.cksumValid) {
+                break;
+            }
+            const entryBlockSize = 512 * Math.ceil((h.size || 0) / 512);
+            if (position + entryBlockSize + 512 > st.size) {
+                break;
+            }
+            // the 512 for the header we just parsed will be added as well
+            // also jump ahead all the blocks for the body
+            position += entryBlockSize;
+            if (opt.mtimeCache && h.mtime) {
+                opt.mtimeCache.set(String(h.path), h.mtime);
+            }
+        }
+        threw = false;
+        streamSync(opt, p, position, fd, files);
+    }
+    finally {
+        if (threw) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+        }
+    }
+};
+const streamSync = (opt, p, position, fd, files) => {
+    const stream = new WriteStreamSync(opt.file, {
+        fd: fd,
+        start: position,
+    });
+    p.pipe(stream);
+    addFilesSync(p, files);
+};
+const replaceAsync = (opt, files) => {
+    files = Array.from(files);
+    const p = new Pack(opt);
+    const getPos = (fd, size, cb_) => {
+        const cb = (er, pos) => {
+            if (er) {
+                fs.close(fd, _ => cb_(er));
+            }
+            else {
+                cb_(null, pos);
+            }
+        };
+        let position = 0;
+        if (size === 0) {
+            return cb(null, 0);
+        }
+        let bufPos = 0;
+        const headBuf = Buffer.alloc(512);
+        const onread = (er, bytes) => {
+            if (er || bytes === undefined) {
+                return cb(er);
+            }
+            bufPos += bytes;
+            if (bufPos < 512 && bytes) {
+                return fs.read(fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos, onread);
+            }
+            if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) {
+                return cb(new Error('cannot append to compressed archives'));
+            }
+            // truncated header
+            if (bufPos < 512) {
+                return cb(null, position);
+            }
+            const h = new Header(headBuf);
+            if (!h.cksumValid) {
+                return cb(null, position);
+            }
+            /* c8 ignore next */
+            const entryBlockSize = 512 * Math.ceil((h.size ?? 0) / 512);
+            if (position + entryBlockSize + 512 > size) {
+                return cb(null, position);
+            }
+            position += entryBlockSize + 512;
+            if (position >= size) {
+                return cb(null, position);
+            }
+            if (opt.mtimeCache && h.mtime) {
+                opt.mtimeCache.set(String(h.path), h.mtime);
+            }
+            bufPos = 0;
+            fs.read(fd, headBuf, 0, 512, position, onread);
+        };
+        fs.read(fd, headBuf, 0, 512, position, onread);
+    };
+    const promise = new Promise((resolve, reject) => {
+        p.on('error', reject);
+        let flag = 'r+';
+        const onopen = (er, fd) => {
+            if (er && er.code === 'ENOENT' && flag === 'r+') {
+                flag = 'w+';
+                return fs.open(opt.file, flag, onopen);
+            }
+            if (er || !fd) {
+                return reject(er);
+            }
+            fs.fstat(fd, (er, st) => {
+                if (er) {
+                    return fs.close(fd, () => reject(er));
+                }
+                getPos(fd, st.size, (er, position) => {
+                    if (er) {
+                        return reject(er);
+                    }
+                    const stream = new WriteStream(opt.file, {
+                        fd: fd,
+                        start: position,
+                    });
+                    p.pipe(stream);
+                    stream.on('error', reject);
+                    stream.on('close', resolve);
+                    addFilesAsync(p, files);
+                });
+            });
+        };
+        fs.open(opt.file, flag, onopen);
+    });
+    return promise;
+};
+const addFilesSync = (p, files) => {
+    files.forEach(file => {
+        if (file.charAt(0) === '@') {
+            list({
+                file: path.resolve(p.cwd, file.slice(1)),
+                sync: true,
+                noResume: true,
+                onReadEntry: entry => p.add(entry),
+            });
+        }
+        else {
+            p.add(file);
+        }
+    });
+    p.end();
+};
+const addFilesAsync = async (p, files) => {
+    for (const file of files) {
+        if (file.charAt(0) === '@') {
+            await list({
+                file: path.resolve(String(p.cwd), file.slice(1)),
+                noResume: true,
+                onReadEntry: entry => p.add(entry),
+            });
+        }
+        else {
+            p.add(file);
+        }
+    }
+    p.end();
+};
+export const replace = makeCommand(replaceSync, replaceAsync, 
+/* c8 ignore start */
+() => {
+    throw new TypeError('file is required');
+}, () => {
+    throw new TypeError('file is required');
+}, 
+/* c8 ignore stop */
+(opt, entries) => {
+    if (!isFile(opt)) {
+        throw new TypeError('file is required');
+    }
+    if (opt.gzip ||
+        opt.brotli ||
+        opt.zstd ||
+        opt.file.endsWith('.br') ||
+        opt.file.endsWith('.tbr')) {
+        throw new TypeError('cannot append to compressed archives');
+    }
+    if (!entries?.length) {
+        throw new TypeError('no paths specified to add/replace');
+    }
+});
+//# sourceMappingURL=replace.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/strip-absolute-path.d.ts b/node_modules/tar/dist/esm/strip-absolute-path.d.ts
new file mode 100644
index 0000000..f355a58
--- /dev/null
+++ b/node_modules/tar/dist/esm/strip-absolute-path.d.ts
@@ -0,0 +1,2 @@
+export declare const stripAbsolutePath: (path: string) => [string, string];
+//# sourceMappingURL=strip-absolute-path.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/strip-absolute-path.js b/node_modules/tar/dist/esm/strip-absolute-path.js
new file mode 100644
index 0000000..cce5ff8
--- /dev/null
+++ b/node_modules/tar/dist/esm/strip-absolute-path.js
@@ -0,0 +1,25 @@
+// unix absolute paths are also absolute on win32, so we use this for both
+import { win32 } from 'node:path';
+const { isAbsolute, parse } = win32;
+// returns [root, stripped]
+// Note that windows will think that //x/y/z/a has a "root" of //x/y, and in
+// those cases, we want to sanitize it to x/y/z/a, not z/a, so we strip /
+// explicitly if it's the first character.
+// drive-specific relative paths on Windows get their root stripped off even
+// though they are not absolute, so `c:../foo` becomes ['c:', '../foo']
+export const stripAbsolutePath = (path) => {
+    let r = '';
+    let parsed = parse(path);
+    while (isAbsolute(path) || parsed.root) {
+        // windows will think that //x/y/z has a "root" of //x/y/
+        // but strip the //?/C:/ off of //?/C:/path
+        const root = path.charAt(0) === '/' && path.slice(0, 4) !== '//?/' ?
+            '/'
+            : parsed.root;
+        path = path.slice(root.length);
+        r += root;
+        parsed = parse(path);
+    }
+    return [r, path];
+};
+//# sourceMappingURL=strip-absolute-path.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/strip-trailing-slashes.d.ts b/node_modules/tar/dist/esm/strip-trailing-slashes.d.ts
new file mode 100644
index 0000000..dcc4637
--- /dev/null
+++ b/node_modules/tar/dist/esm/strip-trailing-slashes.d.ts
@@ -0,0 +1,2 @@
+export declare const stripTrailingSlashes: (str: string) => string;
+//# sourceMappingURL=strip-trailing-slashes.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/strip-trailing-slashes.js b/node_modules/tar/dist/esm/strip-trailing-slashes.js
new file mode 100644
index 0000000..ace4218
--- /dev/null
+++ b/node_modules/tar/dist/esm/strip-trailing-slashes.js
@@ -0,0 +1,14 @@
+// warning: extremely hot code path.
+// This has been meticulously optimized for use
+// within npm install on large package trees.
+// Do not edit without careful benchmarking.
+export const stripTrailingSlashes = (str) => {
+    let i = str.length - 1;
+    let slashesStart = -1;
+    while (i > -1 && str.charAt(i) === '/') {
+        slashesStart = i;
+        i--;
+    }
+    return slashesStart === -1 ? str : str.slice(0, slashesStart);
+};
+//# sourceMappingURL=strip-trailing-slashes.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/symlink-error.d.ts b/node_modules/tar/dist/esm/symlink-error.d.ts
new file mode 100644
index 0000000..849b43d
--- /dev/null
+++ b/node_modules/tar/dist/esm/symlink-error.d.ts
@@ -0,0 +1,9 @@
+export declare class SymlinkError extends Error {
+    path: string;
+    symlink: string;
+    syscall: "symlink";
+    code: "TAR_SYMLINK_ERROR";
+    constructor(symlink: string, path: string);
+    get name(): string;
+}
+//# sourceMappingURL=symlink-error.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/symlink-error.js b/node_modules/tar/dist/esm/symlink-error.js
new file mode 100644
index 0000000..d31766e
--- /dev/null
+++ b/node_modules/tar/dist/esm/symlink-error.js
@@ -0,0 +1,15 @@
+export class SymlinkError extends Error {
+    path;
+    symlink;
+    syscall = 'symlink';
+    code = 'TAR_SYMLINK_ERROR';
+    constructor(symlink, path) {
+        super('TAR_SYMLINK_ERROR: Cannot extract through symbolic link');
+        this.symlink = symlink;
+        this.path = path;
+    }
+    get name() {
+        return 'SymlinkError';
+    }
+}
+//# sourceMappingURL=symlink-error.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/types.d.ts b/node_modules/tar/dist/esm/types.d.ts
new file mode 100644
index 0000000..578669a
--- /dev/null
+++ b/node_modules/tar/dist/esm/types.d.ts
@@ -0,0 +1,16 @@
+export declare const isCode: (c: string) => c is EntryTypeCode;
+export declare const isName: (c: string) => c is EntryTypeName;
+export type EntryTypeCode = '0' | '' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | 'g' | 'x' | 'A' | 'D' | 'I' | 'K' | 'L' | 'M' | 'N' | 'S' | 'V' | 'X';
+export type EntryTypeName = 'File' | 'OldFile' | 'Link' | 'SymbolicLink' | 'CharacterDevice' | 'BlockDevice' | 'Directory' | 'FIFO' | 'ContiguousFile' | 'GlobalExtendedHeader' | 'ExtendedHeader' | 'SolarisACL' | 'GNUDumpDir' | 'Inode' | 'NextFileHasLongLinkpath' | 'NextFileHasLongPath' | 'ContinuationFile' | 'OldGnuLongPath' | 'SparseFile' | 'TapeVolumeHeader' | 'OldExtendedHeader' | 'Unsupported';
+/**
+ * types that are a normal file system entry, not metadata.
+ *
+ * These can be the subject of extended/globalExtended headers, long path
+ * names, long linkpath names, etc.
+ *
+ * Any other types are meta, and cannot be targetted by extended PAX headers.
+ */
+export declare const normalFsTypes: Set<EntryTypeCode>;
+export declare const name: Map<EntryTypeCode, EntryTypeName>;
+export declare const code: Map<EntryTypeName, EntryTypeCode>;
+//# sourceMappingURL=types.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/types.js b/node_modules/tar/dist/esm/types.js
new file mode 100644
index 0000000..c33a6a4
--- /dev/null
+++ b/node_modules/tar/dist/esm/types.js
@@ -0,0 +1,65 @@
+export const isCode = (c) => name.has(c);
+export const isName = (c) => code.has(c);
+/**
+ * types that are a normal file system entry, not metadata.
+ *
+ * These can be the subject of extended/globalExtended headers, long path
+ * names, long linkpath names, etc.
+ *
+ * Any other types are meta, and cannot be targetted by extended PAX headers.
+ */
+export const normalFsTypes = new Set([
+    '0',
+    '',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    'D',
+]);
+// map types from key to human-friendly name
+export const name = new Map([
+    ['0', 'File'],
+    // same as File
+    ['', 'OldFile'],
+    ['1', 'Link'],
+    ['2', 'SymbolicLink'],
+    // Devices and FIFOs aren't fully supported
+    // they are parsed, but skipped when unpacking
+    ['3', 'CharacterDevice'],
+    ['4', 'BlockDevice'],
+    ['5', 'Directory'],
+    ['6', 'FIFO'],
+    // same as File
+    ['7', 'ContiguousFile'],
+    // pax headers
+    ['g', 'GlobalExtendedHeader'],
+    ['x', 'ExtendedHeader'],
+    // vendor-specific stuff
+    // skip
+    ['A', 'SolarisACL'],
+    // like 5, but with data, which should be skipped
+    ['D', 'GNUDumpDir'],
+    // metadata only, skip
+    ['I', 'Inode'],
+    // data = link path of next file
+    ['K', 'NextFileHasLongLinkpath'],
+    // data = path of next file
+    ['L', 'NextFileHasLongPath'],
+    // skip
+    ['M', 'ContinuationFile'],
+    // like L
+    ['N', 'OldGnuLongPath'],
+    // skip
+    ['S', 'SparseFile'],
+    // skip
+    ['V', 'TapeVolumeHeader'],
+    // like x
+    ['X', 'OldExtendedHeader'],
+]);
+// map the other direction
+export const code = new Map(Array.from(name).map(kv => [kv[1], kv[0]]));
+//# sourceMappingURL=types.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/unpack.d.ts b/node_modules/tar/dist/esm/unpack.d.ts
new file mode 100644
index 0000000..bdb9cc2
--- /dev/null
+++ b/node_modules/tar/dist/esm/unpack.d.ts
@@ -0,0 +1,101 @@
+import { type Stats } from 'node:fs';
+import type { MkdirError } from './mkdir.js';
+import { Parser } from './parse.js';
+import type { TarOptions } from './options.js';
+import { PathReservations } from './path-reservations.js';
+import type { ReadEntry } from './read-entry.js';
+import type { WarnData } from './warn-method.js';
+import { SymlinkError } from './symlink-error.js';
+declare const ONENTRY: unique symbol;
+declare const CHECKFS: unique symbol;
+declare const CHECKFS2: unique symbol;
+declare const ISREUSABLE: unique symbol;
+declare const MAKEFS: unique symbol;
+declare const FILE: unique symbol;
+declare const DIRECTORY: unique symbol;
+declare const LINK: unique symbol;
+declare const SYMLINK: unique symbol;
+declare const HARDLINK: unique symbol;
+declare const ENSURE_NO_SYMLINK: unique symbol;
+declare const UNSUPPORTED: unique symbol;
+declare const CHECKPATH: unique symbol;
+declare const STRIPABSOLUTEPATH: unique symbol;
+declare const MKDIR: unique symbol;
+declare const ONERROR: unique symbol;
+declare const PENDING: unique symbol;
+declare const PEND: unique symbol;
+declare const UNPEND: unique symbol;
+declare const ENDED: unique symbol;
+declare const MAYBECLOSE: unique symbol;
+declare const SKIP: unique symbol;
+declare const DOCHOWN: unique symbol;
+declare const UID: unique symbol;
+declare const GID: unique symbol;
+declare const CHECKED_CWD: unique symbol;
+export declare class Unpack extends Parser {
+    [ENDED]: boolean;
+    [CHECKED_CWD]: boolean;
+    [PENDING]: number;
+    reservations: PathReservations;
+    transform?: TarOptions['transform'];
+    writable: true;
+    readable: false;
+    uid?: number;
+    gid?: number;
+    setOwner: boolean;
+    preserveOwner: boolean;
+    processGid?: number;
+    processUid?: number;
+    maxDepth: number;
+    forceChown: boolean;
+    win32: boolean;
+    newer: boolean;
+    keep: boolean;
+    noMtime: boolean;
+    preservePaths: boolean;
+    unlink: boolean;
+    cwd: string;
+    strip: number;
+    processUmask: number;
+    umask: number;
+    dmode: number;
+    fmode: number;
+    chmod: boolean;
+    constructor(opt?: TarOptions);
+    warn(code: string, msg: string | Error, data?: WarnData): void;
+    [MAYBECLOSE](): void;
+    [STRIPABSOLUTEPATH](entry: ReadEntry, field: 'path' | 'linkpath'): boolean;
+    [CHECKPATH](entry: ReadEntry): boolean;
+    [ONENTRY](entry: ReadEntry): void;
+    [ONERROR](er: Error, entry: ReadEntry): void;
+    [MKDIR](dir: string, mode: number, cb: (er?: null | MkdirError, made?: string) => void): void;
+    [DOCHOWN](entry: ReadEntry): boolean;
+    [UID](entry: ReadEntry): number | undefined;
+    [GID](entry: ReadEntry): number | undefined;
+    [FILE](entry: ReadEntry, fullyDone: () => void): void;
+    [DIRECTORY](entry: ReadEntry, fullyDone: () => void): void;
+    [UNSUPPORTED](entry: ReadEntry): void;
+    [SYMLINK](entry: ReadEntry, done: () => void): void;
+    [HARDLINK](entry: ReadEntry, done: () => void): void;
+    [ENSURE_NO_SYMLINK](entry: ReadEntry, cwd: string, parts: string[], done: () => void, onError: (er: SymlinkError) => void): void;
+    [PEND](): void;
+    [UNPEND](): void;
+    [SKIP](entry: ReadEntry): void;
+    [ISREUSABLE](entry: ReadEntry, st: Stats): boolean;
+    [CHECKFS](entry: ReadEntry): void;
+    [CHECKFS2](entry: ReadEntry, fullyDone: (er?: Error) => void): void;
+    [MAKEFS](er: null | undefined | Error, entry: ReadEntry, done: () => void): void;
+    [LINK](entry: ReadEntry, linkpath: string, link: 'link' | 'symlink', done: () => void): void;
+}
+export declare class UnpackSync extends Unpack {
+    sync: true;
+    [MAKEFS](er: null | Error | undefined, entry: ReadEntry): void;
+    [CHECKFS](entry: ReadEntry): void;
+    [FILE](entry: ReadEntry, done: () => void): void;
+    [DIRECTORY](entry: ReadEntry, done: () => void): void;
+    [MKDIR](dir: string, mode: number): unknown;
+    [ENSURE_NO_SYMLINK](_entry: ReadEntry, cwd: string, parts: string[], done: () => void, onError: (er: SymlinkError) => void): void;
+    [LINK](entry: ReadEntry, linkpath: string, link: 'link' | 'symlink', done: () => void): void;
+}
+export {};
+//# sourceMappingURL=unpack.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/unpack.js b/node_modules/tar/dist/esm/unpack.js
new file mode 100644
index 0000000..3bbdad9
--- /dev/null
+++ b/node_modules/tar/dist/esm/unpack.js
@@ -0,0 +1,891 @@
+// the PEND/UNPEND stuff tracks whether we're ready to emit end/close yet.
+// but the path reservations are required to avoid race conditions where
+// parallelized unpack ops may mess with one another, due to dependencies
+// (like a Link depending on its target) or destructive operations (like
+// clobbering an fs object to create one of a different type.)
+import * as fsm from '@isaacs/fs-minipass';
+import assert from 'node:assert';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getWriteFlag } from './get-write-flag.js';
+import { mkdir, mkdirSync } from './mkdir.js';
+import { normalizeWindowsPath } from './normalize-windows-path.js';
+import { Parser } from './parse.js';
+import { stripAbsolutePath } from './strip-absolute-path.js';
+import * as wc from './winchars.js';
+import { PathReservations } from './path-reservations.js';
+import { SymlinkError } from './symlink-error.js';
+import { umask } from './process-umask.js';
+const ONENTRY = Symbol('onEntry');
+const CHECKFS = Symbol('checkFs');
+const CHECKFS2 = Symbol('checkFs2');
+const ISREUSABLE = Symbol('isReusable');
+const MAKEFS = Symbol('makeFs');
+const FILE = Symbol('file');
+const DIRECTORY = Symbol('directory');
+const LINK = Symbol('link');
+const SYMLINK = Symbol('symlink');
+const HARDLINK = Symbol('hardlink');
+const ENSURE_NO_SYMLINK = Symbol('ensureNoSymlink');
+const UNSUPPORTED = Symbol('unsupported');
+const CHECKPATH = Symbol('checkPath');
+const STRIPABSOLUTEPATH = Symbol('stripAbsolutePath');
+const MKDIR = Symbol('mkdir');
+const ONERROR = Symbol('onError');
+const PENDING = Symbol('pending');
+const PEND = Symbol('pend');
+const UNPEND = Symbol('unpend');
+const ENDED = Symbol('ended');
+const MAYBECLOSE = Symbol('maybeClose');
+const SKIP = Symbol('skip');
+const DOCHOWN = Symbol('doChown');
+const UID = Symbol('uid');
+const GID = Symbol('gid');
+const CHECKED_CWD = Symbol('checkedCwd');
+const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+const isWindows = platform === 'win32';
+const DEFAULT_MAX_DEPTH = 1024;
+// Unlinks on Windows are not atomic.
+//
+// This means that if you have a file entry, followed by another
+// file entry with an identical name, and you cannot re-use the file
+// (because it's a hardlink, or because unlink:true is set, or it's
+// Windows, which does not have useful nlink values), then the unlink
+// will be committed to the disk AFTER the new file has been written
+// over the old one, deleting the new file.
+//
+// To work around this, on Windows systems, we rename the file and then
+// delete the renamed file.  It's a sloppy kludge, but frankly, I do not
+// know of a better way to do this, given windows' non-atomic unlink
+// semantics.
+//
+// See: https://github.com/npm/node-tar/issues/183
+/* c8 ignore start */
+const unlinkFile = (path, cb) => {
+    if (!isWindows) {
+        return fs.unlink(path, cb);
+    }
+    const name = path + '.DELETE.' + randomBytes(16).toString('hex');
+    fs.rename(path, name, er => {
+        if (er) {
+            return cb(er);
+        }
+        fs.unlink(name, cb);
+    });
+};
+/* c8 ignore stop */
+/* c8 ignore start */
+const unlinkFileSync = (path) => {
+    if (!isWindows) {
+        return fs.unlinkSync(path);
+    }
+    const name = path + '.DELETE.' + randomBytes(16).toString('hex');
+    fs.renameSync(path, name);
+    fs.unlinkSync(name);
+};
+/* c8 ignore stop */
+// this.gid, entry.gid, this.processUid
+const uint32 = (a, b, c) => a !== undefined && a === a >>> 0 ? a
+    : b !== undefined && b === b >>> 0 ? b
+        : c;
+export class Unpack extends Parser {
+    [ENDED] = false;
+    [CHECKED_CWD] = false;
+    [PENDING] = 0;
+    reservations = new PathReservations();
+    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(opt = {}) {
+        opt.ondone = () => {
+            this[ENDED] = true;
+            this[MAYBECLOSE]();
+        };
+        super(opt);
+        this.transform = opt.transform;
+        this.chmod = !!opt.chmod;
+        if (typeof opt.uid === 'number' || typeof opt.gid === 'number') {
+            // need both or neither
+            if (typeof opt.uid !== 'number' || typeof opt.gid !== 'number') {
+                throw new TypeError('cannot set owner without number uid and gid');
+            }
+            if (opt.preserveOwner) {
+                throw new TypeError('cannot preserve owner in archive and also set owner explicitly');
+            }
+            this.uid = opt.uid;
+            this.gid = opt.gid;
+            this.setOwner = true;
+        }
+        else {
+            this.uid = undefined;
+            this.gid = undefined;
+            this.setOwner = false;
+        }
+        // default true for root
+        this.preserveOwner =
+            opt.preserveOwner === undefined && typeof opt.uid !== 'number' ?
+                !!(process.getuid?.() === 0)
+                : !!opt.preserveOwner;
+        this.processUid =
+            (this.preserveOwner || this.setOwner) && process.getuid ?
+                process.getuid()
+                : undefined;
+        this.processGid =
+            (this.preserveOwner || this.setOwner) && process.getgid ?
+                process.getgid()
+                : undefined;
+        // prevent excessively deep nesting of subfolders
+        // set to `Infinity` to remove this restriction
+        this.maxDepth =
+            typeof opt.maxDepth === 'number' ? opt.maxDepth : DEFAULT_MAX_DEPTH;
+        // mostly just for testing, but useful in some cases.
+        // Forcibly trigger a chown on every entry, no matter what
+        this.forceChown = opt.forceChown === true;
+        // turn ><?| in filenames into 0xf000-higher encoded forms
+        this.win32 = !!opt.win32 || isWindows;
+        // do not unpack over files that are newer than what's in the archive
+        this.newer = !!opt.newer;
+        // do not unpack over ANY files
+        this.keep = !!opt.keep;
+        // do not set mtime/atime of extracted entries
+        this.noMtime = !!opt.noMtime;
+        // allow .., absolute path entries, and unpacking through symlinks
+        // without this, warn and skip .., relativize absolutes, and error
+        // on symlinks in extraction path
+        this.preservePaths = !!opt.preservePaths;
+        // unlink files and links before writing. This breaks existing hard
+        // links, and removes symlink directories rather than erroring
+        this.unlink = !!opt.unlink;
+        this.cwd = normalizeWindowsPath(path.resolve(opt.cwd || process.cwd()));
+        this.strip = Number(opt.strip) || 0;
+        // if we're not chmodding, then we don't need the process umask
+        this.processUmask =
+            !this.chmod ? 0
+                : typeof opt.processUmask === 'number' ? opt.processUmask
+                    : umask();
+        this.umask =
+            typeof opt.umask === 'number' ? opt.umask : this.processUmask;
+        // default mode for dirs created as parents
+        this.dmode = opt.dmode || 0o0777 & ~this.umask;
+        this.fmode = opt.fmode || 0o0666 & ~this.umask;
+        this.on('entry', entry => this[ONENTRY](entry));
+    }
+    // a bad or damaged archive is a warning for Parser, but an error
+    // when extracting.  Mark those errors as unrecoverable, because
+    // the Unpack contract cannot be met.
+    warn(code, msg, data = {}) {
+        if (code === 'TAR_BAD_ARCHIVE' || code === 'TAR_ABORT') {
+            data.recoverable = false;
+        }
+        return super.warn(code, msg, data);
+    }
+    [MAYBECLOSE]() {
+        if (this[ENDED] && this[PENDING] === 0) {
+            this.emit('prefinish');
+            this.emit('finish');
+            this.emit('end');
+        }
+    }
+    // return false if we need to skip this file
+    // return true if the field was successfully sanitized
+    [STRIPABSOLUTEPATH](entry, field) {
+        const p = entry[field];
+        const { type } = entry;
+        if (!p || this.preservePaths)
+            return true;
+        // strip off the root
+        const [root, stripped] = stripAbsolutePath(p);
+        const parts = stripped.replaceAll(/\\/g, '/').split('/');
+        if (parts.includes('..') ||
+            /* c8 ignore next */
+            (isWindows && /^[a-z]:\.\.$/i.test(parts[0] ?? ''))) {
+            // For linkpath, check if the resolved path escapes cwd rather than
+            // just rejecting any path with '..' - relative symlinks like
+            // '../sibling/file' are valid if they resolve within the cwd.
+            // For paths, they just simply may not ever use .. at all.
+            if (field === 'path' || type === 'Link') {
+                this.warn('TAR_ENTRY_ERROR', `${field} contains '..'`, {
+                    entry,
+                    [field]: p,
+                });
+                // not ok!
+                return false;
+            }
+            // Resolve linkpath relative to the entry's directory.
+            // `path.posix` is safe to use because we're operating on
+            // tar paths, not a filesystem.
+            const entryDir = path.posix.dirname(entry.path);
+            const resolved = path.posix.normalize(path.posix.join(entryDir, parts.join('/')));
+            // If the resolved path escapes (starts with ..), reject it
+            if (resolved.startsWith('../') || resolved === '..') {
+                this.warn('TAR_ENTRY_ERROR', `${field} escapes extraction directory`, {
+                    entry,
+                    [field]: p,
+                });
+                return false;
+            }
+        }
+        if (root) {
+            // ok, but triggers warning about stripping root
+            entry[field] = String(stripped);
+            this.warn('TAR_ENTRY_INFO', `stripping ${root} from absolute ${field}`, {
+                entry,
+                [field]: p,
+            });
+        }
+        return true;
+    }
+    // no IO, just string checking for absolute indicators
+    [CHECKPATH](entry) {
+        const p = normalizeWindowsPath(entry.path);
+        const parts = p.split('/');
+        if (this.strip) {
+            if (parts.length < this.strip) {
+                return false;
+            }
+            if (entry.type === 'Link') {
+                const linkparts = normalizeWindowsPath(String(entry.linkpath)).split('/');
+                if (linkparts.length >= this.strip) {
+                    entry.linkpath = linkparts.slice(this.strip).join('/');
+                }
+                else {
+                    return false;
+                }
+            }
+            parts.splice(0, this.strip);
+            entry.path = parts.join('/');
+        }
+        if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
+            this.warn('TAR_ENTRY_ERROR', 'path excessively deep', {
+                entry,
+                path: p,
+                depth: parts.length,
+                maxDepth: this.maxDepth,
+            });
+            return false;
+        }
+        if (!this[STRIPABSOLUTEPATH](entry, 'path') ||
+            !this[STRIPABSOLUTEPATH](entry, 'linkpath')) {
+            return false;
+        }
+        entry.absolute =
+            path.isAbsolute(entry.path) ?
+                normalizeWindowsPath(path.resolve(entry.path))
+                : normalizeWindowsPath(path.resolve(this.cwd, entry.path));
+        // if we somehow ended up with a path that escapes the cwd, and we are
+        // not in preservePaths mode, then something is fishy!  This should have
+        // been prevented above, so ignore this for coverage.
+        /* c8 ignore start - defense in depth */
+        if (!this.preservePaths &&
+            typeof entry.absolute === 'string' &&
+            entry.absolute.indexOf(this.cwd + '/') !== 0 &&
+            entry.absolute !== this.cwd) {
+            this.warn('TAR_ENTRY_ERROR', 'path escaped extraction target', {
+                entry,
+                path: normalizeWindowsPath(entry.path),
+                resolvedPath: entry.absolute,
+                cwd: this.cwd,
+            });
+            return false;
+        }
+        /* c8 ignore stop */
+        // an archive can set properties on the extraction directory, but it
+        // may not replace the cwd with a different kind of thing entirely.
+        if (entry.absolute === this.cwd &&
+            entry.type !== 'Directory' &&
+            entry.type !== 'GNUDumpDir') {
+            return false;
+        }
+        // only encode : chars that aren't drive letter indicators
+        if (this.win32) {
+            const { root: aRoot } = path.win32.parse(String(entry.absolute));
+            entry.absolute =
+                aRoot + wc.encode(String(entry.absolute).slice(aRoot.length));
+            const { root: pRoot } = path.win32.parse(entry.path);
+            entry.path = pRoot + wc.encode(entry.path.slice(pRoot.length));
+        }
+        return true;
+    }
+    [ONENTRY](entry) {
+        if (!this[CHECKPATH](entry)) {
+            return entry.resume();
+        }
+        assert.equal(typeof entry.absolute, 'string');
+        switch (entry.type) {
+            case 'Directory':
+            case 'GNUDumpDir':
+                if (entry.mode) {
+                    entry.mode = entry.mode | 0o700;
+                }
+            // eslint-disable-next-line no-fallthrough
+            case 'File':
+            case 'OldFile':
+            case 'ContiguousFile':
+            case 'Link':
+            case 'SymbolicLink':
+                return this[CHECKFS](entry);
+            case 'CharacterDevice':
+            case 'BlockDevice':
+            case 'FIFO':
+            default:
+                return this[UNSUPPORTED](entry);
+        }
+    }
+    [ONERROR](er, entry) {
+        // Cwd has to exist, or else nothing works. That's serious.
+        // Other errors are warnings, which raise the error in strict
+        // mode, but otherwise continue on.
+        if (er.name === 'CwdError') {
+            this.emit('error', er);
+        }
+        else {
+            this.warn('TAR_ENTRY_ERROR', er, { entry });
+            this[UNPEND]();
+            entry.resume();
+        }
+    }
+    [MKDIR](dir, mode, cb) {
+        void mkdir(normalizeWindowsPath(dir), {
+            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: mode,
+        }, cb);
+    }
+    [DOCHOWN](entry) {
+        // in preserve owner mode, chown if the entry doesn't match process
+        // in set owner mode, chown if setting doesn't match process
+        return (this.forceChown ||
+            (this.preserveOwner &&
+                ((typeof entry.uid === 'number' &&
+                    entry.uid !== this.processUid) ||
+                    (typeof entry.gid === 'number' &&
+                        entry.gid !== this.processGid))) ||
+            (typeof this.uid === 'number' && this.uid !== this.processUid) ||
+            (typeof this.gid === 'number' && this.gid !== this.processGid));
+    }
+    [UID](entry) {
+        return uint32(this.uid, entry.uid, this.processUid);
+    }
+    [GID](entry) {
+        return uint32(this.gid, entry.gid, this.processGid);
+    }
+    [FILE](entry, fullyDone) {
+        const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.fmode;
+        const stream = new fsm.WriteStream(String(entry.absolute), {
+            // slight lie, but it can be numeric flags
+            flags: getWriteFlag(entry.size),
+            mode: mode,
+            autoClose: false,
+        });
+        stream.on('error', (er) => {
+            if (stream.fd) {
+                fs.close(stream.fd, () => { });
+            }
+            // flush all the data out so that we aren't left hanging
+            // if the error wasn't actually fatal.  otherwise the parse
+            // is blocked, and we never proceed.
+            stream.write = () => true;
+            this[ONERROR](er, entry);
+            fullyDone();
+        });
+        let actions = 1;
+        const done = (er) => {
+            if (er) {
+                /* c8 ignore start - we should always have a fd by now */
+                if (stream.fd) {
+                    fs.close(stream.fd, () => { });
+                }
+                /* c8 ignore stop */
+                this[ONERROR](er, entry);
+                fullyDone();
+                return;
+            }
+            if (--actions === 0) {
+                if (stream.fd !== undefined) {
+                    fs.close(stream.fd, er => {
+                        if (er) {
+                            this[ONERROR](er, entry);
+                        }
+                        else {
+                            this[UNPEND]();
+                        }
+                        fullyDone();
+                    });
+                }
+            }
+        };
+        stream.on('finish', () => {
+            // if futimes fails, try utimes
+            // if utimes fails, fail with the original error
+            // same for fchown/chown
+            const abs = String(entry.absolute);
+            const fd = stream.fd;
+            if (typeof fd === 'number' && entry.mtime && !this.noMtime) {
+                actions++;
+                const atime = entry.atime || new Date();
+                const mtime = entry.mtime;
+                fs.futimes(fd, atime, mtime, er => er ?
+                    fs.utimes(abs, atime, mtime, er2 => done(er2 && er))
+                    : done());
+            }
+            if (typeof fd === 'number' && this[DOCHOWN](entry)) {
+                actions++;
+                const uid = this[UID](entry);
+                const gid = this[GID](entry);
+                if (typeof uid === 'number' && typeof gid === 'number') {
+                    fs.fchown(fd, uid, gid, er => er ? fs.chown(abs, uid, gid, er2 => done(er2 && er)) : done());
+                }
+            }
+            done();
+        });
+        const tx = this.transform ? this.transform(entry) || entry : entry;
+        if (tx !== entry) {
+            tx.on('error', er => {
+                this[ONERROR](er, entry);
+                fullyDone();
+            });
+            entry.pipe(tx);
+        }
+        tx.pipe(stream);
+    }
+    [DIRECTORY](entry, fullyDone) {
+        const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.dmode;
+        this[MKDIR](String(entry.absolute), mode, er => {
+            if (er) {
+                this[ONERROR](er, entry);
+                fullyDone();
+                return;
+            }
+            let actions = 1;
+            const done = () => {
+                if (--actions === 0) {
+                    fullyDone();
+                    this[UNPEND]();
+                    entry.resume();
+                }
+            };
+            if (entry.mtime && !this.noMtime) {
+                actions++;
+                fs.utimes(String(entry.absolute), entry.atime || new Date(), entry.mtime, done);
+            }
+            if (this[DOCHOWN](entry)) {
+                actions++;
+                fs.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
+            }
+            done();
+        });
+    }
+    [UNSUPPORTED](entry) {
+        entry.unsupported = true;
+        this.warn('TAR_ENTRY_UNSUPPORTED', `unsupported entry type: ${entry.type}`, { entry });
+        entry.resume();
+    }
+    [SYMLINK](entry, done) {
+        const parts = normalizeWindowsPath(path.relative(this.cwd, path.resolve(path.dirname(String(entry.absolute)), String(entry.linkpath)))).split('/');
+        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, String(entry.linkpath), 'symlink', done), er => {
+            this[ONERROR](er, entry);
+            done();
+        });
+    }
+    [HARDLINK](entry, done) {
+        const linkpath = normalizeWindowsPath(path.resolve(this.cwd, String(entry.linkpath)));
+        const parts = normalizeWindowsPath(String(entry.linkpath)).split('/');
+        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, linkpath, 'link', done), er => {
+            this[ONERROR](er, entry);
+            done();
+        });
+    }
+    [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) {
+        const p = parts.shift();
+        if (this.preservePaths || p === undefined)
+            return done();
+        const t = path.resolve(cwd, p);
+        fs.lstat(t, (er, st) => {
+            if (er)
+                return done();
+            if (st?.isSymbolicLink()) {
+                return onError(new SymlinkError(t, path.resolve(t, parts.join('/'))));
+            }
+            this[ENSURE_NO_SYMLINK](entry, t, parts, done, onError);
+        });
+    }
+    [PEND]() {
+        this[PENDING]++;
+    }
+    [UNPEND]() {
+        this[PENDING]--;
+        this[MAYBECLOSE]();
+    }
+    [SKIP](entry) {
+        this[UNPEND]();
+        entry.resume();
+    }
+    // Check if we can reuse an existing filesystem entry safely and
+    // overwrite it, rather than unlinking and recreating
+    // Windows doesn't report a useful nlink, so we just never reuse entries
+    [ISREUSABLE](entry, st) {
+        return (entry.type === 'File' &&
+            !this.unlink &&
+            st.isFile() &&
+            st.nlink <= 1 &&
+            !isWindows);
+    }
+    // check if a thing is there, and if so, try to clobber it
+    [CHECKFS](entry) {
+        this[PEND]();
+        const paths = [entry.path];
+        if (entry.linkpath) {
+            paths.push(entry.linkpath);
+        }
+        this.reservations.reserve(paths, done => this[CHECKFS2](entry, done));
+    }
+    [CHECKFS2](entry, fullyDone) {
+        const done = (er) => {
+            fullyDone(er);
+        };
+        const checkCwd = () => {
+            this[MKDIR](this.cwd, this.dmode, er => {
+                if (er) {
+                    this[ONERROR](er, entry);
+                    done();
+                    return;
+                }
+                this[CHECKED_CWD] = true;
+                start();
+            });
+        };
+        const start = () => {
+            if (entry.absolute !== this.cwd) {
+                const parent = normalizeWindowsPath(path.dirname(String(entry.absolute)));
+                if (parent !== this.cwd) {
+                    return this[MKDIR](parent, this.dmode, er => {
+                        if (er) {
+                            this[ONERROR](er, entry);
+                            done();
+                            return;
+                        }
+                        afterMakeParent();
+                    });
+                }
+            }
+            afterMakeParent();
+        };
+        const afterMakeParent = () => {
+            fs.lstat(String(entry.absolute), (lstatEr, st) => {
+                if (st &&
+                    (this.keep ||
+                        /* c8 ignore next */
+                        (this.newer && st.mtime > (entry.mtime ?? st.mtime)))) {
+                    this[SKIP](entry);
+                    done();
+                    return;
+                }
+                if (lstatEr || this[ISREUSABLE](entry, st)) {
+                    return this[MAKEFS](null, entry, done);
+                }
+                if (st.isDirectory()) {
+                    if (entry.type === 'Directory') {
+                        const needChmod = this.chmod && entry.mode && (st.mode & 0o7777) !== entry.mode;
+                        const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
+                        if (!needChmod) {
+                            return afterChmod();
+                        }
+                        return fs.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
+                    }
+                    // Not a dir entry, have to remove it.
+                    // NB: the only way to end up with an entry that is the cwd
+                    // itself, in such a way that == does not detect, is a
+                    // tricky windows absolute path with UNC or 8.3 parts (and
+                    // preservePaths:true, or else it will have been stripped).
+                    // In that case, the user has opted out of path protections
+                    // explicitly, so if they blow away the cwd, c'est la vie.
+                    if (entry.absolute !== this.cwd) {
+                        return fs.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+                    }
+                }
+                // not a dir, and not reusable
+                // don't remove if the cwd, we want that error
+                if (entry.absolute === this.cwd) {
+                    return this[MAKEFS](null, entry, done);
+                }
+                unlinkFile(String(entry.absolute), er => this[MAKEFS](er ?? null, entry, done));
+            });
+        };
+        if (this[CHECKED_CWD]) {
+            start();
+        }
+        else {
+            checkCwd();
+        }
+    }
+    [MAKEFS](er, entry, done) {
+        if (er) {
+            this[ONERROR](er, entry);
+            done();
+            return;
+        }
+        switch (entry.type) {
+            case 'File':
+            case 'OldFile':
+            case 'ContiguousFile':
+                return this[FILE](entry, done);
+            case 'Link':
+                return this[HARDLINK](entry, done);
+            case 'SymbolicLink':
+                return this[SYMLINK](entry, done);
+            case 'Directory':
+            case 'GNUDumpDir':
+                return this[DIRECTORY](entry, done);
+        }
+    }
+    [LINK](entry, linkpath, link, done) {
+        fs[link](linkpath, String(entry.absolute), er => {
+            if (er) {
+                this[ONERROR](er, entry);
+            }
+            else {
+                this[UNPEND]();
+                entry.resume();
+            }
+            done();
+        });
+    }
+}
+const callSync = (fn) => {
+    try {
+        return [null, fn()];
+    }
+    catch (er) {
+        return [er, null];
+    }
+};
+export class UnpackSync extends Unpack {
+    sync = true;
+    [MAKEFS](er, entry) {
+        return super[MAKEFS](er, entry, () => { });
+    }
+    [CHECKFS](entry) {
+        if (!this[CHECKED_CWD]) {
+            const er = this[MKDIR](this.cwd, this.dmode);
+            if (er) {
+                return this[ONERROR](er, entry);
+            }
+            this[CHECKED_CWD] = true;
+        }
+        // don't bother to make the parent if the current entry is the cwd,
+        // we've already checked it.
+        if (entry.absolute !== this.cwd) {
+            const parent = normalizeWindowsPath(path.dirname(String(entry.absolute)));
+            if (parent !== this.cwd) {
+                const mkParent = this[MKDIR](parent, this.dmode);
+                if (mkParent) {
+                    return this[ONERROR](mkParent, entry);
+                }
+            }
+        }
+        const [lstatEr, st] = callSync(() => fs.lstatSync(String(entry.absolute)));
+        if (st &&
+            (this.keep ||
+                /* c8 ignore next */
+                (this.newer && st.mtime > (entry.mtime ?? st.mtime)))) {
+            return this[SKIP](entry);
+        }
+        if (lstatEr || this[ISREUSABLE](entry, st)) {
+            return this[MAKEFS](null, entry);
+        }
+        if (st.isDirectory()) {
+            if (entry.type === 'Directory') {
+                const needChmod = this.chmod && entry.mode && (st.mode & 0o7777) !== entry.mode;
+                const [er] = needChmod ?
+                    callSync(() => {
+                        fs.chmodSync(String(entry.absolute), Number(entry.mode));
+                    })
+                    : [];
+                return this[MAKEFS](er, entry);
+            }
+            // not a dir entry, have to remove it
+            const [er] = callSync(() => fs.rmdirSync(String(entry.absolute)));
+            this[MAKEFS](er, entry);
+        }
+        // not a dir, and not reusable.
+        // don't remove if it's the cwd, since we want that error.
+        const [er] = entry.absolute === this.cwd ?
+            []
+            : callSync(() => unlinkFileSync(String(entry.absolute)));
+        this[MAKEFS](er, entry);
+    }
+    [FILE](entry, done) {
+        const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.fmode;
+        const oner = (er) => {
+            let closeError;
+            try {
+                fs.closeSync(fd);
+            }
+            catch (e) {
+                closeError = e;
+            }
+            if (er || closeError) {
+                this[ONERROR](er || closeError, entry);
+            }
+            done();
+        };
+        let fd;
+        try {
+            fd = fs.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
+            /* c8 ignore start - This is only a problem if the file was successfully
+             * statted, BUT failed to open. Testing this is annoying, and we
+             * already have ample testint for other uses of oner() methods.
+             */
+        }
+        catch (er) {
+            return oner(er);
+        }
+        /* c8 ignore stop */
+        const tx = this.transform ? this.transform(entry) || entry : entry;
+        if (tx !== entry) {
+            tx.on('error', er => this[ONERROR](er, entry));
+            entry.pipe(tx);
+        }
+        tx.on('data', (chunk) => {
+            try {
+                fs.writeSync(fd, chunk, 0, chunk.length);
+            }
+            catch (er) {
+                oner(er);
+            }
+        });
+        tx.on('end', () => {
+            let er = null;
+            // try both, falling futimes back to utimes
+            // if either fails, handle the first error
+            if (entry.mtime && !this.noMtime) {
+                const atime = entry.atime || new Date();
+                const mtime = entry.mtime;
+                try {
+                    fs.futimesSync(fd, atime, mtime);
+                }
+                catch (futimeser) {
+                    try {
+                        fs.utimesSync(String(entry.absolute), atime, mtime);
+                    }
+                    catch {
+                        er = futimeser;
+                    }
+                }
+            }
+            if (this[DOCHOWN](entry)) {
+                const uid = this[UID](entry);
+                const gid = this[GID](entry);
+                try {
+                    fs.fchownSync(fd, Number(uid), Number(gid));
+                }
+                catch (fchowner) {
+                    try {
+                        fs.chownSync(String(entry.absolute), Number(uid), Number(gid));
+                    }
+                    catch {
+                        er = er || fchowner;
+                    }
+                }
+            }
+            oner(er);
+        });
+    }
+    [DIRECTORY](entry, done) {
+        const mode = typeof entry.mode === 'number' ? entry.mode & 0o7777 : this.dmode;
+        const er = this[MKDIR](String(entry.absolute), mode);
+        if (er) {
+            this[ONERROR](er, entry);
+            done();
+            return;
+        }
+        if (entry.mtime && !this.noMtime) {
+            try {
+                fs.utimesSync(String(entry.absolute), entry.atime || new Date(), entry.mtime);
+                /* c8 ignore next */
+            }
+            catch { }
+        }
+        if (this[DOCHOWN](entry)) {
+            try {
+                fs.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
+            }
+            catch { }
+        }
+        done();
+        entry.resume();
+    }
+    [MKDIR](dir, mode) {
+        try {
+            return mkdirSync(normalizeWindowsPath(dir), {
+                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: mode,
+            });
+        }
+        catch (er) {
+            return er;
+        }
+    }
+    [ENSURE_NO_SYMLINK](_entry, cwd, parts, done, onError) {
+        if (this.preservePaths || parts.length === 0)
+            return done();
+        let t = cwd;
+        for (const p of parts) {
+            t = path.resolve(t, p);
+            const [er, st] = callSync(() => fs.lstatSync(t));
+            if (er)
+                return done();
+            if (st.isSymbolicLink()) {
+                return onError(new SymlinkError(t, path.resolve(cwd, parts.join('/'))));
+            }
+        }
+        done();
+    }
+    [LINK](entry, linkpath, link, done) {
+        const linkSync = `${link}Sync`;
+        try {
+            fs[linkSync](linkpath, String(entry.absolute));
+            done();
+            entry.resume();
+        }
+        catch (er) {
+            return this[ONERROR](er, entry);
+        }
+    }
+}
+//# sourceMappingURL=unpack.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/update.d.ts b/node_modules/tar/dist/esm/update.d.ts
new file mode 100644
index 0000000..45784eb
--- /dev/null
+++ b/node_modules/tar/dist/esm/update.d.ts
@@ -0,0 +1,2 @@
+export declare const update: import("./make-command.js").TarCommand<never, never>;
+//# sourceMappingURL=update.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/update.js b/node_modules/tar/dist/esm/update.js
new file mode 100644
index 0000000..21398e9
--- /dev/null
+++ b/node_modules/tar/dist/esm/update.js
@@ -0,0 +1,30 @@
+// tar -u
+import { makeCommand } from './make-command.js';
+import { replace as r } from './replace.js';
+// just call tar.r with the filter and mtimeCache
+export const update = makeCommand(r.syncFile, r.asyncFile, r.syncNoFile, r.asyncNoFile, (opt, entries = []) => {
+    r.validate?.(opt, entries);
+    mtimeFilter(opt);
+});
+const mtimeFilter = (opt) => {
+    const filter = opt.filter;
+    if (!opt.mtimeCache) {
+        opt.mtimeCache = new Map();
+    }
+    opt.filter =
+        filter ?
+            (path, stat) => filter(path, stat) &&
+                !(
+                /* c8 ignore start */
+                ((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) >
+                    (stat.mtime ?? 0))
+                /* c8 ignore stop */
+                )
+            : (path, stat) => !(
+            /* c8 ignore start */
+            ((opt.mtimeCache?.get(path) ?? stat.mtime ?? 0) >
+                (stat.mtime ?? 0))
+            /* c8 ignore stop */
+            );
+};
+//# sourceMappingURL=update.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/warn-method.d.ts b/node_modules/tar/dist/esm/warn-method.d.ts
new file mode 100644
index 0000000..2dd9861
--- /dev/null
+++ b/node_modules/tar/dist/esm/warn-method.d.ts
@@ -0,0 +1,24 @@
+import { type Minipass } from 'minipass';
+/** has a warn method */
+export type Warner = {
+    warn(code: string, message: string | Error, data: unknown): void;
+    file?: string;
+    cwd?: string;
+    strict?: boolean;
+    emit(event: 'warn', code: string, message: string, data?: WarnData): void;
+    emit(event: 'error', error: TarError): void;
+};
+export type WarnEvent<T = Buffer> = Minipass.Events<T> & {
+    warn: [code: string, message: string, data: WarnData];
+};
+export type WarnData = {
+    file?: string;
+    cwd?: string;
+    code?: string;
+    tarCode?: string;
+    recoverable?: boolean;
+    [k: string]: unknown;
+};
+export type TarError = Error & WarnData;
+export declare const warnMethod: (self: Warner, code: string, message: string | Error, data?: WarnData) => void;
+//# sourceMappingURL=warn-method.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/warn-method.js b/node_modules/tar/dist/esm/warn-method.js
new file mode 100644
index 0000000..13e798a
--- /dev/null
+++ b/node_modules/tar/dist/esm/warn-method.js
@@ -0,0 +1,27 @@
+export const warnMethod = (self, code, message, data = {}) => {
+    if (self.file) {
+        data.file = self.file;
+    }
+    if (self.cwd) {
+        data.cwd = self.cwd;
+    }
+    data.code =
+        (message instanceof Error &&
+            message.code) ||
+            code;
+    data.tarCode = code;
+    if (!self.strict && data.recoverable !== false) {
+        if (message instanceof Error) {
+            data = Object.assign(message, data);
+            message = message.message;
+        }
+        self.emit('warn', code, message, data);
+    }
+    else if (message instanceof Error) {
+        self.emit('error', Object.assign(message, data));
+    }
+    else {
+        self.emit('error', Object.assign(new Error(`${code}: ${message}`), data));
+    }
+};
+//# sourceMappingURL=warn-method.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/winchars.d.ts b/node_modules/tar/dist/esm/winchars.d.ts
new file mode 100644
index 0000000..6c24143
--- /dev/null
+++ b/node_modules/tar/dist/esm/winchars.d.ts
@@ -0,0 +1,3 @@
+export declare const encode: (s: string) => string;
+export declare const decode: (s: string) => string;
+//# sourceMappingURL=winchars.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/winchars.js b/node_modules/tar/dist/esm/winchars.js
new file mode 100644
index 0000000..4046778
--- /dev/null
+++ b/node_modules/tar/dist/esm/winchars.js
@@ -0,0 +1,9 @@
+// When writing files on Windows, translate the characters to their
+// 0xf000 higher-encoded versions.
+const raw = ['|', '<', '>', '?', ':'];
+const win = raw.map(char => String.fromCodePoint(0xf000 + Number(char.codePointAt(0))));
+const toWin = new Map(raw.map((char, i) => [char, win[i]]));
+const toRaw = new Map(win.map((char, i) => [char, raw[i]]));
+export const encode = (s) => raw.reduce((s, c) => s.split(c).join(toWin.get(c)), s);
+export const decode = (s) => win.reduce((s, c) => s.split(c).join(toRaw.get(c)), s);
+//# sourceMappingURL=winchars.js.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/write-entry.d.ts b/node_modules/tar/dist/esm/write-entry.d.ts
new file mode 100644
index 0000000..9a7c623
--- /dev/null
+++ b/node_modules/tar/dist/esm/write-entry.d.ts
@@ -0,0 +1,129 @@
+import { type Stats } from 'fs';
+import { Minipass } from 'minipass';
+import { Header } from './header.js';
+import type { TarOptions, TarOptionsWithAliases } from './options.js';
+import type { ReadEntry } from './read-entry.js';
+import type { EntryTypeName } from './types.js';
+import type { WarnData, Warner, WarnEvent } from './warn-method.js';
+declare const PROCESS: unique symbol;
+declare const FILE: unique symbol;
+declare const DIRECTORY: unique symbol;
+declare const SYMLINK: unique symbol;
+declare const HARDLINK: unique symbol;
+declare const HEADER: unique symbol;
+declare const READ: unique symbol;
+declare const LSTAT: unique symbol;
+declare const ONLSTAT: unique symbol;
+declare const ONREAD: unique symbol;
+declare const ONREADLINK: unique symbol;
+declare const OPENFILE: unique symbol;
+declare const ONOPENFILE: unique symbol;
+declare const CLOSE: unique symbol;
+declare const MODE: unique symbol;
+declare const AWAITDRAIN: unique symbol;
+declare const ONDRAIN: unique symbol;
+declare const PREFIX: unique symbol;
+export declare class WriteEntry extends Minipass<Buffer, Minipass.ContiguousData, WarnEvent> implements Warner {
+    #private;
+    path: string;
+    portable: boolean;
+    myuid: number;
+    myuser: string;
+    maxReadSize: number;
+    linkCache: Exclude<TarOptions['linkCache'], undefined>;
+    statCache: Exclude<TarOptions['statCache'], undefined>;
+    preservePaths: boolean;
+    cwd: string;
+    strict: boolean;
+    mtime?: Date;
+    noPax: boolean;
+    noMtime: boolean;
+    prefix?: string;
+    fd?: number;
+    blockLen: number;
+    blockRemain: number;
+    buf?: Buffer;
+    pos: number;
+    remain: number;
+    length: number;
+    offset: number;
+    win32: boolean;
+    absolute: string;
+    header?: Header;
+    type?: EntryTypeName | 'Unsupported';
+    linkpath?: string;
+    stat?: Stats;
+    onWriteEntry?: (entry: WriteEntry) => unknown;
+    constructor(p: string, opt_?: TarOptionsWithAliases);
+    warn(code: string, message: string | Error, data?: WarnData): void;
+    emit(ev: keyof WarnEvent, ...data: unknown[]): boolean;
+    [LSTAT](): void;
+    [ONLSTAT](stat: Stats): void;
+    [PROCESS](): void | this;
+    [MODE](mode: number): number;
+    [PREFIX](path: string): string;
+    [HEADER](): void;
+    [DIRECTORY](): void;
+    [SYMLINK](): void;
+    [ONREADLINK](linkpath: string): void;
+    [HARDLINK](linkpath: string): void;
+    [FILE](): void | this;
+    [OPENFILE](): void;
+    [ONOPENFILE](fd: number): void;
+    [READ](): void;
+    [CLOSE](cb?: (er?: null | Error | NodeJS.ErrnoException) => unknown): void;
+    [ONREAD](bytesRead: number): void;
+    [AWAITDRAIN](cb: () => unknown): void;
+    write(buffer: Buffer | string, cb?: () => void): boolean;
+    write(str: Buffer | string, encoding?: BufferEncoding | null, cb?: () => void): boolean;
+    [ONDRAIN](): void;
+}
+export declare class WriteEntrySync extends WriteEntry implements Warner {
+    sync: true;
+    [LSTAT](): void;
+    [SYMLINK](): void;
+    [OPENFILE](): void;
+    [READ](): void;
+    [AWAITDRAIN](cb: () => unknown): void;
+    [CLOSE](cb?: (er?: null | Error | NodeJS.ErrnoException) => unknown): void;
+}
+export declare class WriteEntryTar extends Minipass<Buffer, Buffer | string, WarnEvent> implements Warner {
+    blockLen: number;
+    blockRemain: number;
+    buf: number;
+    pos: number;
+    remain: number;
+    length: number;
+    preservePaths: boolean;
+    portable: boolean;
+    strict: boolean;
+    noPax: boolean;
+    noMtime: boolean;
+    readEntry: ReadEntry;
+    type: EntryTypeName;
+    prefix?: string;
+    path: string;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    uname?: string;
+    gname?: string;
+    header?: Header;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    linkpath?: string;
+    size: number;
+    onWriteEntry?: (entry: WriteEntry) => unknown;
+    warn(code: string, message: string | Error, data?: WarnData): void;
+    constructor(readEntry: ReadEntry, opt_?: TarOptionsWithAliases);
+    [PREFIX](path: string): string;
+    [MODE](mode: number): number;
+    write(buffer: Buffer | string, cb?: () => void): boolean;
+    write(str: Buffer | string, encoding?: BufferEncoding | null, cb?: () => void): boolean;
+    end(cb?: () => void): this;
+    end(chunk: Buffer | string, cb?: () => void): this;
+    end(chunk: Buffer | string, encoding?: BufferEncoding, cb?: () => void): this;
+}
+export {};
+//# sourceMappingURL=write-entry.d.ts.map
\ No newline at end of file
diff --git a/node_modules/tar/dist/esm/write-entry.js b/node_modules/tar/dist/esm/write-entry.js
new file mode 100644
index 0000000..1582602
--- /dev/null
+++ b/node_modules/tar/dist/esm/write-entry.js
@@ -0,0 +1,656 @@
+import fs from 'fs';
+import { Minipass } from 'minipass';
+import path from 'path';
+import { Header } from './header.js';
+import { modeFix } from './mode-fix.js';
+import { normalizeWindowsPath } from './normalize-windows-path.js';
+import { dealias } from './options.js';
+import { Pax } from './pax.js';
+import { stripAbsolutePath } from './strip-absolute-path.js';
+import { stripTrailingSlashes } from './strip-trailing-slashes.js';
+import { warnMethod } from './warn-method.js';
+import * as winchars from './winchars.js';
+const prefixPath = (path, prefix) => {
+    if (!prefix) {
+        return normalizeWindowsPath(path);
+    }
+    path = normalizeWindowsPath(path).replace(/^\.(\/|$)/, '');
+    return stripTrailingSlashes(prefix) + '/' + path;
+};
+const maxReadSize = 16 * 1024 * 1024;
+const PROCESS = Symbol('process');
+const FILE = Symbol('file');
+const DIRECTORY = Symbol('directory');
+const SYMLINK = Symbol('symlink');
+const HARDLINK = Symbol('hardlink');
+const HEADER = Symbol('header');
+const READ = Symbol('read');
+const LSTAT = Symbol('lstat');
+const ONLSTAT = Symbol('onlstat');
+const ONREAD = Symbol('onread');
+const ONREADLINK = Symbol('onreadlink');
+const OPENFILE = Symbol('openfile');
+const ONOPENFILE = Symbol('onopenfile');
+const CLOSE = Symbol('close');
+const MODE = Symbol('mode');
+const AWAITDRAIN = Symbol('awaitDrain');
+const ONDRAIN = Symbol('ondrain');
+const PREFIX = Symbol('prefix');
+export class WriteEntry extends Minipass {
+    path;
+    portable;
+    myuid = (process.getuid && process.getuid()) || 0;
+    // until node has builtin pwnam functions, this'll have to do
+    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;
+    #hadError = false;
+    constructor(p, opt_ = {}) {
+        const opt = dealias(opt_);
+        super();
+        this.path = normalizeWindowsPath(p);
+        // suppress atime, ctime, uid, gid, uname, gname
+        this.portable = !!opt.portable;
+        this.maxReadSize = opt.maxReadSize || maxReadSize;
+        this.linkCache = opt.linkCache || new Map();
+        this.statCache = opt.statCache || new Map();
+        this.preservePaths = !!opt.preservePaths;
+        this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
+        this.strict = !!opt.strict;
+        this.noPax = !!opt.noPax;
+        this.noMtime = !!opt.noMtime;
+        this.mtime = opt.mtime;
+        this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : undefined;
+        this.onWriteEntry = opt.onWriteEntry;
+        if (typeof opt.onwarn === 'function') {
+            this.on('warn', opt.onwarn);
+        }
+        let pathWarn = false;
+        if (!this.preservePaths) {
+            const [root, stripped] = stripAbsolutePath(this.path);
+            if (root && typeof stripped === 'string') {
+                this.path = stripped;
+                pathWarn = root;
+            }
+        }
+        this.win32 = !!opt.win32 || process.platform === 'win32';
+        if (this.win32) {
+            // force the \ to / normalization, since we might not *actually*
+            // be on windows, but want \ to be considered a path separator.
+            this.path = winchars.decode(this.path.replaceAll(/\\/g, '/'));
+            p = p.replaceAll(/\\/g, '/');
+        }
+        this.absolute = normalizeWindowsPath(opt.absolute || path.resolve(this.cwd, p));
+        if (this.path === '') {
+            this.path = './';
+        }
+        if (pathWarn) {
+            this.warn('TAR_ENTRY_INFO', `stripping ${pathWarn} from absolute path`, {
+                entry: this,
+                path: pathWarn + this.path,
+            });
+        }
+        const cs = this.statCache.get(this.absolute);
+        if (cs) {
+            this[ONLSTAT](cs);
+        }
+        else {
+            this[LSTAT]();
+        }
+    }
+    warn(code, message, data = {}) {
+        return warnMethod(this, code, message, data);
+    }
+    emit(ev, ...data) {
+        if (ev === 'error') {
+            this.#hadError = true;
+        }
+        return super.emit(ev, ...data);
+    }
+    [LSTAT]() {
+        fs.lstat(this.absolute, (er, stat) => {
+            if (er) {
+                return this.emit('error', er);
+            }
+            this[ONLSTAT](stat);
+        });
+    }
+    [ONLSTAT](stat) {
+        this.statCache.set(this.absolute, stat);
+        this.stat = stat;
+        if (!stat.isFile()) {
+            stat.size = 0;
+        }
+        this.type = getType(stat);
+        this.emit('stat', stat);
+        this[PROCESS]();
+    }
+    [PROCESS]() {
+        switch (this.type) {
+            case 'File':
+                return this[FILE]();
+            case 'Directory':
+                return this[DIRECTORY]();
+            case 'SymbolicLink':
+                return this[SYMLINK]();
+            // unsupported types are ignored.
+            default:
+                return this.end();
+        }
+    }
+    [MODE](mode) {
+        return modeFix(mode, this.type === 'Directory', this.portable);
+    }
+    [PREFIX](path) {
+        return prefixPath(path, this.prefix);
+    }
+    [HEADER]() {
+        /* c8 ignore start */
+        if (!this.stat) {
+            throw new Error('cannot write header before stat');
+        }
+        /* c8 ignore stop */
+        if (this.type === 'Directory' && this.portable) {
+            this.noMtime = true;
+        }
+        this.onWriteEntry?.(this);
+        this.header = new Header({
+            path: this[PREFIX](this.path),
+            // only apply the prefix to hard links.
+            linkpath: this.type === 'Link' && this.linkpath !== undefined ?
+                this[PREFIX](this.linkpath)
+                : this.linkpath,
+            // only the permissions and setuid/setgid/sticky bitflags
+            // not the higher-order bits that specify file type
+            mode: this[MODE](this.stat.mode),
+            uid: this.portable ? undefined : this.stat.uid,
+            gid: this.portable ? undefined : this.stat.gid,
+            size: this.stat.size,
+            mtime: this.noMtime ? undefined : this.mtime || this.stat.mtime,
+            /* c8 ignore next */
+            type: this.type === 'Unsupported' ? undefined : this.type,
+            uname: this.portable ? undefined
+                : this.stat.uid === this.myuid ? this.myuser
+                    : '',
+            atime: this.portable ? undefined : this.stat.atime,
+            ctime: this.portable ? undefined : this.stat.ctime,
+        });
+        if (this.header.encode() && !this.noPax) {
+            super.write(new Pax({
+                atime: this.portable ? undefined : this.header.atime,
+                ctime: this.portable ? undefined : this.header.ctime,
+                gid: this.portable ? undefined : this.header.gid,
+                mtime: this.noMtime ? undefined : this.mtime || this.header.mtime,
+                path: this[PREFIX](this.path),
+                linkpath: this.type === 'Link' && this.linkpath !== undefined ?
+                    this[PREFIX](this.linkpath)
+                    : this.linkpath,
+                size: this.header.size,
+                uid: this.portable ? undefined : this.header.uid,
+                uname: this.portable ? undefined : this.header.uname,
+                dev: this.portable ? undefined : this.stat.dev,
+                ino: this.portable ? undefined : this.stat.ino,
+                nlink: this.portable ? undefined : this.stat.nlink,
+            }).encode());
+        }
+        const block = this.header?.block;
+        /* c8 ignore start */
+        if (!block) {
+            throw new Error('failed to encode header');
+        }
+        /* c8 ignore stop */
+        super.write(block);
+    }
+    [DIRECTORY]() {
+        /* c8 ignore start */
+        if (!this.stat) {
+            throw new Error('cannot create directory entry without stat');
+        }
+        /* c8 ignore stop */
+        if (this.path.slice(-1) !== '/') {
+            this.path += '/';
+        }
+        this.stat.size = 0;
+        this[HEADER]();
+        this.end();
+    }
+    [SYMLINK]() {
+        fs.readlink(this.absolute, (er, linkpath) => {
+            if (er) {
+                return this.emit('error', er);
+            }
+            this[ONREADLINK](linkpath);
+        });
+    }
+    [ONREADLINK](linkpath) {
+        this.linkpath = normalizeWindowsPath(linkpath);
+        this[HEADER]();
+        this.end();
+    }
+    [HARDLINK](linkpath) {
+        /* c8 ignore start */
+        if (!this.stat) {
+            throw new Error('cannot create link entry without stat');
+        }
+        /* c8 ignore stop */
+        this.type = 'Link';
+        this.linkpath = normalizeWindowsPath(path.relative(this.cwd, linkpath));
+        this.stat.size = 0;
+        this[HEADER]();
+        this.end();
+    }
+    [FILE]() {
+        /* c8 ignore start */
+        if (!this.stat) {
+            throw new Error('cannot create file entry without stat');
+        }
+        /* c8 ignore stop */
+        if (this.stat.nlink > 1) {
+            const linkKey = `${this.stat.dev}:${this.stat.ino}`;
+            const linkpath = this.linkCache.get(linkKey);
+            if (linkpath?.indexOf(this.cwd) === 0) {
+                return this[HARDLINK](linkpath);
+            }
+            this.linkCache.set(linkKey, this.absolute);
+        }
+        this[HEADER]();
+        if (this.stat.size === 0) {
+            return this.end();
+        }
+        this[OPENFILE]();
+    }
+    [OPENFILE]() {
+        fs.open(this.absolute, 'r', (er, fd) => {
+            if (er) {
+                return this.emit('error', er);
+            }
+            this[ONOPENFILE](fd);
+        });
+    }
+    [ONOPENFILE](fd) {
+        this.fd = fd;
+        if (this.#hadError) {
+            return this[CLOSE]();
+        }
+        /* c8 ignore start */
+        if (!this.stat) {
+            throw new Error('should stat before calling onopenfile');
+        }
+        /* c8 ignore start */
+        this.blockLen = 512 * Math.ceil(this.stat.size / 512);
+        this.blockRemain = this.blockLen;
+        const bufLen = Math.min(this.blockLen, this.maxReadSize);
+        this.buf = Buffer.allocUnsafe(bufLen);
+        this.offset = 0;
+        this.pos = 0;
+        this.remain = this.stat.size;
+        this.length = this.buf.length;
+        this[READ]();
+    }
+    [READ]() {
+        const { fd, buf, offset, length, pos } = this;
+        if (fd === undefined || buf === undefined) {
+            throw new Error('cannot read file without first opening');
+        }
+        fs.read(fd, buf, offset, length, pos, (er, bytesRead) => {
+            if (er) {
+                // ignoring the error from close(2) is a bad practice, but at
+                // this point we already have an error, don't need another one
+                return this[CLOSE](() => this.emit('error', er));
+            }
+            this[ONREAD](bytesRead);
+        });
+    }
+    /* c8 ignore start */
+    [CLOSE](cb = () => { }) {
+        /* c8 ignore stop */
+        if (this.fd !== undefined)
+            fs.close(this.fd, cb);
+    }
+    [ONREAD](bytesRead) {
+        if (bytesRead <= 0 && this.remain > 0) {
+            const er = Object.assign(new Error('encountered unexpected EOF'), {
+                path: this.absolute,
+                syscall: 'read',
+                code: 'EOF',
+            });
+            return this[CLOSE](() => this.emit('error', er));
+        }
+        if (bytesRead > this.remain) {
+            const er = Object.assign(new Error('did not encounter expected EOF'), {
+                path: this.absolute,
+                syscall: 'read',
+                code: 'EOF',
+            });
+            return this[CLOSE](() => this.emit('error', er));
+        }
+        /* c8 ignore start */
+        if (!this.buf) {
+            throw new Error('should have created buffer prior to reading');
+        }
+        /* c8 ignore stop */
+        // null out the rest of the buffer, if we could fit the block padding
+        // at the end of this loop, we've incremented bytesRead and this.remain
+        // to be incremented up to the blockRemain level, as if we had expected
+        // to get a null-padded file, and read it until the end.  then we will
+        // decrement both remain and blockRemain by bytesRead, and know that we
+        // reached the expected EOF, without any null buffer to append.
+        if (bytesRead === this.remain) {
+            for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
+                this.buf[i + this.offset] = 0;
+                bytesRead++;
+                this.remain++;
+            }
+        }
+        const chunk = this.offset === 0 && bytesRead === this.buf.length ?
+            this.buf
+            : this.buf.subarray(this.offset, this.offset + bytesRead);
+        const flushed = this.write(chunk);
+        if (!flushed) {
+            this[AWAITDRAIN](() => this[ONDRAIN]());
+        }
+        else {
+            this[ONDRAIN]();
+        }
+    }
+    [AWAITDRAIN](cb) {
+        this.once('drain', cb);
+    }
+    write(chunk, encoding, cb) {
+        /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8');
+        }
+        /* c8 ignore stop */
+        if (this.blockRemain < chunk.length) {
+            const er = Object.assign(new Error('writing more data than expected'), {
+                path: this.absolute,
+            });
+            return this.emit('error', er);
+        }
+        this.remain -= chunk.length;
+        this.blockRemain -= chunk.length;
+        this.pos += chunk.length;
+        this.offset += chunk.length;
+        return super.write(chunk, null, cb);
+    }
+    [ONDRAIN]() {
+        if (!this.remain) {
+            if (this.blockRemain) {
+                super.write(Buffer.alloc(this.blockRemain));
+            }
+            return this[CLOSE](er => (er ? this.emit('error', er) : this.end()));
+        }
+        /* c8 ignore start */
+        if (!this.buf) {
+            throw new Error('buffer lost somehow in ONDRAIN');
+        }
+        /* c8 ignore stop */
+        if (this.offset >= this.length) {
+            // if we only have a smaller bit left to read, alloc a smaller buffer
+            // otherwise, keep it the same length it was before.
+            this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
+            this.offset = 0;
+        }
+        this.length = this.buf.length - this.offset;
+        this[READ]();
+    }
+}
+export class WriteEntrySync extends WriteEntry {
+    sync = true;
+    [LSTAT]() {
+        this[ONLSTAT](fs.lstatSync(this.absolute));
+    }
+    [SYMLINK]() {
+        this[ONREADLINK](fs.readlinkSync(this.absolute));
+    }
+    [OPENFILE]() {
+        this[ONOPENFILE](fs.openSync(this.absolute, 'r'));
+    }
+    [READ]() {
+        let threw = true;
+        try {
+            const { fd, buf, offset, length, pos } = this;
+            /* c8 ignore start */
+            if (fd === undefined || buf === undefined) {
+                throw new Error('fd and buf must be set in READ method');
+            }
+            /* c8 ignore stop */
+            const bytesRead = fs.readSync(fd, buf, offset, length, pos);
+            this[ONREAD](bytesRead);
+            threw = false;
+        }
+        finally {
+            // ignoring the error from close(2) is a bad practice, but at
+            // this point we already have an error, don't need another one
+            if (threw) {
+                try {
+                    this[CLOSE](() => { });
+                }
+                catch { }
+            }
+        }
+    }
+    [AWAITDRAIN](cb) {
+        cb();
+    }
+    /* c8 ignore start */
+    [CLOSE](cb = () => { }) {
+        /* c8 ignore stop */
+        if (this.fd !== undefined)
+            fs.closeSync(this.fd);
+        cb();
+    }
+}
+export class WriteEntryTar extends Minipass {
+    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(code, message, data = {}) {
+        return warnMethod(this, code, message, data);
+    }
+    constructor(readEntry, opt_ = {}) {
+        const opt = dealias(opt_);
+        super();
+        this.preservePaths = !!opt.preservePaths;
+        this.portable = !!opt.portable;
+        this.strict = !!opt.strict;
+        this.noPax = !!opt.noPax;
+        this.noMtime = !!opt.noMtime;
+        this.onWriteEntry = opt.onWriteEntry;
+        this.readEntry = readEntry;
+        const { type } = readEntry;
+        /* c8 ignore start */
+        if (type === 'Unsupported') {
+            throw new Error('writing entry that should be ignored');
+        }
+        /* c8 ignore stop */
+        this.type = type;
+        if (this.type === 'Directory' && this.portable) {
+            this.noMtime = true;
+        }
+        this.prefix = opt.prefix;
+        this.path = normalizeWindowsPath(readEntry.path);
+        this.mode =
+            readEntry.mode !== undefined ? this[MODE](readEntry.mode) : undefined;
+        this.uid = this.portable ? undefined : readEntry.uid;
+        this.gid = this.portable ? undefined : readEntry.gid;
+        this.uname = this.portable ? undefined : readEntry.uname;
+        this.gname = this.portable ? undefined : readEntry.gname;
+        this.size = readEntry.size;
+        this.mtime = this.noMtime ? undefined : opt.mtime || readEntry.mtime;
+        this.atime = this.portable ? undefined : readEntry.atime;
+        this.ctime = this.portable ? undefined : readEntry.ctime;
+        this.linkpath =
+            readEntry.linkpath !== undefined ?
+                normalizeWindowsPath(readEntry.linkpath)
+                : undefined;
+        if (typeof opt.onwarn === 'function') {
+            this.on('warn', opt.onwarn);
+        }
+        let pathWarn = false;
+        if (!this.preservePaths) {
+            const [root, stripped] = stripAbsolutePath(this.path);
+            if (root && typeof stripped === 'string') {
+                this.path = stripped;
+                pathWarn = root;
+            }
+        }
+        this.remain = readEntry.size;
+        this.blockRemain = readEntry.startBlockSize;
+        this.onWriteEntry?.(this);
+        this.header = new Header({
+            path: this[PREFIX](this.path),
+            linkpath: this.type === 'Link' && this.linkpath !== undefined ?
+                this[PREFIX](this.linkpath)
+                : this.linkpath,
+            // only the permissions and setuid/setgid/sticky bitflags
+            // not the higher-order bits that specify file type
+            mode: this.mode,
+            uid: this.portable ? undefined : this.uid,
+            gid: this.portable ? undefined : this.gid,
+            size: this.size,
+            mtime: this.noMtime ? undefined : this.mtime,
+            type: this.type,
+            uname: this.portable ? undefined : this.uname,
+            atime: this.portable ? undefined : this.atime,
+            ctime: this.portable ? undefined : this.ctime,
+        });
+        if (pathWarn) {
+            this.warn('TAR_ENTRY_INFO', `stripping ${pathWarn} from absolute path`, {
+                entry: this,
+                path: pathWarn + this.path,
+            });
+        }
+        if (this.header.encode() && !this.noPax) {
+            super.write(new Pax({
+                atime: this.portable ? undefined : this.atime,
+                ctime: this.portable ? undefined : this.ctime,
+                gid: this.portable ? undefined : this.gid,
+                mtime: this.noMtime ? undefined : this.mtime,
+                path: this[PREFIX](this.path),
+                linkpath: this.type === 'Link' && this.linkpath !== undefined ?
+                    this[PREFIX](this.linkpath)
+                    : this.linkpath,
+                size: this.size,
+                uid: this.portable ? undefined : this.uid,
+                uname: this.portable ? undefined : this.uname,
+                dev: this.portable ? undefined : this.readEntry.dev,
+                ino: this.portable ? undefined : this.readEntry.ino,
+                nlink: this.portable ? undefined : this.readEntry.nlink,
+            }).encode());
+        }
+        const b = this.header?.block;
+        /* c8 ignore start */
+        if (!b)
+            throw new Error('failed to encode header');
+        /* c8 ignore stop */
+        super.write(b);
+        readEntry.pipe(this);
+    }
+    [PREFIX](path) {
+        return prefixPath(path, this.prefix);
+    }
+    [MODE](mode) {
+        return modeFix(mode, this.type === 'Directory', this.portable);
+    }
+    write(chunk, encoding, cb) {
+        /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8');
+        }
+        /* c8 ignore stop */
+        const writeLen = chunk.length;
+        if (writeLen > this.blockRemain) {
+            throw new Error('writing more to entry than is appropriate');
+        }
+        this.blockRemain -= writeLen;
+        return super.write(chunk, cb);
+    }
+    end(chunk, encoding, cb) {
+        if (this.blockRemain) {
+            super.write(Buffer.alloc(this.blockRemain));
+        }
+        /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
+        if (typeof chunk === 'function') {
+            cb = chunk;
+            encoding = undefined;
+            chunk = undefined;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, encoding ?? 'utf8');
+        }
+        if (cb)
+            this.once('finish', cb);
+        if (chunk)
+            super.end(chunk, cb);
+        else
+            super.end(cb);
+        /* c8 ignore stop */
+        return this;
+    }
+}
+const getType = (stat) => stat.isFile() ? 'File'
+    : stat.isDirectory() ? 'Directory'
+        : stat.isSymbolicLink() ? 'SymbolicLink'
+            : 'Unsupported';
+//# sourceMappingURL=write-entry.js.map
\ No newline at end of file