@vltpkg/cli-js 1.0.2 → 1.0.4

package/src-X66SVM5T.js

@@ -0,0 +1,933 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  rimraf
+} from "./chunk-BJBFEQRR.js";
+import "./chunk-VE6CCH33.js";
+import {
+  asError
+} from "./chunk-IITIX4ID.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+import "./chunk-PZLD7RTK.js";
+
+// ../../src/tar/src/unpack.ts
+import { randomBytes } from "node:crypto";
+import { lstat, mkdir, rename, writeFile } from "node:fs/promises";
+import {
+  basename as basename2,
+  dirname,
+  isAbsolute,
+  relative,
+  resolve,
+  sep
+} from "node:path";
+
+// ../../node_modules/.vlt/~npm~tar@7.5.22/node_modules/tar/dist/esm/header.js
+import { posix as pathModule } from "node:path";
+
+// ../../node_modules/.vlt/~npm~tar@7.5.22/node_modules/tar/dist/esm/large-numbers.js
+var encode = (num, buf) => {
+  if (!Number.isSafeInteger(num)) {
+    throw Error("cannot encode number outside of javascript safe integer range");
+  } else if (num < 0) {
+    encodeNegative(num, buf);
+  } else {
+    encodePositive(num, buf);
+  }
+  return buf;
+};
+var encodePositive = (num, buf) => {
+  buf[0] = 128;
+  for (var i = buf.length; i > 1; i--) {
+    buf[i - 1] = num & 255;
+    num = Math.floor(num / 256);
+  }
+};
+var encodeNegative = (num, buf) => {
+  buf[0] = 255;
+  var flipped = false;
+  num = num * -1;
+  for (var i = buf.length; i > 1; i--) {
+    var byte = num & 255;
+    num = Math.floor(num / 256);
+    if (flipped) {
+      buf[i - 1] = onesComp(byte);
+    } else if (byte === 0) {
+      buf[i - 1] = 0;
+    } else {
+      flipped = true;
+      buf[i - 1] = twosComp(byte);
+    }
+  }
+};
+var parse = (buf) => {
+  const pre = buf[0];
+  const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
+  if (value === null) {
+    throw Error("invalid base256 encoding");
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw Error("parsed number outside of javascript safe integer range");
+  }
+  return value;
+};
+var 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;
+};
+var 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;
+};
+var onesComp = (byte) => (255 ^ byte) & 255;
+var twosComp = (byte) => (255 ^ byte) + 1 & 255;
+
+// ../../node_modules/.vlt/~npm~tar@7.5.22/node_modules/tar/dist/esm/types.js
+var isCode = (c) => name.has(c);
+var normalFsTypes = /* @__PURE__ */ new Set([
+  "0",
+  "",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "D"
+]);
+var name = /* @__PURE__ */ 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"]
+]);
+var code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
+
+// ../../node_modules/.vlt/~npm~tar@7.5.22/node_modules/tar/dist/esm/header.js
+var notNegative = (n) => n === void 0 || n < 0 ? void 0 : n;
+var Header = class {
+  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");
+    }
+    const t = decString(buf, off + 156, 1);
+    const isNormalFS = normalFsTypes.has(t);
+    const exForFields = isNormalFS ? ex : void 0;
+    const gexForFields = isNormalFS ? gex : void 0;
+    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 (gexForFields)
+      this.#slurp(gexForFields, true);
+    if (exForFields)
+      this.#slurp(exForFields);
+    if (isCode(t)) {
+      this.#type = t || "0";
+    }
+    if (this.#type === "0" && this.path.slice(-1) === "/") {
+      this.#type = "5";
+    }
+    if (this.#type === "5") {
+      this.size = 0;
+    }
+    this.linkpath = decString(buf, off + 157, 100);
+    if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
+      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;
+      if (buf[off + 475] !== 0) {
+        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;
+        }
+        this.atime = ex?.atime ?? gex?.atime ?? decDate(buf, off + 476, 12);
+        this.ctime = ex?.ctime ?? gex?.ctime ?? decDate(buf, off + 488, 12);
+      }
+    }
+    let sum = 8 * 32;
+    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 === void 0 && sum === 8 * 32) {
+      this.nullBlock = true;
+    }
+  }
+  #slurp(ex, gex = false) {
+    Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+      return !(v === null || v === void 0 || 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\x0000", 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 * 32;
+    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 : name.get(this.#type);
+  }
+  get typeKey() {
+    return this.#type;
+  }
+  set type(type) {
+    const c = String(code.get(type));
+    if (isCode(c) || c === "Unsupported") {
+      this.#type = c;
+    } else if (isCode(type)) {
+      this.#type = type;
+    } else {
+      throw new TypeError("invalid entry type: " + type);
+    }
+  }
+};
+var splitPrefix = (p, prefixSize) => {
+  const pathSize = 100;
+  let pp = p;
+  let prefix = "";
+  let ret = void 0;
+  const root = pathModule.parse(p).root || ".";
+  if (Buffer.byteLength(pp) < pathSize) {
+    ret = [pp, prefix, false];
+  } else {
+    prefix = pathModule.dirname(pp);
+    pp = pathModule.basename(pp);
+    do {
+      if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) {
+        ret = [pp, prefix, false];
+      } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) {
+        ret = [pp.slice(0, pathSize - 1), prefix, true];
+      } else {
+        pp = pathModule.join(pathModule.basename(prefix), pp);
+        prefix = pathModule.dirname(prefix);
+      }
+    } while (prefix !== root && ret === void 0);
+    if (!ret) {
+      ret = [p.slice(0, pathSize - 1), "", true];
+    }
+  }
+  return ret;
+};
+var decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
+var decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+var numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3);
+var decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
+var nanUndef = (value) => isNaN(value) ? void 0 : value;
+var decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+var MAXNUM = {
+  12: 8589934591,
+  8: 2097151
+};
+var encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
+var encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
+var octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+var padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
+var encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
+var NULLS = new Array(156).join("\0");
+var encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
+
+// ../../node_modules/.vlt/~npm~tar@7.5.22/node_modules/tar/dist/esm/pax.js
+import { basename } from "node:path";
+var Pax = 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);
+    const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+    const buf = Buffer.allocUnsafe(bufLen);
+    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 || 420,
+      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");
+    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] === void 0) {
+      return "";
+    }
+    const r = this[field];
+    const v = r instanceof Date ? r.getTime() / 1e3 : r;
+    const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
+    const byteLen = Buffer.byteLength(s);
+    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);
+  }
+};
+var merge = (a, b) => b ? Object.assign({}, b, a) : a;
+var parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
+var parseKVLine = (set, line) => {
+  const n = parseInt(line, 10);
+  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) * 1e3);
+      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;
+};
+
+// ../../src/tar/src/unpack.ts
+import { unzip as unzipCB } from "node:zlib";
+
+// ../../src/tar/src/find-tar-dir.ts
+var findTarDir = (path, tarDir) => {
+  if (tarDir !== void 0) return tarDir;
+  if (!path) return void 0;
+  const i = path.indexOf("/", path.startsWith("./") ? 2 : 0);
+  if (i === -1) return void 0;
+  const chomp = path.substring(0, i);
+  if (chomp === "." || chomp === ".." || chomp === "" || chomp === "./." || chomp === "./.." || chomp === "./") {
+    return void 0;
+  }
+  return chomp + "/";
+};
+
+// ../../src/tar/src/unpack.ts
+var MAX_DECOMPRESSION_RATIO = 1e3;
+var defaultMaxUnpackedBytes = 2 * 1024 * 1024 * 1024;
+var parseMaxUnpackedBytes = (raw) => {
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 1 ? Math.floor(n) : defaultMaxUnpackedBytes;
+};
+var maxUnpackedBytes = parseMaxUnpackedBytes(
+  process.env.VLT_TAR_MAX_UNPACKED_BYTES
+);
+var unzip = async (input) => {
+  const max = Math.min(
+    maxUnpackedBytes,
+    input.length * MAX_DECOMPRESSION_RATIO
+  );
+  return new Promise(
+    (res, rej) => unzipCB(input, { maxOutputLength: max }, (er, result) => {
+      if (!er) return res(result);
+      return rej(
+        er.code === "ERR_BUFFER_TOO_LARGE" ? error("tarball exceeds maximum unpacked size", {
+          found: input.length,
+          max,
+          cause: er
+        }) : er
+      );
+    })
+  );
+};
+var exists = async (path) => {
+  try {
+    await lstat(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var id = 1;
+var tmp = randomBytes(6).toString("hex") + ".";
+var tmpSuffix = () => tmp + String(id++);
+var foldKeys = process.platform === "darwin" || process.platform === "win32";
+var entryKey = (p) => foldKeys ? p.toLowerCase() : p;
+var parseWriteLanes = (raw) => {
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 1 ? Math.floor(n) : 64;
+};
+var writeLaneLimit = parseWriteLanes(
+  process.env.VLT_TAR_WRITE_LANES
+);
+var writeLanesUsed = 0;
+var writeLaneWaiters = [];
+var writeLaneHead = 0;
+var acquireWriteLane = async () => {
+  if (writeLanesUsed < writeLaneLimit) {
+    writeLanesUsed++;
+    return;
+  }
+  await new Promise((res) => writeLaneWaiters.push(res));
+};
+var releaseWriteLane = () => {
+  const next = writeLaneWaiters[writeLaneHead];
+  if (next) {
+    writeLaneWaiters[writeLaneHead] = void 0;
+    writeLaneHead++;
+    if (writeLaneHead === writeLaneWaiters.length) {
+      writeLaneWaiters.length = 0;
+      writeLaneHead = 0;
+    }
+    next();
+  } else {
+    writeLanesUsed--;
+  }
+};
+var withWriteLane = async (fn) => {
+  await acquireWriteLane();
+  try {
+    return await fn();
+  } finally {
+    releaseWriteLane();
+  }
+};
+var rethrowFirst = (results) => {
+  for (const result of results) {
+    if (result.status === "rejected") throw result.reason;
+  }
+};
+var isClearlySafeRelPath = (sub) => {
+  const len = sub.length;
+  if (len === 0) return true;
+  if (sub.charCodeAt(0) === 47) return false;
+  if (len >= 2 && sub.charCodeAt(1) === 58) {
+    const c = sub.charCodeAt(0);
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+      return false;
+    }
+  }
+  let i = 0;
+  while (i < len) {
+    let j = i;
+    while (j < len && sub.charCodeAt(j) !== 47) j++;
+    const slen = j - i;
+    if (slen === 1 && sub.charCodeAt(i) === 46) return false;
+    if (slen === 2 && sub.charCodeAt(i) === 46 && sub.charCodeAt(i + 1) === 46) {
+      return false;
+    }
+    i = j + 1;
+  }
+  return true;
+};
+var checkFs = (h, tarDir, target) => {
+  if (!h.path) return false;
+  if (!tarDir) return false;
+  h.path = h.path.replace(/[\\/]+/g, "/");
+  if (!h.path.startsWith(tarDir)) return false;
+  const sub = h.path.slice(tarDir.length);
+  if (isClearlySafeRelPath(sub)) return true;
+  const rel = relative(target, resolve(target, sub));
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    return false;
+  }
+  return true;
+};
+var write = async (path, body, executable = false) => {
+  await writeFile(path, body, {
+    mode: executable ? 511 : 438
+  });
+};
+var unpack = async (tarData, target) => {
+  const isGzip = tarData[0] === 31 && tarData[1] === 139;
+  await unpackUnzipped(
+    isGzip ? await unzip(tarData) : tarData,
+    target
+  );
+};
+var unpackUnzipped = async (buffer, target) => {
+  const isGzip = buffer[0] === 31 && buffer[1] === 139;
+  if (isGzip) {
+    throw error("still gzipped after unzipping", {
+      found: isGzip,
+      wanted: false
+    });
+  }
+  if (buffer.length % 512 !== 0) {
+    throw error("Invalid tarball: length not divisible by 512", {
+      found: buffer.length
+    });
+  }
+  if (buffer.length < 1024) {
+    throw error(
+      "Invalid tarball: not terminated by 1024 null bytes",
+      { found: buffer.length }
+    );
+  }
+  for (let i = buffer.length - 1024; i < buffer.length; i++) {
+    if (buffer[i] !== 0) {
+      throw error(
+        "Invalid tarball: not terminated by 1024 null bytes",
+        { found: buffer.subarray(i, i + 10) }
+      );
+    }
+  }
+  const tmp2 = dirname(target) + sep + "." + basename2(target) + "." + tmpSuffix();
+  const og = tmp2 + ".ORIGINAL";
+  let succeeded = false;
+  try {
+    const entries = /* @__PURE__ */ new Map();
+    let tarDir = void 0;
+    let offset = 0;
+    let h;
+    let ex = void 0;
+    let gex = void 0;
+    while (offset < buffer.length && !(h = new Header(buffer, offset, ex, gex)).nullBlock) {
+      offset += 512;
+      ex = void 0;
+      gex = void 0;
+      const size = h.size ?? 0;
+      const body = buffer.subarray(offset, offset + size);
+      if (!h.cksumValid) continue;
+      offset += 512 * Math.ceil(size / 512);
+      switch (h.type) {
+        case "File":
+          if (!tarDir) tarDir = findTarDir(h.path, tarDir);
+          if (!tarDir) continue;
+          if (!checkFs(h, tarDir, tmp2)) continue;
+          {
+            const dest = resolve(tmp2, h.path.substring(tarDir.length));
+            const key = entryKey(dest);
+            if (entries.get(key)?.dir === true) {
+              throw error("file/directory collision in tarball", {
+                path: dest
+              });
+            }
+            entries.set(key, {
+              path: dest,
+              body,
+              executable: 1 === ((h.mode ?? 1638) & 1),
+              dir: false
+            });
+          }
+          break;
+        case "Directory":
+          if (!tarDir) tarDir = findTarDir(h.path, tarDir);
+          if (!tarDir) continue;
+          if (!checkFs(h, tarDir, tmp2)) continue;
+          {
+            const dest = resolve(tmp2, h.path.substring(tarDir.length));
+            const key = entryKey(dest);
+            if (entries.get(key)?.dir === false) {
+              throw error("file/directory collision in tarball", {
+                path: dest
+              });
+            }
+            entries.set(key, {
+              path: dest,
+              dir: true
+            });
+          }
+          break;
+        case "GlobalExtendedHeader":
+          gex = Pax.parse(body.toString(), gex, true);
+          break;
+        case "ExtendedHeader":
+        case "OldExtendedHeader":
+          ex = Pax.parse(body.toString(), ex, false);
+          break;
+        case "NextFileHasLongPath":
+        case "OldGnuLongPath":
+          ex ??= /* @__PURE__ */ Object.create(null);
+          ex.path = body.toString().replace(/\0.*/, "");
+          break;
+      }
+    }
+    const dirs = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const e of entries.values()) {
+      if (e.dir) dirs.add(e.path);
+      else {
+        dirs.add(dirname(e.path));
+        files.push(e);
+      }
+    }
+    rethrowFirst(
+      await Promise.allSettled(
+        [...dirs].map(
+          (d) => mkdir(d, { recursive: true, mode: 511 })
+        )
+      )
+    );
+    rethrowFirst(
+      await Promise.allSettled(
+        files.map(
+          (f) => withWriteLane(() => write(f.path, f.body, f.executable))
+        )
+      )
+    );
+    const targetExists = await exists(target);
+    if (targetExists) await rename(target, og);
+    await rename(tmp2, target);
+    if (targetExists) await rimraf(og);
+    succeeded = true;
+  } finally {
+    if (!succeeded) {
+      if (await exists(og)) {
+        await rimraf(target);
+        await rename(og, target);
+      }
+      await rimraf(tmp2);
+    }
+  }
+};
+
+// ../../src/tar/src/pool.ts
+import os from "node:os";
+
+// ../../src/tar/src/unpack-request.ts
+var ID = 1;
+var UnpackRequest = class {
+  id = ID++;
+  tarData;
+  target;
+  resolve;
+  reject;
+  promise = new Promise((res, rej) => {
+    this.resolve = res;
+    this.reject = rej;
+  });
+  constructor(tarData, target) {
+    this.tarData = tarData;
+    this.target = target;
+  }
+};
+
+// ../../src/tar/src/worker.ts
+var isObj = (o) => !!o && typeof o === "object";
+var isResponseOK = (o) => isObj(o) && typeof o.id === "number" && o.ok === true;
+var Worker = class {
+  onMessage;
+  constructor(onMessage) {
+    this.onMessage = onMessage;
+  }
+  async process(req) {
+    const { target, tarData, id: id2 } = req;
+    try {
+      await unpack(tarData, target);
+      const m = { id: id2, ok: true };
+      this.onMessage(m);
+    } catch (error2) {
+      const m = { id: id2, error: error2 };
+      this.onMessage(m);
+    }
+  }
+};
+
+// ../../src/tar/src/pool.ts
+var Pool = class {
+  /**
+   * Number of workers to emplly. Defaults to 1 less than the number of
+   * CPUs, or 1.
+   */
+  /* c8 ignore next */
+  jobs = 8 * (Math.max(os.availableParallelism(), 2) - 1);
+  /**
+   * Set of currently active worker threads
+   */
+  workers = /* @__PURE__ */ new Set();
+  /**
+   * Queue of requests awaiting an available worker
+   */
+  queue = [];
+  /**
+   * Requests that have been assigned to a worker, but have not yet
+   * been confirmed completed.
+   */
+  pending = /* @__PURE__ */ new Map();
+  // handle a message from the worker
+  #onMessage(w, m) {
+    const { id: id2 } = m;
+    const ur = this.pending.get(id2);
+    if (!ur) return;
+    if (isResponseOK(m)) {
+      ur.resolve();
+    } else {
+      ur.reject(
+        error(
+          asError(m.error, "failed without error message").message,
+          {
+            found: m,
+            cause: m.error
+          }
+        )
+      );
+    }
+    const next = this.queue.shift();
+    if (!next) {
+      this.workers.delete(w);
+    } else {
+      void w.process(next);
+    }
+  }
+  // create a new worker
+  #createWorker(req) {
+    const w = new Worker(
+      (m) => this.#onMessage(w, m)
+    );
+    this.workers.add(w);
+    void w.process(req);
+  }
+  /**
+   * Provide the tardata to be unpacked, and the location where it's to be
+   * placed. Will create a new worker up to the `jobs` value, and then start
+   * pushing in the queue for workers to pick up as they become available.
+   *
+   * Returned promise resolves when the provided tarball has been extracted.
+   */
+  async unpack(tarData, target) {
+    const ur = new UnpackRequest(tarData, target);
+    this.pending.set(ur.id, ur);
+    if (this.workers.size < this.jobs) {
+      this.#createWorker(ur);
+    } else {
+      this.queue.push(ur);
+    }
+    return ur.promise;
+  }
+};
+export {
+  Pool,
+  UnpackRequest,
+  Worker,
+  isResponseOK,
+  unpack
+};