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

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

@@ -1,60 +1,47 @@
 "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.getSrcFiles = void 0;
 const included_files_1 = require("../../utils/included_files");
 const package_json_1 = require("../../utils/package_json");
 const traversal_cache_1 = require("../../utils/traversal_cache");
 const traverse_1 = require("../zisi/traverse");
-const getSrcFiles = ({ config, mainFile, pluginsModulesPath, srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
+const getSrcFiles = async ({ config, mainFile, pluginsModulesPath, srcDir }) => {
     const { externalNodeModules = [], includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = yield (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
-    const dependencyPaths = yield getSrcFilesForDependencies({
+    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const dependencyPaths = await getSrcFilesForDependencies({
         dependencies: externalNodeModules,
         basedir: srcDir,
         pluginsModulesPath,
     });
     const includedPaths = (0, included_files_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
     return [...includedPaths, mainFile];
-});
+};
 exports.getSrcFiles = getSrcFiles;
-const getSrcFilesForDependencies = function ({ dependencies: dependencyNames, basedir, state = (0, traversal_cache_1.getNewCache)(), pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (dependencyNames.length === 0) {
-            return [];
-        }
-        const packageJson = yield (0, package_json_1.getPackageJson)(basedir);
-        const dependencies = yield Promise.all(dependencyNames.map((dependencyName) => getSrcFilesForDependency({
-            dependency: dependencyName,
-            basedir,
-            state,
-            packageJson,
-            pluginsModulesPath,
-        })));
-        const paths = new Set(dependencies.flat());
-        return [...paths];
-    });
+const getSrcFilesForDependencies = async function ({ dependencies: dependencyNames, basedir, state = (0, traversal_cache_1.getNewCache)(), pluginsModulesPath, }) {
+    if (dependencyNames.length === 0) {
+        return [];
+    }
+    const packageJson = await (0, package_json_1.getPackageJson)(basedir);
+    const dependencies = await Promise.all(dependencyNames.map((dependencyName) => getSrcFilesForDependency({
+        dependency: dependencyName,
+        basedir,
+        state,
+        packageJson,
+        pluginsModulesPath,
+    })));
+    const paths = new Set(dependencies.flat());
+    return [...paths];
 };
-const getSrcFilesForDependency = function ({ dependency, basedir, state = (0, traversal_cache_1.getNewCache)(), packageJson, pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const paths = yield (0, traverse_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
-            return paths;
-        }
-        catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND') {
-                return [];
-            }
-            throw error;
+const getSrcFilesForDependency = async function ({ dependency, basedir, state = (0, traversal_cache_1.getNewCache)(), packageJson, pluginsModulesPath, }) {
+    try {
+        const paths = await (0, traverse_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
+        return paths;
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            return [];
         }
-    });
+        throw error;
+    }
 };
 //# sourceMappingURL=src_files.js.map

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

@@ -1,32 +1,26 @@
 "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.transpileESM = void 0;
 const path_1 = require("path");
 const fs_1 = require("../../../../utils/fs");
 const transpile_1 = require("./transpile");
-const getPatchedESMPackages = (packages, fsCache) => __awaiter(void 0, void 0, void 0, function* () {
-    const patchedPackages = yield Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
+const getPatchedESMPackages = async (packages, fsCache) => {
+    const patchedPackages = await Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
     const patchedPackagesMap = new Map();
     packages.forEach((packagePath, index) => {
         patchedPackagesMap.set(packagePath, patchedPackages[index]);
     });
     return patchedPackagesMap;
-});
-const patchESMPackage = (path, fsCache) => __awaiter(void 0, void 0, void 0, function* () {
-    const file = (yield (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
+};
+const patchESMPackage = async (path, fsCache) => {
+    const file = (await (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
     const packageJson = JSON.parse(file);
-    const patchedPackageJson = Object.assign(Object.assign({}, packageJson), { type: 'commonjs' });
+    const patchedPackageJson = {
+        ...packageJson,
+        type: 'commonjs',
+    };
     return JSON.stringify(patchedPackageJson);
-});
+};
 const shouldTranspile = (path, cache, esmPaths, reasons) => {
     if (cache.has(path)) {
         return cache.get(path);
@@ -51,7 +45,7 @@ const shouldTranspile = (path, cache, esmPaths, reasons) => {
     cache.set(path, shouldTranspilePath);
     return shouldTranspilePath;
 };
-const transpileESM = ({ basePath, config, esmPaths, fsCache, reasons, }) => __awaiter(void 0, void 0, void 0, function* () {
+const transpileESM = async ({ basePath, config, esmPaths, fsCache, reasons, }) => {
     const cache = new Map();
     const pathsToTranspile = [...esmPaths].filter((path) => shouldTranspile(path, cache, esmPaths, reasons));
     const pathsToTranspileSet = new Set(pathsToTranspile);
@@ -64,13 +58,13 @@ const transpileESM = ({ basePath, config, esmPaths, fsCache, reasons, }) => __aw
         return needsPatch;
     })
         .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
-    const rewrites = yield getPatchedESMPackages(packageJsonPaths, fsCache);
-    yield Promise.all(pathsToTranspile.map((path) => __awaiter(void 0, void 0, void 0, function* () {
+    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 transpiled = yield (0, transpile_1.transpile)(absolutePath, config);
+        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

@@ -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 };
 };
@@ -24,10 +15,10 @@ 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 = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => __awaiter(void 0, void 0, void 0, function* () {
+const bundle = async ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = yield (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
-    const { paths: dependencyPaths, rewrites } = yield traceFilesAndTranspile({
+    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
+    const { paths: dependencyPaths, rewrites } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
         mainFile,
@@ -44,63 +35,59 @@ const bundle = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot
         rewrites,
         srcFiles,
     };
-});
+};
 const ignoreFunction = (path) => {
     const normalizedPath = (0, unixify_1.default)(path);
     const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fsCache = {};
-        const { fileList: dependencyPaths, esmFileList, reasons, } = yield (0, nft_1.nodeFileTrace)([mainFile], {
-            base: basePath,
-            ignore: ignoreFunction,
-            readFile: (path) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const source = (yield (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
-                    return source;
-                }
-                catch (error) {
-                    if (error.code === 'ENOENT' || error.code === 'EISDIR') {
-                        return null;
-                    }
-                    throw error;
-                }
-            }),
-            resolve: (specifier, parent, ...args) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return yield (0, resolve_dependency_1.default)(specifier, parent, ...args);
+const traceFilesAndTranspile = async function ({ basePath, config, mainFile, pluginsModulesPath, }) {
+    const fsCache = {};
+    const { fileList: dependencyPaths, esmFileList, reasons, } = await (0, nft_1.nodeFileTrace)([mainFile], {
+        base: basePath,
+        ignore: ignoreFunction,
+        readFile: async (path) => {
+            try {
+                const source = (await (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
+                return source;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT' || error.code === 'EISDIR') {
+                    return null;
                 }
-                catch (error) {
-                    // If we get a `MODULE_NOT_FOUND` error for what appears to be a module
-                    // name, we try to resolve it a second time using `pluginsModulesPath`
-                    // as the base directory.
-                    if (error.code === 'MODULE_NOT_FOUND' && pluginsModulesPath && appearsToBeModuleName(specifier)) {
-                        const newParent = (0, path_1.join)(pluginsModulesPath, (0, path_1.basename)(parent));
-                        return yield (0, resolve_dependency_1.default)(specifier, newParent, ...args);
-                    }
-                    throw error;
+                throw error;
+            }
+        },
+        resolve: async (specifier, parent, ...args) => {
+            try {
+                return await (0, resolve_dependency_1.default)(specifier, parent, ...args);
+            }
+            catch (error) {
+                // If we get a `MODULE_NOT_FOUND` error for what appears to be a module
+                // name, we try to resolve it a second time using `pluginsModulesPath`
+                // as the base directory.
+                if (error.code === 'MODULE_NOT_FOUND' && pluginsModulesPath && appearsToBeModuleName(specifier)) {
+                    const newParent = (0, path_1.join)(pluginsModulesPath, (0, path_1.basename)(parent));
+                    return await (0, resolve_dependency_1.default)(specifier, newParent, ...args);
                 }
-            }),
-        });
-        const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-        const rewrites = yield (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons });
-        return {
-            paths: normalizedDependencyPaths,
-            rewrites,
-        };
+                throw error;
+            }
+        },
     });
+    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 });
+    return {
+        paths: normalizedDependencyPaths,
+        rewrites,
+    };
 };
-const getSrcFiles = function ({ basePath, config, mainFile }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { includedFiles = [], includedFilesBasePath } = config;
-        const { exclude: excludedPaths, paths: includedFilePaths } = yield (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
-        const { fileList: dependencyPaths } = yield (0, nft_1.nodeFileTrace)([mainFile], { base: basePath, ignore: ignoreFunction });
-        const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-        const includedPaths = (0, included_files_1.filterExcludedPaths)([...normalizedDependencyPaths, ...includedFilePaths], excludedPaths);
-        return includedPaths;
-    });
+const getSrcFiles = async function ({ basePath, config, mainFile }) {
+    const { includedFiles = [], includedFilesBasePath } = config;
+    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const { fileList: dependencyPaths } = await (0, nft_1.nodeFileTrace)([mainFile], { base: basePath, ignore: ignoreFunction });
+    const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
+    const includedPaths = (0, included_files_1.filterExcludedPaths)([...normalizedDependencyPaths, ...includedFilePaths], excludedPaths);
+    return includedPaths;
 };
 const bundler = { bundle, getSrcFiles };
 exports.default = bundler;

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

@@ -1,22 +1,13 @@
 "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.transpile = void 0;
 const esbuild_1 = require("@netlify/esbuild");
 const bundler_target_1 = require("../esbuild/bundler_target");
-const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function* () {
+const transpile = async (path, config) => {
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = (0, bundler_target_1.getBundlerTarget)(config.nodeVersion);
-    const transpiled = yield (0, esbuild_1.build)({
+    const transpiled = await (0, esbuild_1.build)({
         bundle: false,
         entryPoints: [path],
         format: 'cjs',
@@ -27,6 +18,6 @@ const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function*
         write: false,
     });
     return transpiled.outputFiles[0].text;
-});
+};
 exports.transpile = transpile;
 //# sourceMappingURL=transpile.js.map

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

@@ -1,21 +1,15 @@
 "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 });
 const path_1 = require("path");
 const base_path_1 = require("../../utils/base_path");
 const src_files_1 = require("./src_files");
-const bundle = ({ basePath, config, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, runtime, srcDir, srcPath, stat, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const srcFiles = yield (0, src_files_1.getSrcFiles)({
+const bundle = async ({ basePath, config, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, runtime, srcDir, srcPath, stat, }) => {
+    const srcFiles = await (0, src_files_1.getSrcFiles)({
         basePath,
-        config: Object.assign(Object.assign({}, config), { includedFilesBasePath: config.includedFilesBasePath || basePath }),
+        config: {
+            ...config,
+            includedFilesBasePath: config.includedFilesBasePath || basePath,
+        },
         extension,
         featureFlags,
         filename,
@@ -34,7 +28,7 @@ const bundle = ({ basePath, config, extension, featureFlags, filename, mainFile,
         mainFile,
         srcFiles,
     };
-});
+};
 const bundler = { bundle, getSrcFiles: src_files_1.getSrcFiles };
 exports.default = bundler;
 //# sourceMappingURL=index.js.map

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

@@ -18,15 +18,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 };
 };
@@ -56,17 +47,17 @@ const getListImportsPlugin = ({ imports, path }) => ({
         });
     },
 });
-const listImports = ({ functionName, path }) => __awaiter(void 0, void 0, void 0, function* () {
+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
     // will pipe the output to stdout, which we also don't want. So we create
     // a temporary file to serve as the esbuild output and then get rid of it
     // when we're done.
-    const targetPath = yield (0, tmp_promise_1.tmpName)();
+    const targetPath = await (0, tmp_promise_1.tmpName)();
     const imports = new Set();
     try {
-        yield esbuild.build({
+        await esbuild.build({
             bundle: true,
             entryPoints: [path],
             logLevel: 'error',
@@ -87,9 +78,9 @@ const listImports = ({ functionName, path }) => __awaiter(void 0, void 0, void 0
         throw error;
     }
     finally {
-        yield (0, fs_1.safeUnlink)(targetPath);
+        await (0, fs_1.safeUnlink)(targetPath);
     }
     return [...imports];
-});
+};
 exports.listImports = listImports;
 //# sourceMappingURL=list_imports.js.map

package/dist/runtimes/node/bundlers/zisi/published.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 };
 };
@@ -17,17 +8,15 @@ const util_1 = require("util");
 const glob_1 = __importDefault(require("glob"));
 const pGlob = (0, util_1.promisify)(glob_1.default);
 // We use all the files published by the Node.js except some that are not needed
-const getPublishedFiles = function (modulePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const ignore = getIgnoredFiles(modulePath);
-        const publishedFiles = yield pGlob(`${modulePath}/**`, {
-            ignore,
-            nodir: true,
-            absolute: true,
-            dot: true,
-        });
-        return publishedFiles;
+const getPublishedFiles = async function (modulePath) {
+    const ignore = getIgnoredFiles(modulePath);
+    const publishedFiles = await pGlob(`${modulePath}/**`, {
+        ignore,
+        nodir: true,
+        absolute: true,
+        dot: true,
     });
+    return publishedFiles;
 };
 exports.getPublishedFiles = getPublishedFiles;
 const getIgnoredFiles = function (modulePath) {

package/dist/runtimes/node/bundlers/zisi/resolve.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 };
 };
@@ -26,30 +17,28 @@ const BACKSLASH_REGEXP = /\\/g;
 //     - this is important because if a file does a `require('./symlink')`, we
 //       need to bundle the symlink and its target, not only the target
 //     - `path.resolve()` cannot be used for relative|absolute file paths
-//       because it does not resolve ommitted file extension,
+//       because it does not resolve omitted file extension,
 //       e.g. `require('./file')` instead of `require('./file.js')`
 //     - the CLI flag `--preserve-symlinks` can be used with Node.js, but it
 //       cannot be set runtime
 // However it does not give helpful error messages.
 //   https://github.com/browserify/resolve/issues/223
 // So, on errors, we fallback to `require.resolve()`
-const resolvePackage = function (moduleName, baseDirs) {
-    return __awaiter(this, void 0, void 0, function* () {
+const resolvePackage = async function (moduleName, baseDirs) {
+    try {
+        return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
+    }
+    catch (error) {
+        if ((0, semver_1.lt)(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
+            throw error;
+        }
         try {
-            return yield resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
+            return resolvePathFollowSymlinks(`${moduleName}/package.json`, baseDirs);
         }
-        catch (error) {
-            if ((0, semver_1.lt)(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {
-                throw error;
-            }
-            try {
-                return resolvePathFollowSymlinks(`${moduleName}/package.json`, baseDirs);
-            }
-            catch (error_) {
-                return yield resolvePackageFallback(moduleName, baseDirs, error_);
-            }
+        catch (error_) {
+            return await resolvePackageFallback(moduleName, baseDirs, error_);
         }
-    });
+    }
 };
 exports.resolvePackage = resolvePackage;
 // TODO: remove after dropping support for Node <8.9.0
@@ -72,20 +61,17 @@ const resolvePathPreserveSymlinksForDir = function (path, basedir) {
 // the resolve library has a `paths` option but it's not the same as multiple basedirs
 // see https://github.com/browserify/resolve/issues/188#issuecomment-679010477
 // we return the first resolved location or the first error if all failed
-const resolvePathPreserveSymlinks = function (path, baseDirs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let firstError;
-        for (const basedir of baseDirs) {
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                return yield resolvePathPreserveSymlinksForDir(path, basedir);
-            }
-            catch (error) {
-                firstError = firstError || error;
-            }
+const resolvePathPreserveSymlinks = async function (path, baseDirs) {
+    let firstError;
+    for (const basedir of baseDirs) {
+        try {
+            return await resolvePathPreserveSymlinksForDir(path, basedir);
         }
-        throw firstError;
-    });
+        catch (error) {
+            firstError = firstError || error;
+        }
+    }
+    throw firstError;
 };
 exports.resolvePathPreserveSymlinks = resolvePathPreserveSymlinks;
 const resolvePathFollowSymlinks = function (path, baseDirs) {
@@ -99,24 +85,20 @@ const resolvePathFollowSymlinks = function (path, baseDirs) {
 //   - has a `package.json`
 // Theoretically, this might not the root `package.json`, but this is very
 // unlikely, and we don't have any better alternative.
-const resolvePackageFallback = function (moduleName, baseDirs, error) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const mainFilePath = resolvePathFollowSymlinks(moduleName, baseDirs);
-        const packagePath = yield (0, find_up_1.default)(isPackageDir.bind(null, moduleName), { cwd: mainFilePath, type: 'directory' });
-        if (packagePath === undefined) {
-            throw error;
-        }
-        return packagePath;
-    });
+const resolvePackageFallback = async function (moduleName, baseDirs, error) {
+    const mainFilePath = resolvePathFollowSymlinks(moduleName, baseDirs);
+    const packagePath = await (0, find_up_1.default)(isPackageDir.bind(null, moduleName), { cwd: mainFilePath, type: 'directory' });
+    if (packagePath === undefined) {
+        throw error;
+    }
+    return packagePath;
 };
-const isPackageDir = function (moduleName, dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Need to use `endsWith()` to take into account `@scope/package`.
-        // Backslashes need to be converted for Windows.
-        if (!dir.replace(BACKSLASH_REGEXP, '/').endsWith(moduleName) || !(yield (0, path_exists_1.default)(`${dir}/package.json`))) {
-            return;
-        }
-        return dir;
-    });
+const isPackageDir = async function (moduleName, dir) {
+    // Need to use `endsWith()` to take into account `@scope/package`.
+    // Backslashes need to be converted for Windows.
+    if (!dir.replace(BACKSLASH_REGEXP, '/').endsWith(moduleName) || !(await (0, path_exists_1.default)(`${dir}/package.json`))) {
+        return;
+    }
+    return dir;
 };
 //# sourceMappingURL=resolve.js.map

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

@@ -1,26 +1,15 @@
 "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.getSideFiles = void 0;
 const published_1 = require("./published");
 // Some modules generate source files on `postinstall` that are not located
 // inside the module's directory itself.
-const getSideFiles = function (modulePath, moduleName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const sideFiles = SIDE_FILES[moduleName];
-        if (sideFiles === undefined) {
-            return [];
-        }
-        return yield (0, published_1.getPublishedFiles)(`${modulePath}/${sideFiles}`);
-    });
+const getSideFiles = async function (modulePath, moduleName) {
+    const sideFiles = SIDE_FILES[moduleName];
+    if (sideFiles === undefined) {
+        return [];
+    }
+    return await (0, published_1.getPublishedFiles)(`${modulePath}/${sideFiles}`);
 };
 exports.getSideFiles = getSideFiles;
 const SIDE_FILES = {