@vltpkg/cli-js 1.0.0-rc.29 → 1.0.0-rc.30

package/chunk-QI6JZT5E.js

@@ -0,0 +1,781 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  It,
+  Zn,
+  require_lib
+} from "./chunk-HQ4US6G3.js";
+import {
+  minimatch
+} from "./chunk-XYCCQT7N.js";
+import {
+  Spec2 as Spec
+} from "./chunk-IEISSXS4.js";
+import {
+  parse,
+  stringify
+} from "./chunk-HTOTG4TS.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-PZLD7RTK.js";
+
+// ../../node_modules/.vlt/~npm~ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.vlt/~npm~ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path, cache, checkUnignored, slices);
+      }
+      checkIgnore(path) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+          return this.test(path);
+        }
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path, false, MODE_CHECK_IGNORE);
+      }
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// ../../src/cli-sdk/src/pack-tarball.ts
+var ssri = __toESM(require_lib(), 1);
+import assert from "node:assert";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+var import_ignore = __toESM(require_ignore(), 1);
+var replaceWorkspaceAndCatalogSpecs = (manifest_, config) => {
+  const manifest = parse(stringify(manifest_));
+  const { monorepo, catalog = {}, catalogs = {} } = config.options;
+  const depTypes = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies"
+  ];
+  for (const depType of depTypes) {
+    const deps = manifest[depType];
+    if (!deps || typeof deps !== "object") continue;
+    const depsObj = deps;
+    for (const [depName, depSpec] of Object.entries(depsObj)) {
+      if (typeof depSpec !== "string") continue;
+      const spec = Spec.parse(`${depName}@${depSpec}`, {
+        catalog,
+        catalogs
+      });
+      switch (spec.type) {
+        case "workspace": {
+          assert(
+            monorepo,
+            error(`No workspace configuration found for ${depName}`, {
+              found: depName
+            })
+          );
+          const workspaceName = spec.workspace;
+          assert(
+            workspaceName,
+            error(`No workspace name found for ${depName}`, {
+              found: depName
+            })
+          );
+          const workspace = monorepo.get(workspaceName);
+          assert(
+            workspace,
+            error(`Workspace '${workspaceName}' not found`, {
+              found: workspaceName,
+              validOptions: Array.from(monorepo.keys())
+            })
+          );
+          const actualVersion = workspace.manifest.version;
+          assert(
+            actualVersion,
+            error(
+              `No version found for workspace '${workspaceName}'`,
+              {
+                found: workspaceName,
+                wanted: "package version"
+              }
+            )
+          );
+          depsObj[depName] = actualVersion;
+          break;
+        }
+        case "catalog": {
+          const catalogName = spec.catalog || "";
+          const targetCatalog = catalogName ? catalogs[catalogName] : catalog;
+          assert(
+            targetCatalog,
+            error(`Catalog '${catalogName}' not found`, {
+              found: catalogName,
+              validOptions: Object.keys(catalogs)
+            })
+          );
+          const actualVersion = targetCatalog[depName];
+          assert(
+            actualVersion,
+            error(
+              `Package '${depName}' not found in catalog '${catalogName || "default"}'`,
+              {
+                found: depName,
+                validOptions: Object.keys(targetCatalog)
+              }
+            )
+          );
+          depsObj[depName] = actualVersion;
+          break;
+        }
+      }
+    }
+  }
+  return manifest;
+};
+var alwaysExcludePatterns = [
+  /^\.?\/?\.git(\/|$)/,
+  /^\.?\/?node_modules(\/|$)/,
+  /^\.?\/?\.nyc_output(\/|$)/,
+  /^\.?\/?coverage(\/|$)/,
+  /^\.?\/?\.vscode(\/|$)/,
+  /^\.?\/?\.idea(\/|$)/,
+  /^\.?\/?\.DS_Store$/,
+  /^\.?\/?\.npmrc$/,
+  /^\.?\/?\.gitignore$/,
+  /^\.?\/?\.npmignore$/,
+  /^\.?\/?\.editorconfig$/,
+  /^\.?\/?package-lock\.json$/,
+  /^\.?\/?yarn\.lock$/,
+  /^\.?\/?pnpm-lock\.yaml$/,
+  /^\.?\/?bun\.lockb$/,
+  /^\.?\/?bun\.lock$/,
+  /^\.?\/?vlt-lock\.json$/,
+  /^\.?\/?vlt\.json$/,
+  /~$/,
+  /\.swp$/,
+  /\.tgz$/
+];
+var alwaysIncludePatterns = [
+  /^README(\..*)?$/i,
+  /^CHANGELOG(\..*)?$/i,
+  /^HISTORY(\..*)?$/i,
+  /^LICENSE(\..*)?$/i,
+  /^LICENCE(\..*)?$/i
+];
+var readIgnoreFile = (dir, name) => {
+  const filePath = join(dir, name);
+  if (!existsSync(filePath)) return void 0;
+  return readFileSync(filePath, "utf8");
+};
+var buildPackFilter = (manifest, packDir) => {
+  const manifestWithFiles = manifest;
+  const hasFilesField = Array.isArray(manifestWithFiles.files) && manifestWithFiles.files.length > 0;
+  const hasEmptyFilesField = Array.isArray(manifestWithFiles.files) && manifestWithFiles.files.length === 0;
+  let ig;
+  if (!hasFilesField && !hasEmptyFilesField) {
+    const npmignoreContent = readIgnoreFile(packDir, ".npmignore");
+    if (npmignoreContent !== void 0) {
+      ig = (0, import_ignore.default)().add(npmignoreContent);
+    } else {
+      const gitignoreContent = readIgnoreFile(packDir, ".gitignore");
+      if (gitignoreContent !== void 0) {
+        ig = (0, import_ignore.default)().add(gitignoreContent);
+      }
+    }
+  }
+  return (path) => {
+    const normalizedPath = path.replace(/^\.\//, "");
+    if (path === "." || normalizedPath === "") {
+      return true;
+    }
+    if (alwaysExcludePatterns.some(
+      (pattern) => pattern.test(normalizedPath)
+    )) {
+      return false;
+    }
+    if (alwaysIncludePatterns.some(
+      (pattern) => pattern.test(normalizedPath)
+    )) {
+      return true;
+    }
+    if (normalizedPath === "package.json") {
+      return true;
+    }
+    if (hasEmptyFilesField) {
+      return false;
+    }
+    if (hasFilesField && manifestWithFiles.files) {
+      return manifestWithFiles.files.some((pattern) => {
+        if (pattern.endsWith("/")) {
+          const dirName = pattern.slice(0, -1);
+          const globPattern = pattern.replace(/\/$/, "/**");
+          const matchesDir = normalizedPath === dirName;
+          const matchesContents = minimatch(
+            normalizedPath,
+            globPattern,
+            { dot: true }
+          );
+          return matchesDir || matchesContents;
+        }
+        const directMatch = minimatch(normalizedPath, pattern, {
+          dot: true
+        });
+        const isParentDir = pattern.includes("/") && pattern.startsWith(normalizedPath + "/");
+        const isChildOfPattern = minimatch(
+          normalizedPath,
+          pattern + "/**",
+          { dot: true }
+        );
+        return directMatch || isParentDir || isChildOfPattern;
+      });
+    }
+    if (ig?.ignores(normalizedPath)) {
+      return false;
+    }
+    return true;
+  };
+};
+var packTarball = async (manifest, dir, config) => {
+  let packDir = dir;
+  const cliPublishDir = config.get("publish-directory");
+  const manifestPublishDir = manifest.publishConfig?.directory;
+  const publishDirectory = cliPublishDir ?? manifestPublishDir;
+  if (publishDirectory) {
+    const resolvedPublishDir = cliPublishDir ? publishDirectory : join(dir, publishDirectory);
+    assert(
+      existsSync(resolvedPublishDir),
+      error(
+        `Publish directory does not exist: ${resolvedPublishDir}`,
+        {
+          found: resolvedPublishDir
+        }
+      )
+    );
+    assert(
+      statSync(resolvedPublishDir).isDirectory(),
+      error(
+        `Publish directory is not a directory: ${resolvedPublishDir}`,
+        {
+          found: resolvedPublishDir,
+          wanted: "directory"
+        }
+      )
+    );
+    if (existsSync(join(resolvedPublishDir, "package.json"))) {
+      manifest = config.options.packageJson.read(resolvedPublishDir);
+    }
+    packDir = resolvedPublishDir;
+  }
+  assert(
+    manifest.name && manifest.version,
+    error("Package must have a name and version")
+  );
+  const processedManifest = replaceWorkspaceAndCatalogSpecs(
+    manifest,
+    config
+  );
+  const filename = `${manifest.name.replace("@", "").replace("/", "-")}-${manifest.version}.tgz`;
+  const tarballName = `${manifest.name}-${manifest.version}.tgz`;
+  try {
+    config.options.packageJson.write(packDir, processedManifest);
+    const packFilter = buildPackFilter(manifest, packDir);
+    const tarballData = await Zn(
+      {
+        cwd: packDir,
+        gzip: true,
+        portable: true,
+        prefix: "package/",
+        filter: packFilter
+      },
+      ["."]
+    ).concat();
+    let unpackedSize = 0;
+    const files = [];
+    await new Promise((resolve, reject) => {
+      const stream = It({
+        onentry: (entry) => {
+          if (entry.type === "File") {
+            unpackedSize += entry.size;
+            const cleanPath = entry.path.replace(/^[^/]+\//, "");
+            if (cleanPath) {
+              files.push(cleanPath);
+            }
+          }
+        }
+      });
+      stream.on("end", () => resolve()).on("error", reject).write(tarballData);
+      stream.end();
+    });
+    const integrityMap = ssri.fromData(tarballData, {
+      algorithms: [.../* @__PURE__ */ new Set(["sha1", "sha512"])]
+    });
+    const integrity = integrityMap.sha512?.[0]?.toString();
+    const shasum = integrityMap.sha1?.[0]?.hexDigest();
+    return {
+      name: manifest.name,
+      version: manifest.version,
+      filename,
+      tarballName,
+      tarballData,
+      unpackedSize,
+      files,
+      integrity,
+      shasum,
+      resolvedManifest: processedManifest
+    };
+  } finally {
+    config.options.packageJson.write(packDir, manifest);
+  }
+};
+
+export {
+  packTarball
+};