@atlaspack/packager-js 2.14.5-canary.33 → 2.14.5-canary.331

package/dist/ScopeHoistingPackager.js

@@ -0,0 +1,1401 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeHoistingPackager = void 0;
+const utils_1 = require("@atlaspack/utils");
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const assert_1 = __importStar(require("assert"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const globals_1 = __importDefault(require("globals"));
+const path_1 = __importDefault(require("path"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const outdent_1 = require("outdent");
+const ESMOutputFormat_1 = require("./ESMOutputFormat");
+const CJSOutputFormat_1 = require("./CJSOutputFormat");
+const GlobalOutputFormat_1 = require("./GlobalOutputFormat");
+const helpers_1 = require("./helpers");
+const utils_2 = require("./utils");
+// 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;
+const BUILTINS = Object.keys(globals_1.default.builtin);
+const GLOBALS_BY_CONTEXT = {
+    browser: new Set([...BUILTINS, ...Object.keys(globals_1.default.browser)]),
+    'web-worker': new Set([...BUILTINS, ...Object.keys(globals_1.default.worker)]),
+    'service-worker': new Set([
+        ...BUILTINS,
+        ...Object.keys(globals_1.default.serviceworker),
+    ]),
+    worklet: new Set([...BUILTINS]),
+    tesseract: new Set([...BUILTINS, ...Object.keys(globals_1.default.worker)]),
+    node: new Set([...BUILTINS, ...Object.keys(globals_1.default.node)]),
+    'electron-main': new Set([...BUILTINS, ...Object.keys(globals_1.default.node)]),
+    'electron-renderer': new Set([
+        ...BUILTINS,
+        ...Object.keys(globals_1.default.node),
+        ...Object.keys(globals_1.default.browser),
+    ]),
+};
+const OUTPUT_FORMATS = {
+    esmodule: ESMOutputFormat_1.ESMOutputFormat,
+    commonjs: CJSOutputFormat_1.CJSOutputFormat,
+    global: GlobalOutputFormat_1.GlobalOutputFormat,
+};
+class ScopeHoistingPackager {
+    constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime, manualStaticBindingExports, logger) {
+        this.assetOutputs = new Map();
+        this.exportedSymbols = new Map();
+        this.externals = new Map();
+        this.topLevelNames = new Map();
+        this.seenAssets = new Set();
+        this.wrappedAssets = new Set();
+        this.constantAssets = new Set();
+        this.hoistedRequires = new Map();
+        this.seenHoistedRequires = new Set();
+        this.needsPrelude = false;
+        this.usedHelpers = new Set();
+        this.externalAssets = new Set();
+        this.useBothScopeHoistingImprovements = (0, feature_flags_1.getFeatureFlag)('applyScopeHoistingImprovementV2') ||
+            (0, feature_flags_1.getFeatureFlag)('applyScopeHoistingImprovement');
+        this.referencedAssetsCache = new Map();
+        this.options = options;
+        this.bundleGraph = bundleGraph;
+        this.bundle = bundle;
+        this.parcelRequireName = parcelRequireName;
+        this.useAsyncBundleRuntime = useAsyncBundleRuntime;
+        this.manualStaticBindingExports =
+            manualStaticBindingExports?.map((glob) => (0, utils_1.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.bundle.bundleBehavior !== 'inlineIsolated';
+        this.globalNames = GLOBALS_BY_CONTEXT[bundle.env.context];
+    }
+    async package() {
+        await this.loadAssets();
+        this.buildExportedSymbols();
+        // If building a library, the target is actually another bundler rather
+        // than the final output that could be loaded in a browser. So, loader
+        // runtimes are excluded, and instead we add imports into the entry bundle
+        // of each bundle group pointing at the sibling bundles. These can be
+        // picked up by another bundler later at which point runtimes will be added.
+        if (this.bundle.env.isLibrary ||
+            this.bundle.env.outputFormat === 'commonjs') {
+            for (let b of this.bundleGraph.getReferencedBundles(this.bundle, {
+                recursive: false,
+            })) {
+                this.externals.set((0, utils_1.relativeBundlePath)(this.bundle, b), new Map());
+            }
+        }
+        let res = '';
+        let lineCount = 0;
+        let sourceMap = null;
+        let processAsset = (asset) => {
+            this.seenHoistedRequires.clear();
+            let [content, map, lines] = this.visitAsset(asset);
+            if (sourceMap && map) {
+                sourceMap.addSourceMap(map, lineCount);
+            }
+            else if (this.bundle.env.sourceMap) {
+                sourceMap = map;
+            }
+            res += content + '\n';
+            lineCount += lines + 1;
+        };
+        if ((0, feature_flags_1.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 this.wrappedAssets) {
+            if (!this.seenAssets.has(asset)) {
+                processAsset(asset);
+            }
+        }
+        // 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)) {
+                actions.skipChildren();
+                return;
+            }
+            processAsset(asset);
+            actions.skipChildren();
+        });
+        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?.offsetLines(1, preludeLines);
+        let entries = this.bundle.getEntryAssets();
+        let mainEntry = this.bundle.getMainEntry();
+        if (this.isAsyncBundle) {
+            if (this.useBothScopeHoistingImprovements ||
+                (0, feature_flags_1.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) => a.meta?.runtimeAssetRequiringExecutionOnLoad);
+            }
+            else {
+                entries = entries.filter((a) => a.id !== 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) && !this.isScriptEntry(entry)) {
+                let parcelRequire = `parcelRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(entry))});\n`;
+                let entryExports = entry.symbols.get('*')?.local;
+                if (entryExports &&
+                    entry === mainEntry &&
+                    this.exportedSymbols.has(entryExports)) {
+                    (0, assert_1.default)(!needsBundleQueue, 'Entry exports are not yet compaitble with async bundles');
+                    res += `\nvar ${entryExports} = ${parcelRequire}`;
+                }
+                else {
+                    if (needsBundleQueue) {
+                        parcelRequire = this.runWhenReady(this.bundle, parcelRequire);
+                    }
+                    res += `\n${parcelRequire}`;
+                }
+                lineCount += 2;
+            }
+        }
+        let [postlude, postludeLines] = this.outputFormat.buildBundlePostlude();
+        res += postlude;
+        lineCount += postludeLines;
+        // The entry asset of a script bundle gets hoisted outside the bundle wrapper so that
+        // its top-level variables become globals like a real browser script. We need to replace
+        // all dependency references for runtimes with a parcelRequire call.
+        if (this.bundle.env.outputFormat === 'global' &&
+            this.bundle.env.sourceType === 'script') {
+            res += '\n';
+            lineCount++;
+            let mainEntry = (0, nullthrows_1.default)(this.bundle.getMainEntry());
+            let { code, map: mapBuffer } = (0, nullthrows_1.default)(this.assetOutputs.get(mainEntry));
+            let map;
+            if (mapBuffer) {
+                map = new source_map_1.default(this.options.projectRoot, mapBuffer);
+            }
+            res += (0, utils_2.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);
+            }
+        }
+        const result = { contents: res, map: sourceMap };
+        if (utils_1.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, feature_flags_1.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.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, feature_flags_1.getFeatureFlag)('conditionalBundlingApi')) {
+            const conditionSet = this.bundleGraph
+                .getConditionalBundleMapping()
+                .get(bundle.id);
+            for (const [key, { ifTrueBundles, ifFalseBundles },] of conditionSet?.entries() ?? []) {
+                const ifTrueBundleIds = ifTrueBundles
+                    .map((b) => `"${b.publicId}"`)
+                    .join(',');
+                const ifFalseBundleIds = ifFalseBundles
+                    .map((b) => `"${b.publicId}"`)
+                    .join(',');
+                conditions.push(`(globalThis.__MCOND && globalThis.__MCOND('${key}') ? [${ifTrueBundleIds}] : [${ifFalseBundleIds}])`);
+            }
+        }
+        if (deps.length === 0 && conditions.length === 0) {
+            // If no deps we can safely execute immediately
+            return codeToRun;
+        }
+        let params = [
+            JSON.stringify(this.bundle.publicId),
+            (0, helpers_1.fnExpr)(this.bundle.env, [], [codeToRun]),
+            `${JSON.stringify(deps)}${conditions.length > 0
+                ? `.concat([${conditions
+                    .map((conditions) => `...${conditions}`)
+                    .join(',')}])`
+                : ''}`,
+        ];
+        return `$parcel$global.rwr(${params.join(', ')});`;
+    }
+    // Helper to check if an asset is referenced, with cache-first + fast-check hybrid approach
+    isAssetReferencedInBundle(bundle, asset) {
+        // STEP 1: Check expensive computation cache first (fastest when it hits)
+        if ((0, feature_flags_1.getFeatureFlag)('precomputeReferencedAssets')) {
+            let bundleId = bundle.id;
+            let referencedAssets = this.referencedAssetsCache.get(bundleId);
+            if (referencedAssets) {
+                // Cache hit - fastest path (~0.001ms)
+                return referencedAssets.has(asset);
+            }
+        }
+        // STEP 2: Cache miss - try fast checks (~0.01ms)
+        let fastCheckResult = this.bundleGraph.isAssetReferencedFastCheck(bundle, asset);
+        if (fastCheckResult === true) {
+            // Fast check succeeded - asset is referenced
+            return true;
+        }
+        // STEP 3: Need expensive computation (~20-2000ms)
+        if ((0, feature_flags_1.getFeatureFlag)('precomputeReferencedAssets')) {
+            // Compute and cache expensive results for this bundle
+            let bundleId = bundle.id;
+            let referencedAssets = this.bundleGraph.getReferencedAssets(bundle);
+            this.referencedAssetsCache.set(bundleId, referencedAssets);
+            return referencedAssets.has(asset);
+        }
+        else {
+            // No caching - fall back to original expensive method
+            return this.bundleGraph.isAssetReferenced(bundle, asset);
+        }
+    }
+    async loadAssets() {
+        let queue = new utils_1.PromiseQueue({
+            maxConcurrent: 32,
+        });
+        this.bundle.traverseAssets((asset) => {
+            queue.add(async () => {
+                let [code, map] = await Promise.all([
+                    asset.getCode(),
+                    this.bundle.env.sourceMap ? asset.getMapBuffer() : null,
+                ]);
+                return [asset, { code, map }];
+            });
+            if (asset.meta.shouldWrap ||
+                this.bundle.env.sourceType === 'script' ||
+                this.isAssetReferencedInBundle(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);
+                }
+                else if (((0, feature_flags_1.getFeatureFlag)('inlineConstOptimisationFix') ||
+                    this.useBothScopeHoistingImprovements) &&
+                    asset.meta.isConstantModule) {
+                    this.constantAssets.add(asset);
+                }
+            }
+        });
+        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, feature_flags_1.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);
+                    }
+                }
+            }
+            // 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, feature_flags_1.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);
+                }
+            }
+            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());
+    }
+    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') {
+            return;
+        }
+        // TODO: handle ESM exports of wrapped entry assets...
+        let entry = this.bundle.getMainEntry();
+        if (entry && !this.wrappedAssets.has(entry)) {
+            let hasNamespace = entry.symbols.hasExportSymbol('*');
+            for (let { asset, exportAs, symbol, exportSymbol, } of this.bundleGraph.getExportedSymbols(entry)) {
+                if (typeof symbol === 'string') {
+                    // If the module has a namespace (e.g. commonjs), and this is not an entry, only export the namespace
+                    // as default, without individual exports. This mirrors the importing logic in addExternal, avoiding
+                    // extra unused exports and potential for non-identifier export names.
+                    if (hasNamespace && this.isAsyncBundle && exportAs !== '*') {
+                        continue;
+                    }
+                    let symbols = this.exportedSymbols.get(symbol === '*' ? (0, nullthrows_1.default)(entry.symbols.get('*')?.local) : symbol)?.exportAs;
+                    if (!symbols) {
+                        symbols = [];
+                        this.exportedSymbols.set(symbol, {
+                            asset,
+                            exportSymbol,
+                            local: symbol,
+                            exportAs: symbols,
+                        });
+                    }
+                    if (exportAs === '*') {
+                        exportAs = 'default';
+                    }
+                    symbols.push(exportAs);
+                }
+                else if (symbol === null) {
+                    // TODO `meta.exportsIdentifier[exportSymbol]` should be exported
+                    // let relativePath = relative(options.projectRoot, asset.filePath);
+                    // throw getThrowableDiagnosticForNode(
+                    //   md`${relativePath} couldn't be statically analyzed when importing '${exportSymbol}'`,
+                    //   entry.filePath,
+                    //   loc,
+                    // );
+                }
+                else if (symbol !== false) {
+                    // let relativePath = relative(options.projectRoot, asset.filePath);
+                    // throw getThrowableDiagnosticForNode(
+                    //   md`${relativePath} does not export '${exportSymbol}'`,
+                    //   entry.filePath,
+                    //   loc,
+                    // );
+                }
+            }
+        }
+    }
+    getTopLevelName(name) {
+        name = (0, utils_2.makeValidIdentifier)(name);
+        if (this.globalNames.has(name)) {
+            name = '_' + name;
+        }
+        let count = this.topLevelNames.get(name);
+        if (count == null) {
+            this.topLevelNames.set(name, 1);
+            return name;
+        }
+        this.topLevelNames.set(name, count + 1);
+        return name + count;
+    }
+    getPropertyAccess(obj, property) {
+        if ((0, utils_2.isValidIdentifier)(property)) {
+            return `${obj}.${property}`;
+        }
+        return `${obj}[${JSON.stringify(property)}]`;
+    }
+    visitAsset(asset) {
+        (0, assert_1.default)(!this.seenAssets.has(asset), 'Already visited asset');
+        this.seenAssets.add(asset);
+        let { code, map } = (0, nullthrows_1.default)(this.assetOutputs.get(asset));
+        return this.buildAsset(asset, code, map);
+    }
+    getAssetFilePath(asset) {
+        return path_1.default.relative(this.options.projectRoot, asset.filePath);
+    }
+    buildAsset(asset, code, map) {
+        let shouldWrap = this.wrappedAssets.has(asset);
+        let deps = this.bundleGraph.getDependencies(asset);
+        let sourceMap = this.bundle.env.sourceMap && map
+            ? new source_map_1.default(this.options.projectRoot, map)
+            : null;
+        // If this asset is skipped, just add dependencies and not the asset's content.
+        if (this.shouldSkipAsset(asset)) {
+            let depCode = '';
+            let lineCount = 0;
+            for (let dep of deps) {
+                let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+                let skipped = this.bundleGraph.isDependencySkipped(dep);
+                if (skipped) {
+                    continue;
+                }
+                if (!resolved) {
+                    if (!dep.isOptional) {
+                        this.addExternal(dep);
+                    }
+                    continue;
+                }
+                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) {
+                            sourceMap.addSourceMap(map, lineCount);
+                        }
+                        lineCount += lines + 1;
+                    }
+                }
+            }
+            return [depCode, sourceMap, lineCount];
+        }
+        // TODO: maybe a meta prop?
+        if (code.includes('$parcel$global')) {
+            this.usedHelpers.add('$parcel$global');
+        }
+        if (this.bundle.env.isNode() && asset.meta.has_node_replacements) {
+            const relPath = (0, utils_1.normalizeSeparators)(path_1.default.relative(this.bundle.target.distDir, path_1.default.dirname(asset.filePath)));
+            code = code.replace('$parcel$dirnameReplace', relPath);
+            code = code.replace('$parcel$filenameReplace', relPath);
+        }
+        let [depMap, replacements] = this.buildReplacements(asset, deps);
+        let [prepend, prependLines, append] = this.buildAssetPrelude(asset, deps, replacements);
+        if (prependLines > 0) {
+            sourceMap?.offsetLines(1, prependLines);
+            code = prepend + code;
+        }
+        code += append;
+        let lineCount = 0;
+        let depContent = [];
+        if (depMap.size === 0 && replacements.size === 0) {
+            // If there are no dependencies or replacements, use a simple function to count the number of lines.
+            lineCount = (0, utils_1.countLines)(code) - 1;
+        }
+        else {
+            // Otherwise, use a regular expression to perform replacements.
+            // We need to track how many newlines there are for source maps, replace
+            // all import statements with dependency code, and perform inline replacements
+            // of all imported symbols with their resolved export symbols. This is all done
+            // in a single regex so that we only do one pass over the whole code.
+            let offset = 0;
+            let columnStartIndex = 0;
+            code = code.replace((0, feature_flags_1.getFeatureFlag)('conditionalBundlingApi')
+                ? REPLACEMENT_RE_CONDITIONAL
+                : REPLACEMENT_RE, (m, d, i) => {
+                if (m === '\n') {
+                    columnStartIndex = i + offset + 1;
+                    lineCount++;
+                    return '\n';
+                }
+                // If we matched an import, replace with the source code for the dependency.
+                if (d != null) {
+                    let deps = depMap.get(d);
+                    if (!deps) {
+                        return m;
+                    }
+                    let replacement = '';
+                    // A single `${id}:${specifier}:esm` might have been resolved to multiple assets due to
+                    // reexports.
+                    for (let dep of deps) {
+                        let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+                        let skipped = this.bundleGraph.isDependencySkipped(dep);
+                        if (resolved && !skipped) {
+                            // Hoist variable declarations for the referenced parcelRequire dependencies
+                            // 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 = '';
+                            let lines = 0;
+                            let map;
+                            if (!(0, feature_flags_1.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 (this.useBothScopeHoistingImprovements) {
+                                    if (!resolved.meta.isConstantModule &&
+                                        !this.wrappedAssets.has(resolved)) {
+                                        let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                                        if (utils_1.debugTools['asset-file-names-in-output']) {
+                                            let resolvedPath = this.getAssetFilePath(resolved);
+                                            res = (0, outdent_1.outdent) `
+                          /* Scope hoisted asset: ${resolvedPath} */
+                          ${depCode}
+                          /* End: ${resolvedPath} */
+                          ${res}
+                        `;
+                                            lines += 3 + depLines;
+                                        }
+                                        else {
+                                            res = depCode + '\n' + res;
+                                            lines += 1 + depLines;
+                                        }
+                                        map = depMap;
+                                    }
+                                }
+                                else {
+                                    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, feature_flags_1.getFeatureFlag)('applyScopeHoistingImprovementV2')) {
+                                let [requiresCode, requiresLines] = this.getHoistedParcelRequires(asset, dep, resolved);
+                                if (requiresCode) {
+                                    res = requiresCode + '\n' + res;
+                                    lines += requiresLines + 1;
+                                }
+                            }
+                            // Push this asset's source mappings down by the number of lines in the dependency
+                            // plus the number of hoisted parcelRequires. Then insert the source map for the dependency.
+                            if (sourceMap) {
+                                if (lines > 0) {
+                                    sourceMap.offsetLines(lineCount + 1, lines);
+                                }
+                                if (map) {
+                                    sourceMap.addSourceMap(map, lineCount);
+                                }
+                            }
+                            replacement += res;
+                            lineCount += lines;
+                        }
+                    }
+                    return replacement;
+                }
+                // If it wasn't a dependency, then it was an inline replacement (e.g. $id$import$foo -> $id$export$foo).
+                let replacement = replacements.get(m) ?? m;
+                if (sourceMap) {
+                    // Offset the source map columns for this line if the replacement was a different length.
+                    // This assumes that the match and replacement both do not contain any newlines.
+                    let lengthDifference = replacement.length - m.length;
+                    if (lengthDifference !== 0) {
+                        sourceMap.offsetColumns(lineCount + 1, i + offset - columnStartIndex + m.length, lengthDifference);
+                        offset += lengthDifference;
+                    }
+                }
+                return replacement;
+            });
+        }
+        // If the asset is wrapped, we need to insert the dependency code outside the parcelRequire.register
+        // wrapper. Dependencies must be inserted AFTER the asset is registered so that circular dependencies work.
+        if (shouldWrap) {
+            // Offset by one line for the parcelRequire.register wrapper.
+            sourceMap?.offsetLines(1, 1);
+            lineCount++;
+            code = `parcelRegister(${JSON.stringify(this.bundleGraph.getAssetPublicId(asset))}, function(module, exports) {
+${code}
+});
+`;
+            lineCount += 2;
+            if (utils_1.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) {
+                    sourceMap.addSourceMap(map, lineCount);
+                }
+                lineCount += lines + 1;
+            }
+            this.needsPrelude = true;
+        }
+        if (!shouldWrap &&
+            this.shouldBundleQueue(this.bundle) &&
+            this.bundle.getEntryAssets().some((entry) => entry.id === asset.id)) {
+            code = this.runWhenReady(this.bundle, code);
+        }
+        return [code, sourceMap, lineCount];
+    }
+    buildReplacements(asset, deps) {
+        let assetId = asset.meta.id;
+        (0, assert_1.default)(typeof assetId === 'string');
+        // Build two maps: one of import specifiers, and one of imported symbols to replace.
+        // These will be used to build a regex below.
+        let depMap = new utils_1.DefaultMap(() => []);
+        let replacements = new Map();
+        for (let dep of deps) {
+            let specifierType = dep.specifierType === 'esm' ? `:${dep.specifierType}` : '';
+            depMap
+                .get(`${assetId}:${(0, utils_2.getSpecifier)(dep)}${!dep.meta.placeholder ? specifierType : ''}`)
+                .push(dep);
+            let asyncResolution = this.bundleGraph.resolveAsyncDependency(dep, this.bundle);
+            let resolved = asyncResolution?.type === 'asset'
+                ? // Prefer the underlying asset over a runtime to load it. It will
+                    // be wrapped in Promise.resolve() later.
+                    asyncResolution.value
+                : this.bundleGraph.getResolvedAsset(dep, this.bundle);
+            if (!resolved &&
+                !dep.isOptional &&
+                !this.bundleGraph.isDependencySkipped(dep)) {
+                this.addExternal(dep, replacements);
+            }
+            if (!resolved) {
+                continue;
+            }
+            // Handle imports from other bundles in libraries.
+            if (this.bundle.env.isLibrary && !this.bundle.hasAsset(resolved)) {
+                let referencedBundle = this.bundleGraph.getReferencedBundle(dep, this.bundle);
+                if (referencedBundle &&
+                    referencedBundle.getMainEntry() === resolved &&
+                    referencedBundle.type === 'js' &&
+                    !this.isAssetReferencedInBundle(referencedBundle, resolved)) {
+                    this.addExternal(dep, replacements, referencedBundle);
+                    this.externalAssets.add(resolved);
+                    continue;
+                }
+            }
+            for (let [imported, { local }] of dep.symbols) {
+                if (local === '*') {
+                    continue;
+                }
+                let symbol = this.getSymbolResolution(asset, resolved, imported, dep);
+                replacements.set(local, 
+                // If this was an internalized async asset, wrap in a Promise.resolve.
+                asyncResolution?.type === 'asset'
+                    ? `Promise.resolve(${symbol})`
+                    : symbol);
+            }
+            // Async dependencies need a namespace object even if all used symbols were statically analyzed.
+            // This is recorded in the promiseSymbol meta property set by the transformer rather than in
+            // symbols so that we don't mark all symbols as used.
+            if ((dep.priority === 'lazy' || dep.priority === 'conditional') &&
+                dep.meta.promiseSymbol) {
+                let promiseSymbol = dep.meta.promiseSymbol;
+                (0, assert_1.default)(typeof promiseSymbol === 'string');
+                let symbol = this.getSymbolResolution(asset, resolved, '*', dep);
+                replacements.set(promiseSymbol, asyncResolution?.type === 'asset'
+                    ? `Promise.resolve(${symbol})`
+                    : symbol);
+            }
+        }
+        // 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) ||
+            (this.bundle.env.outputFormat === 'commonjs' &&
+                asset === this.bundle.getMainEntry())) {
+            let exportsName = asset.symbols.get('*')?.local || `$${assetId}$exports`;
+            replacements.set(exportsName, 'module.exports');
+        }
+        return [depMap, replacements];
+    }
+    addExternal(dep, replacements, referencedBundle) {
+        if (this.bundle.env.outputFormat === 'global') {
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: 'External modules are not supported when building for browser',
+                    codeFrames: [
+                        {
+                            filePath: (0, nullthrows_1.default)(dep.sourcePath),
+                            codeHighlights: dep.loc
+                                ? [(0, diagnostic_1.convertSourceLocationToHighlight)(dep.loc)]
+                                : [],
+                        },
+                    ],
+                },
+            });
+        }
+        let specifier = dep.specifier;
+        if (referencedBundle) {
+            specifier = (0, utils_1.relativeBundlePath)(this.bundle, referencedBundle);
+        }
+        // Map of DependencySpecifier -> Map<ExportedSymbol, Identifier>>
+        let external = this.externals.get(specifier);
+        if (!external) {
+            external = new Map();
+            this.externals.set(specifier, external);
+        }
+        for (let [imported, { 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);
+                continue;
+            }
+            // For CJS output, always use a property lookup so that exports remain live.
+            // For ESM output, use named imports which are always live.
+            if (this.bundle.env.outputFormat === 'commonjs') {
+                renamed = external.get('*');
+                if (!renamed) {
+                    if (referencedBundle) {
+                        let entry = (0, nullthrows_1.default)(referencedBundle.getMainEntry());
+                        renamed =
+                            entry.symbols.get('*')?.local ??
+                                `$${String(entry.meta.id)}$exports`;
+                    }
+                    else {
+                        renamed = this.getTopLevelName(`$${this.bundle.publicId}$${specifier}`);
+                    }
+                    external.set('*', renamed);
+                }
+                if (local !== '*' && replacements) {
+                    let replacement;
+                    if (imported === '*') {
+                        replacement = renamed;
+                    }
+                    else if (imported === 'default') {
+                        let needsDefaultInterop = true;
+                        if (referencedBundle) {
+                            let entry = (0, nullthrows_1.default)(referencedBundle.getMainEntry());
+                            needsDefaultInterop = this.needsDefaultInterop(entry);
+                        }
+                        if (needsDefaultInterop) {
+                            replacement = `($parcel$interopDefault(${renamed}))`;
+                            this.usedHelpers.add('$parcel$interopDefault');
+                        }
+                        else {
+                            replacement = `${renamed}.default`;
+                        }
+                    }
+                    else {
+                        replacement = this.getPropertyAccess(renamed, imported);
+                    }
+                    replacements.set(local, replacement);
+                }
+            }
+            else {
+                let property;
+                if (referencedBundle) {
+                    let entry = (0, nullthrows_1.default)(referencedBundle.getMainEntry());
+                    if (entry.symbols.hasExportSymbol('*')) {
+                        // If importing * and the referenced module has a * export (e.g. CJS), use default instead.
+                        // This mirrors the logic in buildExportedSymbols.
+                        property = imported;
+                        imported =
+                            referencedBundle?.env.outputFormat === 'esmodule'
+                                ? 'default'
+                                : '*';
+                    }
+                    else {
+                        if (imported === '*') {
+                            let exportedSymbols = this.bundleGraph.getExportedSymbols(entry);
+                            if (local === '*') {
+                                // Re-export all symbols.
+                                for (let exported of exportedSymbols) {
+                                    if (exported.symbol) {
+                                        external.set(exported.exportSymbol, exported.symbol);
+                                    }
+                                }
+                                continue;
+                            }
+                        }
+                        renamed =
+                            this.bundleGraph.getSymbolResolution(entry, imported, this.bundle)
+                                .symbol || undefined;
+                    }
+                }
+                // Rename the specifier so that multiple local imports of the same imported specifier
+                // are deduplicated. We have to prefix the imported name with the bundle id so that
+                // local variables do not shadow it.
+                if (!renamed) {
+                    if (this.exportedSymbols.has(local)) {
+                        renamed = local;
+                    }
+                    else if (imported === 'default' || imported === '*') {
+                        renamed = this.getTopLevelName(`$${this.bundle.publicId}$${specifier}`);
+                    }
+                    else {
+                        renamed = this.getTopLevelName(`$${this.bundle.publicId}$${imported}`);
+                    }
+                }
+                external.set(imported, renamed);
+                if (local !== '*' && replacements) {
+                    let replacement = renamed;
+                    if (property === '*') {
+                        replacement = renamed;
+                    }
+                    else if (property === 'default') {
+                        replacement = `($parcel$interopDefault(${renamed}))`;
+                        this.usedHelpers.add('$parcel$interopDefault');
+                    }
+                    else if (property) {
+                        replacement = this.getPropertyAccess(renamed, property);
+                    }
+                    replacements.set(local, replacement);
+                }
+            }
+        }
+    }
+    isWrapped(resolved, parentAsset) {
+        if (resolved.meta.isConstantModule) {
+            if (!this.bundle.hasAsset(resolved)) {
+                throw new assert_1.AssertionError({
+                    message: `Constant module ${path_1.default.relative(this.options.projectRoot, resolved.filePath)} referenced from ${path_1.default.relative(this.options.projectRoot, parentAsset.filePath)} not found in bundle ${this.bundle.name}`,
+                });
+            }
+            return false;
+        }
+        return ((!this.bundle.hasAsset(resolved) && !this.externalAssets.has(resolved)) ||
+            (this.wrappedAssets.has(resolved) && resolved !== parentAsset));
+    }
+    getSymbolResolution(parentAsset, resolved, imported, dep, replacements) {
+        let { asset: resolvedAsset, exportSymbol, symbol, } = this.bundleGraph.getSymbolResolution(resolved, imported, this.bundle);
+        if (resolvedAsset.type !== 'js' ||
+            (dep && this.bundleGraph.isDependencySkipped(dep))) {
+            // Graceful fallback for non-js imports or when trying to resolve a symbol
+            // that is actually unused but we still need a placeholder value.
+            return '{}';
+        }
+        let isWrapped = this.isWrapped(resolvedAsset, parentAsset);
+        let staticExports = resolvedAsset.meta.staticExports !== false;
+        let publicId = this.bundleGraph.getAssetPublicId(resolvedAsset);
+        // External CommonJS dependencies need to be accessed as an object property rather than imported
+        // directly to maintain live binding.
+        let isExternalCommonJS = !isWrapped &&
+            this.bundle.env.isLibrary &&
+            this.bundle.env.outputFormat === 'commonjs' &&
+            !this.bundle.hasAsset(resolvedAsset);
+        // If the resolved asset is wrapped, but imported at the top-level by this asset,
+        // then we hoist parcelRequire calls to the top of this asset so side effects run immediately.
+        if (isWrapped &&
+            dep &&
+            !dep?.meta.shouldWrap &&
+            symbol !== false &&
+            // 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);
+            if (!hoisted) {
+                hoisted = new Map();
+                this.hoistedRequires.set(dep, hoisted);
+            }
+            hoisted.set(resolvedAsset, `var $${publicId} = parcelRequire(${JSON.stringify(publicId)});`);
+        }
+        if (isWrapped) {
+            this.needsPrelude = true;
+        }
+        // If this is an ESM default import of a CJS module with a `default` symbol,
+        // and no __esModule flag, we need to resolve to the namespace instead.
+        let isDefaultInterop = exportSymbol === 'default' &&
+            staticExports &&
+            !isWrapped &&
+            (dep?.meta.kind === 'Import' || dep?.meta.kind === 'Export') &&
+            resolvedAsset.symbols.hasExportSymbol('*') &&
+            resolvedAsset.symbols.hasExportSymbol('default') &&
+            !resolvedAsset.symbols.hasExportSymbol('__esModule');
+        // Find the namespace object for the resolved module. If wrapped and this
+        // is an inline require (not top-level), use a parcelRequire call, otherwise
+        // the hoisted variable declared above. Otherwise, if not wrapped, use the
+        // namespace export symbol.
+        let assetId = resolvedAsset.meta.id;
+        (0, assert_1.default)(typeof assetId === 'string');
+        let obj;
+        if (isWrapped && (!dep || dep?.meta.shouldWrap)) {
+            // Wrap in extra parenthesis to not change semantics, e.g.`new (parcelRequire("..."))()`.
+            obj = `(parcelRequire(${JSON.stringify(publicId)}))`;
+        }
+        else if (isWrapped && dep) {
+            obj = `$${publicId}`;
+        }
+        else {
+            obj = resolvedAsset.symbols.get('*')?.local || `$${assetId}$exports`;
+            obj = replacements?.get(obj) || obj;
+        }
+        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)) {
+                // Directly use module.exports for wrapped assets importing themselves.
+                return 'module.exports';
+            }
+            else {
+                return obj;
+            }
+        }
+        else if ((!staticExports || isWrapped || !symbol || isExternalCommonJS) &&
+            resolvedAsset !== parentAsset) {
+            // If the resolved asset is wrapped or has non-static exports,
+            // we need to use a member access off the namespace object rather
+            // than a direct reference. If importing default from a CJS module,
+            // use a helper to check the __esModule flag at runtime.
+            let kind = dep?.meta.kind;
+            if ((!dep || kind === 'Import' || kind === 'Export') &&
+                exportSymbol === 'default' &&
+                resolvedAsset.symbols.hasExportSymbol('*') &&
+                this.needsDefaultInterop(resolvedAsset)) {
+                this.usedHelpers.add('$parcel$interopDefault');
+                return `(/*@__PURE__*/$parcel$interopDefault(${obj}))`;
+            }
+            else {
+                return this.getPropertyAccess(obj, exportSymbol);
+            }
+        }
+        else if (!symbol) {
+            (0, assert_1.default)(false, 'Asset was skipped or not found.');
+        }
+        else {
+            return replacements?.get(symbol) || symbol;
+        }
+    }
+    getHoistedParcelRequires(parentAsset, dep, resolved) {
+        if (resolved.type !== 'js') {
+            return ['', 0];
+        }
+        let hoisted = this.hoistedRequires.get(dep);
+        let res = '';
+        let lineCount = 0;
+        let isWrapped = this.isWrapped(resolved, parentAsset);
+        // If the resolved asset is wrapped and is imported in the top-level by this asset,
+        // 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) &&
+            !this.bundleGraph.isDependencySkipped(dep) &&
+            !this.shouldSkipAsset(resolved)) {
+            this.needsPrelude = true;
+            res += `parcelRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(resolved))});`;
+        }
+        if (hoisted) {
+            this.needsPrelude = true;
+            if ((0, feature_flags_1.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];
+    }
+    buildAssetPrelude(asset, deps, replacements) {
+        let prepend = '';
+        let prependLineCount = 0;
+        let append = '';
+        let shouldWrap = this.wrappedAssets.has(asset);
+        let usedSymbols = (0, nullthrows_1.default)(this.bundleGraph.getUsedSymbols(asset));
+        let assetId = asset.meta.id;
+        (0, assert_1.default)(typeof assetId === 'string');
+        // If the asset has a namespace export symbol, it is CommonJS.
+        // 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 ((0, feature_flags_1.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_1.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_1.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
+        // this asset.
+        if (asset.meta.staticExports === false ||
+            shouldWrap ||
+            usedNamespace ||
+            defaultInterop) {
+            // Insert a declaration for the exports namespace object. If the asset is wrapped
+            // we don't need to do this, because we'll use the `module.exports` object provided
+            // by the wrapper instead. This is also true of CommonJS entry assets, which will use
+            // the `module.exports` object provided by CJS.
+            if (!shouldWrap &&
+                (this.bundle.env.outputFormat !== 'commonjs' ||
+                    asset !== this.bundle.getMainEntry())) {
+                prepend += `var $${assetId}$exports = {};\n`;
+                prependLineCount++;
+            }
+            // 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;
+                this.usedHelpers.add('$parcel$defineInteropFlag');
+            }
+            // Find wildcard re-export dependencies, and make sure their exports are also included in
+            // ours. Importantly, add them before the asset's own exports so that wildcard exports get
+            // correctly overwritten by own exports of the same name.
+            for (let dep of deps) {
+                let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+                if (dep.isOptional || this.bundleGraph.isDependencySkipped(dep)) {
+                    continue;
+                }
+                let isWrapped = resolved && resolved.meta.shouldWrap;
+                for (let [imported, { local }] of dep.symbols) {
+                    if (imported === '*' && local === '*') {
+                        if (!resolved) {
+                            // Re-exporting an external module. This should have already been handled in buildReplacements.
+                            let external = (0, nullthrows_1.default)((0, nullthrows_1.default)(this.externals.get(dep.specifier)).get('*'));
+                            append += `$parcel$exportWildcard($${assetId}$exports, ${external});\n`;
+                            this.usedHelpers.add('$parcel$exportWildcard');
+                            continue;
+                        }
+                        // If the resolved asset has an exports object, use the $parcel$exportWildcard helper
+                        // to re-export all symbols. Otherwise, if there's no namespace object available, add
+                        // $parcel$export calls for each used symbol of the dependency.
+                        if (isWrapped ||
+                            resolved.meta.staticExports === false ||
+                            (0, nullthrows_1.default)(this.bundleGraph.getUsedSymbols(resolved)).has('*') ||
+                            // an empty asset
+                            (!resolved.meta.hasCJSExports &&
+                                resolved.symbols.hasExportSymbol('*'))) {
+                            let obj = this.getSymbolResolution(asset, resolved, '*', dep, replacements);
+                            append += `$parcel$exportWildcard($${assetId}$exports, ${obj});\n`;
+                            this.usedHelpers.add('$parcel$exportWildcard');
+                        }
+                        else {
+                            for (let symbol of (0, nullthrows_1.default)(this.bundleGraph.getUsedSymbols(dep))) {
+                                if (symbol === 'default' || // `export * as ...` does not include the default export
+                                    symbol === '__esModule') {
+                                    continue;
+                                }
+                                let resolvedSymbol = this.getSymbolResolution(asset, resolved, symbol, undefined, replacements);
+                                let get = this.buildFunctionExpression([], resolvedSymbol);
+                                let set = asset.meta.hasCJSExports
+                                    ? ', ' +
+                                        this.buildFunctionExpression(['v'], `${resolvedSymbol} = v`)
+                                    : '';
+                                prepend += `$parcel$export($${assetId}$exports, ${JSON.stringify(symbol)}, ${get}${set});\n`;
+                                this.usedHelpers.add('$parcel$export');
+                                prependLineCount++;
+                            }
+                        }
+                    }
+                }
+            }
+            // Find the used exports of this module. This is based on the used symbols of
+            // incoming dependencies rather than the asset's own used exports so that we include
+            // re-exported symbols rather than only symbols declared in this asset.
+            let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
+            let usedExports = [...asset.symbols.exportSymbols()].filter((symbol) => {
+                if (symbol === '*') {
+                    return false;
+                }
+                // If we need default interop, then all symbols are needed because the `default`
+                // symbol really maps to the whole namespace.
+                if (defaultInterop) {
+                    return true;
+                }
+                let unused = incomingDeps.every((d) => {
+                    let symbols = this.bundleGraph.getUsedSymbols(d);
+                    // No used symbols available for the asset, make sure we keep all of them
+                    if (!symbols)
+                        return false;
+                    return !symbols.has(symbol) && !symbols.has('*');
+                });
+                return !unused;
+            });
+            if (usedExports.length > 0) {
+                // Insert $parcel$export calls for each of the used exports. This creates a getter/setter
+                // 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.
+                for (let exp of usedExports) {
+                    let resolved = this.getSymbolResolution(asset, asset, exp, undefined, replacements);
+                    const meta = asset.symbols.get(exp)?.meta;
+                    if ((0, feature_flags_1.getFeatureFlag)('exportsRebindingOptimisation') &&
+                        (meta?.isStaticBindingSafe ||
+                            this.manualStaticBindingExports?.some((regex) => regex.test(asset.filePath)))) {
+                        append += `$${assetId}$exports[${JSON.stringify(exp)}] = ${resolved};\n`;
+                    }
+                    else {
+                        let get = this.buildFunctionExpression([], resolved);
+                        let isEsmExport = !!asset.symbols.get(exp)?.meta?.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];
+    }
+    buildBundlePrelude() {
+        let enableSourceMaps = this.bundle.env.sourceMap;
+        let res = '';
+        let lines = 0;
+        // Add hashbang if the entry asset recorded an interpreter.
+        let mainEntry = this.bundle.getMainEntry();
+        if (mainEntry &&
+            !this.isAsyncBundle &&
+            !this.bundle.target.env.isBrowser()) {
+            let interpreter = mainEntry.meta.interpreter;
+            (0, assert_1.default)(interpreter == null || typeof interpreter === 'string');
+            if (interpreter != null) {
+                res += `#!${interpreter}\n`;
+                lines++;
+            }
+        }
+        // The output format may have specific things to add at the start of the bundle (e.g. imports).
+        let [outputFormatPrelude, outputFormatLines] = this.outputFormat.buildBundlePrelude();
+        res += outputFormatPrelude;
+        lines += outputFormatLines;
+        // Add used helpers.
+        if (this.needsPrelude) {
+            this.usedHelpers.add('$parcel$global');
+        }
+        for (let helper of this.usedHelpers) {
+            let currentHelper = helpers_1.helpers[helper];
+            if (typeof currentHelper === 'function') {
+                currentHelper = helpers_1.helpers[helper](this.bundle.env);
+            }
+            res += currentHelper;
+            if (enableSourceMaps) {
+                lines += (0, utils_1.countLines)(currentHelper) - 1;
+            }
+        }
+        if (this.needsPrelude) {
+            // 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' ||
+                this.bundle.bundleBehavior === 'inlineIsolated' ||
+                // Conditional deps may be loaded before entrypoints on the server
+                this.hasConditionalDependency();
+            if (mightBeFirstJS) {
+                let preludeCode = ((0, feature_flags_1.getFeatureFlag)('useNewPrelude') ? helpers_1.preludeNew : helpers_1.preludeOld)(this.parcelRequireName);
+                res += preludeCode;
+                if (enableSourceMaps) {
+                    lines += (0, utils_1.countLines)(preludeCode) - 1;
+                }
+                if (this.shouldBundleQueue(this.bundle)) {
+                    let bundleQueuePreludeCode = (0, helpers_1.bundleQueuePrelude)(this.bundle.env);
+                    res += bundleQueuePreludeCode;
+                    if (enableSourceMaps) {
+                        lines += (0, utils_1.countLines)(bundleQueuePreludeCode) - 1;
+                    }
+                }
+            }
+            else {
+                // Otherwise, get the current parcelRequire global.
+                const escaped = JSON.stringify(this.parcelRequireName);
+                res += `var parcelRequire = $parcel$global[${escaped}];\n`;
+                lines++;
+                res += `var parcelRegister = parcelRequire.register;\n`;
+                lines++;
+            }
+        }
+        // Add importScripts for sibling bundles in workers.
+        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) {
+                if (this.bundle.env.outputFormat === 'esmodule') {
+                    // importScripts() is not allowed in native ES module workers.
+                    importScripts += `import "${(0, utils_1.relativeBundlePath)(this.bundle, b)}";\n`;
+                }
+                else {
+                    importScripts += `importScripts("${(0, utils_1.relativeBundlePath)(this.bundle, b)}");\n`;
+                }
+            }
+            res += importScripts;
+            lines += bundles.length;
+        }
+        return [res, lines];
+    }
+    needsDefaultInterop(asset) {
+        if (asset.symbols.hasExportSymbol('*') &&
+            !asset.symbols.hasExportSymbol('default')) {
+            return true;
+        }
+        return false;
+    }
+    shouldSkipAsset(asset) {
+        if (this.isScriptEntry(asset)) {
+            return true;
+        }
+        return (asset.sideEffects === false &&
+            (0, nullthrows_1.default)(this.bundleGraph.getUsedSymbols(asset)).size == 0 &&
+            !this.isAssetReferencedInBundle(this.bundle, asset));
+    }
+    isScriptEntry(asset) {
+        return (this.bundle.env.outputFormat === 'global' &&
+            this.bundle.env.sourceType === 'script' &&
+            asset === this.bundle.getMainEntry());
+    }
+    buildFunctionExpression(args, expr) {
+        return this.bundle.env.supports('arrow-functions', true)
+            ? `(${args.join(', ')}) => ${expr}`
+            : `function (${args.join(', ')}) { return ${expr}; }`;
+    }
+    hasConditionalDependency() {
+        if (!(0, feature_flags_1.getFeatureFlag)('conditionalBundlingApi')) {
+            return false;
+        }
+        return this.bundle
+            .getEntryAssets()
+            .some((entry) => this.bundleGraph
+            .getIncomingDependencies(entry)
+            .some((dep) => dep.priority === 'conditional'));
+    }
+}
+exports.ScopeHoistingPackager = ScopeHoistingPackager;