@netlify/zip-it-and-ship-it 5.7.2 → 5.8.0

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

@@ -5,19 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const nft_1 = require("@vercel/nft");
-const resolve_dependency_1 = __importDefault(require("@vercel/nft/out/resolve-dependency"));
+const resolve_dependency_js_1 = __importDefault(require("@vercel/nft/out/resolve-dependency.js"));
 const minimatch_1 = __importDefault(require("minimatch"));
 const unixify_1 = __importDefault(require("unixify"));
-const fs_1 = require("../../../../utils/fs");
-const base_path_1 = require("../../utils/base_path");
-const included_files_1 = require("../../utils/included_files");
-const es_modules_1 = require("./es_modules");
+const fs_js_1 = require("../../../../utils/fs.js");
+const base_path_js_1 = require("../../utils/base_path.js");
+const included_files_js_1 = require("../../utils/included_files.js");
+const es_modules_js_1 = require("./es_modules.js");
 // 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, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
-    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
+    const { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
     const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
@@ -25,12 +25,12 @@ const bundle = async ({ basePath, config, featureFlags, mainFile, pluginsModules
         mainFile,
         pluginsModulesPath,
     });
-    const filteredIncludedPaths = (0, included_files_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
+    const filteredIncludedPaths = (0, included_files_js_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
     const dirnames = filteredIncludedPaths.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath))).sort();
     // Sorting the array to make the checksum deterministic.
     const srcFiles = [...filteredIncludedPaths].sort();
     return {
-        basePath: (0, base_path_1.getBasePath)(dirnames),
+        basePath: (0, base_path_js_1.getBasePath)(dirnames),
         inputs: dependencyPaths,
         mainFile,
         moduleFormat,
@@ -50,7 +50,7 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
         ignore: ignoreFunction,
         readFile: async (path) => {
             try {
-                const source = (await (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
+                const source = (await (0, fs_js_1.cachedReadFile)(fsCache, path, 'utf8'));
                 return source;
             }
             catch (error) {
@@ -62,7 +62,7 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
         },
         resolve: async (specifier, parent, ...args) => {
             try {
-                return await (0, resolve_dependency_1.default)(specifier, parent, ...args);
+                return await (0, resolve_dependency_js_1.default)(specifier, parent, ...args);
             }
             catch (error) {
                 // If we get a `MODULE_NOT_FOUND` error for what appears to be a module
@@ -70,14 +70,14 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
                 // 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);
+                    return await (0, resolve_dependency_js_1.default)(specifier, newParent, ...args);
                 }
                 throw error;
             }
         },
     });
     const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-    const { moduleFormat, rewrites } = await (0, es_modules_1.processESM)({
+    const { moduleFormat, rewrites } = await (0, es_modules_js_1.processESM)({
         basePath,
         config,
         esmPaths: esmFileList,
@@ -94,10 +94,10 @@ const traceFilesAndTranspile = async function ({ basePath, config, featureFlags,
 };
 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 { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_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);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...normalizedDependencyPaths, ...includedFilePaths], excludedPaths);
     return includedPaths;
 };
 const bundler = { bundle, getSrcFiles };

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

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

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

@@ -2,11 +2,11 @@
 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 bundler_target_js_1 = require("../esbuild/bundler_target.js");
 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 nodeTarget = (0, bundler_target_js_1.getBundlerTarget)(config.nodeVersion);
     const transpiled = await (0, esbuild_1.build)({
         bundle: false,
         entryPoints: [path],

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

@@ -1,6 +1,6 @@
-import type { BundleFunction } from '..';
+import type { BundleFunction } from '../index.js';
 declare const bundler: {
     bundle: BundleFunction;
-    getSrcFiles: import("..").GetSrcFilesFunction;
+    getSrcFiles: import("../index.js").GetSrcFilesFunction;
 };
 export default bundler;

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

@@ -1,10 +1,10 @@
 "use strict";
 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 base_path_js_1 = require("../../utils/base_path.js");
+const src_files_js_1 = require("./src_files.js");
 const bundle = async ({ basePath, config, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, runtime, srcDir, srcPath, stat, }) => {
-    const srcFiles = await (0, src_files_1.getSrcFiles)({
+    const srcFiles = await (0, src_files_js_1.getSrcFiles)({
         basePath,
         config: {
             ...config,
@@ -23,13 +23,13 @@ const bundle = async ({ basePath, config, extension, featureFlags, filename, mai
     });
     const dirnames = srcFiles.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath)));
     return {
-        basePath: (0, base_path_1.getBasePath)(dirnames),
+        basePath: (0, base_path_js_1.getBasePath)(dirnames),
         inputs: srcFiles,
         mainFile,
         moduleFormat: 'cjs',
         srcFiles,
     };
 };
-const bundler = { bundle, getSrcFiles: src_files_1.getSrcFiles };
+const bundler = { bundle, getSrcFiles: src_files_js_1.getSrcFiles };
 exports.default = bundler;
 //# sourceMappingURL=index.js.map

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

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

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

@@ -30,7 +30,7 @@ exports.listImports = void 0;
 const esbuild = __importStar(require("@netlify/esbuild"));
 const is_builtin_module_1 = __importDefault(require("is-builtin-module"));
 const tmp_promise_1 = require("tmp-promise");
-const fs_1 = require("../../../../utils/fs");
+const fs_js_1 = require("../../../../utils/fs.js");
 // Maximum number of log messages that an esbuild instance will produce. This
 // limit is important to avoid out-of-memory errors due to too much data being
 // sent in the Go<>Node IPC channel.
@@ -51,7 +51,7 @@ const getListImportsPlugin = ({ imports, path }) => ({
         });
     },
 });
-const listImports = async ({ functionName, path }) => {
+const listImports = async ({ functionName, path, }) => {
     // We're not interested in the output that esbuild generates, we're just
     // using it for its parsing capabilities in order to find import/require
     // statements. However, if we don't give esbuild a path in `outfile`, it
@@ -82,7 +82,7 @@ const listImports = async ({ functionName, path }) => {
         throw error;
     }
     finally {
-        await (0, fs_1.safeUnlink)(targetPath);
+        await (0, fs_js_1.safeUnlink)(targetPath);
     }
     return [...imports];
 };

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

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

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

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

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

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

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

@@ -28,7 +28,7 @@ const BACKSLASH_REGEXP = /\\/g;
 // So, on errors, we fallback to `require.resolve()`
 const resolvePackage = async function (moduleName, baseDirs) {
     try {
-        return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
+        return await (0, exports.resolvePathPreserveSymlinks)(`${moduleName}/package.json`, baseDirs);
     }
     catch (error) {
         if (semver_1.default.lt(process_1.version, REQUEST_RESOLVE_MIN_VERSION)) {

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

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

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSideFiles = void 0;
-const published_1 = require("./published");
+const published_js_1 = require("./published.js");
 // Some modules generate source files on `postinstall` that are not located
 // inside the module's directory itself.
 const getSideFiles = async function (modulePath, moduleName) {
@@ -9,7 +9,7 @@ const getSideFiles = async function (modulePath, moduleName) {
     if (sideFiles === undefined) {
         return [];
     }
-    return await (0, published_1.getPublishedFiles)(`${modulePath}/${sideFiles}`);
+    return await (0, published_js_1.getPublishedFiles)(`${modulePath}/${sideFiles}`);
 };
 exports.getSideFiles = getSideFiles;
 const SIDE_FILES = {

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

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

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

@@ -8,23 +8,23 @@ exports.getSrcFiles = void 0;
 const path_1 = require("path");
 const junk_1 = require("junk");
 const precinct_1 = __importDefault(require("precinct"));
-const non_nullable_1 = require("../../../../utils/non_nullable");
-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 list_imports_1 = require("./list_imports");
-const resolve_1 = require("./resolve");
-const traverse_1 = require("./traverse");
-const tree_files_1 = require("./tree_files");
-const tree_shake_1 = require("./tree_shake");
+const non_nullable_js_1 = require("../../../../utils/non_nullable.js");
+const included_files_js_1 = require("../../utils/included_files.js");
+const package_json_js_1 = require("../../utils/package_json.js");
+const traversal_cache_js_1 = require("../../utils/traversal_cache.js");
+const list_imports_js_1 = require("./list_imports.js");
+const resolve_js_1 = require("./resolve.js");
+const traverse_js_1 = require("./traverse.js");
+const tree_files_js_1 = require("./tree_files.js");
+const tree_shake_js_1 = require("./tree_shake.js");
 // 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 = 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 { exclude: excludedPaths, paths: includedFilePaths } = await (0, included_files_js_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath);
     const [treeFiles, depFiles] = await Promise.all([
-        (0, tree_files_1.getTreeFiles)(srcPath, stat),
+        (0, tree_files_js_1.getTreeFiles)(srcPath, stat),
         getDependencies({ featureFlags, functionName: name, mainFile, pluginsModulesPath, srcDir }),
     ]);
     const files = [...treeFiles, ...depFiles].map(path_1.normalize);
@@ -32,7 +32,7 @@ const getSrcFiles = async function ({ config, featureFlags, mainFile, name, plug
     // 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);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...filteredFiles, ...includedFilePaths], excludedPaths);
     return includedPaths;
 };
 exports.getSrcFiles = getSrcFiles;
@@ -42,8 +42,8 @@ const isNotJunk = function (file) {
 };
 // Retrieve all the files recursively required by a Node.js file
 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)();
+    const packageJson = await (0, package_json_js_1.getPackageJson)(srcDir);
+    const state = (0, traversal_cache_js_1.getNewCache)();
     try {
         return await getFileDependencies({
             featureFlags,
@@ -66,9 +66,9 @@ const getFileDependencies = async function ({ featureFlags, functionName, path,
     state.localFiles.add(path);
     const basedir = (0, path_1.dirname)(path);
     const dependencies = featureFlags.parseWithEsbuild
-        ? await (0, list_imports_1.listImports)({ functionName, path })
+        ? await (0, list_imports_js_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({
+    const depsPaths = await Promise.all(dependencies.filter(non_nullable_js_1.nonNullable).map((dependency) => getImportDependencies({
         dependency,
         basedir,
         featureFlags,
@@ -82,7 +82,7 @@ const getFileDependencies = async function ({ featureFlags, functionName, path,
 };
 const getImportDependencies = function ({ dependency, basedir, featureFlags, functionName, packageJson, pluginsModulesPath, state, treeShakeNext, }) {
     const shouldTreeShakeNext = treeShakeNext || isNextOnNetlify(dependency);
-    if ((0, tree_shake_1.shouldTreeShake)(dependency, shouldTreeShakeNext)) {
+    if ((0, tree_shake_js_1.shouldTreeShake)(dependency, shouldTreeShakeNext)) {
         return getTreeShakedDependencies({
             dependency,
             basedir,
@@ -94,14 +94,14 @@ const getImportDependencies = function ({ dependency, basedir, featureFlags, fun
             treeShakeNext: shouldTreeShakeNext,
         });
     }
-    return (0, traverse_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
+    return (0, traverse_js_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
 };
 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 = 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 path = await (0, resolve_js_1.resolvePathPreserveSymlinks)(dependency, [basedir, pluginsModulesPath].filter(non_nullable_js_1.nonNullable));
     const depsPath = await getFileDependencies({
         featureFlags,
         functionName,

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

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

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

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependencyPathsForDependency = void 0;
+const fs_1 = require("fs");
 const path_1 = require("path");
-const non_nullable_1 = require("../../../../utils/non_nullable");
-const module_1 = require("../../utils/module");
-const nested_1 = require("./nested");
-const published_1 = require("./published");
-const resolve_1 = require("./resolve");
-const side_files_1 = require("./side_files");
+const non_nullable_js_1 = require("../../../../utils/non_nullable.js");
+const module_js_1 = require("../../utils/module.js");
+const nested_js_1 = require("./nested.js");
+const published_js_1 = require("./published.js");
+const resolve_js_1 = require("./resolve.js");
+const side_files_js_1 = require("./side_files.js");
 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 = async function ({ dependency, basedir, state, packageJson, pluginsModulesPath, }) {
-    const moduleName = (0, module_1.getModuleName)(dependency);
+    const moduleName = (0, module_js_1.getModuleName)(dependency);
     // Happens when doing require("@scope") (not "@scope/name") or other oddities
     // Ignore those.
     if (moduleName === null) {
@@ -22,7 +23,7 @@ const getDependencyPathsForDependency = async function ({ dependency, basedir, s
         return await getDependenciesForModuleName({ moduleName, basedir, state, pluginsModulesPath });
     }
     catch (error) {
-        return (0, nested_1.handleModuleNotFound)({ error, moduleName, packageJson });
+        return (0, nested_js_1.handleModuleNotFound)({ error, moduleName, packageJson });
     }
 };
 exports.getDependencyPathsForDependency = getDependencyPathsForDependency;
@@ -31,7 +32,7 @@ const getDependenciesForModuleName = async function ({ moduleName, basedir, stat
         return [];
     }
     // Find the Node.js module directory path
-    const packagePath = await (0, resolve_1.resolvePackage)(moduleName, [basedir, pluginsModulesPath].filter(non_nullable_1.nonNullable));
+    const packagePath = await (0, resolve_js_1.resolvePackage)(moduleName, [basedir, pluginsModulesPath].filter(non_nullable_js_1.nonNullable));
     if (packagePath === undefined) {
         return [];
     }
@@ -42,11 +43,10 @@ const getDependenciesForModuleName = async function ({ moduleName, basedir, stat
     state.moduleNames.add(moduleName);
     state.modulePaths.add(modulePath);
     // The path depends on the user's build, i.e. must be dynamic
-    // eslint-disable-next-line import/no-dynamic-require, node/global-require, @typescript-eslint/no-var-requires
-    const packageJson = require(packagePath);
+    const packageJson = JSON.parse(await fs_1.promises.readFile(packagePath, 'utf8'));
     const [publishedFiles, sideFiles, depsPaths] = await Promise.all([
-        (0, published_1.getPublishedFiles)(modulePath),
-        (0, side_files_1.getSideFiles)(modulePath, moduleName),
+        (0, published_js_1.getPublishedFiles)(modulePath),
+        (0, side_files_js_1.getSideFiles)(modulePath, moduleName),
         getNestedModules({ modulePath, state, packageJson, pluginsModulesPath }),
     ]);
     return [...publishedFiles, ...sideFiles, ...depsPaths];
@@ -55,8 +55,8 @@ const isExcludedModule = function (moduleName) {
     return EXCLUDED_MODULES.has(moduleName) || moduleName.startsWith('@types/');
 };
 const getNestedModules = async function ({ modulePath, state, packageJson, pluginsModulesPath, }) {
-    const dependencies = (0, nested_1.getNestedDependencies)(packageJson);
-    const depsPaths = await Promise.all(dependencies.map((dependency) => getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
+    const dependencies = (0, nested_js_1.getNestedDependencies)(packageJson);
+    const depsPaths = await Promise.all(dependencies.map((dependency) => (0, exports.getDependencyPathsForDependency)({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
     return depsPaths.flat();
 };
 //# sourceMappingURL=traverse.js.map

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

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

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

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

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldTreeShake = void 0;
-const module_1 = require("../../utils/module");
+const module_js_1 = require("../../utils/module.js");
 const LOCAL_IMPORT_REGEXP = /^(\.|\/)/;
 // we tree shake direct local requires to bundle only relevant code
 // we don't tree shake external dependencies since they can break our tree shaking logic by:
@@ -12,7 +12,7 @@ const shouldTreeShake = function (dependency, treeShakeNext) {
     if (LOCAL_IMPORT_REGEXP.test(dependency)) {
         return true;
     }
-    return treeShakeNext && (0, module_1.getModuleName)(dependency) === 'next';
+    return treeShakeNext && (0, module_js_1.getModuleName)(dependency) === 'next';
 };
 exports.shouldTreeShake = shouldTreeShake;
 //# sourceMappingURL=tree_shake.js.map

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

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

package/dist/runtimes/node/finder.js

@@ -7,7 +7,7 @@ exports.findFunctionInPath = exports.findFunctionsInPaths = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const locate_path_1 = __importDefault(require("locate-path"));
-const non_nullable_1 = require("../../utils/non_nullable");
+const non_nullable_js_1 = require("../../utils/non_nullable.js");
 // 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
@@ -20,9 +20,9 @@ const sortByExtension = (fA, fB) => {
     return indexB - indexA;
 };
 const findFunctionsInPaths = async function ({ paths, fsCache, featureFlags }) {
-    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ path, fsCache, featureFlags })));
+    const functions = await Promise.all(paths.map((path) => (0, exports.findFunctionInPath)({ path, fsCache, featureFlags })));
     // It's fine to mutate the array since its scope is local to this function.
-    const sortedFunctions = functions.filter(non_nullable_1.nonNullable).sort((fA, fB) => {
+    const sortedFunctions = functions.filter(non_nullable_js_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());

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

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

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

@@ -1,24 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPath = void 0;
-const non_nullable_1 = require("../../../utils/non_nullable");
-const parser_1 = require("../parser");
-const exports_1 = require("../parser/exports");
-const imports_1 = require("../parser/imports");
-const schedule_1 = require("./properties/schedule");
-const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
-exports.IN_SOURCE_CONFIG_MODULE = IN_SOURCE_CONFIG_MODULE;
+exports.findISCDeclarationsInPath = exports.IN_SOURCE_CONFIG_MODULE = void 0;
+const non_nullable_js_1 = require("../../../utils/non_nullable.js");
+const exports_js_1 = require("../parser/exports.js");
+const imports_js_1 = require("../parser/imports.js");
+const index_js_1 = require("../parser/index.js");
+const schedule_js_1 = require("./properties/schedule.js");
+exports.IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
 // Parses a JS/TS file and looks for in-source config declarations. It returns
 // an array of all declarations found, with `property` indicating the name of
 // the property and `data` its value.
 const findISCDeclarationsInPath = async (sourcePath) => {
-    const ast = await (0, parser_1.safelyParseFile)(sourcePath);
+    const ast = await (0, index_js_1.safelyParseFile)(sourcePath);
     if (ast === null) {
         return {};
     }
-    const imports = ast.body.flatMap((node) => (0, imports_1.getImports)(node, IN_SOURCE_CONFIG_MODULE));
-    const exports = (0, exports_1.getMainExport)(ast.body);
-    const iscExports = exports
+    const imports = ast.body.flatMap((node) => (0, imports_js_1.getImports)(node, exports.IN_SOURCE_CONFIG_MODULE));
+    const mainExports = (0, exports_js_1.getMainExport)(ast.body);
+    const iscExports = mainExports
         .map(({ args, local: exportName }) => {
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
         if (matchingImport === undefined) {
@@ -26,13 +25,13 @@ const findISCDeclarationsInPath = async (sourcePath) => {
         }
         switch (matchingImport.imported) {
             case 'schedule':
-                return (0, schedule_1.parse)({ args });
+                return (0, schedule_js_1.parse)({ args });
             default:
             // no-op
         }
         return null;
     })
-        .filter(non_nullable_1.nonNullable);
+        .filter(non_nullable_js_1.nonNullable);
     const mergedExports = iscExports.reduce((acc, obj) => ({ ...acc, ...obj }), {});
     return mergedExports;
 };

package/dist/runtimes/node/in_source_config/properties/schedule.d.ts

@@ -1,4 +1,4 @@
-import type { ISCHandlerArg } from '..';
+import type { ISCHandlerArg } from '../index.js';
 export declare const parse: ({ args }: {
     args: ISCHandlerArg[];
 }) => {

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

@@ -1,4 +1,4 @@
-import { Runtime } from '../runtime';
-export { NodeVersionString } from './utils/node_version';
+import { Runtime } from '../runtime.js';
+export { NodeVersionString } from './utils/node_version.js';
 declare const runtime: Runtime;
 export default runtime;