@atlaspack/packager-js 2.12.1-dev.3368 → 2.12.1-dev.3401

package/lib/DevPackager.js

@@ -43,11 +43,11 @@ var _utils2 = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const PRELUDE = _fs().default.readFileSync(_path().default.join(__dirname, 'dev-prelude.js'), 'utf8').trim().replace(/;$/, '');
 class DevPackager {
-  constructor(options, bundleGraph, bundle, atlaspackRequireName) {
+  constructor(options, bundleGraph, bundle, parcelRequireName) {
     this.options = options;
     this.bundleGraph = bundleGraph;
     this.bundle = bundle;
-    this.atlaspackRequireName = atlaspackRequireName;
+    this.parcelRequireName = parcelRequireName;
   }
   async package() {
     // Load assets
@@ -118,8 +118,8 @@ class DevPackager {
         wrapped += ']';
         if (this.bundle.env.isNode() && asset.meta.has_node_replacements === true) {
           const relPath = (0, _utils().normalizeSeparators)(_path().default.relative(this.bundle.target.distDir, _path().default.dirname(asset.filePath)));
-          wrapped = wrapped.replace('$atlaspack$dirnameReplace', relPath);
-          wrapped = wrapped.replace('$atlaspack$filenameReplace', relPath);
+          wrapped = wrapped.replace('$parcel$dirnameReplace', relPath);
+          wrapped = wrapped.replace('$parcel$filenameReplace', relPath);
         }
         if (this.bundle.env.sourceMap) {
           if (mapBuffer) {
@@ -145,18 +145,18 @@ class DevPackager {
       });
       mainEntry = null;
     }
-    let contents = prefix + '({' + assets + '},' + JSON.stringify(entries.map(asset => this.bundleGraph.getAssetPublicId(asset))) + ', ' + JSON.stringify(mainEntry ? this.bundleGraph.getAssetPublicId(mainEntry) : null) + ', ' + JSON.stringify(this.atlaspackRequireName) + ')' + '\n';
+    let contents = prefix + '({' + assets + '},' + JSON.stringify(entries.map(asset => this.bundleGraph.getAssetPublicId(asset))) + ', ' + JSON.stringify(mainEntry ? this.bundleGraph.getAssetPublicId(mainEntry) : null) + ', ' + JSON.stringify(this.parcelRequireName) + ')' + '\n';
 
     // The entry asset of a script bundle gets hoisted outside the bundle wrapper function
     // so that its variables become globals. We need to replace any require calls for
-    // runtimes with a atlaspackRequire call.
+    // runtimes with a parcelRequire call.
     if (this.bundle.env.sourceType === 'script' && script) {
       let entryMap;
       let mapBuffer = script.mapBuffer;
       if (mapBuffer) {
         entryMap = new (_sourceMap().default)(this.options.projectRoot, mapBuffer);
       }
-      contents += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, script.code, entryMap, this.atlaspackRequireName);
+      contents += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, script.code, entryMap, this.parcelRequireName);
       if (this.bundle.env.sourceMap && entryMap) {
         map.addSourceMap(entryMap, lineOffset);
       }

package/lib/ESMOutputFormat.js

@@ -76,7 +76,7 @@ class ESMOutputFormat {
       exportAs
     } of this.packager.exportedSymbols.values()) {
       if (this.packager.wrappedAssets.has(asset.id)) {
-        let obj = `atlaspackRequire("${this.packager.bundleGraph.getAssetPublicId(asset)}")`;
+        let obj = `parcelRequire("${this.packager.bundleGraph.getAssetPublicId(asset)}")`;
         res += `\nvar ${local} = ${this.packager.getPropertyAccess(obj, exportSymbol)};`;
         lines++;
       }
@@ -97,7 +97,7 @@ class ESMOutputFormat {
     }
     if (this.packager.needsPrelude && this.packager.shouldBundleQueue(this.packager.bundle)) {
       // Should be last thing the bundle executes on intial eval
-      res += `\n$atlaspack$global.rlb(${JSON.stringify(this.packager.bundle.publicId)})`;
+      res += `\n$parcel$global.rlb(${JSON.stringify(this.packager.bundle.publicId)})`;
       lines++;
     }
     return [res, lines];

package/lib/ScopeHoistingPackager.js

@@ -89,11 +89,11 @@ class ScopeHoistingPackager {
   needsPrelude = false;
   usedHelpers = new Set();
   externalAssets = new Set();
-  constructor(options, bundleGraph, bundle, atlaspackRequireName, useAsyncBundleRuntime) {
+  constructor(options, bundleGraph, bundle, parcelRequireName, useAsyncBundleRuntime) {
     this.options = options;
     this.bundleGraph = bundleGraph;
     this.bundle = bundle;
-    this.atlaspackRequireName = atlaspackRequireName;
+    this.parcelRequireName = parcelRequireName;
     this.useAsyncBundleRuntime = useAsyncBundleRuntime;
     let OutputFormat = OUTPUT_FORMATS[this.bundle.env.outputFormat];
     this.outputFormat = new OutputFormat(this);
@@ -166,20 +166,20 @@ class ScopeHoistingPackager {
     }
     let needsBundleQueue = this.shouldBundleQueue(this.bundle);
 
-    // If any of the entry assets are wrapped, call atlaspackRequire so they are executed.
+    // 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)) {
         var _entry$symbols$get;
-        let atlaspackRequire = `atlaspackRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(entry))});\n`;
+        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;
         if (entryExports && entry === mainEntry && this.exportedSymbols.has(entryExports)) {
           (0, _assert().default)(!needsBundleQueue, 'Entry exports are not yet compaitble with async bundles');
-          res += `\nvar ${entryExports} = ${atlaspackRequire}`;
+          res += `\nvar ${entryExports} = ${parcelRequire}`;
         } else {
           if (needsBundleQueue) {
-            atlaspackRequire = this.runWhenReady(this.bundle, atlaspackRequire);
+            parcelRequire = this.runWhenReady(this.bundle, parcelRequire);
           }
-          res += `\n${atlaspackRequire}`;
+          res += `\n${parcelRequire}`;
         }
         lineCount += 2;
       }
@@ -190,7 +190,7 @@ class ScopeHoistingPackager {
 
     // 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 atlaspackRequire call.
+    // all dependency references for runtimes with a parcelRequire call.
     if (this.bundle.env.outputFormat === 'global' && this.bundle.env.sourceType === 'script') {
       res += '\n';
       lineCount++;
@@ -203,7 +203,7 @@ class ScopeHoistingPackager {
       if (mapBuffer) {
         map = new (_sourceMap2().default)(this.options.projectRoot, mapBuffer);
       }
-      res += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, code, map, this.atlaspackRequireName);
+      res += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, code, map, this.parcelRequireName);
       if (sourceMap && map) {
         sourceMap.addSourceMap(map, lineCount);
       }
@@ -225,7 +225,7 @@ class ScopeHoistingPackager {
       return codeToRun;
     }
     let params = [JSON.stringify(this.bundle.publicId), (0, _helpers.fnExpr)(this.bundle.env, [], [codeToRun]), JSON.stringify(deps)];
-    return `$atlaspack$global.rwr(${params.join(', ')});`;
+    return `$parcel$global.rwr(${params.join(', ')});`;
   }
   async loadAssets() {
     let queue = new (_utils().PromiseQueue)({
@@ -384,13 +384,13 @@ class ScopeHoistingPackager {
     }
 
     // TODO: maybe a meta prop?
-    if (code.includes('$atlaspack$global')) {
-      this.usedHelpers.add('$atlaspack$global');
+    if (code.includes('$parcel$global')) {
+      this.usedHelpers.add('$parcel$global');
     }
     if (this.bundle.env.isNode() && asset.meta.has_node_replacements) {
       const relPath = (0, _utils().normalizeSeparators)(_path().default.relative(this.bundle.target.distDir, _path().default.dirname(asset.filePath)));
-      code = code.replace('$atlaspack$dirnameReplace', relPath);
-      code = code.replace('$atlaspack$filenameReplace', relPath);
+      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);
@@ -433,15 +433,15 @@ class ScopeHoistingPackager {
             let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
             let skipped = this.bundleGraph.isDependencySkipped(dep);
             if (resolved && !skipped) {
-              // Hoist variable declarations for the referenced atlaspackRequire dependencies
+              // 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, lines] = this.getHoistedAtlaspackRequires(asset, dep, resolved);
+              let [res, lines] = this.getHoistedParcelRequires(asset, dep, resolved);
               let map;
               if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved.id)) {
                 // If this asset is wrapped, we need to hoist the code for the dependency
-                // outside our atlaspackRequire.register wrapper. This is safe because all
+                // 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) {
@@ -455,7 +455,7 @@ class ScopeHoistingPackager {
               }
 
               // Push this asset's source mappings down by the number of lines in the dependency
-              // plus the number of hoisted atlaspackRequires. Then insert the source map for 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);
@@ -486,13 +486,13 @@ class ScopeHoistingPackager {
       });
     }
 
-    // If the asset is wrapped, we need to insert the dependency code outside the atlaspackRequire.register
+    // 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 atlaspackRequire.register wrapper.
+      // Offset by one line for the parcelRequire.register wrapper.
       sourceMap === null || sourceMap === void 0 || sourceMap.offsetLines(1, 1);
       lineCount++;
-      code = `atlaspackRegister(${JSON.stringify(this.bundleGraph.getAssetPublicId(asset))}, function(module, exports) {
+      code = `parcelRegister(${JSON.stringify(this.bundleGraph.getAssetPublicId(asset))}, function(module, exports) {
 ${code}
 });
 `;
@@ -634,8 +634,8 @@ ${code}
               needsDefaultInterop = this.needsDefaultInterop(entry);
             }
             if (needsDefaultInterop) {
-              replacement = `($atlaspack$interopDefault(${renamed}))`;
-              this.usedHelpers.add('$atlaspack$interopDefault');
+              replacement = `($parcel$interopDefault(${renamed}))`;
+              this.usedHelpers.add('$parcel$interopDefault');
             } else {
               replacement = `${renamed}.default`;
             }
@@ -688,8 +688,8 @@ ${code}
           if (property === '*') {
             replacement = renamed;
           } else if (property === 'default') {
-            replacement = `($atlaspack$interopDefault(${renamed}))`;
-            this.usedHelpers.add('$atlaspack$interopDefault');
+            replacement = `($parcel$interopDefault(${renamed}))`;
+            this.usedHelpers.add('$parcel$interopDefault');
           } else if (property) {
             replacement = this.getPropertyAccess(renamed, property);
           }
@@ -729,17 +729,17 @@ ${code}
     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 atlaspackRequire calls to the top of this asset so side effects run immediately.
+    // then we hoist parcelRequire calls to the top of this asset so side effects run immediately.
     if (isWrapped && dep && !(dep !== null && dep !== void 0 && dep.meta.shouldWrap) && symbol !== false && (
     // Only do this if the asset is part of a different bundle (so it was definitely
-    // atlaspackRequire.register'ed there), or if it is indeed registered in this bundle.
+    // 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);
       if (!hoisted) {
         hoisted = new Map();
         this.hoistedRequires.set(dep.id, hoisted);
       }
-      hoisted.set(resolvedAsset.id, `var $${publicId} = atlaspackRequire(${JSON.stringify(publicId)});`);
+      hoisted.set(resolvedAsset.id, `var $${publicId} = parcelRequire(${JSON.stringify(publicId)});`);
     }
     if (isWrapped) {
       this.needsPrelude = true;
@@ -750,15 +750,15 @@ ${code}
     let isDefaultInterop = exportSymbol === 'default' && staticExports && !isWrapped && ((dep === null || dep === void 0 ? void 0 : dep.meta.kind) === 'Import' || (dep === null || dep === void 0 ? void 0 : 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 atlaspackRequire call, otherwise
+    // 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().default)(typeof assetId === 'string');
     let obj;
     if (isWrapped && (!dep || dep !== null && dep !== void 0 && dep.meta.shouldWrap)) {
-      // Wrap in extra parenthesis to not change semantics, e.g.`new (atlaspackRequire("..."))()`.
-      obj = `(atlaspackRequire(${JSON.stringify(publicId)}))`;
+      // Wrap in extra parenthesis to not change semantics, e.g.`new (parcelRequire("..."))()`.
+      obj = `(parcelRequire(${JSON.stringify(publicId)}))`;
     } else if (isWrapped && dep) {
       obj = `$${publicId}`;
     } else {
@@ -781,8 +781,8 @@ ${code}
       // use a helper to check the __esModule flag at runtime.
       let kind = dep === null || dep === void 0 ? void 0 : dep.meta.kind;
       if ((!dep || kind === 'Import' || kind === 'Export') && exportSymbol === 'default' && resolvedAsset.symbols.hasExportSymbol('*') && this.needsDefaultInterop(resolvedAsset)) {
-        this.usedHelpers.add('$atlaspack$interopDefault');
-        return `(/*@__PURE__*/$atlaspack$interopDefault(${obj}))`;
+        this.usedHelpers.add('$parcel$interopDefault');
+        return `(/*@__PURE__*/$parcel$interopDefault(${obj}))`;
       } else {
         return this.getPropertyAccess(obj, exportSymbol);
       }
@@ -792,7 +792,7 @@ ${code}
       return (replacements === null || replacements === void 0 ? void 0 : replacements.get(symbol)) || symbol;
     }
   }
-  getHoistedAtlaspackRequires(parentAsset, dep, resolved) {
+  getHoistedParcelRequires(parentAsset, dep, resolved) {
     if (resolved.type !== 'js') {
       return ['', 0];
     }
@@ -803,11 +803,11 @@ ${code}
 
     // 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 atlaspackRequire here
+    // 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)) {
       this.needsPrelude = true;
-      res += `atlaspackRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(resolved))});`;
+      res += `parcelRequire(${JSON.stringify(this.bundleGraph.getAssetPublicId(resolved))});`;
     }
     if (hoisted) {
       this.needsPrelude = true;
@@ -861,9 +861,9 @@ ${code}
       // and the namespace symbol is used.
       // TODO: only if required by CJS?
       if (asset.symbols.hasExportSymbol('default') && usedSymbols.has('*')) {
-        prepend += `\n$atlaspack$defineInteropFlag($${assetId}$exports);\n`;
+        prepend += `\n$parcel$defineInteropFlag($${assetId}$exports);\n`;
         prependLineCount += 2;
-        this.usedHelpers.add('$atlaspack$defineInteropFlag');
+        this.usedHelpers.add('$parcel$defineInteropFlag');
       }
 
       // Find wildcard re-export dependencies, and make sure their exports are also included in
@@ -882,20 +882,20 @@ ${code}
             if (!resolved) {
               // Re-exporting an external module. This should have already been handled in buildReplacements.
               let external = (0, _nullthrows().default)((0, _nullthrows().default)(this.externals.get(dep.specifier)).get('*'));
-              append += `$atlaspack$exportWildcard($${assetId}$exports, ${external});\n`;
-              this.usedHelpers.add('$atlaspack$exportWildcard');
+              append += `$parcel$exportWildcard($${assetId}$exports, ${external});\n`;
+              this.usedHelpers.add('$parcel$exportWildcard');
               continue;
             }
 
-            // If the resolved asset has an exports object, use the $atlaspack$exportWildcard helper
+            // 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
-            // $atlaspack$export calls for each used symbol of the dependency.
+            // $parcel$export calls for each used symbol of the dependency.
             if (isWrapped || resolved.meta.staticExports === false || (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(resolved)).has('*') ||
             // an empty asset
             !resolved.meta.hasCJSExports && resolved.symbols.hasExportSymbol('*')) {
               let obj = this.getSymbolResolution(asset, resolved, '*', dep, replacements);
-              append += `$atlaspack$exportWildcard($${assetId}$exports, ${obj});\n`;
-              this.usedHelpers.add('$atlaspack$exportWildcard');
+              append += `$parcel$exportWildcard($${assetId}$exports, ${obj});\n`;
+              this.usedHelpers.add('$parcel$exportWildcard');
             } else {
               for (let symbol of (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(dep))) {
                 if (symbol === 'default' ||
@@ -906,8 +906,8 @@ ${code}
                 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 += `$atlaspack$export($${assetId}$exports, ${JSON.stringify(symbol)}, ${get}${set});\n`;
-                this.usedHelpers.add('$atlaspack$export');
+                prepend += `$parcel$export($${assetId}$exports, ${JSON.stringify(symbol)}, ${get}${set});\n`;
+                this.usedHelpers.add('$parcel$export');
                 prependLineCount++;
               }
             }
@@ -936,7 +936,7 @@ ${code}
         return !unused;
       });
       if (usedExports.length > 0) {
-        // Insert $atlaspack$export calls for each of the used exports. This creates a getter/setter
+        // 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.
@@ -946,9 +946,9 @@ ${code}
           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 `$atlaspack$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});`;
+          return `$parcel$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});`;
         }).join('\n')}\n`;
-        this.usedHelpers.add('$atlaspack$export');
+        this.usedHelpers.add('$parcel$export');
         prependLineCount += 1 + usedExports.length;
       }
     }
