@netlify/zip-it-and-ship-it 5.3.0 → 5.4.1

package/dist/runtimes/node/bundlers/zisi/src_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 };
 };
@@ -29,22 +20,20 @@ const tree_shake_1 = require("./tree_shake");
 // Retrieve the paths to the Node.js files to zip.
 // We only include the files actually needed by the function because AWS Lambda
 // has a size limit for the zipped file. It also makes cold starts faster.
-const getSrcFiles = function ({ config, featureFlags, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) {
-    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 [treeFiles, depFiles] = yield Promise.all([
-            (0, tree_files_1.getTreeFiles)(srcPath, stat),
-            getDependencies({ featureFlags, functionName: name, mainFile, pluginsModulesPath, srcDir }),
-        ]);
-        const files = [...treeFiles, ...depFiles].map(path_1.normalize);
-        const uniqueFiles = [...new Set(files)];
-        // We sort so that the archive's checksum is deterministic.
-        // Mutating is fine since `Array.filter()` returns a shallow copy
-        const filteredFiles = uniqueFiles.filter(isNotJunk).sort();
-        const includedPaths = (0, included_files_1.filterExcludedPaths)([...filteredFiles, ...includedFilePaths], excludedPaths);
-        return includedPaths;
-    });
+const getSrcFiles = async function ({ config, featureFlags, mainFile, name, pluginsModulesPath, srcDir, srcPath, stat, }) {
+    const { includedFiles = [], includedFilesBasePath } = config;
+    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
+    const [treeFiles, depFiles] = await Promise.all([
+        (0, tree_files_1.getTreeFiles)(srcPath, stat),
+        getDependencies({ featureFlags, functionName: name, mainFile, pluginsModulesPath, srcDir }),
+    ]);
+    const files = [...treeFiles, ...depFiles].map(path_1.normalize);
+    const uniqueFiles = [...new Set(files)];
+    // We sort so that the archive's checksum is deterministic.
+    // Mutating is fine since `Array.filter()` returns a shallow copy
+    const filteredFiles = uniqueFiles.filter(isNotJunk).sort();
+    const includedPaths = (0, included_files_1.filterExcludedPaths)([...filteredFiles, ...includedFilePaths], excludedPaths);
+    return includedPaths;
 };
 exports.getSrcFiles = getSrcFiles;
 // Remove temporary files like *~, *.swp, etc.
@@ -52,48 +41,44 @@ const isNotJunk = function (file) {
     return (0, junk_1.not)((0, path_1.basename)(file));
 };
 // Retrieve all the files recursively required by a Node.js file
