rollup 4.59.1 → 4.60.1

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.59.1
-	Sat, 21 Mar 2026 06:45:31 GMT - commit 0cba9e079e1d6e56882558827b37557f36c52966
+	Rollup.js v4.60.1
+	Mon, 30 Mar 2026 04:32:12 GMT - commit ae871d762f6bbeb4320d28fe179211168f27a434
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.59.1";
+var version = "4.60.1";
 
 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.
@@ -6255,12 +6568,15 @@ class Variable extends ExpressionEntity {
     }
 }
 
+/** Synthetic import name for source phase imports, similar to '*' for namespaces */
+const SOURCE_PHASE_IMPORT = '*source';
 class ExternalVariable extends Variable {
     constructor(module, name) {
         super(name);
         this.referenced = false;
         this.module = module;
         this.isNamespace = name === '*';
+        this.isSourcePhase = name === SOURCE_PHASE_IMPORT;
     }
     addReference(identifier) {
         this.referenced = true;
@@ -12209,6 +12525,13 @@ function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, sy
     return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, symbols)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
 }
 
+function throwOnPhase(outputFormat, chunkId, dependencies) {
+    const sourcePhaseDependency = dependencies.find(dependency => dependency.sourcePhaseImport);
+    if (sourcePhaseDependency) {
+        parseAst_js.error(parseAst_js.logSourcePhaseFormatUnsupported(outputFormat, chunkId, sourcePhaseDependency.importPath));
+    }
+}
+
 function addJsExtension(name) {
     return name.endsWith('.js') ? name : name + '.js';
 }
