rsbuild-plugin-arethetypeswrong 0.1.1 → 0.3.0

package/dist/createTarball.js

@@ -0,0 +1,856 @@
+import promises from "node:fs/promises";
+import node_path, { delimiter, dirname, normalize, resolve } from "node:path";
+import node_process, { cwd as external_node_process_cwd } from "node:process";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { PassThrough } from "node:stream";
+import node_readline from "node:readline";
+const constants_AGENTS = [
+    "npm",
+    "yarn",
+    "yarn@berry",
+    "pnpm",
+    "pnpm@6",
+    "bun",
+    "deno"
+];
+const LOCKS = {
+    "bun.lock": "bun",
+    "bun.lockb": "bun",
+    "deno.lock": "deno",
+    "pnpm-lock.yaml": "pnpm",
+    "pnpm-workspace.yaml": "pnpm",
+    "yarn.lock": "yarn",
+    "package-lock.json": "npm",
+    "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+    "node_modules/.deno/": "deno",
+    "node_modules/.pnpm/": "pnpm",
+    "node_modules/.yarn-state.yml": "yarn",
+    "node_modules/.yarn_integrity": "yarn",
+    "node_modules/.package-lock.json": "npm",
+    ".pnp.cjs": "yarn",
+    ".pnp.js": "yarn",
+    "bun.lock": "bun",
+    "bun.lockb": "bun"
+};
+async function pathExists(path2, type) {
+    try {
+        const stat = await promises.stat(path2);
+        return "file" === type ? stat.isFile() : stat.isDirectory();
+    } catch  {
+        return false;
+    }
+}
+function* lookup(cwd = node_process.cwd()) {
+    let directory = node_path.resolve(cwd);
+    const { root } = node_path.parse(directory);
+    while(directory && directory !== root){
+        yield directory;
+        directory = node_path.dirname(directory);
+    }
+}
+async function parsePackageJson(filepath, options) {
+    if (!filepath || !await pathExists(filepath, "file")) return null;
+    return await handlePackageManager(filepath, options);
+}
+async function detect(options = {}) {
+    const { cwd, strategies = [
+        "lockfile",
+        "packageManager-field",
+        "devEngines-field"
+    ] } = options;
+    let stopDir;
+    if ("string" == typeof options.stopDir) {
+        const resolved = node_path.resolve(options.stopDir);
+        stopDir = (dir)=>dir === resolved;
+    } else stopDir = options.stopDir;
+    for (const directory of lookup(cwd)){
+        for (const strategy of strategies)switch(strategy){
+            case "lockfile":
+                for (const lock of Object.keys(LOCKS))if (await pathExists(node_path.join(directory, lock), "file")) {
+                    const name = LOCKS[lock];
+                    const result = await parsePackageJson(node_path.join(directory, "package.json"), options);
+                    if (result) return result;
+                    return {
+                        name,
+                        agent: name
+                    };
+                }
+                break;
+            case "packageManager-field":
+            case "devEngines-field":
+                {
+                    const result = await parsePackageJson(node_path.join(directory, "package.json"), options);
+                    if (result) return result;
+                    break;
+                }
+            case "install-metadata":
+                for (const metadata of Object.keys(INSTALL_METADATA)){
+                    const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+                    if (await pathExists(node_path.join(directory, metadata), fileOrDir)) {
+                        const name = INSTALL_METADATA[metadata];
+                        const agent = "yarn" === name ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+                        return {
+                            name,
+                            agent
+                        };
+                    }
+                }
+                break;
+        }
+        if (stopDir?.(directory)) break;
+    }
+    return null;
+}
+function getNameAndVer(pkg) {
+    const handelVer = (version)=>version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+    if ("string" == typeof pkg.packageManager) {
+        const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+        return {
+            name,
+            ver: handelVer(ver)
+        };
+    }
+    if ("string" == typeof pkg.devEngines?.packageManager?.name) return {
+        name: pkg.devEngines.packageManager.name,
+        ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+}
+async function handlePackageManager(filepath, options) {
+    try {
+        const content = await promises.readFile(filepath, "utf8");
+        const pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content);
+        let agent;
+        const nameAndVer = getNameAndVer(pkg);
+        if (nameAndVer) {
+            const name = nameAndVer.name;
+            const ver = nameAndVer.ver;
+            let version = ver;
+            if ("yarn" === name && ver && Number.parseInt(ver) > 1) {
+                agent = "yarn@berry";
+                version = "berry";
+                return {
+                    name,
+                    agent,
+                    version
+                };
+            }
+            if ("pnpm" === name && ver && Number.parseInt(ver) < 7) {
+                agent = "pnpm@6";
+                return {
+                    name,
+                    agent,
+                    version
+                };
+            }
+            if (!constants_AGENTS.includes(name)) return options.onUnknown?.(pkg.packageManager) ?? null;
+            agent = name;
+            return {
+                name,
+                agent,
+                version
+            };
+        }
+    } catch  {}
+    return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+    return metadataPath.endsWith(".yarn_integrity");
+}
+var main_l = (e, t)=>()=>(t || e((t = {
+            exports: {}
+        }).exports, t), t.exports);
+var main_u = /* @__PURE__ */ createRequire(import.meta.url);
+const main_d = /^path$/i;
+const main_f = {
+    key: "PATH",
+    value: ""
+};
+function p(e) {
+    for(const t in e){
+        if (!Object.prototype.hasOwnProperty.call(e, t) || !main_d.test(t)) continue;
+        const n = e[t];
+        if (!n) break;
+        return {
+            key: t,
+            value: n
+        };
+    }
+    return main_f;
+}
+function m(e, t) {
+    const i = t.value.split(delimiter);
+    const o = [];
+    let s = e;
+    let c;
+    do {
+        o.push(resolve(s, "node_modules", ".bin"));
+        c = s;
+        s = dirname(s);
+    }while (s !== c);
+    const l = o.concat(i).join(delimiter);
+    return {
+        key: t.key,
+        value: l
+    };
+}
+function h(e, t) {
+    const n = {
+        ...process.env,
+        ...t
+    };
+    const r = m(e, p(n));
+    n[r.key] = r.value;
+    return n;
+}
+const g = (e)=>{
+    let t = e.length;
+    const n = new PassThrough();
+    const r = ()=>{
+        if (0 === --t) n.emit("end");
+    };
+    for (const t of e){
+        t.pipe(n, {
+            end: false
+        });
+        t.on("end", r);
+    }
+    return n;
+};
+var _ = /* @__PURE__ */ main_l((e, t)=>{
+    t.exports = a;
+    a.sync = o;
+    var n = main_u("fs");
+    function r(e, t) {
+        var n = void 0 !== t.pathExt ? t.pathExt : process.env.PATHEXT;
+        if (!n) return true;
+        n = n.split(";");
+        if (-1 !== n.indexOf("")) return true;
+        for(var r = 0; r < n.length; r++){
+            var i = n[r].toLowerCase();
+            if (i && e.substr(-i.length).toLowerCase() === i) return true;
+        }
+        return false;
+    }
+    function i(e, t, n) {
+        if (!e.isSymbolicLink() && !e.isFile()) return false;
+        return r(t, n);
+    }
+    function a(e, t, r) {
+        n.stat(e, function(n, a) {
+            r(n, n ? false : i(a, e, t));
+        });
+    }
+    function o(e, t) {
+        return i(n.statSync(e), e, t);
+    }
+});
+var v = /* @__PURE__ */ main_l((e, t)=>{
+    t.exports = r;
+    r.sync = i;
+    var n = main_u("fs");
+    function r(e, t, r) {
+        n.stat(e, function(e, n) {
+            r(e, e ? false : a(n, t));
+        });
+    }
+    function i(e, t) {
+        return a(n.statSync(e), t);
+    }
+    function a(e, t) {
+        return e.isFile() && o(e, t);
+    }
+    function o(e, t) {
+        var n = e.mode;
+        var r = e.uid;
+        var i = e.gid;
+        var a = void 0 !== t.uid ? t.uid : process.getuid && process.getuid();
+        var o = void 0 !== t.gid ? t.gid : process.getgid && process.getgid();
+        var s = parseInt("100", 8);
+        var c = parseInt("010", 8);
+        var l = parseInt("001", 8);
+        var u = s | c;
+        return n & l || n & c && i === o || n & s && r === a || n & u && 0 === a;
+    }
+});
+var y = /* @__PURE__ */ main_l((e, t)=>{
+    main_u("fs");
+    var n;
+    n = "win32" === process.platform || global.TESTING_WINDOWS ? _() : v();
+    t.exports = r;
+    r.sync = i;
+    function r(e, t, i) {
+        if ("function" == typeof t) {
+            i = t;
+            t = {};
+        }
+        if (!i) {
+            if ("function" != typeof Promise) throw new TypeError("callback not provided");
+            return new Promise(function(n, i) {
+                r(e, t || {}, function(e, t) {
+                    if (e) i(e);
+                    else n(t);
+                });
+            });
+        }
+        n(e, t || {}, function(e, n) {
+            if (e) {
+                if ("EACCES" === e.code || t && t.ignoreErrors) {
+                    e = null;
+                    n = false;
+                }
+            }
+            i(e, n);
+        });
+    }
+    function i(e, t) {
+        try {
+            return n.sync(e, t || {});
+        } catch (e) {
+            if (t && t.ignoreErrors || "EACCES" === e.code) return false;
+            throw e;
+        }
+    }
+});
+var b = /* @__PURE__ */ main_l((e, t)=>{
+    const n = "win32" === process.platform || "cygwin" === process.env.OSTYPE || "msys" === process.env.OSTYPE;
+    const r = main_u("path");
+    const i = n ? ";" : ":";
+    const a = y();
+    const o = (e)=>Object.assign(/* @__PURE__ */ new Error(`not found: ${e}`), {
+            code: "ENOENT"
+        });
+    const s = (e, t)=>{
+        const r = t.colon || i;
+        const a = e.match(/\//) || n && e.match(/\\/) ? [
+            ""
+        ] : [
+            ...n ? [
+                process.cwd()
+            ] : [],
+            ...(t.path || process.env.PATH || "").split(r)
+        ];
+        const o = n ? t.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+        const s = n ? o.split(r) : [
+            ""
+        ];
+        if (n) {
+            if (-1 !== e.indexOf(".") && "" !== s[0]) s.unshift("");
+        }
+        return {
+            pathEnv: a,
+            pathExt: s,
+            pathExtExe: o
+        };
+    };
+    const c = (e, t, n)=>{
+        if ("function" == typeof t) {
+            n = t;
+            t = {};
+        }
+        if (!t) t = {};
+        const { pathEnv: i, pathExt: c, pathExtExe: l } = s(e, t);
+        const u = [];
+        const d = (n)=>new Promise((a, s)=>{
+                if (n === i.length) return t.all && u.length ? a(u) : s(o(e));
+                const c = i[n];
+                const l = /^".*"$/.test(c) ? c.slice(1, -1) : c;
+                const d = r.join(l, e);
+                a(f(!l && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d, n, 0));
+            });
+        const f = (e, n, r)=>new Promise((i, o)=>{
+                if (r === c.length) return i(d(n + 1));
+                const s = c[r];
+                a(e + s, {
+                    pathExt: l
+                }, (a, o)=>{
+                    if (!a && o) if (!t.all) return i(e + s);
+                    else u.push(e + s);
+                    return i(f(e, n, r + 1));
+                });
+            });
+        return n ? d(0).then((e)=>n(null, e), n) : d(0);
+    };
+    const l = (e, t)=>{
+        t = t || {};
+        const { pathEnv: n, pathExt: i, pathExtExe: c } = s(e, t);
+        const l = [];
+        for(let o = 0; o < n.length; o++){
+            const s = n[o];
+            const u = /^".*"$/.test(s) ? s.slice(1, -1) : s;
+            const d = r.join(u, e);
+            const f = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d;
+            for(let e = 0; e < i.length; e++){
+                const n = f + i[e];
+                try {
+                    if (a.sync(n, {
+                        pathExt: c
+                    })) if (!t.all) return n;
+                    else l.push(n);
+                } catch (e) {}
+            }
+        }
+        if (t.all && l.length) return l;
+        if (t.nothrow) return null;
+        throw o(e);
+    };
+    t.exports = c;
+    c.sync = l;
+});
+var x = /* @__PURE__ */ main_l((e, t)=>{
+    const n = (e = {})=>{
+        const t = e.env || process.env;
+        if ("win32" !== (e.platform || process.platform)) return "PATH";
+        return Object.keys(t).reverse().find((e)=>"PATH" === e.toUpperCase()) || "Path";
+    };
+    t.exports = n;
+    t.exports.default = n;
+});
+var S = /* @__PURE__ */ main_l((e, t)=>{
+    const n = main_u("path");
+    const r = b();
+    const i = x();
+    function a(e, t) {
+        const a = e.options.env || process.env;
+        const o = process.cwd();
+        const s = null != e.options.cwd;
+        const c = s && void 0 !== process.chdir && !process.chdir.disabled;
+        if (c) try {
+            process.chdir(e.options.cwd);
+        } catch (e) {}
+        let l;
+        try {
+            l = r.sync(e.command, {
+                path: a[i({
+                    env: a
+                })],
+                pathExt: t ? n.delimiter : void 0
+            });
+        } catch (e) {} finally{
+            if (c) process.chdir(o);
+        }
+        if (l) l = n.resolve(s ? e.options.cwd : "", l);
+        return l;
+    }
+    function o(e) {
+        return a(e) || a(e, true);
+    }
+    t.exports = o;
+});
+var C = /* @__PURE__ */ main_l((e, t)=>{
+    const n = /([()\][%!^"`<>&|;, *?])/g;
+    function r(e) {
+        e = e.replace(n, "^$1");
+        return e;
+    }
+    function i(e, t) {
+        e = `${e}`;
+        e = e.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+        e = e.replace(/(?=(\\+?)?)\1$/, "$1$1");
+        e = `"${e}"`;
+        e = e.replace(n, "^$1");
+        if (t) e = e.replace(n, "^$1");
+        return e;
+    }
+    t.exports.command = r;
+    t.exports.argument = i;
+});
+var w = /* @__PURE__ */ main_l((e, t)=>{
+    t.exports = /^#!(.*)/;
+});
+var T = /* @__PURE__ */ main_l((e, t)=>{
+    const n = w();
+    t.exports = (e = "")=>{
+        const t = e.match(n);
+        if (!t) return null;
+        const [r, i] = t[0].replace(/#! ?/, "").split(" ");
+        const a = r.split("/").pop();
+        if ("env" === a) return i;
+        return i ? `${a} ${i}` : a;
+    };
+});
+var E = /* @__PURE__ */ main_l((e, t)=>{
+    const n = main_u("fs");
+    const r = T();
+    function i(e) {
+        const t = 150;
+        const i = Buffer.alloc(t);
+        let a;
+        try {
+            a = n.openSync(e, "r");
+            n.readSync(a, i, 0, t, 0);
+            n.closeSync(a);
+        } catch (e) {}
+        return r(i.toString());
+    }
+    t.exports = i;
+});
+var D = /* @__PURE__ */ main_l((e, t)=>{
+    const n = main_u("path");
+    const r = S();
+    const i = C();
+    const a = E();
+    const o = "win32" === process.platform;
+    const s = /\.(?:com|exe)$/i;
+    const c = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function l(e) {
+        e.file = r(e);
+        const t = e.file && a(e.file);
+        if (t) {
+            e.args.unshift(e.file);
+            e.command = t;
+            return r(e);
+        }
+        return e.file;
+    }
+    function d(e) {
+        if (!o) return e;
+        const t = l(e);
+        const r = !s.test(t);
+        if (e.options.forceShell || r) {
+            const r = c.test(t);
+            e.command = n.normalize(e.command);
+            e.command = i.command(e.command);
+            e.args = e.args.map((e)=>i.argument(e, r));
+            e.args = [
+                "/d",
+                "/s",
+                "/c",
+                `"${[
+                    e.command
+                ].concat(e.args).join(" ")}"`
+            ];
+            e.command = process.env.comspec || "cmd.exe";
+            e.options.windowsVerbatimArguments = true;
+        }
+        return e;
+    }
+    function f(e, t, n) {
+        if (t && !Array.isArray(t)) {
+            n = t;
+            t = null;
+        }
+        t = t ? t.slice(0) : [];
+        n = Object.assign({}, n);
+        const r = {
+            command: e,
+            args: t,
+            options: n,
+            file: void 0,
+            original: {
+                command: e,
+                args: t
+            }
+        };
+        return n.shell ? r : d(r);
+    }
+    t.exports = f;
+});
+var O = /* @__PURE__ */ main_l((e, t)=>{
+    const n = "win32" === process.platform;
+    function r(e, t) {
+        return Object.assign(/* @__PURE__ */ new Error(`${t} ${e.command} ENOENT`), {
+            code: "ENOENT",
+            errno: "ENOENT",
+            syscall: `${t} ${e.command}`,
+            path: e.command,
+            spawnargs: e.args
+        });
+    }
+    function i(e, t) {
+        if (!n) return;
+        const r = e.emit;
+        e.emit = function(n, i) {
+            if ("exit" === n) {
+                const n = a(i, t);
+                if (n) return r.call(e, "error", n);
+            }
+            return r.apply(e, arguments);
+        };
+    }
+    function a(e, t) {
+        if (n && 1 === e && !t.file) return r(t.original, "spawn");
+        return null;
+    }
+    function o(e, t) {
+        if (n && 1 === e && !t.file) return r(t.original, "spawnSync");
+        return null;
+    }
+    t.exports = {
+        hookChildProcess: i,
+        verifyENOENT: a,
+        verifyENOENTSync: o,
+        notFoundError: r
+    };
+});
+var k = /* @__PURE__ */ main_l((e, t)=>{
+    const n = main_u("child_process");
+    const r = D();
+    const i = O();
+    function a(e, t, a) {
+        const o = r(e, t, a);
+        const s = n.spawn(o.command, o.args, o.options);
+        i.hookChildProcess(s, o);
+        return s;
+    }
+    function o(e, t, a) {
+        const o = r(e, t, a);
+        const s = n.spawnSync(o.command, o.args, o.options);
+        s.error = s.error || i.verifyENOENTSync(s.status, o);
+        return s;
+    }
+    t.exports = a;
+    t.exports.spawn = a;
+    t.exports.sync = o;
+    t.exports._parse = r;
+    t.exports._enoent = i;
+});
+var A = k();
+var j = class extends Error {
+    result;
+    output;
+    get exitCode() {
+        if (null !== this.result.exitCode) return this.result.exitCode;
+    }
+    constructor(e, t){
+        super(`Process exited with non-zero status (${e.exitCode})`);
+        this.result = e;
+        this.output = t;
+    }
+};
+const M = {
+    timeout: void 0,
+    persist: false
+};
+const N = {
+    windowsHide: true
+};
+function P(e, t) {
+    return {
+        command: normalize(e),
+        args: t ?? []
+    };
+}
+function F(e) {
+    const t = new AbortController();
+    for (const n of e){
+        if (n.aborted) {
+            t.abort();
+            return n;
+        }
+        const e = ()=>{
+            t.abort(n.reason);
+        };
+        n.addEventListener("abort", e, {
+            signal: t.signal
+        });
+    }
+    return t.signal;
+}
+async function I(e) {
+    let t = "";
+    for await (const n of e)t += n.toString();
+    return t;
+}
+var L = class {
+    _process;
+    _aborted = false;
+    _options;
+    _command;
+    _args;
+    _resolveClose;
+    _processClosed;
+    _thrownError;
+    get process() {
+        return this._process;
+    }
+    get pid() {
+        return this._process?.pid;
+    }
+    get exitCode() {
+        if (this._process && null !== this._process.exitCode) return this._process.exitCode;
+    }
+    constructor(e, t, n){
+        this._options = {
+            ...M,
+            ...n
+        };
+        this._command = e;
+        this._args = t ?? [];
+        this._processClosed = new Promise((e)=>{
+            this._resolveClose = e;
+        });
+    }
+    kill(e) {
+        return this._process?.kill(e) === true;
+    }
+    get aborted() {
+        return this._aborted;
+    }
+    get killed() {
+        return this._process?.killed === true;
+    }
+    pipe(e, t, n) {
+        return z(e, t, {
+            ...n,
+            stdin: this
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        const e = this._process;
+        if (!e) return;
+        const t = [];
+        if (this._streamErr) t.push(this._streamErr);
+        if (this._streamOut) t.push(this._streamOut);
+        const n = g(t);
+        const r = node_readline.createInterface({
+            input: n
+        });
+        for await (const e of r)yield e.toString();
+        await this._processClosed;
+        e.removeAllListeners();
+        if (this._thrownError) throw this._thrownError;
+        if (this._options?.throwOnError && 0 !== this.exitCode && void 0 !== this.exitCode) throw new j(this);
+    }
+    async _waitForOutput() {
+        const e = this._process;
+        if (!e) throw new Error("No process was started");
+        const [t, n] = await Promise.all([
+            this._streamOut ? I(this._streamOut) : "",
+            this._streamErr ? I(this._streamErr) : ""
+        ]);
+        await this._processClosed;
+        if (this._options?.stdin) await this._options.stdin;
+        e.removeAllListeners();
+        if (this._thrownError) throw this._thrownError;
+        const r = {
+            stderr: n,
+            stdout: t,
+            exitCode: this.exitCode
+        };
+        if (this._options.throwOnError && 0 !== this.exitCode && void 0 !== this.exitCode) throw new j(this, r);
+        return r;
+    }
+    then(e, t) {
+        return this._waitForOutput().then(e, t);
+    }
+    _streamOut;
+    _streamErr;
+    spawn() {
+        const e = external_node_process_cwd();
+        const n = this._options;
+        const r = {
+            ...N,
+            ...n.nodeOptions
+        };
+        const i = [];
+        this._resetState();
+        if (void 0 !== n.timeout) i.push(AbortSignal.timeout(n.timeout));
+        if (void 0 !== n.signal) i.push(n.signal);
+        if (true === n.persist) r.detached = true;
+        if (i.length > 0) r.signal = F(i);
+        r.env = h(e, r.env);
+        const { command: a, args: s } = P(this._command, this._args);
+        const c = (0, A._parse)(a, s, r);
+        const l = spawn(c.command, c.args, c.options);
+        if (l.stderr) this._streamErr = l.stderr;
+        if (l.stdout) this._streamOut = l.stdout;
+        this._process = l;
+        l.once("error", this._onError);
+        l.once("close", this._onClose);
+        if (void 0 !== n.stdin && l.stdin && n.stdin.process) {
+            const { stdout: e } = n.stdin.process;
+            if (e) e.pipe(l.stdin);
+        }
+    }
+    _resetState() {
+        this._aborted = false;
+        this._processClosed = new Promise((e)=>{
+            this._resolveClose = e;
+        });
+        this._thrownError = void 0;
+    }
+    _onError = (e)=>{
+        if ("AbortError" === e.name && (!(e.cause instanceof Error) || "TimeoutError" !== e.cause.name)) {
+            this._aborted = true;
+            return;
+        }
+        this._thrownError = e;
+    };
+    _onClose = ()=>{
+        if (this._resolveClose) this._resolveClose();
+    };
+};
+const R = (e, t, n)=>{
+    const r = new L(e, t, n);
+    r.spawn();
+    return r;
+};
+const z = R;
+async function createTarball(root, pkg) {
+    const tarballPath = node_path.join(root, `${normalizeNpmPackageName(pkg.name)}-${pkg.version}.tgz`);
+    const detectResult = await detect({
+        cwd: root
+    });
+    const [command, args] = function() {
+        switch(detectResult?.agent){
+            case "yarn":
+                return [
+                    "yarn",
+                    [
+                        "pack",
+                        "--filename",
+                        tarballPath
+                    ]
+                ];
+            case "yarn@berry":
+                return [
+                    "yarn",
+                    [
+                        "pack",
+                        "--out",
+                        tarballPath
+                    ]
+                ];
+            case "pnpm":
+            case "pnpm@6":
+                return [
+                    "pnpm",
+                    [
+                        "pack"
+                    ]
+                ];
+            case "npm":
+            case "bun":
+            case "deno":
+            case void 0:
+            default:
+                return [
+                    "npm",
+                    [
+                        "pack"
+                    ]
+                ];
+        }
+    }();
+    await R(command, args, {
+        nodeOptions: {
+            cwd: root
+        },
+        throwOnError: true
+    });
+    return {
+        path: tarballPath,
+        async [Symbol.asyncDispose] () {
+            try {
+                await promises.unlink(tarballPath);
+            } catch  {}
+        }
+    };
+}
+function normalizeNpmPackageName(name) {
+    return name.replaceAll("@", "").replaceAll("/", "-");
+}
+export { createTarball };