@atlaspack/packager-js 2.14.5-canary.28 → 2.14.5-canary.280

package/lib/ScopeHoistingPackager.js

@@ -60,6 +60,13 @@ function _featureFlags() {
   };
   return data;
 }
+function _outdent() {
+  const data = require("outdent");
+  _outdent = function () {
+    return data;
+  };
+  return data;
+}
 var _ESMOutputFormat = require("./ESMOutputFormat");
 var _CJSOutputFormat = require("./CJSOutputFormat");
 var _GlobalOutputFormat = require("./GlobalOutputFormat");
@@ -70,7 +77,6 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // General regex used to replace imports with the resolved code, references with resolutions,
 // and count the number of newlines in the file for source maps.
-//
 // For conditional bundling the only difference in this regex is adding `importCond` where we have `importAsync` etc..
 const REPLACEMENT_RE_CONDITIONAL = /\n|import\s+"([0-9a-f]{16,20}:.+?)";|(?:\$[0-9a-f]{16,20}\$exports)|(?:\$[0-9a-f]{16,20}\$(?:import|importAsync|require|importCond)\$[0-9a-f]+(?:\$[0-9a-f]+)?)/g;
 const REPLACEMENT_RE = /\n|import\s+"([0-9a-f]{16,20}:.+?)";|(?:\$[0-9a-f]{16,20}\$exports)|(?:\$[0-9a-f]{16,20}\$(?:import|importAsync|require)\$[0-9a-f]+(?:\$[0-9a-f]+)?)/g;
