semantic-release-lerna 2.17.2 → 2.18.1

package/dist/index.js

@@ -402,7 +402,7 @@ var require_parse = __commonJS({
     "use strict";
     var path26 = __require("path");
     var resolveCommand = require_resolveCommand();
-    var escape2 = require_escape();
+    var escape3 = require_escape();
     var readShebang = require_readShebang();
     var isWin = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
@@ -426,8 +426,8 @@ var require_parse = __commonJS({
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
         parsed.command = path26.normalize(parsed.command);
-        parsed.command = escape2.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+        parsed.command = escape3.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape3.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.command = process.env.comspec || "cmd.exe";
@@ -15324,25 +15324,25 @@ Please follow the [npm guideline](https://docs.npmjs.com/getting-started/creatin
 }
 
 // src/get-error.js
-function get_error_default(code, ctx = {}) {
+function getError(code, ctx = {}) {
   const { message, details } = errors_exports[code](ctx);
   return new SemanticReleaseError(message, code, details);
 }
 
 // src/get-pkg.js
-async function get_pkg_default({ pkgRoot }, { cwd }) {
+async function getPkg({ pkgRoot }, { cwd }) {
   try {
     const rootDir = pkgRoot ? path.resolve(cwd, String(pkgRoot)) : cwd;
     const filePath = path.join(rootDir, "package.json");
     const content = await fs.readFile(filePath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.name) {
-      throw get_error_default("ENOPKGNAME");
+      throw getError("ENOPKGNAME");
     }
     return pkg;
   } catch (error) {
     if (error.code === "ENOENT") {
-      throw new AggregateError2([get_error_default("ENOPKG")]);
+      throw new AggregateError2([getError("ENOPKG")]);
     }
     throw new AggregateError2([error]);
   }
@@ -22190,6 +22190,7 @@ var PackageGraph = class extends Map {
    *    Pass "dependencies" to create a graph of only dependencies,
    *    excluding the devDependencies that would normally be included.
    */
+  /* eslint-disable-next-line complexity -- inherited technical debt */
   constructor(packages, graphType = "allDependencies") {
     super(packages.map((pkg) => [pkg.name, new PackageGraphNode(pkg)]));
     if (packages.length !== this.size) {
@@ -22209,16 +22210,16 @@ var PackageGraph = class extends Map {
         }
       }
     }
-    this.forEach((currentNode, currentName) => {
+    for (const [currentName, currentNode] of this.entries()) {
       const graphDependencies = graphType === "dependencies" ? { ...currentNode.pkg.optionalDependencies, ...currentNode.pkg.dependencies } : {
         ...currentNode.pkg.devDependencies,
         ...currentNode.pkg.optionalDependencies,
         ...currentNode.pkg.dependencies
       };
-      Object.keys(graphDependencies).forEach((depName) => {
+      for (const depName of Object.keys(graphDependencies)) {
         const depNode = this.get(depName);
         let spec = graphDependencies[depName].replace(/^link:/, "file:");
-        const isWorkspaceSpec = /^workspace:/.test(spec);
+        const isWorkspaceSpec = spec.startsWith("workspace:");
         let fullWorkspaceSpec;
         let workspaceAlias;
         if (isWorkspaceSpec) {
@@ -22239,7 +22240,7 @@ var PackageGraph = class extends Map {
         resolved.workspaceSpec = fullWorkspaceSpec;
         resolved.workspaceAlias = workspaceAlias;
         if (!depNode) {
-          return;
+          continue;
         }
         if (resolved.fetchSpec === depNode.location || depNode.satisfies(resolved)) {
           depNode.localDependents.set(currentName, currentNode);
@@ -22248,8 +22249,8 @@ var PackageGraph = class extends Map {
             `Package specification "${depName}@${spec}" could not be resolved within the workspace. To reference a non-matching, remote version of a local dependency, remove the 'workspace:' prefix.`
           );
         }
-      });
-    });
+      }
+    }
   }
   get rawPackageList() {
     return Array.from(this.values(), (node) => node.pkg);
@@ -22747,9 +22748,9 @@ var shouldExpandGlobstarDirectory = (pattern) => {
   if (!match2) {
     return false;
   }
-  const dirname2 = match2[1];
-  const hasWildcards = /[*?[\]{}]/.test(dirname2);
-  const hasExtension = nodePath.extname(dirname2) && !dirname2.startsWith(".");
+  const dirname = match2[1];
+  const hasWildcards = /[*?[\]{}]/.test(dirname);
+  const hasExtension = nodePath.extname(dirname) && !dirname.startsWith(".");
   return !hasWildcards && !hasExtension;
 };
 var getDirectoryGlob = ({ directoryPath, files, extensions }) => {
@@ -25734,9 +25735,9 @@ var pMapSkip = /* @__PURE__ */ Symbol("skip");
 // src/utils/collect-dependents.js
 function collectDependents(nodes) {
   const collected = /* @__PURE__ */ new Set();
-  nodes.forEach((currentNode) => {
+  for (const currentNode of nodes) {
     if (currentNode.localDependents.size === 0) {
-      return;
+      continue;
     }
     const queue = [currentNode];
     const seen = /* @__PURE__ */ new Set();
@@ -25751,34 +25752,36 @@ function collectDependents(nodes) {
       collected.add(dependentNode);
       queue.push(dependentNode);
     };
-    while (queue.length) {
+    while (queue.length > 0) {
       const node = queue.shift();
       node.localDependents.forEach(visit);
     }
-  });
+  }
   return collected;
 }
 
 // src/utils/collect-packages.js
 function collectPackages(packages, { isCandidate = () => true, onInclude, excludeDependents } = {}) {
   const candidates = /* @__PURE__ */ new Set();
-  packages.forEach((node, name) => {
+  for (const [name, node] of packages.entries()) {
     if (isCandidate(node, name)) {
       candidates.add(node);
     }
-  });
+  }
   if (!excludeDependents) {
-    collectDependents(candidates).forEach((node) => candidates.add(node));
+    for (const node of collectDependents(candidates)) {
+      candidates.add(node);
+    }
   }
   const updates = [];
-  packages.forEach((node, name) => {
+  for (const [name, node] of packages.entries()) {
     if (candidates.has(node)) {
       if (onInclude) {
         onInclude(name);
       }
       updates.push(node);
     }
-  });
+  }
   return updates;
 }
 
@@ -26139,8 +26142,56 @@ var unescape2 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {})
 };
 
 // node_modules/minimatch/dist/esm/ast.js
+var _a;
 var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
 var isExtglobType = (c3) => types.has(c3);
+var isExtglobAST = (c3) => isExtglobType(c3.type);
+var adoptionMap = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]);
+var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]);
+var adoptionAnyMap = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]);
+var usurpMap = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]);
 var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
 var startNoDot = "(?!\\.)";
 var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
@@ -26150,7 +26201,8 @@ var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 var qmark = "[^/]";
 var star = qmark + "*?";
 var starNoEmpty = qmark + "+?";
-var AST = class _AST {
+var ID = 0;
+var AST = class {
   type;
   #root;
   #hasMagic;
@@ -26165,6 +26217,22 @@ var AST = class _AST {
   // set to true if it's an extglob with no children
   // (which really means one child of '')
   #emptyExt = false;
+  id = ++ID;
+  get depth() {
+    return (this.#parent?.depth ?? -1) + 1;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return {
+      "@@type": "AST",
+      id: this.id,
+      type: this.type,
+      root: this.#root.id,
+      parent: this.#parent?.id,
+      depth: this.depth,
+      partsLength: this.#parts.length,
+      parts: this.#parts
+    };
+  }
   constructor(type2, parent, options = {}) {
     this.type = type2;
     if (type2)
@@ -26230,7 +26298,7 @@ var AST = class _AST {
     for (const p of parts) {
       if (p === "")
         continue;
-      if (typeof p !== "string" && !(p instanceof _AST && p.#parent === this)) {
+      if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
         throw new Error("invalid part: " + p);
       }
       this.#parts.push(p);
@@ -26255,7 +26323,7 @@ var AST = class _AST {
     const p = this.#parent;
     for (let i2 = 0; i2 < this.#parentIndex; i2++) {
       const pp = p.#parts[i2];
-      if (!(pp instanceof _AST && pp.type === "!")) {
+      if (!(pp instanceof _a && pp.type === "!")) {
         return false;
       }
     }
@@ -26280,13 +26348,14 @@ var AST = class _AST {
       this.push(part.clone(this));
   }
   clone(parent) {
-    const c3 = new _AST(this.type, parent);
+    const c3 = new _a(this.type, parent);
     for (const p of this.#parts) {
       c3.copyIn(p);
     }
     return c3;
   }
-  static #parseAST(str2, ast, pos, opt) {
+  static #parseAST(str2, ast, pos, opt, extDepth) {
+    const maxDepth = opt.maxExtglobRecursion ?? 2;
     let escaping = false;
     let inBrace = false;
     let braceStart = -1;
@@ -26318,11 +26387,12 @@ var AST = class _AST {
           acc2 += c3;
           continue;
         }
-        if (!opt.noext && isExtglobType(c3) && str2.charAt(i3) === "(") {
+        const doRecurse = !opt.noext && isExtglobType(c3) && str2.charAt(i3) === "(" && extDepth <= maxDepth;
+        if (doRecurse) {
           ast.push(acc2);
           acc2 = "";
-          const ext2 = new _AST(c3, ast);
-          i3 = _AST.#parseAST(str2, ext2, i3, opt);
+          const ext2 = new _a(c3, ast);
+          i3 = _a.#parseAST(str2, ext2, i3, opt, extDepth + 1);
           ast.push(ext2);
           continue;
         }
@@ -26332,7 +26402,7 @@ var AST = class _AST {
       return i3;
     }
     let i2 = pos + 1;
-    let part = new _AST(null, ast);
+    let part = new _a(null, ast);
     const parts = [];
     let acc = "";
     while (i2 < str2.length) {
@@ -26359,19 +26429,22 @@ var AST = class _AST {
         acc += c3;
         continue;
       }
-      if (isExtglobType(c3) && str2.charAt(i2) === "(") {
+      const doRecurse = !opt.noext && isExtglobType(c3) && str2.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+      (extDepth <= maxDepth || ast && ast.#canAdoptType(c3));
+      if (doRecurse) {
+        const depthAdd = ast && ast.#canAdoptType(c3) ? 0 : 1;
         part.push(acc);
         acc = "";
-        const ext2 = new _AST(c3, part);
+        const ext2 = new _a(c3, part);
         part.push(ext2);
-        i2 = _AST.#parseAST(str2, ext2, i2, opt);
+        i2 = _a.#parseAST(str2, ext2, i2, opt, extDepth + depthAdd);
         continue;
       }
       if (c3 === "|") {
         part.push(acc);
         acc = "";
         parts.push(part);
-        part = new _AST(null, ast);
+        part = new _a(null, ast);
         continue;
       }
       if (c3 === ")") {
@@ -26390,9 +26463,71 @@ var AST = class _AST {
     ast.#parts = [str2.substring(pos - 1)];
     return i2;
   }
+  #canAdoptWithSpace(child) {
+    return this.#canAdopt(child, adoptionWithSpaceMap);
+  }
+  #canAdopt(child, map2 = adoptionMap) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canAdoptType(gc.type, map2);
+  }
+  #canAdoptType(c3, map2 = adoptionAnyMap) {
+    return !!map2.get(this.type)?.includes(c3);
+  }
+  #adoptWithSpace(child, index) {
+    const gc = child.#parts[0];
+    const blank = new _a(null, gc, this.options);
+    blank.#parts.push("");
+    gc.push(blank);
+    this.#adopt(child, index);
+  }
+  #adopt(child, index) {
+    const gc = child.#parts[0];
+    this.#parts.splice(index, 1, ...gc.#parts);
+    for (const p of gc.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.#toString = void 0;
+  }
+  #canUsurpType(c3) {
+    const m = usurpMap.get(this.type);
+    return !!m?.has(c3);
+  }
+  #canUsurp(child) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canUsurpType(gc.type);
+  }
+  #usurp(child) {
+    const m = usurpMap.get(this.type);
+    const gc = child.#parts[0];
+    const nt = m?.get(gc.type);
+    if (!nt)
+      return false;
+    this.#parts = gc.#parts;
+    for (const p of this.#parts) {
+      if (typeof p === "object") {
+        p.#parent = this;
+      }
+    }
+    this.type = nt;
+    this.#toString = void 0;
+    this.#emptyExt = false;
+  }
   static fromGlob(pattern, options = {}) {
-    const ast = new _AST(null, void 0, options);
-    _AST.#parseAST(pattern, ast, 0, options);
+    const ast = new _a(null, void 0, options);
+    _a.#parseAST(pattern, ast, 0, options, 0);
     return ast;
   }
   // returns the regular expression if there's magic, or the unescaped
@@ -26486,12 +26621,14 @@ var AST = class _AST {
   // or start or whatever) and prepend ^ or / at the Regexp construction.
   toRegExpSource(allowDot) {
     const dot = allowDot ?? !!this.#options.dot;
-    if (this.#root === this)
+    if (this.#root === this) {
+      this.#flatten();
       this.#fillNegs();
-    if (!this.type) {
+    }
+    if (!isExtglobAST(this)) {
       const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
       const src = this.#parts.map((p) => {
-        const [re, _, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
         this.#uflag = this.#uflag || uflag;
         return re;
@@ -26530,9 +26667,10 @@ var AST = class _AST {
     let body = this.#partsToRegExp(dot);
     if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
       const s = this.toString();
-      this.#parts = [s];
-      this.type = null;
-      this.#hasMagic = void 0;
+      const me = this;
+      me.#parts = [s];
+      me.type = null;
+      me.#hasMagic = void 0;
       return [s, unescape2(this.toString()), false, false];
     }
     let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
@@ -26559,6 +26697,38 @@ var AST = class _AST {
       this.#uflag
     ];
   }
+  #flatten() {
+    if (!isExtglobAST(this)) {
+      for (const p of this.#parts) {
+        if (typeof p === "object") {
+          p.#flatten();
+        }
+      }
+    } else {
+      let iterations = 0;
+      let done = false;
+      do {
+        done = true;
+        for (let i2 = 0; i2 < this.#parts.length; i2++) {
+          const c3 = this.#parts[i2];
+          if (typeof c3 === "object") {
+            c3.#flatten();
+            if (this.#canAdopt(c3)) {
+              done = false;
+              this.#adopt(c3, i2);
+            } else if (this.#canAdoptWithSpace(c3)) {
+              done = false;
+              this.#adoptWithSpace(c3, i2);
+            } else if (this.#canUsurp(c3)) {
+              done = false;
+              this.#usurp(c3);
+            }
+          }
+        }
+      } while (!done && ++iterations < 10);
+    }
+    this.#toString = void 0;
+  }
   #partsToRegExp(dot) {
     return this.#parts.map((p) => {
       if (typeof p === "string") {
@@ -26619,6 +26789,7 @@ var AST = class _AST {
     return [re, unescape2(glob), !!hasMagic, uflag];
   }
 };
+_a = AST;
 
 // node_modules/minimatch/dist/esm/escape.js
 var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
@@ -26777,11 +26948,13 @@ var Minimatch = class {
   isWindows;
   platform;
   windowsNoMagicRoot;
+  maxGlobstarRecursion;
   regexp;
   constructor(pattern, options = {}) {
     assertValidPattern(pattern);
     options = options || {};
     this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
     this.pattern = pattern;
     this.platform = options.platform || defaultPlatform;
     this.isWindows = this.platform === "win32";
@@ -27118,7 +27291,8 @@ var Minimatch = class {
   // out of pattern, then that's fine, as long as all
   // the parts match.
   matchOne(file, pattern, partial = false) {
-    const options = this.options;
+    let fileStartIndex = 0;
+    let patternStartIndex = 0;
     if (this.isWindows) {
       const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
       const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
@@ -27133,11 +27307,8 @@ var Minimatch = class {
         ];
         if (fd.toLowerCase() === pd.toLowerCase()) {
           pattern[pdi] = fd;
-          if (pdi > fdi) {
-            pattern = pattern.slice(pdi);
-          } else if (fdi > pdi) {
-            file = file.slice(fdi);
-          }
+          patternStartIndex = pdi;
+          fileStartIndex = fdi;
         }
       }
     }
@@ -27145,49 +27316,123 @@ var Minimatch = class {
     if (optimizationLevel >= 2) {
       file = this.levelTwoFileOptimize(file);
     }
-    this.debug("matchOne", this, { file, pattern });
-    this.debug("matchOne", file.length, pattern.length);
-    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-      this.debug("matchOne loop");
-      var p = pattern[pi];
-      var f = file[fi];
-      this.debug(pattern, p, f);
-      if (p === false) {
+    if (pattern.includes(GLOBSTAR)) {
+      return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+    }
+    return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+  }
+  #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+    const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+    const lastgs = pattern.lastIndexOf(GLOBSTAR);
+    const [head2, body, tail] = partial ? [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1),
+      []
+    ] : [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1, lastgs),
+      pattern.slice(lastgs + 1)
+    ];
+    if (head2.length) {
+      const fileHead = file.slice(fileIndex, fileIndex + head2.length);
+      if (!this.#matchOne(fileHead, head2, partial, 0, 0)) {
         return false;
       }
-      if (p === GLOBSTAR) {
-        this.debug("GLOBSTAR", [pattern, p, f]);
-        var fr = fi;
-        var pr = pi + 1;
-        if (pr === pl) {
-          this.debug("** at the end");
-          for (; fi < fl; fi++) {
-            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
-              return false;
-          }
-          return true;
+      fileIndex += head2.length;
+      patternIndex += head2.length;
+    }
+    let fileTailMatch = 0;
+    if (tail.length) {
+      if (tail.length + fileIndex > file.length)
+        return false;
+      let tailStart = file.length - tail.length;
+      if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+        fileTailMatch = tail.length;
+      } else {
+        if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
+          return false;
         }
-        while (fr < fl) {
-          var swallowee = file[fr];
-          this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
-          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-            this.debug("globstar found match!", fr, fl, swallowee);
-            return true;
-          } else {
-            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-              this.debug("dot detected!", file, fr, pattern, pr);
-              break;
-            }
-            this.debug("globstar swallow a segment, and continue");
-            fr++;
-          }
+        tailStart--;
+        if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
+          return false;
         }
-        if (partial) {
-          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
-          if (fr === fl) {
-            return true;
-          }
+        fileTailMatch = tail.length + 1;
+      }
+    }
+    if (!body.length) {
+      let sawSome = !!fileTailMatch;
+      for (let i3 = fileIndex; i3 < file.length - fileTailMatch; i3++) {
+        const f = String(file[i3]);
+        sawSome = true;
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
         }
+      }
+      return partial || sawSome;
+    }
+    const bodySegments = [[[], 0]];
+    let currentBody = bodySegments[0];
+    let nonGsParts = 0;
+    const nonGsPartsSums = [0];
+    for (const b of body) {
+      if (b === GLOBSTAR) {
+        nonGsPartsSums.push(nonGsParts);
+        currentBody = [[], 0];
+        bodySegments.push(currentBody);
+      } else {
+        currentBody[0].push(b);
+        nonGsParts++;
+      }
+    }
+    let i2 = bodySegments.length - 1;
+    const fileLength = file.length - fileTailMatch;
+    for (const b of bodySegments) {
+      b[1] = fileLength - (nonGsPartsSums[i2--] + b[0].length);
+    }
+    return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+  }
+  // return false for "nope, not matching"
+  // return null for "not matching, cannot keep trying"
+  #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    const bs = bodySegments[bodyIndex];
+    if (!bs) {
+      for (let i2 = fileIndex; i2 < file.length; i2++) {
+        sawTail = true;
+        const f = file[i2];
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
+        }
+      }
+      return sawTail;
+    }
+    const [body, after] = bs;
+    while (fileIndex <= after) {
+      const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+      if (m && globStarDepth < this.maxGlobstarRecursion) {
+        const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+        if (sub !== false) {
+          return sub;
+        }
+      }
+      const f = file[fileIndex];
+      if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+        return false;
+      }
+      fileIndex++;
+    }
+    return partial || null;
+  }
+  #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+    let fi;
+    let pi;
+    let pl;
+    let fl;
+    for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      let p = pattern[pi];
+      let f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false || p === GLOBSTAR) {
         return false;
       }
       let hit;
@@ -27376,7 +27621,7 @@ function makeDiffPredicate(committish, execOpts, context) {
       })
     )
   );
-  if (ignoreFilters.size) {
+  if (ignoreFilters.size > 0) {
     logger.log("ignoring diff in paths matching", ignoreChanges);
   }
   return function hasDiffSinceThatIsntIgnored(node) {
@@ -27385,12 +27630,12 @@ function makeDiffPredicate(committish, execOpts, context) {
       return false;
     }
     let changedFiles = diff.split("\n");
-    if (ignoreFilters.size) {
+    if (ignoreFilters.size > 0) {
       for (const ignored of ignoreFilters) {
         changedFiles = changedFiles.filter(ignored);
       }
     }
-    if (changedFiles.length) {
+    if (changedFiles.length > 0) {
       logger.log("filtered diff", changedFiles);
     } else {
       logger.log("", "no diff found in %s (after filtering)", node.name);
@@ -27628,8 +27873,8 @@ function getGlobOpts(rootPath, packageConfigs) {
     expandDirectories: false,
     followSymbolicLinks: false
   };
-  if (packageConfigs.some((cfg) => cfg.indexOf("**") > -1)) {
-    if (packageConfigs.some((cfg) => cfg.indexOf("node_modules") > -1)) {
+  if (packageConfigs.some((cfg) => cfg.includes("**"))) {
+    if (packageConfigs.some((cfg) => cfg.includes("node_modules"))) {
       throw new Error("An explicit node_modules package path does not allow globstars (**)");
     }
     globOpts.ignore = [
@@ -27645,6 +27890,7 @@ function makeFileFinder(rootPath, packageConfigs) {
   return (fileName, fileMapper, customGlobOpts) => {
     const options = { ...customGlobOpts, ...globOpts };
     const promise = pMap(
+      /* eslint-disable-next-line unicorn/no-array-sort -- technical debt */
       Array.from(packageConfigs).sort(),
       (globPath) => {
         let chain = globby(path13.posix.join(globPath, fileName), options);
@@ -27657,7 +27903,7 @@ function makeFileFinder(rootPath, packageConfigs) {
       },
       { concurrency: 4 }
     );
-    return promise.then((results) => results.reduce((acc, result) => acc.concat(result), []));
+    return promise.then((results) => results.flat());
   };
 }
 var Project = class {
@@ -27989,7 +28235,7 @@ async function getCurrentVersion(pkg) {
   const pkgData = await readJson(pkg.manifestLocation);
   return [pkgData.name, pkgData.version];
 }
-async function prepare_default(npmrc2, pluginConfig, context) {
+async function prepare(npmrc2, pluginConfig, context) {
   const {
     cwd,
     nextRelease: { version },
@@ -28026,7 +28272,7 @@ async function prepare_default(npmrc2, pluginConfig, context) {
 
 // src/get-channel.js
 var import_valid = __toESM(require_valid2(), 1);
-function get_channel_default(channel) {
+function getChannel(channel) {
   if (channel) {
     return (0, import_valid.default)(channel) ? `release-${channel}` : channel;
   } else {
@@ -28045,7 +28291,7 @@ var GITHUB_ACTIONS_PROVIDER_NAME = "GitHub Actions";
 var GITLAB_PIPELINES_PROVIDER_NAME = "GitLab CI/CD";
 
 // src/get-registry.js
-function get_registry_default({ publishConfig: { registry } = {}, name }, { cwd, env }) {
+function getRegistry({ publishConfig: { registry } = {}, name }, { cwd, env }) {
   return registry || env.NPM_CONFIG_REGISTRY || getRegistryUrl(
     name.split("/")[0],
     (0, import_rc.default)(
@@ -28059,19 +28305,137 @@ function get_registry_default({ publishConfig: { registry } = {}, name }, { cwd,
 // node_modules/normalize-url/index.js
 var DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
 var DATA_URL_DEFAULT_CHARSET = "us-ascii";
-var testParameter = (name, filters) => filters.some((filter2) => filter2 instanceof RegExp ? filter2.test(name) : filter2 === name);
+var encodedReservedCharactersPattern = "%(?:3A|2F|3F|23|5B|5D|40|21|24|26|27|28|29|2A|2B|2C|3B|3D)";
+var temporaryEncodedReservedTokenBase = "__normalize_url_encoded_reserved__";
+var temporaryEncodedReservedTokenPattern = /__normalize_url_encoded_reserved__(\d+)__/g;
+var hasEncodedReservedCharactersRegex = new RegExp(encodedReservedCharactersPattern, "i");
+var encodedReservedCharactersRegex = new RegExp(encodedReservedCharactersPattern, "gi");
+var testParameter = (name, filters) => Array.isArray(filters) && filters.some((filter2) => {
+  if (filter2 instanceof RegExp) {
+    if (filter2.flags.includes("g") || filter2.flags.includes("y")) {
+      return new RegExp(filter2.source, filter2.flags.replaceAll(/[gy]/g, "")).test(name);
+    }
+    return filter2.test(name);
+  }
+  return filter2 === name;
+});
 var supportedProtocols = /* @__PURE__ */ new Set([
   "https:",
   "http:",
   "file:"
 ]);
-var hasCustomProtocol = (urlString) => {
+var normalizeCustomProtocolOption = (protocol) => {
+  if (typeof protocol !== "string") {
+    return void 0;
+  }
+  const normalizedProtocol = protocol.trim().toLowerCase().replace(/:$/, "");
+  return normalizedProtocol === "" ? void 0 : `${normalizedProtocol}:`;
+};
+var getCustomProtocol = (urlString) => {
   try {
     const { protocol } = new URL(urlString);
-    return protocol.endsWith(":") && !protocol.includes(".") && !supportedProtocols.has(protocol);
+    const hasAuthority = urlString.slice(0, protocol.length + 2).toLowerCase() === `${protocol}//`;
+    if (protocol.endsWith(":") && (!protocol.includes(".") || hasAuthority) && !supportedProtocols.has(protocol)) {
+      return protocol;
+    }
   } catch {
-    return false;
   }
+  return void 0;
+};
+var decodeQueryKey = (value) => {
+  try {
+    return decodeURIComponent(value.replaceAll("+", "%20"));
+  } catch {
+    return new URLSearchParams(`${value}=`).keys().next().value;
+  }
+};
+var getKeysWithoutEquals = (search) => {
+  const keys = /* @__PURE__ */ new Set();
+  if (!search) {
+    return keys;
+  }
+  for (const part of search.slice(1).split("&")) {
+    if (part && !part.includes("=")) {
+      keys.add(decodeQueryKey(part));
+    }
+  }
+  return keys;
+};
+var getTemporaryEncodedReservedTokenPrefix = (search) => {
+  let decodedSearch = search;
+  try {
+    decodedSearch = decodeURIComponent(search);
+  } catch {
+    decodedSearch = new URLSearchParams(search).toString();
+  }
+  const getUsedTokenIndexes = (value) => {
+    const indexes = /* @__PURE__ */ new Set();
+    for (const match2 of value.matchAll(temporaryEncodedReservedTokenPattern)) {
+      indexes.add(Number.parseInt(match2[1], 10));
+    }
+    return indexes;
+  };
+  const usedTokenIndexes = getUsedTokenIndexes(search);
+  for (const tokenIndex2 of getUsedTokenIndexes(decodedSearch)) {
+    usedTokenIndexes.add(tokenIndex2);
+  }
+  let tokenIndex = 0;
+  while (usedTokenIndexes.has(tokenIndex)) {
+    tokenIndex++;
+  }
+  return `${temporaryEncodedReservedTokenBase}${tokenIndex}__`;
+};
+var sortSearchParameters = (searchParameters, encodedReservedTokenRegex) => {
+  if (!encodedReservedTokenRegex) {
+    searchParameters.sort();
+    return searchParameters.toString();
+  }
+  const getSortableKey = (key) => key.replace(encodedReservedTokenRegex, (_, hexCode) => String.fromCodePoint(Number.parseInt(hexCode, 16)));
+  const entries = [...searchParameters.entries()];
+  entries.sort(([leftKey], [rightKey]) => {
+    const left = getSortableKey(leftKey);
+    const right = getSortableKey(rightKey);
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+  return new URLSearchParams(entries).toString();
+};
+var decodeReservedTokens = (value, encodedReservedTokenRegex) => {
+  if (!encodedReservedTokenRegex) {
+    return value;
+  }
+  return value.replace(encodedReservedTokenRegex, (_, hexCode) => String.fromCodePoint(Number.parseInt(hexCode, 16)));
+};
+var normalizeEmptyQueryParameters = (search, emptyQueryValue, originalSearch) => {
+  const isAlways = emptyQueryValue === "always";
+  const isNever = emptyQueryValue === "never";
+  const keysWithoutEquals = isAlways || isNever ? void 0 : getKeysWithoutEquals(originalSearch);
+  const normalizeKey = (key) => key.replaceAll("+", "%20");
+  const formatEmptyValue = (normalizedKey) => {
+    if (isAlways) {
+      return `${normalizedKey}=`;
+    }
+    if (isNever) {
+      return normalizedKey;
+    }
+    return keysWithoutEquals.has(decodeQueryKey(normalizedKey)) ? normalizedKey : `${normalizedKey}=`;
+  };
+  const normalizeParameter = (parameter) => {
+    const equalIndex = parameter.indexOf("=");
+    if (equalIndex === -1) {
+      return formatEmptyValue(normalizeKey(parameter));
+    }
+    const key = parameter.slice(0, equalIndex);
+    const value = parameter.slice(equalIndex + 1);
+    if (value === "") {
+      if (key === "") {
+        return "=";
+      }
+      return formatEmptyValue(normalizeKey(key));
+    }
+    return `${normalizeKey(key)}=${value}`;
+  };
+  const parameters = search.slice(1).split("&").filter(Boolean);
+  return parameters.length === 0 ? "" : `?${parameters.map((x) => normalizeParameter(x)).join("&")}`;
 };
 var normalizeDataURL = (urlString, { stripHash }) => {
   const match2 = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
@@ -28084,7 +28448,7 @@ var normalizeDataURL = (urlString, { stripHash }) => {
   if (isBase64) {
     mediaType.pop();
   }
-  const mimeType = mediaType.shift()?.toLowerCase() ?? "";
+  const mimeType = mediaType.shift().toLowerCase();
   const attributes = mediaType.map((attribute) => {
     let [key, value = ""] = attribute.split("=").map((string) => string.trim());
     if (key === "charset") {
@@ -28123,6 +28487,7 @@ function normalizeUrl(urlString, options) {
     sortQueryParameters: true,
     removePath: false,
     transformPath: false,
+    emptyQueryValue: "preserve",
     ...options
   };
   if (typeof options.defaultProtocol === "string" && !options.defaultProtocol.endsWith(":")) {
@@ -28132,12 +28497,15 @@ function normalizeUrl(urlString, options) {
   if (/^data:/i.test(urlString)) {
     return normalizeDataURL(urlString, options);
   }
-  if (hasCustomProtocol(urlString)) {
+  const customProtocols = Array.isArray(options.customProtocols) ? options.customProtocols : [];
+  const normalizedCustomProtocols = new Set(customProtocols.map((protocol) => normalizeCustomProtocolOption(protocol)).filter(Boolean));
+  const customProtocol = getCustomProtocol(urlString);
+  if (customProtocol && !normalizedCustomProtocols.has(customProtocol)) {
     return urlString;
   }
   const hasRelativeProtocol = urlString.startsWith("//");
   const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
-  if (!isRelativeUrl) {
+  if (!isRelativeUrl && !customProtocol) {
     urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
   }
   const urlObject = new URL(urlString);
@@ -28171,17 +28539,17 @@ function normalizeUrl(urlString, options) {
       const protocol = match2[0];
       const protocolAtIndex = match2.index;
       const intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
-      result += intermediate.replace(/\/{2,}/g, "/");
+      result += intermediate.replaceAll(/\/{2,}/g, "/");
       result += protocol;
       lastIndex = protocolAtIndex + protocol.length;
     }
-    const remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
-    result += remnant.replace(/\/{2,}/g, "/");
+    const remnant = urlObject.pathname.slice(lastIndex);
+    result += remnant.replaceAll(/\/{2,}/g, "/");
     urlObject.pathname = result;
   }
   if (urlObject.pathname) {
     try {
-      urlObject.pathname = decodeURI(urlObject.pathname).replace(/\\/g, "%5C");
+      urlObject.pathname = decodeURI(urlObject.pathname).replaceAll("\\", "%5C");
     } catch {
     }
   }
@@ -28210,36 +28578,42 @@ function normalizeUrl(urlString, options) {
       urlObject.hostname = urlObject.hostname.replace(/^www\./, "");
     }
   }
-  if (Array.isArray(options.removeQueryParameters)) {
-    for (const key of [...urlObject.searchParams.keys()]) {
-      if (testParameter(key, options.removeQueryParameters)) {
-        urlObject.searchParams.delete(key);
+  const originalSearch = urlObject.search;
+  let encodedReservedTokenRegex;
+  if (options.sortQueryParameters && hasEncodedReservedCharactersRegex.test(originalSearch)) {
+    const encodedReservedTokenPrefix = getTemporaryEncodedReservedTokenPrefix(originalSearch);
+    urlObject.search = originalSearch.replaceAll(encodedReservedCharactersRegex, (match2) => `${encodedReservedTokenPrefix}${match2.slice(1).toUpperCase()}`);
+    encodedReservedTokenRegex = new RegExp(`${encodedReservedTokenPrefix}([0-9A-F]{2})`, "g");
+  }
+  const hasKeepQueryParameters = Array.isArray(options.keepQueryParameters);
+  const { searchParams } = urlObject;
+  if (!hasKeepQueryParameters && Array.isArray(options.removeQueryParameters) && options.removeQueryParameters.length > 0) {
+    for (const key of [...searchParams.keys()]) {
+      if (testParameter(decodeReservedTokens(key, encodedReservedTokenRegex), options.removeQueryParameters)) {
+        searchParams.delete(key);
       }
     }
   }
-  if (!Array.isArray(options.keepQueryParameters) && options.removeQueryParameters === true) {
+  if (!hasKeepQueryParameters && options.removeQueryParameters === true) {
     urlObject.search = "";
   }
-  if (Array.isArray(options.keepQueryParameters) && options.keepQueryParameters.length > 0) {
-    for (const key of [...urlObject.searchParams.keys()]) {
-      if (!testParameter(key, options.keepQueryParameters)) {
-        urlObject.searchParams.delete(key);
+  if (hasKeepQueryParameters && options.keepQueryParameters.length > 0) {
+    for (const key of [...searchParams.keys()]) {
+      if (!testParameter(decodeReservedTokens(key, encodedReservedTokenRegex), options.keepQueryParameters)) {
+        searchParams.delete(key);
       }
     }
+  } else if (hasKeepQueryParameters) {
+    urlObject.search = "";
   }
   if (options.sortQueryParameters) {
-    const originalSearch = urlObject.search;
-    urlObject.searchParams.sort();
-    try {
-      urlObject.search = decodeURIComponent(urlObject.search);
-    } catch {
-    }
-    const partsWithoutEquals = originalSearch.slice(1).split("&").filter((p) => p && !p.includes("="));
-    for (const part of partsWithoutEquals) {
-      const decoded = decodeURIComponent(part);
-      urlObject.search = urlObject.search.replace(`?${decoded}=`, `?${decoded}`).replace(`&${decoded}=`, `&${decoded}`);
+    urlObject.search = sortSearchParameters(urlObject.searchParams, encodedReservedTokenRegex);
+    urlObject.search = decodeURIComponent(urlObject.search.replaceAll(/%(?:26|23|3f|25|2b)/gi, (match2) => `%25${match2.slice(1)}`));
+    if (encodedReservedTokenRegex) {
+      urlObject.search = urlObject.search.replace(encodedReservedTokenRegex, "%$1");
     }
   }
+  urlObject.search = normalizeEmptyQueryParameters(urlObject.search, options.emptyQueryValue, originalSearch);
   if (options.removeTrailingSlash) {
     urlObject.pathname = urlObject.pathname.replace(/\/$/, "");
   }
@@ -28264,7 +28638,7 @@ function normalizeUrl(urlString, options) {
 }
 
 // src/get-release-info.js
-function get_release_info_default({ name }, { env: { DEFAULT_NPM_REGISTRY = OFFICIAL_REGISTRY }, nextRelease: { version } }, distTag, registry) {
+function getReleaseInfo({ name }, { env: { DEFAULT_NPM_REGISTRY = OFFICIAL_REGISTRY }, nextRelease: { version } }, distTag, registry) {
   return {
     name: `npm package (@${distTag} dist-tag)`,
     url: normalizeUrl(registry) === normalizeUrl(DEFAULT_NPM_REGISTRY) ? `https://www.npmjs.com/package/${name}/v/${version}` : void 0,
@@ -28273,7 +28647,7 @@ function get_release_info_default({ name }, { env: { DEFAULT_NPM_REGISTRY = OFFI
 }
 
 // src/publish.js
-async function publish_default(npmrc2, config, pkg, context) {
+async function publish(npmrc2, config, pkg, context) {
   const { npmPublish } = config;
   const {
     cwd,
@@ -28284,8 +28658,8 @@ async function publish_default(npmrc2, config, pkg, context) {
     logger
   } = context;
   if (npmPublish !== false) {
-    const registry = get_registry_default(pkg, context);
-    const distTag = get_channel_default(channel);
+    const registry = getRegistry(pkg, context);
+    const distTag = getChannel(channel);
     logger.log("Publishing version %s to npm registry", version);
     const lerna = __require.resolve("lerna/cli");
     const result = execa(
@@ -28320,7 +28694,7 @@ async function publish_default(npmrc2, config, pkg, context) {
     result.stdout.pipe(stdout, { end: false });
     result.stderr.pipe(stderr, { end: false });
     await result;
-    return get_release_info_default(pkg, context, distTag, registry);
+    return getReleaseInfo(pkg, context, distTag, registry);
   }
   logger.log(`Skip publishing to npm registry as npmPublish false`);
   return false;
@@ -28332,7 +28706,7 @@ import path17 from "node:path";
 var import_nerf_dart = __toESM(require_nerf_dart(), 1);
 var import_rc2 = __toESM(require_rc(), 1);
 import getAuthToken from "registry-auth-token";
-async function set_npmrc_auth_default(npmrc2, registry, { cwd, env: { NPM_TOKEN, NPM_CONFIG_USERCONFIG }, logger }) {
+async function setNpmrcAuth(npmrc2, registry, { cwd, env: { NPM_TOKEN, NPM_CONFIG_USERCONFIG }, logger }) {
   logger.log("Verify authentication for registry %s", registry);
   const { configs, config, ...rcConfig } = (0, import_rc2.default)(
     "npm",
@@ -28342,7 +28716,10 @@ async function set_npmrc_auth_default(npmrc2, registry, { cwd, env: { NPM_TOKEN,
   if (configs) {
     logger.log("Reading npm config from %s", configs.join(", "));
   }
-  const currentConfig = configs ? (await Promise.all(configs.map((config2) => fs8.readFile(config2)))).join("\n") : "";
+  const currentConfig = configs ? (
+    /* eslint-disable-next-line unicorn/no-await-expression-member -- technical debt */
+    (await Promise.all(configs.map((config2) => fs8.readFile(config2)))).join("\n")
+  ) : "";
   if (getAuthToken(registry, { npmrc: rcConfig })) {
     await fs8.mkdir(path17.dirname(npmrc2), { recursive: true });
     await fs8.writeFile(npmrc2, currentConfig);
@@ -28356,7 +28733,7 @@ async function set_npmrc_auth_default(npmrc2, registry, { cwd, env: { NPM_TOKEN,
     await fs8.writeFile(npmrc2, `${oldConfig}${newConfig}`);
     logger.log(`Wrote NPM_TOKEN to ${npmrc2}`);
   } else {
-    throw new AggregateError2([get_error_default("ENONPMTOKEN", { registry })]);
+    throw new AggregateError2([getError("ENONPMTOKEN", { registry })]);
   }
 }
 
@@ -30642,7 +31019,7 @@ async function verifyAuthContextAgainstRegistry(npmrc2, registry, context) {
     whoamiResult.stderr.pipe(stderr, { end: false });
     await whoamiResult;
   } catch {
-    throw new AggregateError2([get_error_default("EINVALIDNPMTOKEN", { registry })]);
+    throw new AggregateError2([getError("EINVALIDNPMTOKEN", { registry })]);
   }
 }
 async function verifyTokenAuth(registry, npmrc2, context) {
@@ -30653,15 +31030,16 @@ async function verifyTokenAuth(registry, npmrc2, context) {
     await verifyAuthContextAgainstRegistry(npmrc2, registry, context);
   }
 }
-async function verify_auth_default(npmrc2, pkg, context) {
+async function verifyAuth(npmrc2, pkg, context) {
   const { cwd, logger } = context;
-  const registry = get_registry_default(pkg, context);
+  const registry = getRegistry(pkg, context);
   const project = new Project(cwd, logger);
-  const packages = (await project.getPackages()).filter((pkg2) => !pkg2.private);
+  const allPackages = await project.getPackages();
+  const packages = allPackages.filter((pkg2) => !pkg2.private);
   if (await oidcContextEstablished(registry, packages, context)) {
     return;
   }
-  await set_npmrc_auth_default(npmrc2, registry, context);
+  await setNpmrcAuth(npmrc2, registry, context);
   await verifyTokenAuth(registry, npmrc2, context);
 }
 
@@ -30675,9 +31053,9 @@ var VALIDATORS = {
   tarballDir: isNonEmptyString,
   pkgRoot: isNonEmptyString
 };
-function verify_config_default({ npmPublish, tarballDir, pkgRoot }) {
+function verifyConfig({ npmPublish, tarballDir, pkgRoot }) {
   return Object.entries({ npmPublish, tarballDir, pkgRoot }).reduce(
-    (errors, [option, value]) => !isNil(value) && !VALIDATORS[option](value) ? [...errors, get_error_default(`EINVALID${option.toUpperCase()}`, { [option]: value })] : errors,
+    (errors, [option, value]) => !isNil(value) && !VALIDATORS[option](value) ? [...errors, getError(`EINVALID${option.toUpperCase()}`, { [option]: value })] : errors,
     []
   );
 }
@@ -30699,12 +31077,11 @@ async function verifyGit(context) {
       return [name, details];
     })
   );
-  return result.filter(([, details]) => details).map(([name, details]) => get_error_default(`E${name.toUpperCase()}`, details));
+  return result.filter(([, details]) => details).map(([name, details]) => getError(`E${name.toUpperCase()}`, details));
 }
 
 // src/generate-notes.js
-import { dirname } from "node:path";
-import { fileURLToPath as fileURLToPath11, format as format5 } from "node:url";
+import { format as format5 } from "node:url";
 import conventionalChangelogAngular from "conventional-changelog-angular";
 import * as writerModule from "conventional-changelog-writer";
 
@@ -30796,8 +31173,11 @@ function* filterRevertedCommitsSync(commits) {
 
 // node_modules/conventional-commits-parser/dist/regex.js
 var nomatchRegex = /(?!.*)/;
+function escape2(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function join(parts, joiner) {
-  return parts.map((val) => val.trim()).filter(Boolean).join(joiner);
+  return parts.map((val) => escape2(val.trim())).filter(Boolean).join(joiner);
 }
 function getNotesRegex(noteKeywords, notesPattern) {
   if (!noteKeywords) {
@@ -30897,7 +31277,7 @@ var defaultOptions = {
     "scope",
     "subject"
   ],
-  revertPattern: /^Revert\s"([\s\S]*)"\s*This reverts commit (\w*)\./,
+  revertPattern: /^Revert\s"([\s\S]*)"\s*This reverts commit (\w*)\.?/,
   revertCorrespondence: ["header", "hash"],
   fieldPattern: /^-(.*?)-$/
 };
@@ -31155,6 +31535,15 @@ var CommitParser = class {
     commit.notes.forEach((note) => {
       note.text = trimNewLines(note.text);
     });
+    const referencesSet = /* @__PURE__ */ new Set();
+    commit.references = commit.references.filter((reference) => {
+      const uid = `${reference.action} ${reference.raw}`.toLocaleLowerCase();
+      const ok = !referencesSet.has(uid);
+      if (ok) {
+        referencesSet.add(uid);
+      }
+      return ok;
+    });
   }
   /**
    * Parse commit message string into an object.
@@ -32871,7 +33260,7 @@ async function loadChangelogConfig(pluginConfig, context) {
   const { preset, config, parserOpts, writerOpts, presetConfig } = pluginConfig;
   const { cwd } = context;
   let loadedConfig;
-  const __dirname = dirname(fileURLToPath11(import.meta.url));
+  const __dirname = import.meta.dirname;
   if (preset) {
     const presetPackage = `conventional-changelog-${preset.toLowerCase()}`;
     loadedConfig = await (await import_from_esm_default.silent(__dirname, presetPackage) || await import_from_esm_default(cwd, presetPackage))(presetConfig);
@@ -32994,11 +33383,11 @@ async function verifyConditions(pluginConfig, context) {
   pluginConfig.npmPublish = defaultTo(pluginConfig.npmPublish, defaultConfig.npmPublish);
   pluginConfig.tarballDir = defaultTo(pluginConfig.tarballDir, defaultConfig.tarballDir);
   pluginConfig.pkgRoot = defaultTo(pluginConfig.pkgRoot, defaultConfig.pkgRoot);
-  const errors = [...verify_config_default(pluginConfig), ...await verifyGit(context)];
+  const errors = [...verifyConfig(pluginConfig), ...await verifyGit(context)];
   try {
     if (pluginConfig.npmVerifyAuth) {
-      const pkg = await get_pkg_default(pluginConfig, context);
-      await verify_auth_default(npmrc, pkg, context);
+      const pkg = await getPkg(pluginConfig, context);
+      await verifyAuth(npmrc, pkg, context);
     }
   } catch (error) {
     if (Array.isArray(error.errors)) {
@@ -33012,13 +33401,13 @@ async function verifyConditions(pluginConfig, context) {
   }
   verified = true;
 }
-async function prepare(pluginConfig, context) {
+async function prepare2(pluginConfig, context) {
   pluginConfig.latch = defaultTo(pluginConfig.latch, defaultConfig.latch);
-  const errors = verified ? [] : verify_config_default(pluginConfig);
+  const errors = verified ? [] : verifyConfig(pluginConfig);
   try {
     if (pluginConfig.npmVerifyAuth) {
-      const pkg = await get_pkg_default(pluginConfig, context);
-      await verify_auth_default(npmrc, pkg, context);
+      const pkg = await getPkg(pluginConfig, context);
+      await verifyAuth(npmrc, pkg, context);
     }
   } catch (error) {
     if (Array.isArray(error.errors)) {
@@ -33030,15 +33419,15 @@ async function prepare(pluginConfig, context) {
   if (errors.length > 0) {
     throw new AggregateError2(errors);
   }
-  await prepare_default(npmrc, pluginConfig, context);
+  await prepare(npmrc, pluginConfig, context);
 }
-async function publish(pluginConfig, context) {
+async function publish2(pluginConfig, context) {
   let pkg;
-  const errors = verified ? [] : verify_config_default(pluginConfig);
+  const errors = verified ? [] : verifyConfig(pluginConfig);
   try {
-    pkg = await get_pkg_default(pluginConfig, context);
+    pkg = await getPkg(pluginConfig, context);
     if (!verified && pluginConfig.npmPublish !== false && pkg.private !== true) {
-      await verify_auth_default(npmrc, pkg, context);
+      await verifyAuth(npmrc, pkg, context);
     }
   } catch (error) {
     if (Array.isArray(error.errors)) {
@@ -33050,12 +33439,12 @@ async function publish(pluginConfig, context) {
   if (errors.length > 0) {
     throw new AggregateError2(errors);
   }
-  return publish_default(npmrc, pluginConfig, pkg, context);
+  return publish(npmrc, pluginConfig, pkg, context);
 }
 export {
   generateNotes,
-  prepare,
-  publish,
+  prepare2 as prepare,
+  publish2 as publish,
   verifyConditions
 };
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-release-lerna",
-  "version": "2.17.2",
+  "version": "2.18.1",
   "description": "semantic-release plugin to publish lerna monorepo packages to npm",
   "keywords": [
     "npm",
@@ -41,7 +41,7 @@
     "@semantic-release/error": "^4.0.0",
     "conventional-changelog-angular": "^7.0.0 || ^8.0.0",
     "conventional-changelog-writer": "^7.0.0 || ^8.0.0",
-    "cosmiconfig": "^9.0.0",
+    "cosmiconfig": "^9.0.1",
     "libnpmversion": "^8.0.3",
     "registry-auth-token": "^5.1.1"
   },
@@ -50,7 +50,7 @@
     "semantic-release": "^22.0.0 || ^23.0.0 || ^24.0.0 || ^25.0.0"
   },
   "engines": {
-    "node": "^20.17 || >= 22.9"
+    "node": "^20.17 || >= 22.16"
   },
   "publishConfig": {
     "access": "public",