-const getDependencies = function ({ featureFlags, functionName, mainFile, pluginsModulesPath, srcDir, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const packageJson = yield (0, package_json_1.getPackageJson)(srcDir);
-        const state = (0, traversal_cache_1.getNewCache)();
-        try {
-            return yield getFileDependencies({
-                featureFlags,
-                functionName,
-                path: mainFile,
-                packageJson,
-                pluginsModulesPath,
-                state,
-            });
-        }
-        catch (error) {
-            error.message = `In file "${mainFile}"\n${error.message}`;
-            throw error;
-        }
-    });
-};
-const getFileDependencies = function ({ featureFlags, functionName, path, packageJson, pluginsModulesPath, state, treeShakeNext = false, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (state.localFiles.has(path)) {
-            return [];
-        }
-        state.localFiles.add(path);
-        const basedir = (0, path_1.dirname)(path);
-        const dependencies = featureFlags.parseWithEsbuild
-            ? yield (0, list_imports_1.listImports)({ functionName, path })
-            : yield precinct_1.default.paperwork(path, { includeCore: false });
-        const depsPaths = yield Promise.all(dependencies.filter(non_nullable_1.nonNullable).map((dependency) => getImportDependencies({
-            dependency,
-            basedir,
+const getDependencies = async function ({ featureFlags, functionName, mainFile, pluginsModulesPath, srcDir, }) {
+    const packageJson = await (0, package_json_1.getPackageJson)(srcDir);
+    const state = (0, traversal_cache_1.getNewCache)();
+    try {
+        return await getFileDependencies({
             featureFlags,
             functionName,
+            path: mainFile,
             packageJson,
             pluginsModulesPath,
             state,
-            treeShakeNext,
-        })));
-        return depsPaths.flat();
-    });
+        });
+    }
+    catch (error) {
+        error.message = `In file "${mainFile}"\n${error.message}`;
+        throw error;
+    }
+};
+const getFileDependencies = async function ({ featureFlags, functionName, path, packageJson, pluginsModulesPath, state, treeShakeNext = false, }) {
+    if (state.localFiles.has(path)) {
+        return [];
+    }
+    state.localFiles.add(path);
+    const basedir = (0, path_1.dirname)(path);
+    const dependencies = featureFlags.parseWithEsbuild
+        ? await (0, list_imports_1.listImports)({ functionName, path })
+        : await precinct_1.default.paperwork(path, { includeCore: false });
+    const depsPaths = await Promise.all(dependencies.filter(non_nullable_1.nonNullable).map((dependency) => getImportDependencies({
+        dependency,
+        basedir,
+        featureFlags,
+        functionName,
+        packageJson,
+        pluginsModulesPath,
+        state,
+        treeShakeNext,
+    })));
+    return depsPaths.flat();
 };
 const getImportDependencies = function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
     const shouldTreeShakeNext = treeShakeNext || isNextOnNetlify(dependency);
@@ -115,20 +100,18 @@ const isNextOnNetlify = function (dependency) {
     return (0, path_1.basename)(dependency, '.js') === 'renderNextPage';
 };
 // When a file requires another one, we apply the top-level logic recursively
-const getTreeShakedDependencies = function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const path = yield (0, resolve_1.resolvePathPreserveSymlinks)(dependency, [basedir, pluginsModulesPath].filter(non_nullable_1.nonNullable));
-        const depsPath = yield getFileDependencies({
-            featureFlags,
-            functionName,
-            path,
-            packageJson,
-            pluginsModulesPath,
-            state,
-            treeShakeNext,
-        });
-        return [path, ...depsPath];
+const getTreeShakedDependencies = async function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
+    const path = await (0, resolve_1.resolvePathPreserveSymlinks)(dependency, [basedir, pluginsModulesPath].filter(non_nullable_1.nonNullable));
+    const depsPath = await getFileDependencies({
+        featureFlags,
+        functionName,
+        path,
+        packageJson,
+        pluginsModulesPath,
+        state,
+        treeShakeNext,
     });
+    return [path, ...depsPath];
 };
 /* eslint-enable max-lines */
 //# sourceMappingURL=src_files.js.map

package/dist/runtimes/node/bundlers/zisi/traverse.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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependencyPathsForDependency = void 0;
 const path_1 = require("path");
@@ -20,58 +11,52 @@ const side_files_1 = require("./side_files");
 const EXCLUDED_MODULES = new Set(['aws-sdk']);
 // When a file requires a module, we find its path inside `node_modules` and
 // use all its published files. We also recurse on the module's dependencies.
-const getDependencyPathsForDependency = function ({ dependency, basedir, state, packageJson, pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const moduleName = (0, module_1.getModuleName)(dependency);
-        // Happens when doing require("@scope") (not "@scope/name") or other oddities
-        // Ignore those.
-        if (moduleName === null) {
-            return [];
-        }
-        try {
-            return yield getDependenciesForModuleName({ moduleName, basedir, state, pluginsModulesPath });
-        }
-        catch (error) {
-            return (0, nested_1.handleModuleNotFound)({ error, moduleName, packageJson });
-        }
-    });
+const getDependencyPathsForDependency = async function ({ dependency, basedir, state, packageJson, pluginsModulesPath, }) {
+    const moduleName = (0, module_1.getModuleName)(dependency);
+    // Happens when doing require("@scope") (not "@scope/name") or other oddities
+    // Ignore those.
+    if (moduleName === null) {
+        return [];
+    }
+    try {
+        return await getDependenciesForModuleName({ moduleName, basedir, state, pluginsModulesPath });
+    }
+    catch (error) {
+        return (0, nested_1.handleModuleNotFound)({ error, moduleName, packageJson });
+    }
 };
 exports.getDependencyPathsForDependency = getDependencyPathsForDependency;
