@netlify/zip-it-and-ship-it 5.6.0 → 5.7.3

package/dist/runtimes/node/bundlers/nft/es_modules.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpileESM = void 0;
+exports.processESM = void 0;
 const path_1 = require("path");
 const fs_1 = require("../../../../utils/fs");
+const node_version_1 = require("../../utils/node_version");
+const package_json_1 = require("../../utils/package_json");
 const transpile_1 = require("./transpile");
 const getPatchedESMPackages = async (packages, fsCache) => {
     const patchedPackages = await Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
@@ -12,6 +14,11 @@ const getPatchedESMPackages = async (packages, fsCache) => {
     });
     return patchedPackagesMap;
 };
+const isEntrypointESM = ({ basePath, esmPaths, mainFile, }) => {
+    const absoluteESMPaths = new Set([...esmPaths].map((path) => resolvePath(path, basePath)));
+    const entrypointIsESM = absoluteESMPaths.has(mainFile);
+    return entrypointIsESM;
+};
 const patchESMPackage = async (path, fsCache) => {
     const file = (await (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
     const packageJson = JSON.parse(file);
@@ -21,6 +28,28 @@ const patchESMPackage = async (path, fsCache) => {
     };
     return JSON.stringify(patchedPackageJson);
 };
+const processESM = async ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }) => {
+    const entrypointIsESM = isEntrypointESM({ basePath, esmPaths, mainFile });
+    if (!entrypointIsESM) {
+        return {
+            moduleFormat: 'cjs',
+        };
+    }
+    const packageJson = await (0, package_json_1.getPackageJsonIfAvailable)((0, path_1.dirname)(mainFile));
+    const nodeSupport = (0, node_version_1.getNodeSupportMatrix)(config.nodeVersion);
+    if (featureFlags.zisi_pure_esm && packageJson.type === 'module' && nodeSupport.esm) {
+        return {
+            moduleFormat: 'esm',
+        };
+    }
+    const rewrites = await transpileESM({ basePath, config, esmPaths, fsCache, reasons });
+    return {
+        moduleFormat: 'cjs',
+        rewrites,
+    };
+};
+exports.processESM = processESM;
+const resolvePath = (relativePath, basePath) => basePath ? (0, path_1.resolve)(basePath, relativePath) : (0, path_1.resolve)(relativePath);
 const shouldTranspile = (path, cache, esmPaths, reasons) => {
     if (cache.has(path)) {
         return cache.get(path);
@@ -33,15 +62,16 @@ const shouldTranspile = (path, cache, esmPaths, reasons) => {
         return false;
     }
     const { parents } = reason;
+    const parentPaths = [...parents].filter((parentPath) => parentPath !== path);
     // If the path is an entrypoint, we transpile it only if it's an ESM file.
-    if (parents.size === 0) {
+    if (parentPaths.length === 0) {
         const isESM = esmPaths.has(path);
         cache.set(path, isESM);
         return isESM;
     }
     // The path should be transpiled if every parent will also be transpiled, or
     // if there is no parent.
-    const shouldTranspilePath = [...parents].every((parentPath) => shouldTranspile(parentPath, cache, esmPaths, reasons));
+    const shouldTranspilePath = parentPaths.every((parentPath) => shouldTranspile(parentPath, cache, esmPaths, reasons));
     cache.set(path, shouldTranspilePath);
     return shouldTranspilePath;
 };
@@ -60,11 +90,10 @@ const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, }) =
         .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
     const rewrites = await getPatchedESMPackages(packageJsonPaths, fsCache);
     await Promise.all(pathsToTranspile.map(async (path) => {
-        const absolutePath = basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path);
+        const absolutePath = resolvePath(path, basePath);
         const transpiled = await (0, transpile_1.transpile)(absolutePath, config);
         rewrites.set(absolutePath, transpiled);
     }));
     return rewrites;
 };
-exports.transpileESM = transpileESM;
 //# sourceMappingURL=es_modules.js.map