@@ -977,7 +977,7 @@ ${code}
 
     // Add used helpers.
     if (this.needsPrelude) {
-      this.usedHelpers.add('$atlaspack$global');
+      this.usedHelpers.add('$parcel$global');
     }
     for (let helper of this.usedHelpers) {
       let currentHelper = _helpers.helpers[helper];
@@ -995,7 +995,7 @@ ${code}
       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';
       if (mightBeFirstJS) {
-        let preludeCode = (0, _helpers.prelude)(this.atlaspackRequireName);
+        let preludeCode = (0, _helpers.prelude)(this.parcelRequireName);
         res += preludeCode;
         if (enableSourceMaps) {
           lines += (0, _utils().countLines)(preludeCode) - 1;
@@ -1008,11 +1008,11 @@ ${code}
           }
         }
       } else {
-        // Otherwise, get the current atlaspackRequire global.
-        const escaped = JSON.stringify(this.atlaspackRequireName);
-        res += `var atlaspackRequire = $atlaspack$global[${escaped}];\n`;
+        // Otherwise, get the current parcelRequire global.
+        const escaped = JSON.stringify(this.parcelRequireName);
+        res += `var parcelRequire = $parcel$global[${escaped}];\n`;
         lines++;
-        res += `var atlaspackRegister = atlaspackRequire.register;\n`;
+        res += `var parcelRegister = parcelRequire.register;\n`;
         lines++;
       }
     }