@@ -80,6 +86,7 @@ const GLOBALS_BY_CONTEXT = {
   'web-worker': new Set([...BUILTINS, ...Object.keys(_globals().default.worker)]),
   'service-worker': new Set([...BUILTINS, ...Object.keys(_globals().default.serviceworker)]),
   worklet: new Set([...BUILTINS]),
+  tesseract: new Set([...BUILTINS, ...Object.keys(_globals().default.worker)]),
   node: new Set([...BUILTINS, ...Object.keys(_globals().default.node)]),
   'electron-main': new Set([...BUILTINS, ...Object.keys(_globals().default.node)]),
   'electron-renderer': new Set([...BUILTINS, ...Object.keys(_globals().default.node), ...Object.keys(_globals().default.browser)])
@@ -90,32 +97,35 @@ const OUTPUT_FORMATS = {
   global: _GlobalOutputFormat.GlobalOutputFormat
 };
 class ScopeHoistingPackager {
+  assetOutputs = new Map();
   exportedSymbols = new Map();
   externals = new Map();
   topLevelNames = new Map();
   seenAssets = new Set();
   wrappedAssets = new Set();
+  constantAssets = new Set();
   hoistedRequires = new Map();
+  seenHoistedRequires = new Set();
   needsPrelude = false;
   usedHelpers = new Set();
   externalAssets = new Set();
-  forceSkipWrapAssets = [];
-  constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime, forceSkipWrapAssets, logger) {
+  useBothScopeHoistingImprovements = (0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2') || (0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovement');
+  constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime, manualStaticBindingExports, logger) {
     this.options = options;
     this.bundleGraph = bundleGraph;
     this.bundle = bundle;
     this.parcelRequireName = parcelRequireName;
     this.useAsyncBundleRuntime = useAsyncBundleRuntime;
-    this.forceSkipWrapAssets = forceSkipWrapAssets ?? [];
+    this.manualStaticBindingExports = (manualStaticBindingExports === null || manualStaticBindingExports === void 0 ? void 0 : manualStaticBindingExports.map(glob => (0, _utils().globToRegex)(glob))) ?? null;
     this.logger = logger;
     let OutputFormat = OUTPUT_FORMATS[this.bundle.env.outputFormat];
     this.outputFormat = new OutputFormat(this);
-    this.isAsyncBundle = this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') && !this.bundle.env.isIsolated() && this.bundle.bundleBehavior !== 'isolated';
+    this.isAsyncBundle = this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') && !this.bundle.env.isIsolated() && this.bundle.bundleBehavior !== 'isolated' && this.bundle.bundleBehavior !== 'inlineIsolated';
     this.globalNames = GLOBALS_BY_CONTEXT[bundle.env.context];
   }
   async package() {
     var _sourceMap;
-    let wrappedAssets = await this.loadAssets();
+    await this.loadAssets();
     this.buildExportedSymbols();
 
     // If building a library, the target is actually another bundler rather
@@ -134,8 +144,10 @@ class ScopeHoistingPackager {
     let lineCount = 0;
     let sourceMap = null;
     let processAsset = asset => {
+      this.seenHoistedRequires.clear();
       let [content, map, lines] = this.visitAsset(asset);
       if (sourceMap && map) {
+        // @ts-expect-error TS2551 - addSourceMap method exists but missing from @parcel/source-map type definitions
         sourceMap.addSourceMap(map, lineCount);
       } else if (this.bundle.env.sourceMap) {
         sourceMap = map;
@@ -143,11 +155,19 @@ class ScopeHoistingPackager {
       res += content + '\n';
       lineCount += lines + 1;
     };
+    if ((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') || this.useBothScopeHoistingImprovements) {
+      // Write out all constant modules used by this bundle
+      for (let asset of this.constantAssets) {
+        if (!this.seenAssets.has(asset)) {
+          processAsset(asset);
+        }
+      }
+    }
 
     // Hoist wrapped asset to the top of the bundle to ensure that they are registered
     // before they are used.
-    for (let asset of wrappedAssets) {
-      if (!this.seenAssets.has(asset.id)) {
+    for (let asset of this.wrappedAssets) {
+      if (!this.seenAssets.has(asset)) {
         processAsset(asset);
       }
     }
@@ -155,7 +175,7 @@ class ScopeHoistingPackager {
     // Add each asset that is directly connected to the bundle. Dependencies will be handled
     // by replacing `import` statements in the code.
     this.bundle.traverseAssets((asset, _, actions) => {
-      if (this.seenAssets.has(asset.id)) {
+      if (this.seenAssets.has(asset)) {
         actions.skipChildren();
         return;
       }
@@ -165,23 +185,35 @@ class ScopeHoistingPackager {
     let [prelude, preludeLines] = this.buildBundlePrelude();
     res = prelude + res;
     lineCount += preludeLines;
+    // @ts-expect-error TS2339 - offsetLines method exists but missing from @parcel/source-map type definitions
     (_sourceMap = sourceMap) === null || _sourceMap === void 0 || _sourceMap.offsetLines(1, preludeLines);
     let entries = this.bundle.getEntryAssets();
     let mainEntry = this.bundle.getMainEntry();
     if (this.isAsyncBundle) {
-      // In async bundles we don't want the main entry to execute until we require it
-      // as there might be dependencies in a sibling bundle that hasn't loaded yet.
-      entries = entries.filter(a => {
-        var _mainEntry;
-        return a.id !== ((_mainEntry = mainEntry) === null || _mainEntry === void 0 ? void 0 : _mainEntry.id);
-      });
+      if (this.useBothScopeHoistingImprovements || (0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+        // Generally speaking, async bundles should not be executed on load, as
+        // they're just collections of assets that other assets require.
+        // However, there are some special cases where a runtime asset needs to be
+        // injected, but no other asset will require it (mostly the bundle
+        // manifest).
+        // In this case, those assets need to be required on load.
+        entries = entries.filter(a => {
+          var _a$meta;
+          return (_a$meta = a.meta) === null || _a$meta === void 0 ? void 0 : _a$meta.runtimeAssetRequiringExecutionOnLoad;
+        });
+      } else {
+        entries = entries.filter(a => {
+          var _mainEntry;
+          return a.id !== ((_mainEntry = mainEntry) === null || _mainEntry === void 0 ? void 0 : _mainEntry.id);
+        });
+      }
       mainEntry = null;
     }
     let needsBundleQueue = this.shouldBundleQueue(this.bundle);
 
     // If any of the entry assets are wrapped, call parcelRequire so they are executed.
     for (let entry of entries) {
-      if (this.wrappedAssets.has(entry.id) && !this.isScriptEntry(entry)) {
+      if (this.wrappedAssets.has(entry) && !this.isScriptEntry(entry)) {
         var _entry$symbols$get;
         let parcelRequire = `parcelRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(entry))});\n`;
         let entryExports = (_entry$symbols$get = entry.symbols.get('*')) === null || _entry$symbols$get === void 0 ? void 0 : _entry$symbols$get.local;
@@ -211,38 +243,46 @@ class ScopeHoistingPackager {
       let {
         code,
         map: mapBuffer
-      } = (0, _nullthrows().default)(this.assetOutputs.get(mainEntry.id));
+      } = (0, _nullthrows().default)(this.assetOutputs.get(mainEntry));
       let map;
       if (mapBuffer) {
         map = new (_sourceMap2().default)(this.options.projectRoot, mapBuffer);
       }
       res += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, code, map, this.parcelRequireName);
       if (sourceMap && map) {
+        // @ts-expect-error TS2339 - addSourceMap method exists but missing from @parcel/source-map type definitions
         sourceMap.addSourceMap(map, lineCount);
       }
     }
-    return {
+    const result = {
       contents: res,
       map: sourceMap
     };
+    if (_utils().debugTools['scope-hoisting-stats']) {
+      result.scopeHoistingStats = {
+        totalAssets: this.assetOutputs.size,
+        wrappedAssets: this.wrappedAssets.size
+      };
+    }
+    return result;
   }
   shouldBundleQueue(bundle) {
     let referencingBundles = this.bundleGraph.getReferencingBundles(bundle);
     let hasHtmlReference = referencingBundles.some(b => b.type === 'html');
     let hasConditionalReference = false;
     let isConditionalBundle = false;
-    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && (0, _featureFlags().getFeatureFlag)('conditionalBundlingAsyncRuntime')) {
+    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
       // If the bundle has a conditional bundle reference (has an importCond)
       hasConditionalReference = this.bundleGraph.getReferencedConditionalBundles(bundle).length > 0;
       // If the bundle is a conditional bundle
       isConditionalBundle = this.hasConditionalDependency();
     }
-    return this.useAsyncBundleRuntime && bundle.type === 'js' && bundle.bundleBehavior !== 'inline' && bundle.env.outputFormat === 'esmodule' && !bundle.env.isIsolated() && bundle.bundleBehavior !== 'isolated' && (hasHtmlReference || hasConditionalReference || isConditionalBundle);
+    return this.useAsyncBundleRuntime && bundle.type === 'js' && bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inlineIsolated' && bundle.env.outputFormat === 'esmodule' && !bundle.env.isIsolated() && bundle.bundleBehavior !== 'isolated' && (hasHtmlReference || hasConditionalReference || isConditionalBundle);
   }
   runWhenReady(bundle, codeToRun) {
     let deps = this.bundleGraph.getReferencedBundles(bundle).filter(b => this.shouldBundleQueue(b)).map(b => b.publicId);
     const conditions = [];
-    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && (0, _featureFlags().getFeatureFlag)('conditionalBundlingAsyncRuntime')) {
+    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
       const conditionSet = this.bundleGraph.getConditionalBundleMapping().get(bundle.id);
       for (const [key, {
         ifTrueBundles,
@@ -264,11 +304,10 @@ class ScopeHoistingPackager {
     let queue = new (_utils().PromiseQueue)({
       maxConcurrent: 32
     });
-    let wrapped = [];
     this.bundle.traverseAssets(asset => {
       queue.add(async () => {
         let [code, map] = await Promise.all([asset.getCode(), this.bundle.env.sourceMap ? asset.getMapBuffer() : null]);
-        return [asset.id, {
+        return [asset, {
           code,
           map
         }];
@@ -276,40 +315,86 @@ class ScopeHoistingPackager {
       if (asset.meta.shouldWrap || this.bundle.env.sourceType === 'script' || this.bundleGraph.isAssetReferenced(this.bundle, asset) || this.bundleGraph.getIncomingDependencies(asset).some(dep => dep.meta.shouldWrap && dep.specifierType !== 'url')) {
         // Don't wrap constant "entry" modules _except_ if they are referenced by any lazy dependency
         if (!asset.meta.isConstantModule || this.bundleGraph.getIncomingDependencies(asset).some(dep => dep.priority === 'lazy')) {
-          this.wrappedAssets.add(asset.id);
-          wrapped.push(asset);
+          this.wrappedAssets.add(asset);
+        } else if (((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') || this.useBothScopeHoistingImprovements) && asset.meta.isConstantModule) {
+          this.constantAssets.add(asset);
         }
       }
     });
-    for (let wrappedAssetRoot of [...wrapped]) {
-      this.bundle.traverseAssets((asset, _, actions) => {
-        if (asset === wrappedAssetRoot) {
-          return;
-        }
-        if (this.wrappedAssets.has(asset.id)) {
-          actions.skipChildren();
-          return;
-        }
-        // This prevents children of a wrapped asset also being wrapped - it's an "unsafe" optimisation
-        // that should only be used when you know (or think you know) what you're doing.
-        //
-        // In particular this can force an async bundle to be scope hoisted where it previously would not be
-        // due to the entry asset being wrapped.
-        if (this.forceSkipWrapAssets.length > 0 && this.forceSkipWrapAssets.some(p => p === _path().default.relative(this.options.projectRoot, asset.filePath))) {
-          this.logger.verbose({
-            message: `Force skipping wrapping of ${_path().default.relative(this.options.projectRoot, asset.filePath)}`
-          });
-          actions.skipChildren();
-          return;
+    if (this.useBothScopeHoistingImprovements) {
+      // Tracks which assets have been assigned to a wrap group
+      let assignedAssets = new Set();
+
+      // In V2 scope hoisting, we iterate from the main entry, rather than
+      // wrapping the entry assets
+      if (!(0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+        // Make all entry assets wrapped, to avoid any top level hoisting
+        for (let entryAsset of this.bundle.getEntryAssets()) {
+          if (!this.wrappedAssets.has(entryAsset)) {
+            this.wrappedAssets.add(entryAsset);
+          }
         }
-        if (!asset.meta.isConstantModule) {
-          this.wrappedAssets.add(asset.id);
-          wrapped.push(asset);
+      }
+
+      // We need to make a new copy here so that we can add to the list and
+      // iterate the newly added items, without mutating the wrappedAssets set
+      let moduleGroupParents = [...this.wrappedAssets.values()];
+      if ((0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+        // The main entry needs to be check to find assets that would have gone in
+        // the top level scope
+        let mainEntry = this.bundle.getMainEntry();
+        if (mainEntry && !this.wrappedAssets.has(mainEntry)) {
+          moduleGroupParents.unshift(mainEntry);
         }
-      }, wrappedAssetRoot);
+      }
+      for (let moduleGroupParentAsset of moduleGroupParents) {
+        this.bundle.traverseAssets((asset, _, actions) => {
+          if (asset === moduleGroupParentAsset) {
+            return;
+          }
+          if (this.wrappedAssets.has(asset)) {
+            actions.skipChildren();
+            return;
+          }
+          if (!asset.meta.isConstantModule && (assignedAssets.has(asset) || this.isReExported(asset))) {
+            this.wrappedAssets.add(asset);
+
+            // This also needs to be added to the traversal so that we iterate
+            // it during this check.
+            moduleGroupParents.push(asset);
+            actions.skipChildren();
+            return;
+          }
+          assignedAssets.add(asset);
+        }, moduleGroupParentAsset);
+      }
+    } else {
+      for (let wrappedAssetRoot of this.wrappedAssets) {
+        this.bundle.traverseAssets((asset, _, actions) => {
+          if (asset === wrappedAssetRoot) {
+            return;
+          }
+          if (this.wrappedAssets.has(asset)) {
+            actions.skipChildren();
+            return;
+          }
+          if (!asset.meta.isConstantModule) {
+            this.wrappedAssets.add(asset);
+          }
+        }, wrappedAssetRoot);
+      }
     }
     this.assetOutputs = new Map(await queue.run());
-    return wrapped;
+  }
+  isReExported(asset) {
+    let parentSymbols = this.bundleGraph.getIncomingDependencies(asset).map(dep => this.bundleGraph.getAssetWithDependency(dep)).flatMap(parent => {
+      if (parent == null) {
+        return [];
+      }
+      return this.bundleGraph.getExportedSymbols(parent, this.bundle);
+    });
+    let assetSymbols = this.bundleGraph.getExportedSymbols(asset, this.bundle);
+    return assetSymbols.some(assetSymbol => parentSymbols.some(parentSymbol => parentSymbol.symbol === assetSymbol.symbol));
   }
   buildExportedSymbols() {
     if (!this.bundle.env.isLibrary || this.bundle.env.outputFormat !== 'esmodule') {
@@ -318,7 +403,7 @@ class ScopeHoistingPackager {
 
     // TODO: handle ESM exports of wrapped entry assets...
     let entry = this.bundle.getMainEntry();
-    if (entry && !this.wrappedAssets.has(entry.id)) {
+    if (entry && !this.wrappedAssets.has(entry)) {
       let hasNamespace = entry.symbols.hasExportSymbol('*');
       for (let {
         asset,
@@ -387,16 +472,19 @@ class ScopeHoistingPackager {
     return `${obj}[${JSON.stringify(property)}]`;
   }
   visitAsset(asset) {
-    (0, _assert().default)(!this.seenAssets.has(asset.id), 'Already visited asset');
-    this.seenAssets.add(asset.id);
+    (0, _assert().default)(!this.seenAssets.has(asset), 'Already visited asset');
+    this.seenAssets.add(asset);
     let {
       code,
       map
-    } = (0, _nullthrows().default)(this.assetOutputs.get(asset.id));
+    } = (0, _nullthrows().default)(this.assetOutputs.get(asset));
     return this.buildAsset(asset, code, map);
   }
+  getAssetFilePath(asset) {
+    return _path().default.relative(this.options.projectRoot, asset.filePath);
+  }
   buildAsset(asset, code, map) {
-    let shouldWrap = this.wrappedAssets.has(asset.id);
+    let shouldWrap = this.wrappedAssets.has(asset);
     let deps = this.bundleGraph.getDependencies(asset);
     let sourceMap = this.bundle.env.sourceMap && map ? new (_sourceMap2().default)(this.options.projectRoot, map) : null;
 
@@ -416,13 +504,27 @@ class ScopeHoistingPackager {
           }
           continue;
         }
-        if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved.id)) {
-          let [code, map, lines] = this.visitAsset(resolved);
-          depCode += code + '\n';
-          if (sourceMap && map) {
-            sourceMap.addSourceMap(map, lineCount);
+        if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved)) {
+          if (this.useBothScopeHoistingImprovements && this.wrappedAssets.has(resolved)) {
+            if (this.wrappedAssets.has(asset)) {
+              // If both the asset and the dep are wrapped there's no need to
+              // drop a side-effect require. This is an extremely rare case.
+              continue;
+            }
+
+            // When the dep is wrapped then we just need to drop a side effect
+            // require instead of inlining
+            depCode += `parcelRequire("${this.bundleGraph.getAssetPublicId(resolved)}");\n`;
+            lineCount += 1;
+          } else {
+            let [code, map, lines] = this.visitAsset(resolved);
+            depCode += code + '\n';
+            if (sourceMap && map) {
+              // @ts-expect-error TS2551 - addSourceMap method exists but missing from @parcel/source-map type definitions
+              sourceMap.addSourceMap(map, lineCount);
+            }
+            lineCount += lines + 1;
           }
-          lineCount += lines + 1;
         }
       }
       return [depCode, sourceMap, lineCount];
@@ -482,20 +584,51 @@ class ScopeHoistingPackager {
               // after the dependency is declared. This handles the case where the resulting asset
               // is wrapped, but the dependency in this asset is not marked as wrapped. This means
               // that it was imported/required at the top-level, so its side effects should run immediately.
-              let [res, lines] = this.getHoistedParcelRequires(asset, dep, resolved);
+              let res = '';
+              let lines = 0;
               let map;
-              if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved.id)) {
+              if (!(0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+                [res, lines] = this.getHoistedParcelRequires(asset, dep, resolved);
+              }
+              if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved)) {
                 // If this asset is wrapped, we need to hoist the code for the dependency
                 // outside our parcelRequire.register wrapper. This is safe because all
                 // assets referenced by this asset will also be wrapped. Otherwise, inline the
                 // asset content where the import statement was.
-                if (shouldWrap) {
-                  depContent.push(this.visitAsset(resolved));
+                if (this.useBothScopeHoistingImprovements) {
+                  if (!resolved.meta.isConstantModule && !this.wrappedAssets.has(resolved)) {
+                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                    if (_utils().debugTools['asset-file-names-in-output']) {
+                      let resolvedPath = this.getAssetFilePath(resolved);
+                      res = (0, _outdent().outdent)`
+                          /* Scope hoisted asset: ${resolvedPath} */
+                          ${depCode}
+                          /* End: ${resolvedPath} */
+                          ${res}
+                        `;
+                      lines += 3 + depLines;
+                    } else {
+                      res = depCode + '\n' + res;
+                      lines += 1 + depLines;
+                    }
+                    map = depMap;
+                  }
                 } else {
-                  let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                  res = depCode + '\n' + res;
-                  lines += 1 + depLines;
-                  map = depMap;
+                  if (shouldWrap) {
+                    depContent.push(this.visitAsset(resolved));
+                  } else {
+                    let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                    res = depCode + '\n' + res;
+                    lines += 1 + depLines;
+                    map = depMap;
+                  }
+                }
+              }
+              if ((0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+                let [requiresCode, requiresLines] = this.getHoistedParcelRequires(asset, dep, resolved);
+                if (requiresCode) {
+                  res = requiresCode + '\n' + res;
+                  lines += requiresLines + 1;
                 }
               }
 
@@ -506,6 +639,7 @@ class ScopeHoistingPackager {
                   sourceMap.offsetLines(lineCount + 1, lines);
                 }
                 if (map) {
+                  // @ts-expect-error TS2551 - addSourceMap method exists but missing from @parcel/source-map type definitions
                   sourceMap.addSourceMap(map, lineCount);
                 }
               }
@@ -542,10 +676,15 @@ ${code}
 });
 `;
       lineCount += 2;
+      if (_utils().debugTools['asset-file-names-in-output']) {
+        code = `/* ${this.getAssetFilePath(asset)} */\n` + code;
+        lineCount += 1;
+      }
       for (let [depCode, map, lines] of depContent) {
         if (!depCode) continue;
         code += depCode + '\n';
         if (sourceMap && map) {
+          // @ts-expect-error TS2551 - addSourceMap method exists but missing from @parcel/source-map type definitions
           sourceMap.addSourceMap(map, lineCount);
         }
         lineCount += lines + 1;
@@ -614,7 +753,7 @@ ${code}
 
     // If this asset is wrapped, we need to replace the exports namespace with `module.exports`,
     // which will be provided to us by the wrapper.
-    if (this.wrappedAssets.has(asset.id) || this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry()) {
+    if (this.wrappedAssets.has(asset) || this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry()) {
       var _asset$symbols$get;
       let exportsName = ((_asset$symbols$get = asset.symbols.get('*')) === null || _asset$symbols$get === void 0 ? void 0 : _asset$symbols$get.local) || `$${assetId}$exports`;
       replacements.set(exportsName, 'module.exports');
@@ -648,6 +787,7 @@ ${code}
       local
     }] of dep.symbols) {
       // If already imported, just add the already renamed variable to the mapping.
+
       let renamed = external.get(imported);
       if (renamed && local !== '*' && replacements) {
         replacements.set(local, renamed);
@@ -711,7 +851,7 @@ ${code}
                 continue;
               }
             }
-            renamed = this.bundleGraph.getSymbolResolution(entry, imported, this.bundle).symbol;
+            renamed = this.bundleGraph.getSymbolResolution(entry, imported, this.bundle).symbol || undefined;
           }
         }
 
@@ -752,7 +892,7 @@ ${code}
       }
       return false;
     }
-    return !this.bundle.hasAsset(resolved) && !this.externalAssets.has(resolved) || this.wrappedAssets.has(resolved.id) && resolved !== parentAsset;
+    return !this.bundle.hasAsset(resolved) && !this.externalAssets.has(resolved) || this.wrappedAssets.has(resolved) && resolved !== parentAsset;
   }
   getSymbolResolution(parentAsset, resolved, imported, dep, replacements) {
     let {
@@ -779,12 +919,12 @@ ${code}
     // Only do this if the asset is part of a different bundle (so it was definitely
     // parcelRequire.register'ed there), or if it is indeed registered in this bundle.
     !this.bundle.hasAsset(resolvedAsset) || !this.shouldSkipAsset(resolvedAsset))) {
-      let hoisted = this.hoistedRequires.get(dep.id);
+      let hoisted = this.hoistedRequires.get(dep);
       if (!hoisted) {
         hoisted = new Map();
-        this.hoistedRequires.set(dep.id, hoisted);
+        this.hoistedRequires.set(dep, hoisted);
       }
-      hoisted.set(resolvedAsset.id, `var $${publicId} = parcelRequire(${JSON.stringify(publicId)});`);
+      hoisted.set(resolvedAsset, `var $${publicId} = parcelRequire(${JSON.stringify(publicId)});`);
     }
     if (isWrapped) {
       this.needsPrelude = true;
@@ -813,7 +953,7 @@ ${code}
     }
     if (imported === '*' || exportSymbol === '*' || isDefaultInterop) {
       // Resolve to the namespace object if requested or this is a CJS default interop reqiure.
-      if (parentAsset === resolvedAsset && this.wrappedAssets.has(resolvedAsset.id)) {
+      if (parentAsset === resolvedAsset && this.wrappedAssets.has(resolvedAsset)) {
         // Directly use module.exports for wrapped assets importing themselves.
         return 'module.exports';
       } else {
@@ -841,7 +981,7 @@ ${code}
     if (resolved.type !== 'js') {
       return ['', 0];
     }
-    let hoisted = this.hoistedRequires.get(dep.id);
+    let hoisted = this.hoistedRequires.get(dep);
     let res = '';
     let lineCount = 0;
     let isWrapped = this.isWrapped(resolved, parentAsset);
@@ -850,14 +990,23 @@ ${code}
     // we need to run side effects when this asset runs. If the resolved asset is not
     // the first one in the hoisted requires, we need to insert a parcelRequire here
     // so it runs first.
-    if (isWrapped && !dep.meta.shouldWrap && (!hoisted || hoisted.keys().next().value !== resolved.id) && !this.bundleGraph.isDependencySkipped(dep) && !this.shouldSkipAsset(resolved)) {
+    if (isWrapped && !dep.meta.shouldWrap && (!hoisted || hoisted.keys().next().value !== resolved) && !this.bundleGraph.isDependencySkipped(dep) && !this.shouldSkipAsset(resolved)) {
       this.needsPrelude = true;
       res += `parcelRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(resolved))});`;
     }
     if (hoisted) {
       this.needsPrelude = true;
-      res += '\n' + [...hoisted.values()].join('\n');
-      lineCount += hoisted.size;
+      if ((0, _featureFlags().getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+        let hoistedValues = [...hoisted.values()].filter(val => !this.seenHoistedRequires.has(val));
+        for (let val of hoistedValues) {
+          this.seenHoistedRequires.add(val);
+        }
+        res += '\n' + hoistedValues.join('\n');
+        lineCount += hoisted.size;
+      } else {
+        res += '\n' + [...hoisted.values()].join('\n');
+        lineCount += hoisted.size;
+      }
     }
     return [res, lineCount];
   }
@@ -865,7 +1014,7 @@ ${code}
     let prepend = '';
     let prependLineCount = 0;
     let append = '';
-    let shouldWrap = this.wrappedAssets.has(asset.id);
+    let shouldWrap = this.wrappedAssets.has(asset);
     let usedSymbols = (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(asset));
     let assetId = asset.meta.id;
     (0, _assert().default)(typeof assetId === 'string');
@@ -874,20 +1023,28 @@ ${code}
     // If there's no __esModule flag, and default is a used symbol, we need
     // to insert an interop helper.
     let defaultInterop = asset.symbols.hasExportSymbol('*') && usedSymbols.has('default') && !asset.symbols.hasExportSymbol('__esModule');
-    let usedNamespace =
-    // If the asset has * in its used symbols, we might need the exports namespace.
-    // The one case where this isn't true is in ESM library entries, where the only
-    // dependency on * is the entry dependency. In this case, we will use ESM exports
-    // instead of the namespace object.
-    usedSymbols.has('*') && (this.bundle.env.outputFormat !== 'esmodule' || !this.bundle.env.isLibrary || asset !== this.bundle.getMainEntry() || this.bundleGraph.getIncomingDependencies(asset).some(dep => !dep.isEntry && this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'))) ||
-    // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
-    // we fallback on the namespace object.
-    asset.symbols.hasExportSymbol('*') && [...usedSymbols].some(s => !asset.symbols.hasExportSymbol(s)) ||
-    // If the exports has this asset's namespace (e.g. ESM output from CJS input),
-    // include the namespace object for the default export.
-    this.exportedSymbols.has(`$${assetId}$exports`) ||
-    // CommonJS library bundle entries always need a namespace.
-    this.bundle.env.isLibrary && this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry();
+    let usedNamespace;
+    if ((0, _featureFlags().getFeatureFlag)('inlineConstOptimisationFix') && asset.meta.isConstantModule) {
+      // Only set usedNamespace if there is an incoming dependency in the current bundle that uses '*'
+      usedNamespace = this.bundleGraph.getIncomingDependencies(asset).some(dep => this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'));
+    } else {
+      usedNamespace =
+      // If the asset has * in its used symbols, we might need the exports namespace.
+      // The one case where this isn't true is in ESM library entries, where the only
+      // dependency on * is the entry dependency. In this case, we will use ESM exports
+      // instead of the namespace object.
+
+      usedSymbols.has('*') && (this.bundle.env.outputFormat !== 'esmodule' || !this.bundle.env.isLibrary || asset !== this.bundle.getMainEntry() || this.bundleGraph.getIncomingDependencies(asset).some(dep => !dep.isEntry && this.bundle.hasDependency(dep) && (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep)).has('*'))) ||
+      // If a symbol is imported (used) from a CJS asset but isn't listed in the symbols,
+      // we fallback on the namespace object.
+
+      asset.symbols.hasExportSymbol('*') && [...usedSymbols].some(s => !asset.symbols.hasExportSymbol(s)) ||
+      // If the exports has this asset's namespace (e.g. ESM output from CJS input),
+      // include the namespace object for the default export.
+      this.exportedSymbols.has(`$${assetId}$exports`) ||
+      // CommonJS library bundle entries always need a namespace.
+      this.bundle.env.isLibrary && this.bundle.env.outputFormat === 'commonjs' && asset === this.bundle.getMainEntry();
+    }
 
     // If the asset doesn't have static exports, should wrap, the namespace is used,
     // or we need default interop, then we need to synthesize a namespace object for
@@ -905,6 +1062,7 @@ ${code}
       // Insert the __esModule interop flag for this module if it has a `default` export
       // and the namespace symbol is used.
       // TODO: only if required by CJS?
+
       if (asset.symbols.hasExportSymbol('default') && usedSymbols.has('*')) {
         prepend += `\n$parcel$defineInteropFlag($${assetId}$exports);\n`;
         prependLineCount += 2;
@@ -988,16 +1146,22 @@ ${code}
         // for the symbol so that when the value changes the object property also changes. This is
         // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
         // additional assignments after each mutation of the original binding.
-        prepend += `\n${usedExports.map(exp => {
-          var _asset$symbols$get2;
+        for (let exp of usedExports) {
+          var _asset$symbols$get2, _this$manualStaticBin;
           let resolved = this.getSymbolResolution(asset, asset, exp, undefined, replacements);
-          let get = this.buildFunctionExpression([], resolved);
-          let isEsmExport = !!((_asset$symbols$get2 = asset.symbols.get(exp)) !== null && _asset$symbols$get2 !== void 0 && (_asset$symbols$get2 = _asset$symbols$get2.meta) !== null && _asset$symbols$get2 !== void 0 && _asset$symbols$get2.isEsm);
-          let set = !isEsmExport && asset.meta.hasCJSExports ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`) : '';
-          return `$parcel$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});`;
-        }).join('\n')}\n`;
-        this.usedHelpers.add('$parcel$export');
-        prependLineCount += 1 + usedExports.length;
+          const meta = (_asset$symbols$get2 = asset.symbols.get(exp)) === null || _asset$symbols$get2 === void 0 ? void 0 : _asset$symbols$get2.meta;
+          if ((0, _featureFlags().getFeatureFlag)('exportsRebindingOptimisation') && (meta !== null && meta !== void 0 && meta.isStaticBindingSafe || (_this$manualStaticBin = this.manualStaticBindingExports) !== null && _this$manualStaticBin !== void 0 && _this$manualStaticBin.some(regex => regex.test(asset.filePath)))) {
+            append += `$${assetId}$exports[${JSON.stringify(exp)}] = ${resolved};\n`;
+          } else {
+            var _asset$symbols$get3;
+            let get = this.buildFunctionExpression([], resolved);
+            let isEsmExport = !!((_asset$symbols$get3 = asset.symbols.get(exp)) !== null && _asset$symbols$get3 !== void 0 && (_asset$symbols$get3 = _asset$symbols$get3.meta) !== null && _asset$symbols$get3 !== void 0 && _asset$symbols$get3.isEsm);
+            let set = !isEsmExport && asset.meta.hasCJSExports ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`) : '';
+            prepend += `$parcel$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});\n`;
+            this.usedHelpers.add('$parcel$export');
+            prependLineCount += 1 + usedExports.length;
+          }
+        }
       }
     }
     return [prepend, prependLineCount, append];
@@ -1041,11 +1205,11 @@ ${code}
       // Add the prelude if this is potentially the first JS bundle to load in a
       // particular context (e.g. entry scripts in HTML, workers, etc.).
       let parentBundles = this.bundleGraph.getParentBundles(this.bundle);
-      let mightBeFirstJS = parentBundles.length === 0 || parentBundles.some(b => b.type !== 'js') || this.bundleGraph.getBundleGroupsContainingBundle(this.bundle).some(g => this.bundleGraph.isEntryBundleGroup(g)) || this.bundle.env.isIsolated() || this.bundle.bundleBehavior === 'isolated' ||
+      let mightBeFirstJS = parentBundles.length === 0 || parentBundles.some(b => b.type !== 'js') || this.bundleGraph.getBundleGroupsContainingBundle(this.bundle).some(g => this.bundleGraph.isEntryBundleGroup(g)) || this.bundle.env.isIsolated() || this.bundle.bundleBehavior === 'isolated' || this.bundle.bundleBehavior === 'inlineIsolated' ||
       // Conditional deps may be loaded before entrypoints on the server
       this.hasConditionalDependency();
       if (mightBeFirstJS) {
-        let preludeCode = (0, _helpers.prelude)(this.parcelRequireName);
+        let preludeCode = ((0, _featureFlags().getFeatureFlag)('useNewPrelude') ? _helpers.preludeNew : _helpers.preludeOld)(this.parcelRequireName);
         res += preludeCode;
         if (enableSourceMaps) {
           lines += (0, _utils().countLines)(preludeCode) - 1;
@@ -1068,7 +1232,7 @@ ${code}
     }
 
     // Add importScripts for sibling bundles in workers.
-    if (this.bundle.env.isWorker() || this.bundle.env.isWorklet()) {
+    if (this.bundle.env.isWorker() || this.bundle.env.isTesseract() || this.bundle.env.isWorklet()) {
       let importScripts = '';
       let bundles = this.bundleGraph.getReferencedBundles(this.bundle);
       for (let b of bundles) {