-const getDependenciesForModuleName = function ({ moduleName, basedir, state, pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (isExcludedModule(moduleName)) {
-            return [];
-        }
-        // Find the Node.js module directory path
-        const packagePath = yield (0, resolve_1.resolvePackage)(moduleName, [basedir, pluginsModulesPath].filter(non_nullable_1.nonNullable));
-        if (packagePath === undefined) {
-            return [];
-        }
-        const modulePath = (0, path_1.dirname)(packagePath);
-        if (state.modulePaths.has(modulePath)) {
-            return [];
-        }
-        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 [publishedFiles, sideFiles, depsPaths] = yield Promise.all([
-            (0, published_1.getPublishedFiles)(modulePath),
-            (0, side_files_1.getSideFiles)(modulePath, moduleName),
-            getNestedModules({ modulePath, state, packageJson, pluginsModulesPath }),
-        ]);
-        return [...publishedFiles, ...sideFiles, ...depsPaths];
-    });
+const getDependenciesForModuleName = async function ({ moduleName, basedir, state, pluginsModulesPath, }) {
+    if (isExcludedModule(moduleName)) {
+        return [];
+    }
+    // Find the Node.js module directory path
+    const packagePath = await (0, resolve_1.resolvePackage)(moduleName, [basedir, pluginsModulesPath].filter(non_nullable_1.nonNullable));
+    if (packagePath === undefined) {
+        return [];
+    }
+    const modulePath = (0, path_1.dirname)(packagePath);
+    if (state.modulePaths.has(modulePath)) {
+        return [];
+    }
+    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 [publishedFiles, sideFiles, depsPaths] = await Promise.all([
+        (0, published_1.getPublishedFiles)(modulePath),
+        (0, side_files_1.getSideFiles)(modulePath, moduleName),
+        getNestedModules({ modulePath, state, packageJson, pluginsModulesPath }),
+    ]);
+    return [...publishedFiles, ...sideFiles, ...depsPaths];
 };
 const isExcludedModule = function (moduleName) {
     return EXCLUDED_MODULES.has(moduleName) || moduleName.startsWith('@types/');
 };
-const getNestedModules = function ({ modulePath, state, packageJson, pluginsModulesPath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const dependencies = (0, nested_1.getNestedDependencies)(packageJson);
-        const depsPaths = yield Promise.all(dependencies.map((dependency) => getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
-        return depsPaths.flat();
-    });
+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 })));
+    return depsPaths.flat();
 };
 //# sourceMappingURL=traverse.js.map

package/dist/runtimes/node/bundlers/zisi/tree_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 };
 };
@@ -17,16 +8,14 @@ const util_1 = require("util");
 const glob_1 = __importDefault(require("glob"));
 const pGlob = (0, util_1.promisify)(glob_1.default);
 // When using a directory, we include all its descendants except `node_modules`
-const getTreeFiles = function (srcPath, stat) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!stat.isDirectory()) {
-            return [srcPath];
-        }
-        return yield pGlob(`${srcPath}/**`, {
-            ignore: `${srcPath}/**/node_modules/**`,
-            nodir: true,
-            absolute: true,
-        });
+const getTreeFiles = async function (srcPath, stat) {
+    if (!stat.isDirectory()) {
+        return [srcPath];
+    }
+    return await pGlob(`${srcPath}/**`, {
+        ignore: `${srcPath}/**/node_modules/**`,
+        nodir: true,
+        absolute: true,
     });
 };
 exports.getTreeFiles = getTreeFiles;

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

