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

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import { FunctionSource } from './function';
-import type { NodeBundlerName, NodeVersion } from './runtimes/node';
+import type { NodeVersionString } from './runtimes/node';
+import type { NodeBundlerName } from './runtimes/node/bundlers';
 interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
@@ -7,7 +8,7 @@ interface FunctionConfig {
     ignoredNodeModules?: string[];
     nodeBundler?: NodeBundlerName;
     nodeSourcemap?: boolean;
-    nodeVersion?: NodeVersion;
+    nodeVersion?: NodeVersionString;
     processDynamicNodeImports?: boolean;
     rustTargetDirectory?: string;
     schedule?: string;

package/dist/feature_flags.js

@@ -8,6 +8,7 @@ const FLAGS = {
     defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
     parseWithEsbuild: false,
     traceWithNft: false,
+    zisi_pure_esm: false,
 };
 exports.defaultFlags = FLAGS;
 // List of supported flags and their default value.

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

@@ -78,6 +78,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         bundlerWarnings,
         inputs,
         mainFile: normalizedMainFile,
+        moduleFormat: 'cjs',
         nativeNodeModules,
         nodeModulesWithDynamicImports,
         srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],

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

@@ -1,8 +1,9 @@
 import type { Message } from '@netlify/esbuild';
-import type { NodeBundlerName } from '..';
 import { FunctionConfig } from '../../../config';
 import { FeatureFlag, FeatureFlags } from '../../../feature_flags';
 import { FunctionSource } from '../../../function';
+import { ModuleFormat } from '../utils/module_format';
+export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
 declare type BundlerWarning = Message;
 declare type CleanupFunction = () => Promise<void>;
 declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
@@ -20,6 +21,7 @@ declare type BundleFunction = (args: {
     cleanupFunction?: CleanupFunction;
     inputs: string[];
     mainFile: string;
+    moduleFormat: ModuleFormat;
     nativeNodeModules?: NativeNodeModules;
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
@@ -36,5 +38,10 @@ interface NodeBundler {
     getSrcFiles: GetSrcFilesFunction;
 }
 declare const getBundler: (name: NodeBundlerName) => NodeBundler;
-export { getBundler };
+declare const getDefaultBundler: ({ extension, mainFile, featureFlags, }: {
+    extension: string;
+    mainFile: string;
+    featureFlags: FeatureFlags;
+}) => Promise<NodeBundlerName>;
+export { getBundler, getDefaultBundler };
 export type { BundleFunction, GetSrcFilesFunction, NativeNodeModules };

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

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBundler = void 0;
+exports.getDefaultBundler = exports.getBundler = void 0;
+const detect_es_module_1 = require("../utils/detect_es_module");
 const esbuild_1 = __importDefault(require("./esbuild"));
 const nft_1 = __importDefault(require("./nft"));
 const zisi_1 = __importDefault(require("./zisi"));
@@ -21,4 +22,23 @@ const getBundler = (name) => {
     }
 };
 exports.getBundler = getBundler;
+// 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';
+};
+exports.getDefaultBundler = getDefaultBundler;
 //# sourceMappingURL=index.js.map

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

@@ -1,11 +1,18 @@
 import { NodeFileTraceReasons } from '@vercel/nft';
 import type { FunctionConfig } from '../../../../config';
+import { FeatureFlags } from '../../../../feature_flags';
 import { FsCache } from '../../../../utils/fs';
