rollup 4.60.0 → 4.60.2

package/dist/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
 

package/dist/shared/rollup.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
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.60.0";
+var version = "4.60.2";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -980,6 +980,8 @@ function requireConstants () {
 	const WIN_SLASH = '\\\\/';
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
+	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+
 	/**
 	 * Posix glob regex
 	 */
@@ -1046,6 +1048,7 @@ function requireConstants () {
 	 */
 
 	const POSIX_REGEX_SOURCE = {
+	  __proto__: null,
 	  alnum: 'a-zA-Z0-9',
 	  alpha: 'a-zA-Z',
 	  ascii: '\\x00-\\x7F',
@@ -1063,6 +1066,7 @@ function requireConstants () {
 	};
 
 	constants = {
+	  DEFAULT_MAX_EXTGLOB_RECURSION,
 	  MAX_LENGTH: 1024 * 64,
 	  POSIX_REGEX_SOURCE,
 
@@ -1684,6 +1688,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
@@ -1864,6 +2139,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');
@@ -1873,6 +2150,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;
 
@@ -2965,6 +3270,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.
@@ -3000,10 +3313,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.
@@ -3422,7 +3735,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) {
@@ -10758,7 +11071,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;
         }
@@ -12309,6 +12622,8 @@ const builtinModules = [
 	"stream",
 	"node:stream/consumers",
 	"stream/consumers",
+	"node:stream/iter",
+	"stream/iter",
 	"node:stream/promises",
 	"stream/promises",
 	"node:stream/web",
@@ -12342,7 +12657,9 @@ const builtinModules = [
 	"node:worker_threads",
 	"worker_threads",
 	"node:zlib",
-	"zlib"
+	"zlib",
+	"node:zlib/iter",
+	"zlib/iter"
 ];
 
 const nodeBuiltins = new Set(builtinModules);
@@ -18471,7 +18788,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)) {
@@ -18483,10 +18800,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) {
@@ -18807,7 +19126,7 @@ class Module {
         }
         return this.syntheticNamespace;
     }
-    getVariableForExportName(name, { importerForSideEffects, importChain = [], isExportAllSearch, onlyExplicit, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
+    getVariableForExportName(name, { importerForSideEffects, importChain = [], isExportAllSearch, onlyExplicit, searchedNamesAndModules, sideEffectModules, exportOrReexportModules } = parseAst_js.EMPTY_OBJECT) {
         if (name[0] === '*') {
             if (name.length === 1) {
                 // export * from './other'
@@ -18822,7 +19141,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(parseAst_js.logMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id, !!options?.missingButExportExists), reexportDeclaration.start);
             }
@@ -18832,6 +19151,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);
@@ -18841,8 +19164,10 @@ class Module {
             }
             const name = exportDeclaration.localName;
             const variable = this.traceVariable(name, {
+                exportOrReexportModules,
                 importerForSideEffects,
-                searchedNamesAndModules
+                searchedNamesAndModules,
+                sideEffectModules
             });
             if (!variable) {
                 return [null, { missingButExportExists: true }];
@@ -18851,6 +19176,8 @@ class Module {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
                 getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
             }
+            sideEffectModules?.add(this);
+            exportOrReexportModules?.add(this);
             return [variable];
         }
         if (onlyExplicit) {
@@ -18861,6 +19188,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;
             }
         }
@@ -19064,7 +19404,7 @@ class Module {
             transformFiles: this.transformFiles
         };
     }
-    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
+    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules, sideEffectModules, exportOrReexportModules } = parseAst_js.EMPTY_OBJECT) {
         const localVariable = this.scope.variables.get(name);
         if (localVariable) {
             return localVariable;
@@ -19075,7 +19415,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(parseAst_js.logMissingExport(importDescription.name, this.id, otherModule.id, !!options?.missingButExportExists), importDescription.start);
             }
@@ -19296,6 +19636,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) {
@@ -19304,7 +19646,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);
             }
@@ -19321,7 +19663,7 @@ class Module {
             const foundDeclarationList = [...foundInternalDeclarations];
             const usedDeclaration = foundDeclarationList[0][0];
             if (foundDeclarationList.length === 1) {
-                return [usedDeclaration];
+                return [usedDeclaration, { exportOrReexportModules, sideEffectModules }];
             }
             this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
             // TODO we are pretending it was not found while it should behave like "undefined"
@@ -19333,10 +19675,13 @@ class Module {
             if (foundDeclarationList.length > 1) {
                 this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.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];
     }
@@ -20742,6 +21087,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);
@@ -22706,8 +23061,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);
                     }
                 }
             }
@@ -22981,8 +23336,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();
         }
@@ -23276,9 +23631,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())) {
-                    parseAst_js.error(parseAst_js.logImplicitDependantIsNotIncluded(dependant));
+            for (const dependent of module.implicitlyLoadedAfter) {
+                if (!(dependent.info.isEntry || dependent.isIncluded())) {
+                    parseAst_js.error(parseAst_js.logImplicitDependantIsNotIncluded(dependent));
                 }
             }
         }

package/dist/shared/watch-cli.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
 

package/dist/shared/watch.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