package/lib/dev-prelude.js

@@ -6,7 +6,7 @@
 // anything defined in a previous bundle is accessed via the
 // orig method which is the require for previous bundles
 
-(function (modules, entry, mainEntry, atlaspackRequireName, globalName) {
+(function (modules, entry, mainEntry, parcelRequireName, globalName) {
   /* eslint-disable no-undef */
   var globalObject =
     typeof globalThis !== 'undefined'
@@ -22,8 +22,8 @@
 
   // Save the require from previous bundle to this closure if any
   var previousRequire =
-    typeof globalObject[atlaspackRequireName] === 'function' &&
-    globalObject[atlaspackRequireName];
+    typeof globalObject[parcelRequireName] === 'function' &&
+    globalObject[parcelRequireName];
 
   var cache = previousRequire.cache || {};
   // Do not use `require` to prevent Webpack from trying to bundle this call
@@ -39,8 +39,8 @@
         // cache jump to the current global require ie. the last bundle
         // that was added to the page.
         var currentRequire =
-          typeof globalObject[atlaspackRequireName] === 'function' &&
-          globalObject[atlaspackRequireName];
+          typeof globalObject[parcelRequireName] === 'function' &&
+          globalObject[parcelRequireName];
         if (!jumped && currentRequire) {
           return currentRequire(name, true);
         }
@@ -96,7 +96,7 @@
     this.exports = {};
   }
 
-  newRequire.isAtlaspackRequire = true;
+  newRequire.isParcelRequire = true;
   newRequire.Module = Module;
   newRequire.modules = modules;
   newRequire.cache = cache;
@@ -112,11 +112,11 @@
 
   Object.defineProperty(newRequire, 'root', {
     get: function () {
-      return globalObject[atlaspackRequireName];
+      return globalObject[parcelRequireName];
     },
   });
 
-  globalObject[atlaspackRequireName] = newRequire;
+  globalObject[parcelRequireName] = newRequire;
 
   for (var i = 0; i < entry.length; i++) {
     newRequire(entry[i]);

package/lib/helpers.js

@@ -4,22 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.prelude = exports.helpers = exports.fnExpr = exports.bundleQueuePrelude = void 0;
-const prelude = atlaspackRequireName => `
-var $atlaspack$modules = {};
-var $atlaspack$inits = {};
+const prelude = parcelRequireName => `
+var $parcel$modules = {};
+var $parcel$inits = {};
 
-var atlaspackRequire = $atlaspack$global[${JSON.stringify(atlaspackRequireName)}];
+var parcelRequire = $parcel$global[${JSON.stringify(parcelRequireName)}];
 
-if (atlaspackRequire == null) {
-  atlaspackRequire = function(id) {
-    if (id in $atlaspack$modules) {
-      return $atlaspack$modules[id].exports;
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    if (id in $parcel$modules) {
+      return $parcel$modules[id].exports;
     }
-    if (id in $atlaspack$inits) {
-      var init = $atlaspack$inits[id];
-      delete $atlaspack$inits[id];
+    if (id in $parcel$inits) {
+      var init = $parcel$inits[id];
+      delete $parcel$inits[id];
       var module = {id: id, exports: {}};
-      $atlaspack$modules[id] = module;
+      $parcel$modules[id] = module;
       init.call(module.exports, module, module.exports);
       return module.exports;
     }
@@ -28,14 +28,14 @@ if (atlaspackRequire == null) {
     throw err;
   };
 
-  atlaspackRequire.register = function register(id, init) {
-    $atlaspack$inits[id] = init;
+  parcelRequire.register = function register(id, init) {
+    $parcel$inits[id] = init;
   };
 
-  $atlaspack$global[${JSON.stringify(atlaspackRequireName)}] = atlaspackRequire;
+  $parcel$global[${JSON.stringify(parcelRequireName)}] = parcelRequire;
 }
 
-var atlaspackRegister = atlaspackRequire.register;
+var parcelRegister = parcelRequire.register;
 `;
 exports.prelude = prelude;
 const fnExpr = (env, params, body) => {
@@ -47,34 +47,34 @@ const fnExpr = (env, params, body) => {
 };
 exports.fnExpr = fnExpr;
 const bundleQueuePrelude = env => `
-if (!$atlaspack$global.lb) {
+if (!$parcel$global.lb) {
   // Set of loaded bundles
-  $atlaspack$global.lb = new Set();
+  $parcel$global.lb = new Set();
   // Queue of bundles to execute once they're dep bundles are loaded
-  $atlaspack$global.bq = [];
+  $parcel$global.bq = [];
 
   // Register loaded bundle
-  $atlaspack$global.rlb = ${fnExpr(env, ['bundle'], ['$atlaspack$global.lb.add(bundle);', '$atlaspack$global.pq();'])}
+  $parcel$global.rlb = ${fnExpr(env, ['bundle'], ['$parcel$global.lb.add(bundle);', '$parcel$global.pq();'])}
 
   // Run when ready
-  $atlaspack$global.rwr = ${fnExpr(env,
+  $parcel$global.rwr = ${fnExpr(env,
 // b = bundle public id
 // r = run function to execute the bundle entry
 // d = list of dependent bundles this bundle requires before executing
-['b', 'r', 'd'], ['$atlaspack$global.bq.push({b, r, d});', '$atlaspack$global.pq();'])}
+['b', 'r', 'd'], ['$parcel$global.bq.push({b, r, d});', '$parcel$global.pq();'])}
 
   // Process queue
-  $atlaspack$global.pq = ${fnExpr(env, [], [`var runnableEntry = $atlaspack$global.bq.find(${fnExpr(env, ['i'], [`return i.d.every(${fnExpr(env, ['dep'], ['return $atlaspack$global.lb.has(dep);'])});`])});`, 'if (runnableEntry) {', `$atlaspack$global.bq = $atlaspack$global.bq.filter(${fnExpr(env, ['i'], ['return i.b !== runnableEntry.b;'])});`, 'runnableEntry.r();', '$atlaspack$global.pq();', '}'])}
+  $parcel$global.pq = ${fnExpr(env, [], [`var runnableEntry = $parcel$global.bq.find(${fnExpr(env, ['i'], [`return i.d.every(${fnExpr(env, ['dep'], ['return $parcel$global.lb.has(dep);'])});`])});`, 'if (runnableEntry) {', `$parcel$global.bq = $parcel$global.bq.filter(${fnExpr(env, ['i'], ['return i.b !== runnableEntry.b;'])});`, 'runnableEntry.r();', '$parcel$global.pq();', '}'])}
 }
 `;
 exports.bundleQueuePrelude = bundleQueuePrelude;
-const $atlaspack$export = `
-function $atlaspack$export(e, n, v, s) {
+const $parcel$export = `
+function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
 `;
-const $atlaspack$exportWildcard = `
-function $atlaspack$exportWildcard(dest, source) {
+const $parcel$exportWildcard = `
+function $parcel$exportWildcard(dest, source) {
   Object.keys(source).forEach(function(key) {
     if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
       return;
@@ -91,19 +91,19 @@ function $atlaspack$exportWildcard(dest, source) {
   return dest;
 }
 `;
-const $atlaspack$interopDefault = `
-function $atlaspack$interopDefault(a) {
+const $parcel$interopDefault = `
+function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
 `;
-const $atlaspack$global = env => {
+const $parcel$global = env => {
   if (env.supports('global-this')) {
     return `
-      var $atlaspack$global = globalThis;
+      var $parcel$global = globalThis;
     `;
   }
   return `
-      var $atlaspack$global =
+      var $parcel$global =
         typeof globalThis !== 'undefined'
           ? globalThis
           : typeof self !== 'undefined'
@@ -115,15 +115,15 @@ const $atlaspack$global = env => {
           : {};
   `;
 };
-const $atlaspack$defineInteropFlag = `
-function $atlaspack$defineInteropFlag(a) {
+const $parcel$defineInteropFlag = `
+function $parcel$defineInteropFlag(a) {
   Object.defineProperty(a, '__esModule', {value: true, configurable: true});
 }
 `;
 const helpers = exports.helpers = {
-  $atlaspack$export,
-  $atlaspack$exportWildcard,
-  $atlaspack$interopDefault,
-  $atlaspack$global,
-  $atlaspack$defineInteropFlag
+  $parcel$export,
+  $parcel$exportWildcard,
+  $parcel$interopDefault,
+  $parcel$global,
+  $parcel$defineInteropFlag
 };

package/lib/index.js

@@ -70,14 +70,14 @@ var _default = exports.default = new (_plugin().Packager)({
       }, packageKey, `Invalid config for ${packageKey}`);
     }
 
-    // Generate a name for the global atlaspackRequire function that is unique to this project.
-    // This allows multiple atlaspack builds to coexist on the same page.
+    // Generate a name for the global parcelRequire function that is unique to this project.
+    // This allows multiple parcel builds to coexist on the same page.
     let packageName = await config.getConfigFrom(options.projectRoot + '/index', [], {
       packageKey: 'name'
     });
     let name = (packageName === null || packageName === void 0 || (_packageName$contents = packageName.contents) === null || _packageName$contents === void 0 ? void 0 : _packageName$contents.name) ?? '';
     return {
-      atlaspackRequireName: 'atlaspackRequire' + (0, _rust().hashString)(name).slice(-4),
+      parcelRequireName: 'parcelRequire' + (0, _rust().hashString)(name).slice(-4),
       unstable_asyncBundleRuntime: Boolean(conf === null || conf === void 0 || (_conf$contents = conf.contents) === null || _conf$contents === void 0 ? void 0 : _conf$contents.unstable_asyncBundleRuntime)
     };
   },
@@ -100,7 +100,7 @@ var _default = exports.default = new (_plugin().Packager)({
       }
     }
     if (contents == null) {
-      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).atlaspackRequireName, (0, _nullthrows().default)(config).unstable_asyncBundleRuntime) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).atlaspackRequireName);
+      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName, (0, _nullthrows().default)(config).unstable_asyncBundleRuntime) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName);
       ({
         contents,
         map