@@ -1,6 +1,4 @@
-import { SourceFile } from '../../function';
-declare const findFunctionsInPaths: ({ paths }: {
-    paths: string[];
-}) => Promise<SourceFile[]>;
-declare const getFunctionAtPath: (srcPath: string) => Promise<SourceFile | undefined>;
-export { findFunctionsInPaths, getFunctionAtPath };
+import { FindFunctionsInPathsFunction, FindFunctionInPathFunction } from '../runtime';
+declare const findFunctionsInPaths: FindFunctionsInPathsFunction;
+declare const findFunctionInPath: FindFunctionInPathFunction;
+export { findFunctionsInPaths, findFunctionInPath };

package/dist/runtimes/node/finder.js

@@ -1,24 +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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionAtPath = exports.findFunctionsInPaths = void 0;
+exports.findFunctionInPath = exports.findFunctionsInPaths = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const util_1 = require("util");
 const locate_path_1 = __importDefault(require("locate-path"));
 const non_nullable_1 = require("../../utils/non_nullable");
-const pLstat = (0, util_1.promisify)(fs_1.lstat);
 // List of extensions that this runtime will look for, in order of precedence.
 const allowedExtensions = ['.js', '.zip', '.cjs', '.mjs', '.ts'];
 // Sorting function, compatible with the callback of Array.sort, which sorts
@@ -30,64 +19,58 @@ const sortByExtension = (fA, fB) => {
     const indexB = allowedExtensions.indexOf(fB.extension);
     return indexB - indexA;
 };
