@netlify/zip-it-and-ship-it 5.4.0 → 5.5.2

package/dist/runtimes/node/index.js

@@ -1,24 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -33,7 +13,7 @@ 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 = ({ extension, mainFile, featureFlags, }) => __awaiter(void 0, void 0, void 0, function* () {
+const getDefaultBundler = async ({ extension, mainFile, featureFlags, }) => {
     const { defaultEsModulesToEsbuild, traceWithNft } = featureFlags;
     if (['.mjs', '.ts'].includes(extension)) {
         return 'esbuild';
@@ -42,100 +22,97 @@ const getDefaultBundler = ({ extension, mainFile, featureFlags, }) => __awaiter(
         return 'nft';
     }
     if (defaultEsModulesToEsbuild) {
-        const isEsModule = yield (0, detect_es_module_1.detectEsModule)({ mainFile });
+        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 = (parameters) => __awaiter(void 0, void 0, void 0, function* () {
-    const pluginsModulesPath = yield (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
+const getSrcFilesWithBundler = async (parameters) => {
+    const pluginsModulesPath = await (0, plugin_modules_path_1.getPluginsModulesPath)(parameters.srcDir);
     const bundlerName = parameters.config.nodeBundler ||
-        (yield getDefaultBundler({
+        (await getDefaultBundler({
             extension: parameters.extension,
             featureFlags: parameters.featureFlags,
             mainFile: parameters.mainFile,
         }));
     const bundler = (0, bundlers_1.getBundler)(bundlerName);
-    return bundler.getSrcFiles(Object.assign(Object.assign({}, parameters), { pluginsModulesPath }));
-});
-const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const pluginsModulesPath = yield (0, plugin_modules_path_1.getPluginsModulesPath)(srcDir);
-        const bundlerName = config.nodeBundler || (yield 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.
-        if (extension === '.zip') {
-            const destPath = (0, path_1.join)(destFolder, filename);
-            yield (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, } = yield bundler.bundle({
-            basePath,
-            config,
-            extension,
-            featureFlags,
-            filename,
-            mainFile,
-            name,
-            pluginsModulesPath,
-            repositoryRoot,
-            runtime,
-            srcDir,
-            srcPath,
-            stat,
-        });
-        const inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
-        (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
-        const zipPath = yield (0, zip_1.zipNodeJs)({
-            aliases,
-            archiveFormat,
-            basePath: finalBasePath,
-            destFolder,
-            extension,
-            filename,
-            mainFile: finalMainFile,
-            rewrites,
-            srcFiles,
-        });
-        yield (cleanupFunction === null || cleanupFunction === void 0 ? void 0 : cleanupFunction());
-        return {
-            bundler: bundlerName,
-            bundlerWarnings,
-            config,
-            inputs,
-            inSourceConfig,
-            nativeNodeModules,
-            nodeModulesWithDynamicImports,
-            path: zipPath,
-        };
+    return bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
+};
+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 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.
+    if (extension === '.zip') {
+        const destPath = (0, path_1.join)(destFolder, filename);
+        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({
+        basePath,
+        config,
+        extension,
+        featureFlags,
+        filename,
+        mainFile,
+        name,
+        pluginsModulesPath,
+        repositoryRoot,
+        runtime,
+        srcDir,
+        srcPath,
+        stat,
     });
+    const inSourceConfig = await (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
+    (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
+    const zipPath = await (0, zip_1.zipNodeJs)({
+        aliases,
+        archiveFormat,
+        basePath: finalBasePath,
+        destFolder,
+        extension,
+        filename,
+        mainFile: finalMainFile,
+        rewrites,
+        srcFiles,
+    });
+    await (cleanupFunction === null || cleanupFunction === void 0 ? void 0 : cleanupFunction());
+    return {
+        bundler: bundlerName,
+        bundlerWarnings,
+        config,
+        inputs,
+        inSourceConfig,
+        nativeNodeModules,
+        nodeModulesWithDynamicImports,
+        path: zipPath,
+    };
 };
-const zipWithFunctionWithFallback = (_a) => __awaiter(void 0, void 0, void 0, function* () {
-    var { config = {} } = _a, parameters = __rest(_a, ["config"]);
+const zipWithFunctionWithFallback = async ({ config = {}, ...parameters }) => {
     // If a specific JS bundler version is specified, we'll use it.
     if (config.nodeBundler !== 'esbuild_zisi') {
-        return zipFunction(Object.assign(Object.assign({}, parameters), { config }));
+        return zipFunction({ ...parameters, config });
     }
     // Otherwise, we'll try to bundle with esbuild and, if that fails, fallback
     // to zisi.
     try {
-        return yield zipFunction(Object.assign(Object.assign({}, parameters), { config: Object.assign(Object.assign({}, config), { nodeBundler: 'esbuild' }) }));
+        return await zipFunction({ ...parameters, config: { ...config, nodeBundler: 'esbuild' } });
     }
     catch (esbuildError) {
         try {
-            const data = yield zipFunction(Object.assign(Object.assign({}, parameters), { config: Object.assign(Object.assign({}, config), { nodeBundler: 'zisi' }) }));
-            return Object.assign(Object.assign({}, data), { bundlerErrors: esbuildError.errors });
+            const data = await zipFunction({ ...parameters, config: { ...config, nodeBundler: 'zisi' } });
+            return { ...data, bundlerErrors: esbuildError.errors };
         }
-        catch (zisiError) {
+        catch {
             throw esbuildError;
         }
     }
-});
+};
 const runtime = {
     findFunctionsInPaths: finder_1.findFunctionsInPaths,
     findFunctionInPath: finder_1.findFunctionInPath,

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

@@ -1,19 +1,10 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.safelyParseFile = exports.parseExpression = void 0;
 /* eslint-disable max-lines */
+const fs_1 = require("fs");
 const path_1 = require("path");
 const parser_1 = require("@babel/parser");
-const fs_1 = require("../../../utils/fs");
 const non_nullable_1 = require("../../../utils/non_nullable");
 const GLOB_WILDCARD = '**';
 // Transforms an array of glob nodes into a glob string including an absolute
@@ -80,34 +71,34 @@ const parseExpression = ({ basePath, expression: rawExpression, resolveDir, }) =
                 type: expression.callee.name,
             };
         }
-        catch (_) {
+        catch {
             // no-op
         }
     }
 };
 exports.parseExpression = parseExpression;
 // Parses a JS/TS file and returns the resulting AST.
-const parseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
-    const code = yield (0, fs_1.readFile)(path, 'utf8');
+const parseFile = async (path) => {
+    const code = await fs_1.promises.readFile(path, 'utf8');
     const ast = (0, parser_1.parse)(code, {
         plugins: ['typescript'],
         sourceType: 'module',
     });
     return ast.program;
-});
-// Attemps to parse a JS/TS file at the given path, returning its AST if
+};
+// Attempts to parse a JS/TS file at the given path, returning its AST if
 // successful, or `null` if not.
-const safelyParseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+const safelyParseFile = async (path) => {
     if (!path) {
         return null;
     }
     try {
-        return yield parseFile(path);
+        return await parseFile(path);
     }
-    catch (error) {
+    catch {
         return null;
     }
-});
+};
 exports.safelyParseFile = safelyParseFile;
 // Parses a `require()` and returns a glob string with an absolute path.
 const parseRequire = ({ basePath, expression, resolveDir, }) => {
@@ -121,7 +112,7 @@ const parseRequire = ({ basePath, expression, resolveDir, }) => {
             const globNodes = parseBinaryExpression(firstArg);
             return getAbsoluteGlob({ basePath, globNodes, resolveDir });
         }
-        catch (_) {
+        catch {
             // no-op
         }
     }

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

@@ -1,32 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectEsModule = void 0;
 const fs_1 = require("fs");
-const util_1 = require("util");
 const es_module_lexer_1 = require("es-module-lexer");
-const pReadFile = (0, util_1.promisify)(fs_1.readFile);
-const detectEsModule = ({ mainFile }) => __awaiter(void 0, void 0, void 0, function* () {
+const detectEsModule = async ({ mainFile }) => {
     if (!mainFile) {
         return false;
     }
     try {
-        const [mainFileContents] = yield Promise.all([pReadFile(mainFile, 'utf8'), es_module_lexer_1.init]);
+        const [mainFileContents] = await Promise.all([fs_1.promises.readFile(mainFile, 'utf8'), es_module_lexer_1.init]);
         const [imports, exports] = (0, es_module_lexer_1.parse)(mainFileContents);
         return imports.length !== 0 || exports.length !== 0;
     }
-    catch (_a) {
+    catch {
         // If there are any problems with init or parsing, assume it's not an ES module
         return false;
     }
-});
+};
 exports.detectEsModule = detectEsModule;
 //# sourceMappingURL=detect_es_module.js.map

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,7 +19,7 @@ const filterExcludedPaths = (paths, exclude = []) => {
     return excludedPaths;
 };
 exports.filterExcludedPaths = filterExcludedPaths;
-const getPathsOfIncludedFiles = (includedFiles, basePath) => __awaiter(void 0, void 0, void 0, function* () {
+const getPathsOfIncludedFiles = async (includedFiles, basePath) => {
     if (basePath === undefined) {
         return { exclude: [], paths: [] };
     }
@@ -49,12 +40,12 @@ const getPathsOfIncludedFiles = (includedFiles, basePath) => __awaiter(void 0, v
             exclude: acc.exclude,
         };
     }, { include: [], exclude: [] });
-    const pathGroups = yield Promise.all(include.map((expression) => pGlob(expression, { absolute: true, cwd: basePath, ignore: exclude, nodir: true })));
+    const pathGroups = await Promise.all(include.map((expression) => pGlob(expression, { absolute: true, cwd: basePath, ignore: exclude, nodir: true })));
     // `pathGroups` is an array containing the paths for each expression in the
     // `include` array. We flatten it into a single dimension.
     const paths = pathGroups.flat();
     const normalizedPaths = paths.map(path_1.normalize);
     return { exclude, paths: [...new Set(normalizedPaths)] };
-});
+};
 exports.getPathsOfIncludedFiles = getPathsOfIncludedFiles;
 //# sourceMappingURL=included_files.js.map

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -20,26 +11,27 @@ const sanitiseFiles = (files) => {
     }
     return files.filter((file) => typeof file === 'string');
 };
-const sanitisePackageJson = (packageJson) => (Object.assign(Object.assign({}, packageJson), { files: sanitiseFiles(packageJson.files) }));
+const sanitisePackageJson = (packageJson) => ({
+    ...packageJson,
+    files: sanitiseFiles(packageJson.files),
+});
 exports.sanitisePackageJson = sanitisePackageJson;
 // Retrieve the `package.json` of a specific project or module
-const getPackageJson = function (srcDir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const packageRoot = yield (0, pkg_dir_1.default)(srcDir);
-        if (packageRoot === undefined) {
-            return {};
-        }
-        const packageJsonPath = `${packageRoot}/package.json`;
-        try {
-            // 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(packageJsonPath);
-            return sanitisePackageJson(packageJson);
-        }
-        catch (error) {
-            throw new Error(`${packageJsonPath} is invalid JSON: ${error.message}`);
-        }
-    });
+const getPackageJson = async function (srcDir) {
+    const packageRoot = await (0, pkg_dir_1.default)(srcDir);
+    if (packageRoot === undefined) {
+        return {};
+    }
+    const packageJsonPath = `${packageRoot}/package.json`;
+    try {
+        // 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(packageJsonPath);
+        return sanitisePackageJson(packageJson);
+    }
+    catch (error) {
+        throw new Error(`${packageJsonPath} is invalid JSON: ${error.message}`);
+    }
 };
 exports.getPackageJson = getPackageJson;
 //# sourceMappingURL=package_json.js.map

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

@@ -1,24 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -26,95 +6,86 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipNodeJs = void 0;
 /* eslint-disable max-lines */
 const buffer_1 = require("buffer");
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = require("fs");
 const os_1 = __importDefault(require("os"));
 const path_1 = require("path");
-const util_1 = require("util");
 const cp_file_1 = __importDefault(require("cp-file"));
 const del_1 = __importDefault(require("del"));
-const make_dir_1 = __importDefault(require("make-dir"));
 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 pLstat = (0, util_1.promisify)(fs_1.default.lstat);
-const pWriteFile = (0, util_1.promisify)(fs_1.default.writeFile);
 // 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 = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, rewrites = new Map(), srcFiles, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { contents: entryContents, filename: entryFilename } = getEntryFile({
+const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, rewrites = new Map(), srcFiles, }) {
+    const { contents: entryContents, filename: entryFilename } = getEntryFile({
+        commonPrefix: basePath,
+        filename,
+        mainFile,
+        userNamespace: DEFAULT_USER_SUBDIRECTORY,
+    });
+    const functionFolder = (0, path_1.join)(destFolder, (0, path_1.basename)(filename, extension));
+    // Deleting the functions directory in case it exists before creating it.
+    await (0, del_1.default)(functionFolder, { force: true });
+    await fs_1.promises.mkdir(functionFolder, { recursive: true });
+    // Writing entry file.
+    await fs_1.promises.writeFile((0, path_1.join)(functionFolder, entryFilename), entryContents);
+    // Copying source files.
+    await (0, p_map_1.default)(srcFiles, (srcFile) => {
+        const destPath = aliases.get(srcFile) || srcFile;
+        const normalizedDestPath = normalizeFilePath({
             commonPrefix: basePath,
-            filename,
-            mainFile,
+            path: destPath,
             userNamespace: DEFAULT_USER_SUBDIRECTORY,
         });
-        const functionFolder = (0, path_1.join)(destFolder, (0, path_1.basename)(filename, extension));
-        // Deleting the functions directory in case it exists before creating it.
-        yield (0, del_1.default)(functionFolder, { force: true });
-        yield (0, make_dir_1.default)(functionFolder);
-        // Writing entry file.
-        yield pWriteFile((0, path_1.join)(functionFolder, entryFilename), entryContents);
-        // Copying source files.
-        yield (0, p_map_1.default)(srcFiles, (srcFile) => {
-            const destPath = aliases.get(srcFile) || srcFile;
-            const normalizedDestPath = normalizeFilePath({
-                commonPrefix: basePath,
-                path: destPath,
-                userNamespace: DEFAULT_USER_SUBDIRECTORY,
-            });
-            const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
-            if (rewrites.has(srcFile)) {
-                return (0, fs_2.mkdirAndWriteFile)(absoluteDestPath, rewrites.get(srcFile));
-            }
-            return (0, cp_file_1.default)(srcFile, absoluteDestPath);
-        }, { concurrency: COPY_FILE_CONCURRENCY });
-        return functionFolder;
-    });
-};
-const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, rewrites, srcFiles, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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`;
-        const entryFilePath = (0, path_1.resolve)(basePath, entryFilename);
-        // We don't need an entry file if it would end up with the same path as the
-        // function's main file.
-        const needsEntryFile = entryFilePath !== mainFile;
-        // There is a naming conflict with the entry file if one of the supporting
-        // files (i.e. not the main file) has the path that the entry file needs to
-        // take.
-        const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile);
-        // If there is a naming conflict, we move all user files (everything other
-        // 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 });
-            addEntryFileToZip(archive, entryFile);
+        const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
+        if (rewrites.has(srcFile)) {
+            return (0, fs_2.mkdirAndWriteFile)(absoluteDestPath, rewrites.get(srcFile));
         }
-        const srcFilesInfos = yield Promise.all(srcFiles.map(addStat));
-        // We ensure this is not async, so that the archive's checksum is
-        // deterministic. Otherwise it depends on the order the files were added.
-        srcFilesInfos.forEach(({ srcFile, stat }) => {
-            zipJsFile({
-                aliases,
-                archive,
-                commonPrefix: basePath,
-                rewrites,
-                srcFile,
-                stat,
-                userNamespace,
-            });
+        return (0, cp_file_1.default)(srcFile, absoluteDestPath);
+    }, { concurrency: COPY_FILE_CONCURRENCY });
+    return functionFolder;
+};
+const createZipArchive = async function ({ aliases, basePath, destFolder, extension, filename, mainFile, 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`;
+    const entryFilePath = (0, path_1.resolve)(basePath, entryFilename);
+    // We don't need an entry file if it would end up with the same path as the
+    // function's main file.
+    const needsEntryFile = entryFilePath !== mainFile;
+    // There is a naming conflict with the entry file if one of the supporting
+    // files (i.e. not the main file) has the path that the entry file needs to
+    // take.
+    const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile);
+    // If there is a naming conflict, we move all user files (everything other
+    // 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 });
+        addEntryFileToZip(archive, entryFile);
+    }
+    const srcFilesInfos = await Promise.all(srcFiles.map(addStat));
+    // We ensure this is not async, so that the archive's checksum is
+    // deterministic. Otherwise it depends on the order the files were added.
+    srcFilesInfos.forEach(({ srcFile, stat }) => {
+        zipJsFile({
+            aliases,
+            archive,
+            commonPrefix: basePath,
+            rewrites,
+            srcFile,
+            stat,
+            userNamespace,
         });
-        yield (0, archive_1.endZip)(archive, output);
-        return destPath;
     });
+    await (0, archive_1.endZip)(archive, output);
+    return destPath;
 };
-const zipNodeJs = function (_a) {
-    var { archiveFormat } = _a, options = __rest(_a, ["archiveFormat"]);
+const zipNodeJs = function ({ archiveFormat, ...options }) {
     if (archiveFormat === 'zip') {
         return createZipArchive(options);
     }
@@ -125,11 +96,9 @@ const addEntryFileToZip = function (archive, { contents, filename }) {
     const contentBuffer = buffer_1.Buffer.from(contents);
     (0, archive_1.addZipContent)(archive, contentBuffer, filename);
 };
-const addStat = function (srcFile) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const stat = yield pLstat(srcFile);
-        return { srcFile, stat };
-    });
+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 });