@@ -12347,6 +12670,7 @@ function warnOnBuiltins(log, dependencies) {
 
 function amd(magicString, { accessedGlobals, dependencies, exports: exports$1, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, generatedCode: { symbols }, interop, reexportProtoFromExternal, strict }) {
     warnOnBuiltins(log, dependencies);
+    throwOnPhase('amd', id, dependencies);
     const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
     const parameters = dependencies.map(m => m.name);
     const { n, getNonArrowFunctionIntro, _ } = snippets;
@@ -12384,7 +12708,8 @@ function amd(magicString, { accessedGlobals, dependencies, exports: exports$1, h
         .append(`${n}${n}}));`);
 }
 
-function cjs(magicString, { accessedGlobals, dependencies, exports: exports$1, hasDefaultExport, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
+function cjs(magicString, { accessedGlobals, dependencies, exports: exports$1, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
+    throwOnPhase('cjs', id, dependencies);
     const { _, n } = snippets;
     const useStrict = strict ? `'use strict';${n}${n}` : '';
     let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
@@ -12437,11 +12762,16 @@ function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencie
 }
 function getImportBlock(dependencies, importAttributesKey, { _ }) {
     const importBlock = [];
-    for (const { importPath, reexports, imports, name, attributes } of dependencies) {
+    for (const { importPath, reexports, imports, name, attributes, sourcePhaseImport } of dependencies) {
         const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
         const pathWithAssertion = `'${importPath}'${assertion};`;
+        if (sourcePhaseImport) {
+            importBlock.push(`import source ${sourcePhaseImport} from${_}${pathWithAssertion}`);
+        }
         if (!reexports && !imports) {
-            importBlock.push(`import${_}${pathWithAssertion}`);
+            if (!sourcePhaseImport) {
+                importBlock.push(`import${_}${pathWithAssertion}`);
+            }
             continue;
         }
         if (imports) {
@@ -12595,7 +12925,8 @@ function trimEmptyImports(dependencies) {
     return [];
 }
 
-function iife(magicString, { accessedGlobals, dependencies, exports: exports$1, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
+function iife(magicString, { accessedGlobals, dependencies, exports: exports$1, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
+    throwOnPhase('iife', id, dependencies);
     const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
     const isNamespaced = name && name.includes('.');
     const useVariableAssignment = !extend && !isNamespaced;
@@ -12654,7 +12985,8 @@ function iife(magicString, { accessedGlobals, dependencies, exports: exports$1,
 
 const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
 
-function system(magicString, { accessedGlobals, dependencies, exports: exports$1, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
+function system(magicString, { accessedGlobals, dependencies, exports: exports$1, hasExports, id, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
+    throwOnPhase('system', id, dependencies);
     const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
     const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports$1, t, snippets);
     const registeredName = name ? `'${name}',${_}` : '';
@@ -12822,6 +13154,7 @@ function umd(magicString, { accessedGlobals, dependencies, exports: exports$1, h
     if (hasExports && !name) {
         return parseAst_js.error(parseAst_js.logMissingNameOptionForUmdExport());
     }
+    throwOnPhase('umd', id, dependencies);
     warnOnBuiltins(log, dependencies);
     const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
     const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
@@ -17730,6 +18063,8 @@ const bufferParsers = [
         node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
         node.source = convertNode(node, scope, buffer[position + 1], buffer);
         node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+        const phaseIndex = buffer[position + 3];
+        node.phase = phaseIndex === 0 ? undefined : parseAst_js.FIXED_STRINGS[phaseIndex];
     },
     function importDefaultSpecifier(node, position, buffer) {
         const { scope } = node;
@@ -17741,6 +18076,8 @@ const bufferParsers = [
         node.sourceAstNode = parseAst_js.convertNode(buffer[position], buffer);
         const optionsPosition = buffer[position + 1];
         node.options = optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer);
+        const phaseIndex = buffer[position + 2];
+        node.phase = phaseIndex === 0 ? undefined : parseAst_js.FIXED_STRINGS[phaseIndex];
     },
     function importNamespaceSpecifier(node, position, buffer) {
         const { scope } = node;
@@ -18447,7 +18784,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)) {
@@ -18459,10 +18796,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) {
@@ -18519,6 +18858,7 @@ class Module {
         this.isUserDefinedEntryPoint = false;
         this.needsExportShim = false;
         this.sideEffectDependenciesByVariable = new Map();
+        this.sourcePhaseSources = new Set();
         this.sourcesWithAttributes = new Map();
         this.allExportsIncluded = false;
         this.ast = null;
@@ -18782,7 +19122,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'
@@ -18797,7 +19137,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);
             }
@@ -18807,6 +19147,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);
@@ -18816,8 +19160,10 @@ class Module {
             }
             const name = exportDeclaration.localName;
             const variable = this.traceVariable(name, {
+                exportOrReexportModules,
                 importerForSideEffects,
-                searchedNamesAndModules
+                searchedNamesAndModules,
+                sideEffectModules
             });
             if (!variable) {
                 return [null, { missingButExportExists: true }];
@@ -18826,6 +19172,8 @@ class Module {
                 setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
                 getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
             }
+            sideEffectModules?.add(this);
+            exportOrReexportModules?.add(this);
             return [variable];
         }
         if (onlyExplicit) {
@@ -18836,6 +19184,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;
             }
         }
@@ -19039,7 +19400,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;
@@ -19050,7 +19411,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);
             }
@@ -19169,16 +19530,19 @@ class Module {
             if (this.scope.variables.has(localName) || this.importDescriptions.has(localName)) {
                 this.error(parseAst_js.logRedeclarationError(localName), specifier.local.start);
             }
-            const name = specifier instanceof ImportDefaultSpecifier
-                ? 'default'
-                : specifier instanceof ImportNamespaceSpecifier
-                    ? '*'
-                    : specifier.imported instanceof Identifier
-                        ? specifier.imported.name
-                        : specifier.imported.value;
+            const name = node.phase === 'source'
+                ? SOURCE_PHASE_IMPORT
+                : specifier instanceof ImportDefaultSpecifier
+                    ? 'default'
+                    : specifier instanceof ImportNamespaceSpecifier
+                        ? '*'
+                        : specifier.imported instanceof Identifier
+                            ? specifier.imported.name
+                            : specifier.imported.value;
             this.importDescriptions.set(localName, {
                 module: null, // filled in later
                 name,
+                phase: node.phase === 'source' ? 'source' : 'instance',
                 source,
                 start: specifier.start
             });
@@ -19251,6 +19615,9 @@ class Module {
         else {
             this.sourcesWithAttributes.set(source, parsedAttributes);
         }
+        if (declaration.phase === 'source') {
+            this.sourcePhaseSources.add(source);
+        }
     }
     getImportedJsxFactoryVariable(baseName, nodeStart, importSource) {
         const { id } = this.resolvedIds[importSource];
@@ -19265,6 +19632,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) {
@@ -19273,7 +19642,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);
             }
@@ -19290,7 +19659,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"
@@ -19302,10 +19671,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];
     }
@@ -19464,6 +19836,9 @@ function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconf
                 ? externalChunkByModule.get(module)
                 : chunkByModule.get(module)).variableName);
         }
+        else if (module instanceof ExternalModule && variable.isSourcePhase) {
+            variable.setRenderNames(null, getSafeName(module.suggestedVariableName + '__source', usedNames, variable.forbiddenNames));
+        }
         else if (module instanceof ExternalModule && name === 'default') {
             variable.setRenderNames(null, getSafeName([...module.exportedVariables].some(([exportedVariable, exportedName]) => exportedName === '*' && exportedVariable.included)
                 ? module.suggestedVariableName + '__default'
@@ -20401,10 +20776,14 @@ class Chunk {
             const module = variable.module;
             let dependency;
             let imported;
+            const isSourcePhase = module instanceof ExternalModule && variable.isSourcePhase;
             if (module instanceof ExternalModule) {
                 dependency = this.externalChunkByModule.get(module);
                 imported = variable.name;
-                if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
+                if (!isSourcePhase &&
+                    imported !== 'default' &&
+                    imported !== '*' &&
+                    interop(module.id) === 'defaultOnly') {
                     return parseAst_js.error(parseAst_js.logUnexpectedNamedImport(module.id, imported, false));
                 }
             }
@@ -20414,7 +20793,8 @@ class Chunk {
             }
             getOrCreate(importsByDependency, dependency, getNewArray).push({
                 imported,
-                local: variable.getName(this.snippets.getPropertyAccess)
+                local: variable.getName(this.snippets.getPropertyAccess),
+                phase: isSourcePhase ? 'source' : 'instance'
             });
         }
         return importsByDependency;
@@ -20565,6 +20945,9 @@ class Chunk {
             const reexports = reexportSpecifiers.get(dependency) || null;
             const namedExportsMode = dependency instanceof ExternalChunk || dependency.exportMode !== 'default';
             const importPath = dependency.getImportPath(fileName);
+            // Separate source-phase imports from regular imports
+            const sourcePhaseImport = imports?.find(index => index.phase === 'source');
+            const instanceImports = imports?.filter(index => index.phase !== 'source') ?? null;
             renderedDependencies.set(dependency, {
                 attributes: dependency instanceof ExternalChunk
                     ? dependency.getImportAttributes(this.snippets)
@@ -20574,12 +20957,13 @@ class Chunk {
                     (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
                     getGlobalName(dependency, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
                 importPath,
-                imports,
+                imports: instanceImports && instanceImports.length > 0 ? instanceImports : null,
                 isChunk: dependency instanceof Chunk,
                 name: dependency.variableName,
                 namedExportsMode,
                 namespaceVariableName: dependency.namespaceVariableName,
-                reexports
+                reexports,
+                sourcePhaseImport: sourcePhaseImport?.local
             });
         }
         return (this.renderedDependencies = renderedDependencies);
@@ -22748,13 +23132,16 @@ class ModuleLoader {
         return loadNewModulesPromise;
     }
     async fetchDynamicDependencies(module, resolveDynamicImportPromises) {
-        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([{ node }, resolvedId]) => {
+        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([{ argument, node }, resolvedId]) => {
             if (resolvedId === null)
                 return null;
             if (typeof resolvedId === 'string') {
                 node.resolution = resolvedId;
                 return null;
             }
+            if (node.phase === 'source' && !resolvedId.external) {
+                return parseAst_js.error(parseAst_js.logNonExternalSourcePhaseImport(typeof argument === 'string' ? argument : parseAst_js.relativeId(resolvedId.id), module.id));
+            }
             return (node.resolution = await this.fetchResolvedDependency(parseAst_js.relativeId(resolvedId.id), module.id, resolvedId));
         })));
         for (const dependency of dependencies) {
@@ -22834,7 +23221,12 @@ class ModuleLoader {
         return this.fetchModule(resolvedId, importer, false, false);
     }
     async fetchStaticDependencies(module, resolveStaticDependencyPromises) {
-        for (const dependency of await Promise.all(resolveStaticDependencyPromises.map(resolveStaticDependencyPromise => resolveStaticDependencyPromise.then(([source, resolvedId]) => this.fetchResolvedDependency(source, module.id, resolvedId))))) {
+        for (const dependency of await Promise.all(resolveStaticDependencyPromises.map(resolveStaticDependencyPromise => resolveStaticDependencyPromise.then(([source, resolvedId]) => {
+            if (module.sourcePhaseSources.has(source) && !resolvedId.external) {
+                return parseAst_js.error(parseAst_js.logNonExternalSourcePhaseImport(source, module.id));
+            }
+            return this.fetchResolvedDependency(source, module.id, resolvedId);
+        })))) {
             module.dependencies.add(dependency);
             dependency.importers.push(module.id);
         }
@@ -23246,7 +23638,7 @@ class Graph {
     warnForMissingExports() {
         for (const module of this.modules) {
             for (const importDescription of module.importDescriptions.values()) {
-                if (importDescription.name !== '*') {
+                if (importDescription.name !== '*' && importDescription.phase !== 'source') {
                     const [variable, options] = importDescription.module.getVariableForExportName(importDescription.name, { importChain: [module.id] });
                     if (!variable) {
                         module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingExport(importDescription.name, module.id, importDescription.module.id, !!options?.missingButExportExists), importDescription.start);