-declare const transpileESM: ({ basePath, config, esmPaths, fsCache, reasons, }: {
+import { ModuleFormat } from '../../utils/module_format';
+declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }: {
     basePath: string | undefined;
     config: FunctionConfig;
     esmPaths: Set<string>;
+    featureFlags: FeatureFlags;
     fsCache: FsCache;
+    mainFile: string;
     reasons: NodeFileTraceReasons;
-}) => Promise<Map<string, string>>;
-export { transpileESM };
+}) => Promise<{
+    rewrites?: Map<string, string> | undefined;
+    moduleFormat: ModuleFormat;
+}>;
+export { processESM };

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.getPackageJson)((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);
@@ -60,11 +89,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/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/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/utils/entry_file.d.ts

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

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/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 type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+interface NodeVersionSupport {
+    esm: boolean;
+}
 declare const DEFAULT_NODE_VERSION = 14;
 declare const getNodeVersion: (configVersion?: string | undefined) => number;
+declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
 declare const parseVersion: (input: string | undefined) => number | undefined;
-export { DEFAULT_NODE_VERSION, getNodeVersion, parseVersion, NodeVersion };
+export { DEFAULT_NODE_VERSION, getNodeSupportMatrix, getNodeVersion, NodeVersionString, NodeVersionSupport, parseVersion, };

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

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVersion = exports.getNodeVersion = exports.DEFAULT_NODE_VERSION = void 0;
+exports.parseVersion = exports.getNodeVersion = exports.getNodeSupportMatrix = exports.DEFAULT_NODE_VERSION = void 0;
 // Must match the default version used in Bitballoon.
 const DEFAULT_NODE_VERSION = 14;
 exports.DEFAULT_NODE_VERSION = DEFAULT_NODE_VERSION;
 const VERSION_REGEX = /(nodejs)?(\d+)\.x/;
 const getNodeVersion = (configVersion) => { var _a; return (_a = parseVersion(configVersion)) !== null && _a !== void 0 ? _a : DEFAULT_NODE_VERSION; };
 exports.getNodeVersion = getNodeVersion;
+const getNodeSupportMatrix = (configVersion) => {
+    const versionNumber = getNodeVersion(configVersion);
+    return {
+        esm: versionNumber >= 14,
+    };
+};
+exports.getNodeSupportMatrix = getNodeSupportMatrix;
 // Takes a string in the format defined by the `NodeVersion` type and returns
 // the numeric major version (e.g. "nodejs14.x" => 14).
 const parseVersion = (input) => {
@@ -24,4 +31,5 @@ const parseVersion = (input) => {
     return version;
 };
 exports.parseVersion = parseVersion;
+/* eslint-enable no-magic-numbers */
 //# sourceMappingURL=node_version.js.map

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

@@ -0,0 +1,6 @@
+declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
+    commonPrefix: string;
+    path: string;
+    userNamespace: string;
+}) => string;
+export { normalizeFilePath };

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

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFilePath = void 0;
+const path_1 = require("path");
+const unixify_1 = __importDefault(require("unixify"));
+// `adm-zip` and `require()` expect Unix paths.
+// We remove the common path prefix.
+// With files on different Windows drives, we remove the drive letter.
+const normalizeFilePath = function ({ commonPrefix, path, userNamespace, }) {
+    const userNamespacePathSegment = userNamespace ? `${userNamespace}${path_1.sep}` : '';
+    const pathA = (0, path_1.normalize)(path);
+    const pathB = pathA.replace(commonPrefix, userNamespacePathSegment);
+    const pathC = (0, unixify_1.default)(pathB);
+    return pathC;
+};
+exports.normalizeFilePath = normalizeFilePath;
+//# sourceMappingURL=normalize_path.js.map

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

@@ -1,3 +1,4 @@
+import type { ModuleFormat } from './module_format';
 declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;
@@ -6,6 +7,7 @@ interface ZipNodeParameters {
     extension: string;
     filename: string;
     mainFile: string;
+    moduleFormat: ModuleFormat;
     rewrites?: Map<string, string>;
     srcFiles: string[];
 }

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

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipNodeJs = void 0;
-/* eslint-disable max-lines */
 const buffer_1 = require("buffer");
 const fs_1 = require("fs");
 const os_1 = __importDefault(require("os"));
@@ -12,19 +11,21 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const del_1 = __importDefault(require("del"));
 const p_map_1 = __importDefault(require("p-map"));
-const unixify_1 = __importDefault(require("unixify"));
 const archive_1 = require("../../../archive");
 const fs_2 = require("../../../utils/fs");