package/dist/runtimes/node/bundlers/nft/index.js

@@ -15,12 +15,13 @@ const es_modules_1 = require("./es_modules");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = async ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
+const bundle = async ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
-    const { paths: dependencyPaths, rewrites } = await traceFilesAndTranspile({
+    const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
+        featureFlags,
         mainFile,
         pluginsModulesPath,
     });
@@ -32,6 +33,7 @@ const bundle = async ({ basePath, config, mainFile, pluginsModulesPath, reposito
         basePath: (0, base_path_1.getBasePath)(dirnames),
         inputs: dependencyPaths,
         mainFile,
+        moduleFormat,
         rewrites,
         srcFiles,
     };
@@ -41,7 +43,7 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = async function ({ basePath, config, mainFile, pluginsModulesPath, }) {
+const traceFilesAndTranspile = async function ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, }) {
     const fsCache = {};
     const { fileList: dependencyPaths, esmFileList, reasons, } = await (0, nft_1.nodeFileTrace)([mainFile], {
         base: basePath,
@@ -75,8 +77,17 @@ const traceFilesAndTranspile = async function ({ basePath, config, mainFile, plu
         },
     });
     const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-    const rewrites = await (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons });
+    const { moduleFormat, rewrites } = await (0, es_modules_1.processESM)({
+        basePath,
+        config,
+        esmPaths: esmFileList,
+        featureFlags,
+        fsCache,
+        mainFile,
+        reasons,
+    });
     return {
+        moduleFormat,
         paths: normalizedDependencyPaths,
         rewrites,
     };

package/dist/runtimes/node/bundlers/nft/transpile.d.ts

@@ -1,3 +1,2 @@
 import type { FunctionConfig } from '../../../../config';
-declare const transpile: (path: string, config: FunctionConfig) => Promise<string>;
-export { transpile };
+export declare const transpile: (path: string, config: FunctionConfig) => Promise<string>;

package/dist/runtimes/node/bundlers/zisi/index.js

@@ -26,6 +26,7 @@ const bundle = async ({ basePath, config, extension, featureFlags, filename, mai
         basePath: (0, base_path_1.getBasePath)(dirnames),
         inputs: srcFiles,
         mainFile,
+        moduleFormat: 'cjs',
         srcFiles,
     };
 };

package/dist/runtimes/node/bundlers/zisi/list_imports.d.ts

@@ -1,5 +1,4 @@
-declare const listImports: ({ functionName, path }: {
+export declare const listImports: ({ functionName, path, }: {
     functionName: string;
     path: string;
 }) => Promise<string[]>;
-export { listImports };

package/dist/runtimes/node/bundlers/zisi/list_imports.js

@@ -1,7 +1,11 @@
 "use strict";
 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];
@@ -47,7 +51,7 @@ const getListImportsPlugin = ({ imports, path }) => ({
         });
     },
 });
