semantic-release-lerna 2.17.0 → 2.17.2

package/dist/index.js

@@ -22267,7 +22267,7 @@ import process11 from "node:process";
 import fs4 from "node:fs";
 import nodePath from "node:path";
 import { Readable as Readable4 } from "node:stream";
-var import_fast_glob2 = __toESM(require_out4(), 1);
+var import_fast_glob3 = __toESM(require_out4(), 1);
 
 // node_modules/globby/node_modules/unicorn-magic/node.js
 import { promisify as promisify3 } from "node:util";
@@ -22280,7 +22280,7 @@ function toPath2(urlOrPath) {
 var TEN_MEGABYTES_IN_BYTES2 = 10 * 1024 * 1024;
 
 // node_modules/globby/ignore.js
-var import_fast_glob = __toESM(require_out4(), 1);
+var import_fast_glob2 = __toESM(require_out4(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
 import process10 from "node:process";
 import fs3 from "node:fs";
@@ -22306,11 +22306,55 @@ function slash(path26) {
 }
 
 // node_modules/globby/utilities.js
+var import_fast_glob = __toESM(require_out4(), 1);
 import fs2 from "node:fs";
 import path8 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var isNegativePattern = (pattern) => pattern[0] === "!";
-var normalizeAbsolutePatternToRelative = (pattern) => pattern.startsWith("/") ? pattern.slice(1) : pattern;
+var normalizeAbsolutePatternToRelative = (pattern) => {
+  if (!pattern.startsWith("/")) {
+    return pattern;
+  }
+  const inner = pattern.slice(1);
+  const firstSlashIndex = inner.indexOf("/");
+  const firstSegment = firstSlashIndex > 0 ? inner.slice(0, firstSlashIndex) : inner;
+  if (firstSlashIndex > 0 && !import_fast_glob.default.isDynamicPattern(firstSegment)) {
+    return pattern;
+  }
+  return inner;
+};
+var absolutePrefixesMatch = (positivePrefix, negativePrefix) => negativePrefix === positivePrefix;
+var getStaticAbsolutePathPrefix = (pattern) => {
+  if (!path8.isAbsolute(pattern)) {
+    return void 0;
+  }
+  const staticSegments = [];
+  for (const segment of pattern.split("/")) {
+    if (!segment) {
+      continue;
+    }
+    if (import_fast_glob.default.isDynamicPattern(segment)) {
+      break;
+    }
+    staticSegments.push(segment);
+  }
+  return staticSegments.length === 0 ? void 0 : `/${staticSegments.join("/")}`;
+};
+var normalizeNegativePattern = (pattern, positiveAbsolutePathPrefixes = [], hasRelativePositivePattern = false) => {
+  if (!pattern.startsWith("/")) {
+    return pattern;
+  }
+  const normalizedPattern = normalizeAbsolutePatternToRelative(pattern);
+  if (normalizedPattern !== pattern) {
+    return normalizedPattern;
+  }
+  if (hasRelativePositivePattern) {
+    return pattern.slice(1);
+  }
+  const negativeAbsolutePathPrefix = getStaticAbsolutePathPrefix(pattern);
+  const preserveAsAbsolutePattern = negativeAbsolutePathPrefix !== void 0 && positiveAbsolutePathPrefixes.some((positiveAbsolutePathPrefix) => absolutePrefixesMatch(positiveAbsolutePathPrefix, negativeAbsolutePathPrefix));
+  return preserveAsAbsolutePattern ? pattern : pattern.slice(1);
+};
 var bindFsMethod = (object, methodName) => {
   const method = object?.[methodName];
   return typeof method === "function" ? method.bind(object) : void 0;
@@ -22636,7 +22680,7 @@ var normalizeOptions2 = (options = {}) => {
 };
 var collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgnoreFiles) => {
   const normalizedOptions = normalizeOptions2(options);
-  const childPaths = await globIgnoreFiles(import_fast_glob.default, patterns, normalizedOptions);
+  const childPaths = await globIgnoreFiles(import_fast_glob2.default, patterns, normalizedOptions);
   const gitRoot = includeParentIgnoreFiles ? await findGitRoot(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
   const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
   const readFileMethod = getReadFileMethod(normalizedOptions.fs);
@@ -22645,7 +22689,7 @@ var collectIgnoreFileArtifactsAsync = async (patterns, options, includeParentIgn
 };
 var collectIgnoreFileArtifactsSync = (patterns, options, includeParentIgnoreFiles) => {
   const normalizedOptions = normalizeOptions2(options);
-  const childPaths = globIgnoreFiles(import_fast_glob.default.sync, patterns, normalizedOptions);
+  const childPaths = globIgnoreFiles(import_fast_glob2.default.sync, patterns, normalizedOptions);
   const gitRoot = includeParentIgnoreFiles ? findGitRootSync(normalizedOptions.cwd, normalizedOptions.fs) : void 0;
   const allPaths = combineIgnoreFilePaths(gitRoot, normalizedOptions, childPaths);
   const readFileSyncMethod = getReadFileSyncMethod(normalizedOptions.fs);
@@ -22855,7 +22899,23 @@ var convertNegativePatterns = (patterns, options) => {
     }
     patterns = ["**/*", ...patterns];
   }
-  patterns = patterns.map((pattern) => isNegativePattern(pattern) ? `!${normalizeAbsolutePatternToRelative(pattern.slice(1))}` : pattern);
+  const positiveAbsolutePathPrefixes = [];
+  let hasRelativePositivePattern = false;
+  const normalizedPatterns = [];
+  for (const pattern of patterns) {
+    if (isNegativePattern(pattern)) {
+      normalizedPatterns.push(`!${normalizeNegativePattern(pattern.slice(1), positiveAbsolutePathPrefixes, hasRelativePositivePattern)}`);
+      continue;
+    }
+    normalizedPatterns.push(pattern);
+    const staticAbsolutePathPrefix = getStaticAbsolutePathPrefix(pattern);
+    if (staticAbsolutePathPrefix === void 0) {
+      hasRelativePositivePattern = true;
+      continue;
+    }
+    positiveAbsolutePathPrefixes.push(staticAbsolutePathPrefix);
+  }
+  patterns = normalizedPatterns;
   const tasks = [];
   while (patterns.length > 0) {
     const index = patterns.findIndex((pattern) => isNegativePattern(pattern));
@@ -22938,29 +22998,29 @@ var generateTasksSync = (patterns, options) => {
 var globby = normalizeArguments(async (patterns, options) => {
   const { options: modifiedOptions, filter: filter2 } = await applyIgnoreFilesAndGetFilter(options);
   const tasks = await generateTasks(patterns, modifiedOptions);
-  const results = await Promise.all(tasks.map((task) => (0, import_fast_glob2.default)(task.patterns, task.options)));
+  const results = await Promise.all(tasks.map((task) => (0, import_fast_glob3.default)(task.patterns, task.options)));
   return unionFastGlobResults(results, filter2);
 });
 var globbySync = normalizeArgumentsSync((patterns, options) => {
   const { options: modifiedOptions, filter: filter2 } = applyIgnoreFilesAndGetFilterSync(options);
   const tasks = generateTasksSync(patterns, modifiedOptions);
-  const results = tasks.map((task) => import_fast_glob2.default.sync(task.patterns, task.options));
+  const results = tasks.map((task) => import_fast_glob3.default.sync(task.patterns, task.options));
   return unionFastGlobResults(results, filter2);
 });
 var globbyStream = normalizeArgumentsSync((patterns, options) => {
   const { options: modifiedOptions, filter: filter2 } = applyIgnoreFilesAndGetFilterSync(options);
   const tasks = generateTasksSync(patterns, modifiedOptions);
-  const streams = tasks.map((task) => import_fast_glob2.default.stream(task.patterns, task.options));
+  const streams = tasks.map((task) => import_fast_glob3.default.stream(task.patterns, task.options));
   if (streams.length === 0) {
     return Readable4.from([]);
   }
   const stream = mergeStreams(streams).filter((fastGlobResult) => filter2(fastGlobResult));
   return stream;
 });
-var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob2.default.isDynamicPattern(pattern, options)));
+var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob3.default.isDynamicPattern(pattern, options)));
 var generateGlobTasks = normalizeArguments(generateTasks);
 var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
-var { convertPathToPattern } = import_fast_glob2.default;
+var { convertPathToPattern } = import_fast_glob3.default;
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -25737,7 +25797,7 @@ function hasTags(opts, logger) {
 // src/utils/make-diff-predicate.js
 import path11 from "node:path/posix";
 
-// node_modules/@isaacs/balanced-match/dist/esm/index.js
+// node_modules/minimatch/node_modules/balanced-match/dist/esm/index.js
 var balanced = (a2, b, str2) => {
   const ma = a2 instanceof RegExp ? maybeMatch(a2, str2) : a2;
   const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
@@ -25790,7 +25850,7 @@ var range = (a2, b, str2) => {
   return result;
 };
 
-// node_modules/@isaacs/brace-expansion/dist/esm/index.js
+// node_modules/minimatch/node_modules/brace-expansion/dist/esm/index.js
 var escSlash = "\0SLASH" + Math.random() + "\0";
 var escOpen = "\0OPEN" + Math.random() + "\0";
 var escClose = "\0CLOSE" + Math.random() + "\0";
@@ -26513,6 +26573,7 @@ var AST = class _AST {
     let escaping = false;
     let re = "";
     let uflag = false;
+    let inStar = false;
     for (let i2 = 0; i2 < glob.length; i2++) {
       const c3 = glob.charAt(i2);
       if (escaping) {
@@ -26520,6 +26581,16 @@ var AST = class _AST {
         re += (reSpecials.has(c3) ? "\\" : "") + c3;
         continue;
       }
+      if (c3 === "*") {
+        if (inStar)
+          continue;
+        inStar = true;
+        re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
+        hasMagic = true;
+        continue;
+      } else {
+        inStar = false;
+      }
       if (c3 === "\\") {
         if (i2 === glob.length - 1) {
           re += "\\\\";
@@ -26538,11 +26609,6 @@ var AST = class _AST {
           continue;
         }
       }
-      if (c3 === "*") {
-        re += noEmpty && glob === "*" ? starNoEmpty : star;
-        hasMagic = true;
-        continue;
-      }
       if (c3 === "?") {
         re += qmark;
         hasMagic = true;
@@ -26678,7 +26744,7 @@ var braceExpand = (pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return expand(pattern);
+  return expand(pattern, { max: options.braceExpandMax });
 };
 minimatch.braceExpand = braceExpand;
 var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
@@ -26719,7 +26785,8 @@ var Minimatch = class {
     this.pattern = pattern;
     this.platform = options.platform || defaultPlatform;
     this.isWindows = this.platform === "win32";
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    const awe = "allowWindowsEscape";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
     if (this.windowsPathsNoEscape) {
       this.pattern = this.pattern.replace(/\\/g, "/");
     }
@@ -26776,7 +26843,10 @@ var Minimatch = class {
         const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
         const isDrive = /^[a-z]:/i.test(s[0]);
         if (isUNC) {
-          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+          return [
+            ...s.slice(0, 4),
+            ...s.slice(4).map((ss) => this.parse(ss))
+          ];
         } else if (isDrive) {
           return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
         }
@@ -27057,7 +27127,10 @@ var Minimatch = class {
       const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
       const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
       if (typeof fdi === "number" && typeof pdi === "number") {
-        const [fd, pd] = [file[fdi], pattern[pdi]];
+        const [fd, pd] = [
+          file[fdi],
+          pattern[pdi]
+        ];
         if (fd.toLowerCase() === pd.toLowerCase()) {
           pattern[pdi] = fd;
           if (pdi > fdi) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-release-lerna",
-  "version": "2.17.0",
+  "version": "2.17.2",
   "description": "semantic-release plugin to publish lerna monorepo packages to npm",
   "keywords": [
     "npm",