rollup 4.60.0 → 4.60.2

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.60.0
-	Sun, 22 Mar 2026 06:57:22 GMT - commit 6ecd69fb2ce736c8aabb50829edd227d1792c957
+	Rollup.js v4.60.2
+	Sat, 18 Apr 2026 13:58:01 GMT - commit a6be82b8abd747458afdc7484319f7b5deb92535
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _mergeNamespaces(n, m) {
   return Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' });
 }
 
-var version = "4.60.0";
+var version = "4.60.2";
 
 // src/vlq.ts
 var comma = ",".charCodeAt(0);
@@ -6981,7 +6981,7 @@ class ExportDefaultDeclaration extends NodeBase {
                 : null, options);
         }
         else if (this.variable.getOriginalVariable() !== this.variable) {
-            // Remove altogether to prevent re-declaring the same variable
+            // Remove altogether to prevent redeclaring the same variable
             treeshakeNode(this, code, start, end);
             return;
         }
@@ -8532,6 +8532,8 @@ const builtinModules = [
 	"stream",
 	"node:stream/consumers",
 	"stream/consumers",
+	"node:stream/iter",
+	"stream/iter",
 	"node:stream/promises",
 	"stream/promises",
 	"node:stream/web",
@@ -8565,7 +8567,9 @@ const builtinModules = [
 	"node:worker_threads",
 	"worker_threads",
 	"node:zlib",
-	"zlib"
+	"zlib",
+	"node:zlib/iter",
+	"zlib/iter"
 ];
 
 const nodeBuiltins = new Set(builtinModules);
@@ -9200,6 +9204,8 @@ function requireConstants () {
 	const WIN_SLASH = '\\\\/';
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
+	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+
 	/**
 	 * Posix glob regex
 	 */
@@ -9266,6 +9272,7 @@ function requireConstants () {
 	 */
 
 	const POSIX_REGEX_SOURCE = {
+	  __proto__: null,
 	  alnum: 'a-zA-Z0-9',
 	  alpha: 'a-zA-Z',
 	  ascii: '\\x00-\\x7F',
@@ -9283,6 +9290,7 @@ function requireConstants () {
 	};
 
 	constants = {
+	  DEFAULT_MAX_EXTGLOB_RECURSION,
 	  MAX_LENGTH: 1024 * 64,
 	  POSIX_REGEX_SOURCE,
 
@@ -9904,6 +9912,277 @@ function requireParse () {
 	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
 	};
 
+	const splitTopLevel = input => {
+	  const parts = [];
+	  let bracket = 0;
+	  let paren = 0;
+	  let quote = 0;
+	  let value = '';
+	  let escaped = false;
+
+	  for (const ch of input) {
+	    if (escaped === true) {
+	      value += ch;
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      value += ch;
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (ch === '"') {
+	      quote = quote === 1 ? 0 : 1;
+	      value += ch;
+	      continue;
+	    }
+
+	    if (quote === 0) {
+	      if (ch === '[') {
+	        bracket++;
+	      } else if (ch === ']' && bracket > 0) {
+	        bracket--;
+	      } else if (bracket === 0) {
+	        if (ch === '(') {
+	          paren++;
+	        } else if (ch === ')' && paren > 0) {
+	          paren--;
+	        } else if (ch === '|' && paren === 0) {
+	          parts.push(value);
+	          value = '';
+	          continue;
+	        }
+	      }
+	    }
+
+	    value += ch;
+	  }
+
+	  parts.push(value);
+	  return parts;
+	};
+
+	const isPlainBranch = branch => {
+	  let escaped = false;
+
+	  for (const ch of branch) {
+	    if (escaped === true) {
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (/[?*+@!()[\]{}]/.test(ch)) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	};
+
+	const normalizeSimpleBranch = branch => {
+	  let value = branch.trim();
+	  let changed = true;
+
+	  while (changed === true) {
+	    changed = false;
+
+	    if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+	      value = value.slice(2, -1);
+	      changed = true;
+	    }
+	  }
+
+	  if (!isPlainBranch(value)) {
+	    return;
+	  }
+
+	  return value.replace(/\\(.)/g, '$1');
+	};
+
+	const hasRepeatedCharPrefixOverlap = branches => {
+	  const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+
+	  for (let i = 0; i < values.length; i++) {
+	    for (let j = i + 1; j < values.length; j++) {
+	      const a = values[i];
+	      const b = values[j];
+	      const char = a[0];
+
+	      if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+	        continue;
+	      }
+
+	      if (a === b || a.startsWith(b) || b.startsWith(a)) {
+	        return true;
+	      }
+	    }
+	  }
+
+	  return false;
+	};
+
+	const parseRepeatedExtglob = (pattern, requireEnd = true) => {
+	  if ((pattern[0] !== '+' && pattern[0] !== '*') || pattern[1] !== '(') {
+	    return;
+	  }
+
+	  let bracket = 0;
+	  let paren = 0;
+	  let quote = 0;
+	  let escaped = false;
+
+	  for (let i = 1; i < pattern.length; i++) {
+	    const ch = pattern[i];
+
+	    if (escaped === true) {
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (ch === '"') {
+	      quote = quote === 1 ? 0 : 1;
+	      continue;
+	    }
+
+	    if (quote === 1) {
+	      continue;
+	    }
+
+	    if (ch === '[') {
+	      bracket++;
+	      continue;
+	    }
+
+	    if (ch === ']' && bracket > 0) {
+	      bracket--;
+	      continue;
+	    }
+
+	    if (bracket > 0) {
+	      continue;
+	    }
+
+	    if (ch === '(') {
+	      paren++;
+	      continue;
+	    }
+
+	    if (ch === ')') {
+	      paren--;
+
+	      if (paren === 0) {
+	        if (requireEnd === true && i !== pattern.length - 1) {
+	          return;
+	        }
+
+	        return {
+	          type: pattern[0],
+	          body: pattern.slice(2, i),
+	          end: i
+	        };
+	      }
+	    }
+	  }
+	};
+
+	const getStarExtglobSequenceOutput = pattern => {
+	  let index = 0;
+	  const chars = [];
+
+	  while (index < pattern.length) {
+	    const match = parseRepeatedExtglob(pattern.slice(index), false);
+
+	    if (!match || match.type !== '*') {
+	      return;
+	    }
+
+	    const branches = splitTopLevel(match.body).map(branch => branch.trim());
+	    if (branches.length !== 1) {
+	      return;
+	    }
+
+	    const branch = normalizeSimpleBranch(branches[0]);
+	    if (!branch || branch.length !== 1) {
+	      return;
+	    }
+
+	    chars.push(branch);
+	    index += match.end + 1;
+	  }
+
+	  if (chars.length < 1) {
+	    return;
+	  }
+
+	  const source = chars.length === 1
+	    ? utils.escapeRegex(chars[0])
+	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+	  return `${source}*`;
+	};
+
+	const repeatedExtglobRecursion = pattern => {
+	  let depth = 0;
+	  let value = pattern.trim();
+	  let match = parseRepeatedExtglob(value);
+
+	  while (match) {
+	    depth++;
+	    value = match.body.trim();
+	    match = parseRepeatedExtglob(value);
+	  }
+
+	  return depth;
+	};
+
+	const analyzeRepeatedExtglob = (body, options) => {
+	  if (options.maxExtglobRecursion === false) {
+	    return { risky: false };
+	  }
+
+	  const max =
+	    typeof options.maxExtglobRecursion === 'number'
+	      ? options.maxExtglobRecursion
+	      : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+
+	  const branches = splitTopLevel(body).map(branch => branch.trim());
+
+	  if (branches.length > 1) {
+	    if (
+	      branches.some(branch => branch === '') ||
+	      branches.some(branch => /^[*?]+$/.test(branch)) ||
+	      hasRepeatedCharPrefixOverlap(branches)
+	    ) {
+	      return { risky: true };
+	    }
+	  }
+
+	  for (const branch of branches) {
+	    const safeOutput = getStarExtglobSequenceOutput(branch);
+	    if (safeOutput) {
+	      return { risky: true, safeOutput };
+	    }
+
+	    if (repeatedExtglobRecursion(branch) > max) {
+	      return { risky: true };
+	    }
+	  }
+
+	  return { risky: false };
+	};
+
 	/**
 	 * Parse the given input string.
 	 * @param {String} input
@@ -10084,6 +10363,8 @@ function requireParse () {
 	    token.prev = prev;
 	    token.parens = state.parens;
 	    token.output = state.output;
+	    token.startIndex = state.index;
+	    token.tokensIndex = tokens.length;
 	    const output = (opts.capture ? '(' : '') + token.open;
 
 	    increment('parens');
@@ -10093,6 +10374,34 @@ function requireParse () {
 	  };
 
 	  const extglobClose = token => {
+	    const literal = input.slice(token.startIndex, state.index + 1);
+	    const body = input.slice(token.startIndex + 2, state.index);
+	    const analysis = analyzeRepeatedExtglob(body, opts);
+
+	    if ((token.type === 'plus' || token.type === 'star') && analysis.risky) {
+	      const safeOutput = analysis.safeOutput
+	        ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput)
+	        : undefined;
+	      const open = tokens[token.tokensIndex];
+
+	      open.type = 'text';
+	      open.value = literal;
+	      open.output = safeOutput || utils.escapeRegex(literal);
+
+	      for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+	        tokens[i].value = '';
+	        tokens[i].output = '';
+	        delete tokens[i].suffix;
+	      }
+
+	      state.output = token.output + open.output;
+	      state.backtrack = true;
+
+	      push({ type: 'paren', extglob: true, value, output: '' });
+	      decrement('parens');
+	      return;
+	    }
+
 	    let output = token.close + (opts.capture ? ')' : '');
 	    let rest;
 
@@ -11185,6 +11494,14 @@ function requirePicomatch$1 () {
 	 * Compile a regular expression from the `state` object returned by the
 	 * [parse()](#parse) method.
 	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
 	 * @param {Object} `state`
 	 * @param {Object} `options`
 	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
@@ -11220,10 +11537,10 @@ function requirePicomatch$1 () {
 	 *
 	 * ```js
 	 * const picomatch = require('picomatch');
-	 * const state = picomatch.parse('*.js');
-	 * // picomatch.compileRe(state[, options]);
+	 * // picomatch.makeRe(state[, options]);
 	 *
-	 * console.log(picomatch.compileRe(state));
+	 * const result = picomatch.makeRe('*.js');
+	 * console.log(result);
 	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
 	 * ```
 	 * @param {String} `state` The object returned from the `.parse` method.
@@ -16868,7 +17185,7 @@ const MISSING_EXPORT_SHIM_DESCRIPTION = {
     identifier: null,
     localName: MISSING_EXPORT_SHIM_VARIABLE
 };
-function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map(), importChain) {
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map(), importChain, sideEffectModules, exportOrReexportModules) {
     const searchedModules = searchedNamesAndModules.get(name);
     if (searchedModules) {
         if (searchedModules.has(target)) {
@@ -16880,10 +17197,12 @@ function getVariableForExportNameRecursive(target, name, importerForSideEffects,
         searchedNamesAndModules.set(name, new Set([target]));
     }
     return target.getVariableForExportName(name, {
+        exportOrReexportModules,
         importChain,
         importerForSideEffects,
         isExportAllSearch,
-        searchedNamesAndModules
+        searchedNamesAndModules,
+        sideEffectModules
     });
 }
 function getAndExtendSideEffectModules(variable, module) {
@@ -17204,7 +17523,7 @@ class Module {
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, { importerForSideEffects, importChain = [], isExportAllSearch, onlyExplicit, searchedNamesAndModules } = EMPTY_OBJECT) {
+    getVariableForExportName(name, { importerForSideEffects, importChain = [], isExportAllSearch, onlyExplicit, searchedNamesAndModules, sideEffectModules, exportOrReexportModules } = EMPTY_OBJECT) {
         if (name[0] === '*') {
             if (name.length === 1) {
                 // export * from './other'
@@ -17219,7 +17538,7 @@ class Module {
         // export { foo } from './other'
         const reexportDeclaration = this.reexportDescriptions.get(name);
         if (reexportDeclaration) {
-            const [variable, options] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules, [...importChain, this.id]);
+            const [variable, options] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules, [...importChain, this.id], sideEffectModules, exportOrReexportModules);
             if (!variable) {
                 return this.error(logMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id, !!options?.missingButExportExists), reexportDeclaration.start);
             }
@@ -17229,6 +17548,10 @@ class Module {
                     getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
                 }
             }
+            if (this.info.moduleSideEffects) {
+                sideEffectModules?.add(this);
+            }
+            exportOrReexportModules?.add(this);
             return [variable];
         }
         const exportDeclaration = this.exportDescriptions.get(name);
@@ -17238,8 +17561,10 @@ class Module {
             }
             const name = exportDeclaration.localName;
             const variable = this.traceVariable(name, {
+                exportOrReexportModules,
                 importerForSideEffects,
-                searchedNamesAndModules
+                searchedNamesAndModules,
+                sideEffectModules
             });
             if (!variable) {
                 return [null, { missingButExportExists: true }];
@@ -17248,6 +17573,8 @@ class Module {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
                 getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
             }
+            sideEffectModules?.add(this);
+            exportOrReexportModules?.add(this);
             return [variable];
         }
         if (onlyExplicit) {
@@ -17258,6 +17585,19 @@ class Module {
                 this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules, [...importChain, this.id]);
             this.namespaceReexportsByName.set(name, foundNamespaceReexport);
             if (foundNamespaceReexport[0]) {
+                const [namespaceReexportVariable, namespaceReexportOptions] = foundNamespaceReexport;
+                if (importerForSideEffects) {
+                    const { exportOrReexportModules, sideEffectModules } = namespaceReexportOptions;
+                    for (const module of exportOrReexportModules) {
+                        if (importerForSideEffects.alternativeReexportModules.has(namespaceReexportVariable)) {
+                            continue;
+                        }
+                        setAlternativeExporterIfCyclic(namespaceReexportVariable, importerForSideEffects, module);
+                    }
+                    for (const module of sideEffectModules) {
+                        getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, namespaceReexportVariable, (getNewSet)).add(module);
+                    }
+                }
                 return foundNamespaceReexport;
             }
         }
@@ -17461,7 +17801,7 @@ class Module {
             transformFiles: this.transformFiles
         };
     }
-    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = EMPTY_OBJECT) {
+    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules, sideEffectModules, exportOrReexportModules } = EMPTY_OBJECT) {
         const localVariable = this.scope.variables.get(name);
         if (localVariable) {
             return localVariable;
@@ -17472,7 +17812,7 @@ class Module {
             if (otherModule instanceof Module && importDescription.name === '*') {
                 return otherModule.namespace;
             }
-            const [declaration, options] = getVariableForExportNameRecursive(otherModule, importDescription.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules, [this.id]);
+            const [declaration, options] = getVariableForExportNameRecursive(otherModule, importDescription.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules, [this.id], sideEffectModules, exportOrReexportModules);
             if (!declaration) {
                 return this.error(logMissingExport(importDescription.name, this.id, otherModule.id, !!options?.missingButExportExists), importDescription.start);
             }
@@ -17693,6 +18033,8 @@ class Module {
         let foundSyntheticDeclaration = null;
         const foundInternalDeclarations = new Map();
         const foundExternalDeclarations = new Set();
+        const sideEffectModules = new Set();
+        const exportOrReexportModules = new Set();
         for (const module of this.exportAllModules) {
             // Synthetic namespaces should not hide "regular" exports of the same name
             if (module.info.syntheticNamedExports === name) {
@@ -17701,7 +18043,7 @@ class Module {
             const [variable, options] = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, 
             // We are creating a copy to handle the case where the same binding is
             // imported through different namespace reexports gracefully
-            copyNameToModulesMap(searchedNamesAndModules), importChain);
+            copyNameToModulesMap(searchedNamesAndModules), importChain, sideEffectModules, exportOrReexportModules);
             if (module instanceof ExternalModule || options?.indirectExternal) {
                 foundExternalDeclarations.add(variable);
             }
@@ -17718,7 +18060,7 @@ class Module {
             const foundDeclarationList = [...foundInternalDeclarations];
             const usedDeclaration = foundDeclarationList[0][0];
             if (foundDeclarationList.length === 1) {
-                return [usedDeclaration];
+                return [usedDeclaration, { exportOrReexportModules, sideEffectModules }];
             }
             this.options.onLog(LOGLEVEL_WARN, logNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
             // TODO we are pretending it was not found while it should behave like "undefined"
@@ -17730,10 +18072,13 @@ class Module {
             if (foundDeclarationList.length > 1) {
                 this.options.onLog(LOGLEVEL_WARN, logAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
             }
-            return [usedDeclaration, { indirectExternal: true }];
+            return [
+                usedDeclaration,
+                { exportOrReexportModules, indirectExternal: true, sideEffectModules }
+            ];
         }
         if (foundSyntheticDeclaration) {
-            return [foundSyntheticDeclaration];
+            return [foundSyntheticDeclaration, { exportOrReexportModules, sideEffectModules }];
         }
         return [null];
     }
@@ -19248,6 +19593,16 @@ class Chunk {
     }
     setIdentifierRenderResolutions() {
         const { format, generatedCode: { symbols }, interop, preserveModules, externalLiveBindings } = this.outputOptions;
+        // Reset stale render names from previous output renderings of the same
+        // module graph. Without this, variables that were renamed during a prior
+        // output's import deconfliction (e.g. given a chunk-prefixed
+        // `renderBaseName` like `vendor`) would carry that name into the next
+        // output, producing invalid identifiers such as `function vendor.foo()`.
+        for (const module of this.orderedModules) {
+            for (const variable of module.scope.variables.values()) {
+                variable.setRenderNames(null, null);
+            }
+        }
         const syntheticExports = new Set();
         for (const exportName of this.getExportNames()) {
             const exportVariable = this.exportsByName.get(exportName);
@@ -21477,8 +21832,8 @@ class ModuleLoader {
                     for (const module of implicitlyLoadedAfterModules) {
                         entryModule.implicitlyLoadedAfter.add(module);
                     }
-                    for (const dependant of entryModule.implicitlyLoadedAfter) {
-                        dependant.implicitlyLoadedBefore.add(entryModule);
+                    for (const dependent of entryModule.implicitlyLoadedAfter) {
+                        dependent.implicitlyLoadedBefore.add(entryModule);
                     }
                 }
             }
@@ -21752,8 +22107,8 @@ class ModuleLoader {
             // be performed atomically
             module.info.isEntry = true;
             this.implicitEntryModules.delete(module);
-            for (const dependant of module.implicitlyLoadedAfter) {
-                dependant.implicitlyLoadedBefore.delete(module);
+            for (const dependent of module.implicitlyLoadedAfter) {
+                dependent.implicitlyLoadedBefore.delete(module);
             }
             module.implicitlyLoadedAfter.clear();
         }
@@ -22656,7 +23011,7 @@ class PluginDriver {
      * Run a sync plugin hook and return the result.
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
      * @param args Arguments passed to the plugin hook.
-     * @param plugin The acutal plugin
+     * @param plugin The actual plugin
      * @param replaceContext When passed, the plugin context can be overridden.
      */
     runHookSync(hookName, parameters, plugin, replaceContext) {
@@ -22904,9 +23259,9 @@ class Graph {
         for (const externalModule of this.externalModules)
             externalModule.warnUnusedImports();
         for (const module of this.implicitEntryModules) {
-            for (const dependant of module.implicitlyLoadedAfter) {
-                if (!(dependant.info.isEntry || dependant.isIncluded())) {
-                    error(logImplicitDependantIsNotIncluded(dependant));
+            for (const dependent of module.implicitlyLoadedAfter) {
+                if (!(dependent.info.isEntry || dependent.isIncluded())) {
+                    error(logImplicitDependantIsNotIncluded(dependent));
                 }
             }
         }

package/dist/es/shared/parseAst.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.60.0
-	Sun, 22 Mar 2026 06:57:22 GMT - commit 6ecd69fb2ce736c8aabb50829edd227d1792c957
+	Rollup.js v4.60.2
+	Sat, 18 Apr 2026 13:58:01 GMT - commit a6be82b8abd747458afdc7484319f7b5deb92535
 
 	https://github.com/rollup/rollup