@vercel/node 2.11.0 → 2.13.0

package/dist/index.js

@@ -15545,7 +15545,7 @@ function hoistVariables(path, emit, kind = "var") {
 
 /***/ }),
 
-/***/ 60732:
+/***/ 92288:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -15555,11 +15555,8 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = void 0;
-
 var _assert = __webpack_require__(42357);
-
 var _t = __webpack_require__(32338);
-
 const {
   callExpression,
   cloneNode,
@@ -15574,7 +15571,6 @@ const {
   variableDeclaration,
   variableDeclarator
 } = _t;
-
 class ImportBuilder {
   constructor(importedSource, scope, hub) {
     this._statements = [];
@@ -15584,139 +15580,102 @@ class ImportBuilder {
     this._hub = hub;
     this._importedSource = importedSource;
   }
-
   done() {
     return {
       statements: this._statements,
       resultName: this._resultName
     };
   }
-
   import() {
     this._statements.push(importDeclaration([], stringLiteral(this._importedSource)));
-
     return this;
   }
-
   require() {
     this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)])));
-
     return this;
   }
-
   namespace(name = "namespace") {
     const local = this._scope.generateUidIdentifier(name);
-
     const statement = this._statements[this._statements.length - 1];
-
     _assert(statement.type === "ImportDeclaration");
-
     _assert(statement.specifiers.length === 0);
-
     statement.specifiers = [importNamespaceSpecifier(local)];
     this._resultName = cloneNode(local);
     return this;
   }
-
   default(name) {
     const id = this._scope.generateUidIdentifier(name);
-
     const statement = this._statements[this._statements.length - 1];
-
     _assert(statement.type === "ImportDeclaration");
-
     _assert(statement.specifiers.length === 0);
-
     statement.specifiers = [importDefaultSpecifier(id)];
     this._resultName = cloneNode(id);
     return this;
   }
-
   named(name, importName) {
     if (importName === "default") return this.default(name);
-
     const id = this._scope.generateUidIdentifier(name);
-
     const statement = this._statements[this._statements.length - 1];
-
     _assert(statement.type === "ImportDeclaration");
-
     _assert(statement.specifiers.length === 0);
-
     statement.specifiers = [importSpecifier(id, identifier(importName))];
     this._resultName = cloneNode(id);
     return this;
   }
-
   var(name) {
     const id = this._scope.generateUidIdentifier(name);
-
     let statement = this._statements[this._statements.length - 1];
-
     if (statement.type !== "ExpressionStatement") {
       _assert(this._resultName);
-
       statement = expressionStatement(this._resultName);
-
       this._statements.push(statement);
     }
-
     this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]);
     this._resultName = cloneNode(id);
     return this;
   }
-
   defaultInterop() {
     return this._interop(this._hub.addHelper("interopRequireDefault"));
   }
-
   wildcardInterop() {
     return this._interop(this._hub.addHelper("interopRequireWildcard"));
   }
-
   _interop(callee) {
     const statement = this._statements[this._statements.length - 1];
-
     if (statement.type === "ExpressionStatement") {
       statement.expression = callExpression(callee, [statement.expression]);
     } else if (statement.type === "VariableDeclaration") {
       _assert(statement.declarations.length === 1);
-
       statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
     } else {
       _assert.fail("Unexpected type.");
     }
-
     return this;
   }
-
   prop(name) {
     const statement = this._statements[this._statements.length - 1];
-
     if (statement.type === "ExpressionStatement") {
       statement.expression = memberExpression(statement.expression, identifier(name));
     } else if (statement.type === "VariableDeclaration") {
       _assert(statement.declarations.length === 1);
-
       statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name));
     } else {
       _assert.fail("Unexpected type:" + statement.type);
     }
-
     return this;
   }
-
   read(name) {
     this._resultName = memberExpression(this._resultName, identifier(name));
   }
-
 }
-
 exports.default = ImportBuilder;
 
+//# sourceMappingURL=import-builder.js.map
+
+
 /***/ }),
 
-/***/ 27340:
+/***/ 37615:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -15726,20 +15685,14 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = void 0;
-
 var _assert = __webpack_require__(42357);
-
 var _t = __webpack_require__(32338);
-
-var _importBuilder = __webpack_require__(60732);
-
-var _isModule = __webpack_require__(77901);
-
+var _importBuilder = __webpack_require__(92288);
+var _isModule = __webpack_require__(59462);
 const {
   numericLiteral,
   sequenceExpression
 } = _t;