-const findFunctionsInPaths = function ({ paths }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map(getFunctionAtPath));
-        // 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
-            // that `{name}/{name}.js` takes precedence over `{name}.js`.
-            const directorySort = Number(fA.stat.isDirectory()) - Number(fB.stat.isDirectory());
-            if (directorySort !== 0) {
-                return directorySort;
-            }
-            // If the functions have the same name, we sort them according to the order
-            // defined in `allowedExtensions`.
-            if (fA.name === fB.name) {
-                return sortByExtension(fA, fB);
-            }
-            return 0;
-        });
-        return sortedFunctions;
-    });
-};
-exports.findFunctionsInPaths = findFunctionsInPaths;
-const getFunctionAtPath = function (srcPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const filename = (0, path_1.basename)(srcPath);
-        if (filename === 'node_modules') {
-            return;
+const findFunctionsInPaths = async function ({ paths, fsCache, featureFlags }) {
+    const functions = await Promise.all(paths.map((path) => 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
+        // that `{name}/{name}.js` takes precedence over `{name}.js`.
+        const directorySort = Number(fA.stat.isDirectory()) - Number(fB.stat.isDirectory());
+        if (directorySort !== 0) {
+            return directorySort;
         }
-        const stat = yield pLstat(srcPath);
-        const mainFile = yield getMainFile(srcPath, filename, stat);
-        if (mainFile === undefined) {
-            return;
+        // If the functions have the same name, we sort them according to the order
+        // defined in `allowedExtensions`.
+        if (fA.name === fB.name) {
+            return sortByExtension(fA, fB);
         }
-        const extension = (0, path_1.extname)(srcPath);
-        const srcDir = stat.isDirectory() ? srcPath : (0, path_1.dirname)(srcPath);
-        const name = (0, path_1.basename)(srcPath, (0, path_1.extname)(srcPath));
-        return { extension, filename, mainFile, name, srcDir, srcPath, stat };
+        return 0;
     });
+    return sortedFunctions;
 };
-exports.getFunctionAtPath = getFunctionAtPath;
+exports.findFunctionsInPaths = findFunctionsInPaths;
+const findFunctionInPath = async function ({ path: srcPath }) {
+    const filename = (0, path_1.basename)(srcPath);
+    if (filename === 'node_modules') {
+        return;
+    }
+    const stat = await fs_1.promises.lstat(srcPath);
+    const mainFile = await getMainFile(srcPath, filename, stat);
+    if (mainFile === undefined) {
+        return;
+    }
+    const extension = (0, path_1.extname)(srcPath);
+    const srcDir = stat.isDirectory() ? srcPath : (0, path_1.dirname)(srcPath);
+    const name = (0, path_1.basename)(srcPath, (0, path_1.extname)(srcPath));
+    return { extension, filename, mainFile, name, srcDir, srcPath, stat };
+};
+exports.findFunctionInPath = findFunctionInPath;
 // Each `srcPath` can also be a directory with an `index` file or a file using
 // the same filename as its directory.
-const getMainFile = function (srcPath, filename, stat) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (stat.isDirectory()) {
-            return yield (0, locate_path_1.default)([
-                (0, path_1.join)(srcPath, `${filename}.js`),
-                (0, path_1.join)(srcPath, 'index.js'),
-                (0, path_1.join)(srcPath, `${filename}.mjs`),
-                (0, path_1.join)(srcPath, 'index.mjs'),
-                (0, path_1.join)(srcPath, `${filename}.ts`),
-                (0, path_1.join)(srcPath, 'index.ts'),
-            ], { type: 'file' });
-        }
-        const extension = (0, path_1.extname)(srcPath);
-        if (allowedExtensions.includes(extension)) {
-            return srcPath;
-        }
-    });
+const getMainFile = async function (srcPath, filename, stat) {
+    if (stat.isDirectory()) {
+        return await (0, locate_path_1.default)([
+            (0, path_1.join)(srcPath, `${filename}.js`),
+            (0, path_1.join)(srcPath, 'index.js'),
+            (0, path_1.join)(srcPath, `${filename}.mjs`),
+            (0, path_1.join)(srcPath, 'index.mjs'),
+            (0, path_1.join)(srcPath, `${filename}.ts`),
+            (0, path_1.join)(srcPath, 'index.ts'),
+        ], { type: 'file' });
+    }
+    const extension = (0, path_1.extname)(srcPath);
+    if (allowedExtensions.includes(extension)) {
+        return srcPath;
+    }
 };
 //# sourceMappingURL=finder.js.map

package/dist/runtimes/node/in_source_config/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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPath = void 0;
 const non_nullable_1 = require("../../../utils/non_nullable");
@@ -20,12 +11,12 @@ exports.IN_SOURCE_CONFIG_MODULE = IN_SOURCE_CONFIG_MODULE;
 // 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.
-const findISCDeclarationsInPath = (sourcePath) => __awaiter(void 0, void 0, void 0, function* () {
-    const ast = yield (0, parser_1.safelyParseFile)(sourcePath);
+const findISCDeclarationsInPath = async (sourcePath) => {
+    const ast = await (0, parser_1.safelyParseFile)(sourcePath);
     if (ast === null) {
         return {};
     }
-    const imports = ast.body.map((node) => (0, imports_1.getImports)(node, IN_SOURCE_CONFIG_MODULE)).flat();
+    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
         .map(({ args, local: exportName }) => {
@@ -42,8 +33,8 @@ const findISCDeclarationsInPath = (sourcePath) => __awaiter(void 0, void 0, void
         return null;
     })
         .filter(non_nullable_1.nonNullable);
-    const mergedExports = iscExports.reduce((acc, obj) => (Object.assign(Object.assign({}, acc), obj)), {});
+    const mergedExports = iscExports.reduce((acc, obj) => ({ ...acc, ...obj }), {});
     return mergedExports;
-});
+};
 exports.findISCDeclarationsInPath = findISCDeclarationsInPath;
 //# sourceMappingURL=index.js.map