-const listImports = async ({ functionName, path }) => {
+const listImports = async ({ functionName, path, }) => {
     // We're not interested in the output that esbuild generates, we're just
     // using it for its parsing capabilities in order to find import/require
     // statements. However, if we don't give esbuild a path in `outfile`, it

package/dist/runtimes/node/bundlers/zisi/nested.d.ts

@@ -1,10 +1,9 @@
 import { PackageJson } from '../../utils/package_json';
-declare const getNestedDependencies: ({ dependencies, peerDependencies, optionalDependencies, }: PackageJson) => string[];
-declare const handleModuleNotFound: ({ error, moduleName, packageJson, }: {
+export declare const getNestedDependencies: ({ dependencies, peerDependencies, optionalDependencies, }: PackageJson) => string[];
+export declare const handleModuleNotFound: ({ error, moduleName, packageJson, }: {
     error: Error & {
         code: string;
     };
     moduleName: string;
     packageJson: PackageJson;
 }) => [] | never;
-export { getNestedDependencies, handleModuleNotFound };

package/dist/runtimes/node/bundlers/zisi/nested.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleModuleNotFound = exports.getNestedDependencies = void 0;
-const semver_1 = require("semver");
+const semver_1 = __importDefault(require("semver"));
 // Apply the Node.js module logic recursively on its own dependencies, using
 // the `package.json` `dependencies`, `peerDependencies` and
 // `optionalDependencies` keys
@@ -57,7 +60,8 @@ const isOptionalModule = function (moduleName, { optionalDependencies = {}, peer
             peerDependencies[moduleName] !== undefined));
 };
 const MIN_NEXT_VERSION = '10.0.4';
-const satisfiesRange = (range) => Boolean((0, semver_1.validRange)(range)) && ((0, semver_1.satisfies)(MIN_NEXT_VERSION, range) || (0, semver_1.ltr)(MIN_NEXT_VERSION, range));
+const satisfiesRange = (range) => Boolean(semver_1.default.validRange(range)) &&
+    (semver_1.default.satisfies(MIN_NEXT_VERSION, range) || semver_1.default.ltr(MIN_NEXT_VERSION, range));
 // 'critters' is used only in Next.js >= 10.0.4 when enabling an experimental option and has to be installed manually
 // we ignore it if it's missing
 const isExternalCrittersModule = function (moduleName, { dependencies = {}, devDependencies = {} }) {
@@ -70,8 +74,8 @@ const isExternalCrittersModule = function (moduleName, { dependencies = {}, devD
     }
     // can the declared Next.js version resolve to >=10.0.4 ?
     // test exact versions
-    if ((0, semver_1.valid)(nextVersion)) {
-        return (0, semver_1.gte)(nextVersion, MIN_NEXT_VERSION);
+    if (semver_1.default.valid(nextVersion)) {
+        return semver_1.default.gte(nextVersion, MIN_NEXT_VERSION);
     }
     return satisfiesRange(nextVersion);
 };

package/dist/runtimes/node/bundlers/zisi/published.d.ts

@@ -1,2 +1 @@
-declare const getPublishedFiles: (modulePath: string) => Promise<string[]>;
-export { getPublishedFiles };
+export declare const getPublishedFiles: (modulePath: string) => Promise<string[]>;

package/dist/runtimes/node/bundlers/zisi/resolve.d.ts

@@ -1,3 +1,2 @@
-declare const resolvePackage: (moduleName: string, baseDirs: string[]) => Promise<string>;
-declare const resolvePathPreserveSymlinks: (path: string, baseDirs: string[]) => Promise<string>;
-export { resolvePackage, resolvePathPreserveSymlinks };
+export declare const resolvePackage: (moduleName: string, baseDirs: string[]) => Promise<string>;
+export declare const resolvePathPreserveSymlinks: (path: string, baseDirs: string[]) => Promise<string>;

package/dist/runtimes/node/bundlers/zisi/resolve.js

@@ -4,11 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePathPreserveSymlinks = exports.resolvePackage = void 0;
+const module_1 = require("module");
 const process_1 = require("process");
 const find_up_1 = __importDefault(require("find-up"));
 const path_exists_1 = __importDefault(require("path-exists"));
 const resolve_1 = __importDefault(require("resolve"));
-const semver_1 = require("semver");
+const semver_1 = __importDefault(require("semver"));
+const requireLib = (0, module_1.createRequire)(__filename);
 const BACKSLASH_REGEXP = /\\/g;
 // Find the path to a module's `package.json`
 // We need to use `resolve` instead of `require.resolve()` because:
@@ -26,10 +28,10 @@ const BACKSLASH_REGEXP = /\\/g;
 // So, on errors, we fallback to `require.resolve()`
 const resolvePackage = async function (moduleName, baseDirs) {
     try {
-        return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
+        return await (0, exports.resolvePathPreserveSymlinks)(`${moduleName}/package.json`, baseDirs);
     }
     catch (error) {
-        if ((0, semver_1.lt)(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
+        if (semver_1.default.lt(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
             throw error;
         }
         try {
@@ -75,7 +77,7 @@ const resolvePathPreserveSymlinks = async function (path, baseDirs) {
 };
 exports.resolvePathPreserveSymlinks = resolvePathPreserveSymlinks;
 const resolvePathFollowSymlinks = function (path, baseDirs) {
-    return require.resolve(path, { paths: baseDirs });
+    return requireLib.resolve(path, { paths: baseDirs });
 };
 // `require.resolve()` on a module's specific file (like `package.json`)
 // can be forbidden by the package author by using an `exports` field in

package/dist/runtimes/node/bundlers/zisi/side_files.d.ts

@@ -1,2 +1 @@
-declare const getSideFiles: (modulePath: string, moduleName: string) => Promise<string[]>;
-export { getSideFiles };
+export declare const getSideFiles: (modulePath: string, moduleName: string) => Promise<string[]>;

package/dist/runtimes/node/bundlers/zisi/src_files.d.ts

@@ -1,3 +1,2 @@
 import type { GetSrcFilesFunction } from '..';
-declare const getSrcFiles: GetSrcFilesFunction;
-export { getSrcFiles };
+export declare const getSrcFiles: GetSrcFilesFunction;

package/dist/runtimes/node/bundlers/zisi/traverse.d.ts

@@ -1,10 +1,9 @@
 import { PackageJson } from '../../utils/package_json';
 import { TraversalCache } from '../../utils/traversal_cache';
-declare const getDependencyPathsForDependency: ({ dependency, basedir, state, packageJson, pluginsModulesPath, }: {
+export declare const getDependencyPathsForDependency: ({ dependency, basedir, state, packageJson, pluginsModulesPath, }: {
     dependency: string;
     basedir: string;
     state: TraversalCache;
     packageJson: PackageJson;
     pluginsModulesPath?: string | undefined;
 }) => Promise<string[]>;
-export { getDependencyPathsForDependency };

package/dist/runtimes/node/bundlers/zisi/traverse.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependencyPathsForDependency = void 0;
+const fs_1 = require("fs");
 const path_1 = require("path");
 const non_nullable_1 = require("../../../../utils/non_nullable");
 const module_1 = require("../../utils/module");
@@ -42,8 +43,7 @@ const getDependenciesForModuleName = async function ({ moduleName, basedir, stat
     state.moduleNames.add(moduleName);
     state.modulePaths.add(modulePath);
     // The path depends on the user's build, i.e. must be dynamic
-    // eslint-disable-next-line import/no-dynamic-require, node/global-require, @typescript-eslint/no-var-requires
-    const packageJson = require(packagePath);
+    const packageJson = JSON.parse(await fs_1.promises.readFile(packagePath, 'utf8'));
     const [publishedFiles, sideFiles, depsPaths] = await Promise.all([
         (0, published_1.getPublishedFiles)(modulePath),
         (0, side_files_1.getSideFiles)(modulePath, moduleName),
@@ -56,7 +56,7 @@ const isExcludedModule = function (moduleName) {
 };
 const getNestedModules = async function ({ modulePath, state, packageJson, pluginsModulesPath, }) {
     const dependencies = (0, nested_1.getNestedDependencies)(packageJson);
-    const depsPaths = await Promise.all(dependencies.map((dependency) => getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
+    const depsPaths = await Promise.all(dependencies.map((dependency) => (0, exports.getDependencyPathsForDependency)({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
     return depsPaths.flat();
 };
 //# sourceMappingURL=traverse.js.map

package/dist/runtimes/node/bundlers/zisi/tree_files.d.ts

@@ -1,3 +1,2 @@
 import { Stats } from 'fs';
-declare const getTreeFiles: (srcPath: string, stat: Stats) => Promise<string[]>;
-export { getTreeFiles };
+export declare const getTreeFiles: (srcPath: string, stat: Stats) => Promise<string[]>;

package/dist/runtimes/node/bundlers/zisi/tree_shake.d.ts

@@ -1,2 +1 @@
-declare const shouldTreeShake: (dependency: string, treeShakeNext: boolean) => boolean;
-export { shouldTreeShake };
+export declare const shouldTreeShake: (dependency: string, treeShakeNext: boolean) => boolean;

package/dist/runtimes/node/finder.d.ts

@@ -1,4 +1,3 @@
 import { FindFunctionsInPathsFunction, FindFunctionInPathFunction } from '../runtime';
-declare const findFunctionsInPaths: FindFunctionsInPathsFunction;
-declare const findFunctionInPath: FindFunctionInPathFunction;
-export { findFunctionsInPaths, findFunctionInPath };
+export declare const findFunctionsInPaths: FindFunctionsInPathsFunction;
+export declare const findFunctionInPath: FindFunctionInPathFunction;

package/dist/runtimes/node/finder.js

@@ -20,7 +20,7 @@ const sortByExtension = (fA, fB) => {
     return indexB - indexA;
 };
 const findFunctionsInPaths = async function ({ paths, fsCache, featureFlags }) {
-    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ path, fsCache, featureFlags })));
+    const functions = await Promise.all(paths.map((path) => (0, exports.findFunctionInPath)({ path, fsCache, featureFlags })));
     // It's fine to mutate the array since its scope is local to this function.
     const sortedFunctions = functions.filter(non_nullable_1.nonNullable).sort((fA, fB) => {
         // We first sort the functions array to put directories first. This is so

package/dist/runtimes/node/in_source_config/index.d.ts

@@ -1,12 +1,10 @@
 import { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName } from '@babel/types';
 import { parse as parseSchedule } from './properties/schedule';
-declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
-declare type ISCValues = Partial<ReturnType<typeof parseSchedule>>;
-declare const findISCDeclarationsInPath: (sourcePath: string) => Promise<ISCValues>;
-declare type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
-interface ISCExport {
+export declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
+export declare type ISCValues = Partial<ReturnType<typeof parseSchedule>>;
+export declare const findISCDeclarationsInPath: (sourcePath: string) => Promise<ISCValues>;
+export declare type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
+export interface ISCExport {
     local: string;
     args: ISCHandlerArg[];
 }
-export { findISCDeclarationsInPath, IN_SOURCE_CONFIG_MODULE };
-export type { ISCExport, ISCHandlerArg, ISCValues };

package/dist/runtimes/node/in_source_config/index.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPath = void 0;
+exports.findISCDeclarationsInPath = exports.IN_SOURCE_CONFIG_MODULE = void 0;
 const non_nullable_1 = require("../../../utils/non_nullable");
 const parser_1 = require("../parser");
 const exports_1 = require("../parser/exports");
 const imports_1 = require("../parser/imports");
 const schedule_1 = require("./properties/schedule");
-const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
-exports.IN_SOURCE_CONFIG_MODULE = IN_SOURCE_CONFIG_MODULE;
+exports.IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
 // Parses a JS/TS file and looks for in-source config declarations. It returns
 // an array of all declarations found, with `property` indicating the name of
 // the property and `data` its value.
@@ -16,9 +15,9 @@ const findISCDeclarationsInPath = async (sourcePath) => {
     if (ast === null) {
         return {};
     }
-    const imports = ast.body.flatMap((node) => (0, imports_1.getImports)(node, IN_SOURCE_CONFIG_MODULE));
-    const exports = (0, exports_1.getMainExport)(ast.body);
-    const iscExports = exports
+    const imports = ast.body.flatMap((node) => (0, imports_1.getImports)(node, exports.IN_SOURCE_CONFIG_MODULE));
+    const mainExports = (0, exports_1.getMainExport)(ast.body);
+    const iscExports = mainExports
         .map(({ args, local: exportName }) => {
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
         if (matchingImport === undefined) {

package/dist/runtimes/node/index.d.ts

@@ -1,5 +1,4 @@
 import { Runtime } from '../runtime';
-export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
-export { NodeVersion } from './utils/node_version';
+export { NodeVersionString } from './utils/node_version';
 declare const runtime: Runtime;
 export default runtime;

package/dist/runtimes/node/index.js

@@ -8,33 +8,14 @@ const cp_file_1 = __importDefault(require("cp-file"));
 const bundlers_1 = require("./bundlers");
 const finder_1 = require("./finder");
 const in_source_config_1 = require("./in_source_config");
-const detect_es_module_1 = require("./utils/detect_es_module");
 const plugin_modules_path_1 = require("./utils/plugin_modules_path");
 const zip_1 = require("./utils/zip");
-// We use ZISI as the default bundler, except for certain extensions, for which
-// esbuild is the only option.
-const getDefaultBundler = async ({ extension, mainFile, featureFlags, }) => {
-    const { defaultEsModulesToEsbuild, traceWithNft } = featureFlags;
-    if (['.mjs', '.ts'].includes(extension)) {
-        return 'esbuild';
-    }
-    if (traceWithNft) {
-        return 'nft';
-    }
-    if (defaultEsModulesToEsbuild) {
-        const isEsModule = await (0, detect_es_module_1.detectEsModule)({ mainFile });
-        if (isEsModule) {
-            return 'esbuild';
-        }
-    }
-    return 'zisi';
-};
 // A proxy for the `getSrcFiles` function which adds a default `bundler` using
 // the `getDefaultBundler` function.
 const getSrcFilesWithBundler = async (parameters) => {
     const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
     const bundlerName = parameters.config.nodeBundler ||
-        (await getDefaultBundler({
+        (await (0, bundlers_1.getDefaultBundler)({
             extension: parameters.extension,
             featureFlags: parameters.featureFlags,
             mainFile: parameters.mainFile,
@@ -44,7 +25,7 @@ const getSrcFilesWithBundler = async (parameters) => {
 };
 const zipFunction = async function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
     const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(srcDir);
-    const bundlerName = config.nodeBundler || (await getDefaultBundler({ extension, mainFile, featureFlags }));
+    const bundlerName = config.nodeBundler || (await (0, bundlers_1.getDefaultBundler)({ extension, mainFile, featureFlags }));
     const bundler = (0, bundlers_1.getBundler)(bundlerName);
     // If the file is a zip, we assume the function is bundled and ready to go.
     // We simply copy it to the destination path with no further processing.
@@ -53,7 +34,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         await (0, cp_file_1.default)(srcPath, destPath);
         return { config, path: destPath };
     }
-    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
+    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
         basePath,
         config,
         extension,
@@ -78,6 +59,7 @@ const zipFunction = async function ({ archiveFormat, basePath, config = {}, dest
         extension,
         filename,
         mainFile: finalMainFile,
+        moduleFormat,
         rewrites,
         srcFiles,
     });

package/dist/runtimes/node/parser/exports.d.ts

@@ -1,4 +1,3 @@
 import { Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config';
-declare const getMainExport: (nodes: Statement[]) => ISCExport[];
-export { getMainExport };
+export declare const getMainExport: (nodes: Statement[]) => ISCExport[];

package/dist/runtimes/node/parser/helpers.d.ts

@@ -1,7 +1,6 @@
 import { AssignmentExpression, Expression, ExpressionStatement, ImportDeclaration, Statement } from '@babel/types';
-declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
-declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
+export declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
+export declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
     expression: AssignmentExpression;
 };
-declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;
-export { isImport, isModuleExports, isRequire };
+export declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;

package/dist/runtimes/node/parser/imports.d.ts

@@ -1,6 +1,5 @@
 import { Statement } from '@babel/types';
-declare const getImports: (node: Statement, importPath: string) => {
+export declare const getImports: (node: Statement, importPath: string) => {
     imported: string;
     local: string;
 }[];
-export { getImports };

package/dist/runtimes/node/parser/index.d.ts

@@ -1,4 +1,4 @@
-declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
+export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
     basePath: string;
     expression: string;
     resolveDir: string;
@@ -6,5 +6,4 @@ declare const parseExpression: ({ basePath, expression: rawExpression, resolveDi
     includedPathsGlob: string | null | undefined;
     type: string;
 } | undefined;
-declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;
-export { parseExpression, safelyParseFile };
+export declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;

package/dist/runtimes/node/utils/base_path.d.ts

@@ -1,2 +1 @@
-declare const getBasePath: (dirnames: string[]) => string;
-export { getBasePath };
+export declare const getBasePath: (dirnames: string[]) => string;

package/dist/runtimes/node/utils/detect_es_module.d.ts

@@ -1,4 +1,3 @@
-declare const detectEsModule: ({ mainFile }: {
+export declare const detectEsModule: ({ mainFile }: {
     mainFile: string;
 }) => Promise<boolean>;
-export { detectEsModule };

package/dist/runtimes/node/utils/detect_native_module.d.ts

@@ -1,3 +1,2 @@
 import { PackageJson } from './package_json';
-declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;
-export { isNativeModule };
+export declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;

package/dist/runtimes/node/utils/entry_file.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFormat } from './module_format';
+export interface EntryFile {
+    contents: string;
+    filename: string;
+}
+export declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
+    commonPrefix: string;
+    filename: string;
+    mainFile: string;
+    moduleFormat: ModuleFormat;
+    userNamespace: string;
+}) => EntryFile;

package/dist/runtimes/node/utils/entry_file.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryFile = void 0;
+const path_1 = require("path");
+const normalize_path_1 = require("./normalize_path");
+const getEntryFileContents = (mainPath, moduleFormat) => {
+    const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
+    if (moduleFormat === 'cjs') {
+        return `module.exports = require('${importPath}')`;
+    }
+    return `export { handler } from '${importPath}'`;
+};
+const getEntryFile = ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }) => {
+    const mainPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: mainFile, userNamespace });
+    const extension = (0, path_1.extname)(filename);
+    const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
+    const contents = getEntryFileContents(mainPath, moduleFormat);
+    return {
+        contents,
+        filename: entryFilename,
+    };
+};
+exports.getEntryFile = getEntryFile;
+//# sourceMappingURL=entry_file.js.map

package/dist/runtimes/node/utils/included_files.d.ts

@@ -1,6 +1,5 @@
-declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
-declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
+export declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
+export declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
     exclude: string[];
     paths: string[];
 }>;
-export { filterExcludedPaths, getPathsOfIncludedFiles };

package/dist/runtimes/node/utils/module.d.ts

@@ -1,2 +1 @@
-declare const getModuleName: (dependency: string) => string;
-export { getModuleName };
+export declare const getModuleName: (dependency: string) => string;

package/dist/runtimes/node/utils/module_format.d.ts

@@ -0,0 +1 @@
+export declare type ModuleFormat = 'cjs' | 'esm';

package/dist/runtimes/node/utils/module_format.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=module_format.js.map

package/dist/runtimes/node/utils/node_version.d.ts

@@ -1,6 +1,10 @@
 declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
-declare type NodeVersion = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
-declare const DEFAULT_NODE_VERSION = 14;
-declare const getNodeVersion: (configVersion?: string | undefined) => number;
-declare const parseVersion: (input: string | undefined) => number | undefined;
-export { DEFAULT_NODE_VERSION, getNodeVersion, parseVersion, NodeVersion };
+export declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+export interface NodeVersionSupport {
+    esm: boolean;
+}
+export declare const DEFAULT_NODE_VERSION = 14;
+export declare const getNodeVersion: (configVersion?: string | undefined) => number;
+export declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
+export declare const parseVersion: (input: string | undefined) => number | undefined;
+export {};