-
 class ImportInjector {
   constructor(path, importedSource, opts) {
     this._defaultOpts = {
@@ -15757,46 +15710,35 @@ class ImportInjector {
     this._hub = programPath.hub;
     this._defaultOpts = this._applyDefaults(importedSource, opts, true);
   }
-
   addDefault(importedSourceIn, opts) {
     return this.addNamed("default", importedSourceIn, opts);
   }
-
   addNamed(importName, importedSourceIn, opts) {
     _assert(typeof importName === "string");
-
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
   }
-
   addNamespace(importedSourceIn, opts) {
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
   }
-
   addSideEffect(importedSourceIn, opts) {
     return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0);
   }
-
   _applyDefaults(importedSource, opts, isInit = false) {
     let newOpts;
-
     if (typeof importedSource === "string") {
       newOpts = Object.assign({}, this._defaultOpts, {
         importedSource
       }, opts);
     } else {
       _assert(!opts, "Unexpected secondary arguments.");
-
       newOpts = Object.assign({}, this._defaultOpts, importedSource);
     }
-
     if (!isInit && opts) {
       if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
       if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
     }
-
     return newOpts;
   }
-
   _generateImport(opts, importName) {
     const isDefault = importName === "default";
     const isNamed = !!importName && !isDefault;
@@ -15816,20 +15758,15 @@ class ImportInjector {
     const isMod = (0, _isModule.default)(this._programPath);
     const isModuleForNode = isMod && importingInterop === "node";
     const isModuleForBabel = isMod && importingInterop === "babel";
-
     if (importPosition === "after" && !isMod) {
       throw new Error(`"importPosition": "after" is only supported in modules`);
     }
-
     const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
-
     if (importedType === "es6") {
       if (!isModuleForNode && !isModuleForBabel) {
         throw new Error("Cannot import an ES6 module from CommonJS");
       }
-
       builder.import();
-
       if (isNamespace) {
         builder.namespace(nameHint || importedSource);
       } else if (isDefault || isNamed) {
@@ -15842,7 +15779,6 @@ class ImportInjector {
         name = name !== "default" ? name : importedSource;
         const es6Default = `${importedSource}$es6Default`;
         builder.import();
-
         if (isNamespace) {
           builder.default(es6Default).var(name || importedSource).wildcardInterop();
         } else if (isDefault) {
@@ -15856,7 +15792,6 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
-
         if (isNamespace) {
           builder.namespace(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15864,7 +15799,6 @@ class ImportInjector {
         }
       } else {
         builder.require();
-
         if (isNamespace) {
           builder.var(name || importedSource).wildcardInterop();
         } else if ((isDefault || isNamed) && ensureLiveReference) {
@@ -15884,7 +15818,6 @@ class ImportInjector {
     } else if (importedInterop === "compiled") {
       if (isModuleForNode) {
         builder.import();
-
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15892,7 +15825,6 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
-
         if (isNamespace) {
           builder.namespace(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15900,7 +15832,6 @@ class ImportInjector {
         }
       } else {
         builder.require();
-
         if (isNamespace) {
           builder.var(name || importedSource);
         } else if (isDefault || isNamed) {
@@ -15915,10 +15846,8 @@ class ImportInjector {
       if (isDefault && ensureLiveReference) {
         throw new Error("No live reference for commonjs default");
       }
-
       if (isModuleForNode) {
         builder.import();
-
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault) {
@@ -15928,7 +15857,6 @@ class ImportInjector {
         }
       } else if (isModuleForBabel) {
         builder.import();
-
         if (isNamespace) {
           builder.default(name || importedSource);
         } else if (isDefault) {
@@ -15938,7 +15866,6 @@ class ImportInjector {
         }
       } else {
         builder.require();
-
         if (isNamespace) {
           builder.var(name || importedSource);
         } else if (isDefault) {
@@ -15954,24 +15881,18 @@ class ImportInjector {
     } else {
       throw new Error(`Unknown importedInterop "${importedInterop}".`);
     }
-
     const {
       statements,
       resultName
     } = builder.done();
-
     this._insertStatements(statements, importPosition, blockHoist);
-
     if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
       return sequenceExpression([numericLiteral(0), resultName]);
     }
-
     return resultName;
   }
-
   _insertStatements(statements, importPosition = "before", blockHoist = 3) {
     const body = this._programPath.get("body");
-
     if (importPosition === "after") {
       for (let i = body.length - 1; i >= 0; i--) {
         if (body[i].isImportDeclaration()) {
@@ -15987,23 +15908,22 @@ class ImportInjector {
         const val = p.node._blockHoist;
         return Number.isFinite(val) && val < 4;
       });
-
       if (targetPath) {
         targetPath.insertBefore(statements);
         return;
       }
     }
-
     this._programPath.unshiftContainer("body", statements);
   }
-
 }
-
 exports.default = ImportInjector;
 
+//# sourceMappingURL=import-injector.js.map
+
+
 /***/ }),
 
-/***/ 96150:
+/***/ 10742:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -16028,30 +15948,27 @@ Object.defineProperty(exports, "isModule", ({
     return _isModule.default;
   }
 }));
-
-var _importInjector = __webpack_require__(27340);
-
-var _isModule = __webpack_require__(77901);
-
+var _importInjector = __webpack_require__(37615);
+var _isModule = __webpack_require__(59462);
 function addDefault(path, importedSource, opts) {
   return new _importInjector.default(path).addDefault(importedSource, opts);
 }
-
 function addNamed(path, name, importedSource, opts) {
   return new _importInjector.default(path).addNamed(name, importedSource, opts);
 }
-
 function addNamespace(path, importedSource, opts) {
   return new _importInjector.default(path).addNamespace(importedSource, opts);
 }
-
 function addSideEffect(path, importedSource, opts) {
   return new _importInjector.default(path).addSideEffect(importedSource, opts);
 }
 
+//# sourceMappingURL=index.js.map
+
+
 /***/ }),
 
-/***/ 77901:
+/***/ 59462:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -16061,19 +15978,13 @@ Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
 exports.default = isModule;
-
 function isModule(path) {
-  const {
-    sourceType
-  } = path.node;
-
-  if (sourceType !== "module" && sourceType !== "script") {
-    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
-  }
-
   return path.node.sourceType === "module";
 }
 
+//# sourceMappingURL=is-module.js.map
+
+
 /***/ }),
 
 /***/ 40380:
@@ -16252,7 +16163,7 @@ exports.wrapInterop = wrapInterop;
 var _assert = __webpack_require__(42357);
 var _t = __webpack_require__(32338);
 var _template = __webpack_require__(82272);
-var _helperModuleImports = __webpack_require__(96150);
+var _helperModuleImports = __webpack_require__(10742);
 var _rewriteThis = __webpack_require__(52831);
 var _rewriteLiveReferences = __webpack_require__(72337);
 var _normalizeAndLoadMetadata = __webpack_require__(34376);
@@ -140038,17 +139949,12 @@ const path_1 = __webpack_require__(85622);
 function forkDevServer(options) {
     let nodeOptions = process.env.NODE_OPTIONS;
     const tsNodePath = options.require_.resolve('ts-node');
-    const esmLoader = url_1.pathToFileURL(path_1.join(tsNodePath, '..', '..', 'esm.mjs'));
-    const cjsLoader = path_1.join(tsNodePath, '..', '..', 'register', 'index.js');
-    const devServerPath = options.devServerPath || path_1.join(__dirname, 'dev-server.js');
+    const esmLoader = (0, url_1.pathToFileURL)((0, path_1.join)(tsNodePath, '..', '..', 'esm.mjs'));
+    const cjsLoader = (0, path_1.join)(tsNodePath, '..', '..', 'register', 'index.js');
+    const devServerPath = options.devServerPath || (0, path_1.join)(__dirname, 'dev-server.mjs');
     if (options.maybeTranspile) {
         if (options.isTypeScript) {
-            if (options.isEsm) {
-                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
+            nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
         }
         else {
             if (options.isEsm) {
@@ -140062,9 +139968,8 @@ function forkDevServer(options) {
     const forkOptions = {
         cwd: options.workPath,
         execArgv: [],
-        env: build_utils_1.cloneEnv(process.env, options.meta.env, {
+        env: (0, build_utils_1.cloneEnv)(process.env, options.meta.env, {
             VERCEL_DEV_ENTRYPOINT: options.entrypoint,
-            VERCEL_DEV_IS_ESM: options.isEsm ? '1' : undefined,
             VERCEL_DEV_CONFIG: JSON.stringify(options.config),
             VERCEL_DEV_BUILD_ENV: JSON.stringify(options.meta.buildEnv || {}),
             TS_NODE_TRANSPILE_ONLY: '1',
@@ -140074,7 +139979,7 @@ function forkDevServer(options) {
             NODE_OPTIONS: nodeOptions,
         }),
     };
-    const child = child_process_1.fork(devServerPath, [], forkOptions);
+    const child = (0, child_process_1.fork)(devServerPath, [], forkOptions);
     checkForPid(devServerPath, child);
     return child;
 }
@@ -140090,7 +139995,7 @@ function checkForPid(path, process) {
  * or it is listening to new requests, and we can start proxying requests.
  */
 async function readMessage(child) {
-    const onMessage = once_1.default(child, 'message');
+    const onMessage = (0, once_1.default)(child, 'message');
     const onExit = once_1.default.spread(child, 'close');
     const result = await Promise.race([
         onMessage.then(x => {
@@ -140116,7 +140021,11 @@ exports.readMessage = readMessage;
 
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -140129,6 +140038,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.startDevServer = exports.prepareCache = exports.build = exports.version = exports.shouldServe = void 0;
+const error_utils_1 = __webpack_require__(27915);
 const url_1 = __importDefault(__webpack_require__(78835));
 const child_process_1 = __webpack_require__(63129);
 const fs_1 = __webpack_require__(35747);
@@ -140145,15 +140055,15 @@ const utils_1 = __webpack_require__(76136);
 const fork_dev_server_1 = __webpack_require__(31158);
 const ALLOWED_RUNTIMES = ['nodejs', ...Object.values(utils_1.EdgeRuntimes)];
 const require_ = eval('require');
-const tscPath = path_1.resolve(path_1.dirname(require_.resolve('typescript')), '../bin/tsc');
+const tscPath = (0, path_1.resolve)((0, path_1.dirname)(require_.resolve('typescript')), '../bin/tsc');
 // eslint-disable-next-line no-useless-escape
 const libPathRegEx = /^node_modules|[\/\\]node_modules[\/\\]/;
 async function downloadInstallAndBundle({ files, entrypoint, workPath, config, meta, }) {
-    const downloadedFiles = await build_utils_1.download(files, workPath, meta);
-    const entrypointFsDirname = path_1.join(workPath, path_1.dirname(entrypoint));
-    const nodeVersion = await build_utils_1.getNodeVersion(entrypointFsDirname, undefined, config, meta);
-    const spawnOpts = build_utils_1.getSpawnOptions(meta, nodeVersion);
-    await build_utils_1.runNpmInstall(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
+    const downloadedFiles = await (0, build_utils_1.download)(files, workPath, meta);
+    const entrypointFsDirname = (0, path_1.join)(workPath, (0, path_1.dirname)(entrypoint));
+    const nodeVersion = await (0, build_utils_1.getNodeVersion)(entrypointFsDirname, undefined, config, meta);
+    const spawnOpts = (0, build_utils_1.getSpawnOptions)(meta, nodeVersion);
+    await (0, build_utils_1.runNpmInstall)(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
     const entrypointPath = downloadedFiles[entrypoint].fsPath;
     return { entrypointPath, entrypointFsDirname, nodeVersion, spawnOpts };
 }
@@ -140179,10 +140089,10 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
             ? [config.includeFiles]
             : config.includeFiles;
         for (const pattern of includeFiles) {
-            const files = await build_utils_1.glob(pattern, workPath);
+            const files = await (0, build_utils_1.glob)(pattern, workPath);
             await Promise.all(Object.values(files).map(async (entry) => {
                 const { fsPath } = entry;
-                const relPath = path_1.relative(baseDir, fsPath);
+                const relPath = (0, path_1.relative)(baseDir, fsPath);
                 fsCache.set(relPath, entry);
                 preparedFiles[relPath] = entry;
             }));
@@ -140190,9 +140100,9 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
     }
     let tsCompile;
     function compileTypeScript(path, source) {
-        const relPath = path_1.relative(baseDir, path);
+        const relPath = (0, path_1.relative)(baseDir, path);
         if (!tsCompile) {
-            tsCompile = typescript_1.register({
+            tsCompile = (0, typescript_1.register)({
                 basePath: workPath,
                 project: path,
                 files: true,
@@ -140211,7 +140121,7 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
     const conditions = isEdgeFunction
         ? ['edge-light', 'browser', 'module', 'import', 'require']
         : undefined;
-    const { fileList, esmFileList, warnings } = await nft_1.nodeFileTrace([...inputFiles], {
+    const { fileList, esmFileList, warnings } = await (0, nft_1.nodeFileTrace)([...inputFiles], {
         base: baseDir,
         processCwd: workPath,
         ts: true,
@@ -140219,29 +140129,29 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
         conditions,
         resolve(id, parent, job, cjsResolve) {
             const normalizedWasmImports = id.replace(/\.wasm\?module$/i, '.wasm');
-            return resolve_dependency_1.default(normalizedWasmImports, parent, job, cjsResolve);
+            return (0, resolve_dependency_1.default)(normalizedWasmImports, parent, job, cjsResolve);
         },
         ignore: config.excludeFiles,
         async readFile(fsPath) {
-            const relPath = path_1.relative(baseDir, fsPath);
+            const relPath = (0, path_1.relative)(baseDir, fsPath);
             // If this file has already been read then return from the cache
             const cached = sourceCache.get(relPath);
             if (typeof cached !== 'undefined')
                 return cached;
             try {
                 let entry;
-                let source = fs_1.readFileSync(fsPath);
-                const { mode } = fs_1.lstatSync(fsPath);
-                if (build_utils_1.isSymbolicLink(mode)) {
+                let source = (0, fs_1.readFileSync)(fsPath);
+                const { mode } = (0, fs_1.lstatSync)(fsPath);
+                if ((0, build_utils_1.isSymbolicLink)(mode)) {
                     entry = new build_utils_1.FileFsRef({ fsPath, mode });
                 }
-                if (isEdgeFunction && path_1.basename(fsPath) === 'package.json') {
+                if (isEdgeFunction && (0, path_1.basename)(fsPath) === 'package.json') {
                     // For Edge Functions, patch "main" field to prefer "browser" or "module"
                     const pkgJson = JSON.parse(source.toString());
                     for (const prop of ['browser', 'module']) {
                         const val = pkgJson[prop];
                         if (typeof val === 'string') {
-                            build_utils_1.debug(`Using "${prop}" field in ${fsPath}`);
+                            (0, build_utils_1.debug)(`Using "${prop}" field in ${fsPath}`);
                             pkgJson.main = val;
                             // Create the `entry` with the original so that the output is unmodified
                             if (!entry) {
@@ -140264,38 +140174,39 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
                 sourceCache.set(relPath, source);
                 return source;
             }
-            catch (e) {
-                if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+            catch (error) {
+                if ((0, error_utils_1.isErrnoException)(error) &&
+                    (error.code === 'ENOENT' || error.code === 'EISDIR')) {
                     // `null` represents a not found
                     sourceCache.set(relPath, null);
                     return null;
                 }
-                throw e;
+                throw error;
             }
         },
     });
     for (const warning of warnings) {
-        build_utils_1.debug(`Warning from trace: ${warning.message}`);
+        (0, build_utils_1.debug)(`Warning from trace: ${warning.message}`);
     }
     for (const path of fileList) {
         let entry = fsCache.get(path);
         if (!entry) {
-            const fsPath = path_1.resolve(baseDir, path);
-            const { mode } = fs_1.lstatSync(fsPath);
-            if (build_utils_1.isSymbolicLink(mode)) {
+            const fsPath = (0, path_1.resolve)(baseDir, path);
+            const { mode } = (0, fs_1.lstatSync)(fsPath);
+            if ((0, build_utils_1.isSymbolicLink)(mode)) {
                 entry = new build_utils_1.FileFsRef({ fsPath, mode });
             }
             else {
-                const source = fs_1.readFileSync(fsPath);
+                const source = (0, fs_1.readFileSync)(fsPath);
                 entry = new build_utils_1.FileBlob({ data: source, mode });
             }
         }
-        if (build_utils_1.isSymbolicLink(entry.mode) && entry.type === 'FileFsRef') {
+        if ((0, build_utils_1.isSymbolicLink)(entry.mode) && entry.type === 'FileFsRef') {
             // ensure the symlink target is added to the file list
-            const symlinkTarget = path_1.relative(baseDir, path_1.resolve(path_1.dirname(entry.fsPath), fs_1.readlinkSync(entry.fsPath)));
+            const symlinkTarget = (0, path_1.relative)(baseDir, (0, path_1.resolve)((0, path_1.dirname)(entry.fsPath), (0, fs_1.readlinkSync)(entry.fsPath)));
             if (!symlinkTarget.startsWith('..' + path_1.sep) &&
                 !fileList.has(symlinkTarget)) {
-                const stats = fs_1.statSync(path_1.resolve(baseDir, symlinkTarget));
+                const stats = (0, fs_1.statSync)((0, path_1.resolve)(baseDir, symlinkTarget));
                 if (stats.isFile()) {
                     fileList.add(symlinkTarget);
                 }
@@ -140316,9 +140227,9 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
     if (esmPaths.length) {
         const babelCompile = __webpack_require__(20007)/* .compile */ .M;
         for (const path of esmPaths) {
-            const pathDir = path_1.join(workPath, path_1.dirname(path));
+            const pathDir = (0, path_1.join)(workPath, (0, path_1.dirname)(path));
             if (!pkgCache.has(pathDir)) {
-                const pathToPkg = await build_utils_1.walkParentDirs({
+                const pathToPkg = await (0, build_utils_1.walkParentDirs)({
                     base: workPath,
                     start: pathDir,
                     filename: 'package.json',
@@ -140333,7 +140244,7 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
                 // https://nodejs.org/api/packages.html#packages_type
                 continue;
             }
-            const filename = path_1.basename(path);
+            const filename = (0, path_1.basename)(path);
             const { data: source } = await build_utils_1.FileBlob.fromStream({
                 stream: preparedFiles[path].toStream(),
             });
@@ -140358,7 +140269,7 @@ function getAWSLambdaHandler(entrypoint, config) {
         return config.awsLambdaHandler;
     }
     if (process.env.NODEJS_AWS_HANDLER_NAME) {
-        const { dir, name } = path_1.parse(entrypoint);
+        const { dir, name } = (0, path_1.parse)(entrypoint);
         return `${dir}${dir ? path_1.sep : ''}${name}.${process.env.NODEJS_AWS_HANDLER_NAME}`;
     }
     return '';
@@ -140376,7 +140287,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
         config,
         meta,
     });
-    await build_utils_1.runPackageJsonScript(entrypointFsDirname, 
+    await (0, build_utils_1.runPackageJsonScript)(entrypointFsDirname, 
     // Don't consider "build" script since its intended for frontend code
     ['vercel-build', 'now-build'], spawnOpts);
     const isMiddleware = config.middleware === true;
@@ -140385,7 +140296,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
     // `export const config = { runtime: 'edge' }`
     let isEdgeFunction = isMiddleware;
     const project = new ts_morph_1.Project();
-    const staticConfig = static_config_1.getConfig(project, entrypointPath);
+    const staticConfig = (0, static_config_1.getConfig)(project, entrypointPath);
     if (staticConfig?.runtime) {
         if (!ALLOWED_RUNTIMES.includes(staticConfig.runtime)) {
             throw new Error(`Unsupported "runtime" property in \`config\`: ${JSON.stringify(staticConfig.runtime)} (must be one of: ${JSON.stringify(ALLOWED_RUNTIMES)})`);
@@ -140393,16 +140304,16 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
         if (staticConfig.runtime === 'nodejs') {
             console.log(`Detected unused static config runtime "nodejs" in "${entrypointPath}"`);
         }
-        isEdgeFunction = utils_1.isEdgeRuntime(staticConfig.runtime);
+        isEdgeFunction = (0, utils_1.isEdgeRuntime)(staticConfig.runtime);
     }
-    build_utils_1.debug('Tracing input files...');
+    (0, build_utils_1.debug)('Tracing input files...');
     const traceTime = Date.now();
     const { preparedFiles, shouldAddSourcemapSupport } = await compile(workPath, baseDir, entrypointPath, config, nodeVersion, isEdgeFunction);
-    build_utils_1.debug(`Trace complete [${Date.now() - traceTime}ms]`);
+    (0, build_utils_1.debug)(`Trace complete [${Date.now() - traceTime}ms]`);
     let routes;
     let output;
-    const handler = renameTStoJS(path_1.relative(baseDir, entrypointPath));
-    const outputPath = utils_1.entrypointToOutputPath(entrypoint, config.zeroConfig);
+    const handler = renameTStoJS((0, path_1.relative)(baseDir, entrypointPath));
+    const outputPath = (0, utils_1.entrypointToOutputPath)(entrypoint, config.zeroConfig);
     // Add a `route` for Middleware
     if (isMiddleware) {
         if (!isEdgeFunction) {
@@ -140410,7 +140321,7 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
             throw new Error(`Middleware file can not be a Node.js Serverless Function`);
         }
         // Middleware is a catch-all for all paths unless a `matcher` property is defined
-        const src = utils_1.getRegExpFromMatchers(staticConfig?.matcher);
+        const src = (0, utils_1.getRegExpFromMatchers)(staticConfig?.matcher);
         const middlewareRawSrc = [];
         if (staticConfig?.matcher) {
             if (Array.isArray(staticConfig.matcher)) {
@@ -140461,19 +140372,19 @@ const build = async ({ files, entrypoint, workPath, repoRootPath, config = {}, m
 };
 exports.build = build;
 const prepareCache = ({ repoRootPath, workPath }) => {
-    return build_utils_1.glob('**/node_modules/**', repoRootPath || workPath);
+    return (0, build_utils_1.glob)('**/node_modules/**', repoRootPath || workPath);
 };
 exports.prepareCache = prepareCache;
 const startDevServer = async (opts) => {
     const { entrypoint, workPath, config, meta = {} } = opts;
-    const entrypointPath = path_1.join(workPath, entrypoint);
+    const entrypointPath = (0, path_1.join)(workPath, entrypoint);
     if (config.middleware === true && typeof meta.requestUrl === 'string') {
         // TODO: static config is also parsed in `dev-server.ts`.
         // we should pass in this version as an env var instead.
         const project = new ts_morph_1.Project();
-        const staticConfig = static_config_1.getConfig(project, entrypointPath);
+        const staticConfig = (0, static_config_1.getConfig)(project, entrypointPath);
         // Middleware is a catch-all for all paths unless a `matcher` property is defined
-        const matchers = new RegExp(utils_1.getRegExpFromMatchers(staticConfig?.matcher));
+        const matchers = new RegExp((0, utils_1.getRegExpFromMatchers)(staticConfig?.matcher));
         const parsed = url_1.default.parse(meta.requestUrl, true);
         if (typeof parsed.pathname !== 'string' ||
             !matchers.test(parsed.pathname)) {
@@ -140482,21 +140393,21 @@ const startDevServer = async (opts) => {
             return null;
         }
     }
-    const entryDir = path_1.dirname(entrypointPath);
-    const ext = path_1.extname(entrypoint);
-    const pathToTsConfig = await build_utils_1.walkParentDirs({
+    const entryDir = (0, path_1.dirname)(entrypointPath);
+    const ext = (0, path_1.extname)(entrypoint);
+    const pathToTsConfig = await (0, build_utils_1.walkParentDirs)({
         base: workPath,
         start: entryDir,
         filename: 'tsconfig.json',
     });
-    const pathToPkg = await build_utils_1.walkParentDirs({
+    const pathToPkg = await (0, build_utils_1.walkParentDirs)({
         base: workPath,
         start: entryDir,
         filename: 'package.json',
     });
     const pkg = pathToPkg ? require_(pathToPkg) : {};
-    const isTypescript = ['.ts', '.tsx', '.mts', '.cts'].includes(ext);
-    const maybeTranspile = isTypescript || !['.cjs', '.mjs'].includes(ext);
+    const isTypeScript = ['.ts', '.tsx', '.mts', '.cts'].includes(ext);
+    const maybeTranspile = isTypeScript || !['.cjs', '.mjs'].includes(ext);
     const isEsm = ext === '.mjs' ||
         ext === '.mts' ||
         (pkg.type === 'module' && ['.js', '.ts', '.tsx'].includes(ext));
@@ -140521,22 +140432,35 @@ const startDevServer = async (opts) => {
         }
         // Otherwise fall back to using the copy that `@vercel/node` uses
         if (!ts) {
-            compiler = resolveTypescript(path_1.join(__dirname, '..'));
+            compiler = resolveTypescript((0, path_1.join)(__dirname, '..'));
             ts = requireTypescript(compiler);
         }
         if (pathToTsConfig) {
             try {
                 tsConfig = ts.readConfigFile(pathToTsConfig, ts.sys.readFile).config;
             }
-            catch (err) {
-                if (err.code !== 'ENOENT') {
+            catch (error) {
+                if ((0, error_utils_1.isErrnoException)(error) && error.code !== 'ENOENT') {
                     console.error(`Error while parsing "${pathToTsConfig}"`);
-                    throw err;
+                    throw error;
                 }
             }
         }
+        // if we're using ESM, we need to tell TypeScript to use `nodenext` to
+        // preserve the `import` semantics
+        if (isEsm) {
+            if (!tsConfig.compilerOptions) {
+                tsConfig.compilerOptions = {};
+            }
+            if (tsConfig.compilerOptions.module === undefined) {
+                tsConfig.compilerOptions.module = 'nodenext';
+            }
+            if (tsConfig.compilerOptions.moduleResolution === undefined) {
+                tsConfig.compilerOptions.moduleResolution = 'nodenext';
+            }
+        }
         const nodeVersionMajor = Number(process.versions.node.split('.')[0]);
-        typescript_1.fixConfig(tsConfig, nodeVersionMajor);
+        (0, typescript_1.fixConfig)(tsConfig, nodeVersionMajor);
         // In prod, `.ts` inputs use TypeScript and
         // `.js` inputs use Babel to convert ESM to CJS.
         // In dev, both `.ts` and `.js` inputs use ts-node
@@ -140546,22 +140470,22 @@ const startDevServer = async (opts) => {
         // In dev, we don't emit because we use ts-node.
         tsConfig.compilerOptions.noEmit = true;
     }
-    const child = fork_dev_server_1.forkDevServer({
+    const child = (0, fork_dev_server_1.forkDevServer)({
         workPath,
         config,
         entrypoint,
         require_,
         isEsm,
-        isTypeScript: isTypescript,
+        isTypeScript,
         maybeTranspile,
         meta,
         tsConfig,
     });
     const { pid } = child;
-    const message = await fork_dev_server_1.readMessage(child);
+    const message = await (0, fork_dev_server_1.readMessage)(child);
     if (message.state === 'message') {
         // "message" event
-        if (isTypescript) {
+        if (isTypeScript) {
             // Invoke `tsc --noEmit` asynchronously in the background, so
             // that the HTTP request is not blocked by the type checking.
             doTypeCheck(opts, pathToTsConfig).catch((err) => {
@@ -140579,35 +140503,33 @@ const startDevServer = async (opts) => {
 };
 exports.startDevServer = startDevServer;
 async function doTypeCheck({ entrypoint, workPath, meta = {} }, projectTsConfig) {
-    const { devCacheDir = path_1.join(workPath, '.vercel', 'cache') } = meta;
-    const entrypointCacheDir = path_1.join(devCacheDir, 'node', entrypoint);
+    const { devCacheDir = (0, path_1.join)(workPath, '.vercel', 'cache') } = meta;
+    const entrypointCacheDir = (0, path_1.join)(devCacheDir, 'node', entrypoint);
     // In order to type-check a single file, a standalone tsconfig
     // file needs to be created that inherits from the base one :(
     // See: https://stackoverflow.com/a/44748041/376773
     //
     // A different filename needs to be used for different `extends` tsconfig.json
     const tsconfigName = projectTsConfig
-        ? `tsconfig-with-${path_1.relative(workPath, projectTsConfig).replace(/[\\/.]/g, '-')}.json`
+        ? `tsconfig-with-${(0, path_1.relative)(workPath, projectTsConfig).replace(/[\\/.]/g, '-')}.json`
         : 'tsconfig.json';
-    const tsconfigPath = path_1.join(entrypointCacheDir, tsconfigName);
+    const tsconfigPath = (0, path_1.join)(entrypointCacheDir, tsconfigName);
     const tsconfig = {
         extends: projectTsConfig
-            ? path_1.relative(entrypointCacheDir, projectTsConfig)
+            ? (0, path_1.relative)(entrypointCacheDir, projectTsConfig)
             : undefined,
-        include: [path_1.relative(entrypointCacheDir, path_1.join(workPath, entrypoint))],
+        include: [(0, path_1.relative)(entrypointCacheDir, (0, path_1.join)(workPath, entrypoint))],
     };
     try {
         const json = JSON.stringify(tsconfig, null, '\t');
         await fs_1.promises.mkdir(entrypointCacheDir, { recursive: true });
         await fs_1.promises.writeFile(tsconfigPath, json, { flag: 'wx' });
     }
-    catch (err) {
-        // Don't throw if the file already exists
-        if (err.code !== 'EEXIST') {
-            throw err;
-        }
+    catch (error) {
+        if ((0, error_utils_1.isErrnoException)(error) && error.code !== 'EEXIST')
+            throw error;
     }
-    const child = child_process_1.spawn(process.execPath, [
+    const child = (0, child_process_1.spawn)(process.execPath, [
         tscPath,
         '--project',
         tsconfigPath,
@@ -140869,7 +140791,7 @@ function register(opts = {}) {
             const diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics);
             reportTSError(diagnosticList, config.options.noEmitOnError);
             if (output.emitSkipped) {
-                throw new TypeError(`${path_1.relative(cwd, fileName)}: Emit skipped`);
+                throw new TypeError(`${(0, path_1.relative)(cwd, fileName)}: Emit skipped`);
             }
             // Throw an error when requiring `.d.ts` files.
             if (output.outputFiles.length === 0) {
@@ -140877,7 +140799,7 @@ function register(opts = {}) {
                     'This is usually the result of a faulty configuration or import. ' +
                     'Make sure there is a `.js`, `.json` or another executable extension and ' +
                     'loader (attached before `ts-node`) available alongside ' +
-                    `\`${path_1.basename(fileName)}\`.`);
+                    `\`${(0, path_1.basename)(fileName)}\`.`);
             }
             const file = {
                 code: output.outputFiles[1].text,
@@ -140905,7 +140827,7 @@ function register(opts = {}) {
      */
     function readConfig(configFileName) {
         let config = { compilerOptions: {} };
-        const basePath = normalizeSlashes(path_1.dirname(configFileName));
+        const basePath = normalizeSlashes((0, path_1.dirname)(configFileName));
         // Read project configuration when available.
         if (configFileName) {
             const result = ts.readConfigFile(configFileName, readFile);
@@ -140947,7 +140869,7 @@ function register(opts = {}) {
         const output = {
             code: value,
             map: Object.assign(JSON.parse(sourceMap), {
-                file: path_1.basename(fileName),
+                file: (0, path_1.basename)(fileName),
                 sources: [fileName],
             }),
         };
@@ -141016,10 +140938,10 @@ function filterDiagnostics(diagnostics, ignore) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
-const path_1 = __webpack_require__(85622);
-const path_to_regexp_1 = __webpack_require__(91344);
+exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = __webpack_require__(63445);
+const path_to_regexp_1 = __webpack_require__(91344);
+const path_1 = __webpack_require__(85622);
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -141038,9 +140960,9 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
     if (!matcher.startsWith('/')) {
         throw new Error(`Middleware's \`config.matcher\` values must start with "/". Received: ${matcher}`);
     }
-    const regExps = [path_to_regexp_1.pathToRegexp(matcher).source];
+    const regExps = [(0, path_to_regexp_1.pathToRegexp)(matcher).source];
     if (matcher === '/' && !allMatchers.includes('/index')) {
-        regExps.push(path_to_regexp_1.pathToRegexp('/index').source);
+        regExps.push((0, path_to_regexp_1.pathToRegexp)('/index').source);
     }
     return regExps;
 }
@@ -141055,7 +140977,7 @@ function getRegExpFromMatcher(matcher, index, allMatchers) {
  */
 function entrypointToOutputPath(entrypoint, zeroConfig) {
     if (zeroConfig) {
-        const ext = path_1.extname(entrypoint);
+        const ext = (0, path_1.extname)(entrypoint);
         return entrypoint.slice(0, entrypoint.length - ext.length);
     }
     return entrypoint;
@@ -141068,7 +140990,7 @@ function logError(error) {
         // because it points to internals, not user code
         const errorPrefixLength = 'Error: '.length;
         const errorMessageLength = errorPrefixLength + error.message.length;
-        build_utils_1.debug(error.stack.substring(errorMessageLength + 1));
+        (0, build_utils_1.debug)(error.stack.substring(errorMessageLength + 1));
     }
 }
 exports.logError = logError;
@@ -141082,6 +141004,12 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+async function serializeBody(request) {
+    return request.method !== 'GET' && request.method !== 'HEAD'
+        ? await (0, build_utils_1.streamToBuffer)(request)
+        : undefined;
+}
+exports.serializeBody = serializeBody;
 
 
 /***/ }),
@@ -141157,6 +141085,14 @@ module.exports = require("@vercel/build-utils");
 
 /***/ }),
 
+/***/ 27915:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("@vercel/error-utils");
+
+/***/ }),
+
 /***/ 27167:
 /***/ ((module) => {