+const entry_file_1 = require("./entry_file");
+const normalize_path_1 = require("./normalize_path");
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.default.cpus().length * 2;
 // Sub-directory to place all user-defined files  (i.e. everything other than
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
-const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, rewrites = new Map(), srcFiles, }) {
-    const { contents: entryContents, filename: entryFilename } = getEntryFile({
+const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
+    const { contents: entryContents, filename: entryFilename } = (0, entry_file_1.getEntryFile)({
         commonPrefix: basePath,
         filename,
         mainFile,
+        moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
     });
     const functionFolder = (0, path_1.join)(destFolder, (0, path_1.basename)(filename, extension));
@@ -36,7 +37,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     // Copying source files.
     await (0, p_map_1.default)(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
-        const normalizedDestPath = normalizeFilePath({
+        const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({
             commonPrefix: basePath,
             path: destPath,
             userNamespace: DEFAULT_USER_SUBDIRECTORY,
@@ -49,7 +50,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     }, { concurrency: COPY_FILE_CONCURRENCY });
     return functionFolder;
 };
-const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, rewrites, srcFiles, }) {
+const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
     const { archive, output } = (0, archive_1.startZip)(destPath);
     const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
@@ -65,7 +66,7 @@ const createZipArchive = async function ({ aliases, basePath, destFolder, extens
     // than the entry file) to its own sub-directory.
     const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
     if (needsEntryFile) {
-        const entryFile = getEntryFile({ commonPrefix: basePath, filename, mainFile, userNamespace });
+        const entryFile = (0, entry_file_1.getEntryFile)({ commonPrefix: basePath, filename, mainFile, moduleFormat, userNamespace });
         addEntryFileToZip(archive, entryFile);
     }
     const srcFilesInfos = await Promise.all(srcFiles.map(addStat));
@@ -100,18 +101,9 @@ const addStat = async function (srcFile) {
     const stat = await fs_1.promises.lstat(srcFile);
     return { srcFile, stat };
 };
-const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace, }) => {
-    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
-    const extension = (0, path_1.extname)(filename);
-    const entryFilename = `${(0, path_1.basename)(filename, extension)}.js`;
-    return {
-        contents: `module.exports = require('.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}')`,
-        filename: entryFilename,
-    };
-};
 const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrites = new Map(), stat, srcFile, userNamespace, }) {
     const destPath = aliases.get(srcFile) || srcFile;
-    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, userNamespace });
+    const normalizedDestPath = (0, normalize_path_1.normalizeFilePath)({ commonPrefix, path: destPath, userNamespace });
     if (rewrites.has(srcFile)) {
         (0, archive_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
     }
@@ -119,15 +111,4 @@ const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, rewrit
         (0, archive_1.addZipFile)(archive, srcFile, normalizedDestPath, stat);
     }
 };
-// `adm-zip` and `require()` expect Unix paths.
-// We remove the common path prefix.
-// With files on different Windows drives, we remove the drive letter.
-const normalizeFilePath = function ({ commonPrefix, path, userNamespace, }) {
-    const userNamespacePathSegment = userNamespace ? `${userNamespace}${path_1.sep}` : '';
-    const pathA = (0, path_1.normalize)(path);
-    const pathB = pathA.replace(commonPrefix, userNamespacePathSegment);
-    const pathC = (0, unixify_1.default)(pathB);
-    return pathC;
-};
-/* eslint-enable max-lines */
 //# sourceMappingURL=zip.js.map

package/dist/runtimes/runtime.d.ts

@@ -3,7 +3,7 @@ import { FunctionConfig } from '../config';
 import { FeatureFlags } from '../feature_flags';
 import { FunctionSource, SourceFile } from '../function';
 import { FsCache } from '../utils/fs';
-import type { NodeBundlerName } from './node';
+import type { NodeBundlerName } from './node/bundlers';
 import type { ISCValues } from './node/in_source_config';
 declare type RuntimeName = 'go' | 'js' | 'rs';
 declare type FindFunctionsInPathsFunction = (args: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -87,7 +87,7 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^5.1.2",
+    "@netlify/eslint-config-node": "^5.1.4",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",