@netlify/zip-it-and-ship-it 5.7.3 → 5.7.4

package/dist/bin.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const process_1 = require("process");
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
-const main_1 = require("./main");
+const main_js_1 = require("./main.js");
 // CLI entry point
 const runCli = async function () {
     // @ts-expect-error TODO: `destFolder` and  `srcFolder` are not being passed
@@ -15,7 +15,7 @@ const runCli = async function () {
     const { destFolder, srcFolder, ...options } = parseArgs();
     try {
         // @ts-expect-error TODO: `options` is not getting the right types.
-        const zipped = await (0, main_1.zipFunctions)(srcFolder, destFolder, options);
+        const zipped = await (0, main_js_1.zipFunctions)(srcFolder, destFolder, options);
         console.log(JSON.stringify(zipped, null, 2));
     }
     catch (error) {

package/dist/config.d.ts

@@ -1,6 +1,6 @@
-import { FunctionSource } from './function';
-import type { NodeVersionString } from './runtimes/node';
-import type { NodeBundlerName } from './runtimes/node/bundlers';
+import { FunctionSource } from './function.js';
+import type { NodeBundlerName } from './runtimes/node/bundlers/index.js';
+import type { NodeVersionString } from './runtimes/node/index.js';
 export interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];

package/dist/function.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Stats } from 'fs';
-import type { FunctionConfig } from './config';
-import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
+import type { FunctionConfig } from './config.js';
+import type { Runtime, ZipFunctionResult } from './runtimes/runtime.js';
 export declare type FunctionArchive = ZipFunctionResult & {
     mainFile: string;
     name: string;

package/dist/main.d.ts

@@ -1,7 +1,7 @@
-import { Config } from './config';
-import { FeatureFlags } from './feature_flags';
-import { RuntimeName } from './runtimes/runtime';
-export { zipFunction, zipFunctions } from './zip';
+import { Config } from './config.js';
+import { FeatureFlags } from './feature_flags.js';
+import { RuntimeName } from './runtimes/runtime.js';
+export { zipFunction, zipFunctions } from './zip.js';
 interface ListedFunction {
     name: string;
     mainFile: string;

package/dist/main.js

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = exports.zipFunctions = exports.zipFunction = void 0;
 const path_1 = require("path");
-const feature_flags_1 = require("./feature_flags");
-const runtimes_1 = require("./runtimes");
-const in_source_config_1 = require("./runtimes/node/in_source_config");
-const fs_1 = require("./utils/fs");
-var zip_1 = require("./zip");
-Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
-Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
+const feature_flags_js_1 = require("./feature_flags.js");
+const index_js_1 = require("./runtimes/index.js");
+const index_js_2 = require("./runtimes/node/in_source_config/index.js");
+const fs_js_1 = require("./utils/fs.js");
+var zip_js_1 = require("./zip.js");
+Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_js_1.zipFunction; } });
+Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_js_1.zipFunctions; } });
 const augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
     if (func.runtime.name !== 'js') {
         return func;
     }
-    const inSourceConfig = await (0, in_source_config_1.findISCDeclarationsInPath)(func.mainFile);
+    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(func.mainFile);
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory
 const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { featureFlags, config });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     return augmentedFunctions.map(getListedFunction);
@@ -30,8 +30,8 @@ const listFunctions = async function (relativeSrcFolders, { featureFlags: inputF
 exports.listFunctions = listFunctions;
 // Finds a function at a specific path.
 const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const func = await (0, runtimes_1.getFunctionFromPath)(path, { featureFlags, config });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const func = await (0, index_js_1.getFunctionFromPath)(path, { featureFlags, config });
     if (!func) {
         return;
     }
@@ -41,10 +41,10 @@ const listFunction = async function (path, { featureFlags: inputFeatureFlags, co
 exports.listFunction = listFunction;
 // List all Netlify Functions files for a specific directory
 const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
-    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { config, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));

package/dist/manifest.d.ts

@@ -1,4 +1,4 @@
-import { FunctionResult } from './utils/format_result';
+import { FunctionResult } from './utils/format_result.js';
 interface ManifestFunction {
     mainFile: string;
     name: string;

package/dist/runtimes/detect_runtime.d.ts

@@ -1,5 +1,5 @@
-import { FsCache } from '../utils/fs';
-import type { RuntimeName } from './runtime';
+import { FsCache } from '../utils/fs.js';
+import type { RuntimeName } from './runtime.js';
 export declare const detectBinaryRuntime: ({ fsCache, path, }: {
     fsCache: FsCache;
     path: string;

package/dist/runtimes/detect_runtime.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectBinaryRuntime = void 0;
 const elf_cam_1 = require("elf-cam");
-const fs_1 = require("../utils/fs");
+const fs_js_1 = require("../utils/fs.js");
 // Try to guess the runtime by inspecting the binary file.
 const detectBinaryRuntime = async function ({ fsCache, path, }) {
     try {
-        const buffer = await (0, fs_1.cachedReadFile)(fsCache, path);
+        const buffer = await (0, fs_js_1.cachedReadFile)(fsCache, path);
         // We're using the Type Assertion because the `cachedReadFile` abstraction
         // loses part of the return type information. We can safely say it's a
         // Buffer in this case because we're not specifying an encoding.

package/dist/runtimes/go/builder.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const shell_1 = require("../../utils/shell");
+const shell_js_1 = require("../../utils/shell.js");
 const build = async ({ destPath, mainFile, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
     try {
-        await shell_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        await shell_js_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',

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

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

package/dist/runtimes/go/index.js

@@ -5,20 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
-const fs_1 = require("../../utils/fs");
-const non_nullable_1 = require("../../utils/non_nullable");
-const zip_binary_1 = require("../../zip_binary");
-const detect_runtime_1 = require("../detect_runtime");
-const builder_1 = require("./builder");
+const fs_js_1 = require("../../utils/fs.js");
+const non_nullable_js_1 = require("../../utils/non_nullable.js");
+const zip_binary_js_1 = require("../../zip_binary.js");
+const detect_runtime_js_1 = require("../detect_runtime.js");
+const builder_js_1 = require("./builder.js");
 const detectGoFunction = async ({ fsCache, path }) => {
-    const stat = await (0, fs_1.cachedLstat)(fsCache, path);
+    const stat = await (0, fs_js_1.cachedLstat)(fsCache, path);
     if (!stat.isDirectory()) {
         return;
     }
     const directoryName = (0, path_1.basename)(path);
     // @ts-expect-error TODO: The `makeCachedFunction` abstraction is causing the
     // return value of `readdir` to be incorrectly typed.
-    const files = (await (0, fs_1.cachedReaddir)(fsCache, path));
+    const files = (await (0, fs_js_1.cachedReaddir)(fsCache, path));
     const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
     if (mainFileName === undefined) {
         return;
@@ -27,10 +27,10 @@ const detectGoFunction = async ({ fsCache, path }) => {
 };
 const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
     const functions = await Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
-    return functions.filter(non_nullable_1.nonNullable);
+    return functions.filter(non_nullable_js_1.nonNullable);
 };
 const findFunctionInPath = async function ({ featureFlags, fsCache, path }) {
-    const runtime = await (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+    const runtime = await (0, detect_runtime_js_1.detectBinaryRuntime)({ fsCache, path });
     if (runtime === 'go') {
         return processBinary({ fsCache, path });
     }
@@ -43,7 +43,7 @@ const findFunctionInPath = async function ({ featureFlags, fsCache, path }) {
     }
 };
 const processBinary = async ({ fsCache, path }) => {
-    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
+    const stat = (await (0, fs_js_1.cachedLstat)(fsCache, path));
     const extension = (0, path_1.extname)(path);
     const filename = (0, path_1.basename)(path);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -62,7 +62,7 @@ const processSource = async ({ fsCache, mainFile, path, }) => {
     // the `FunctionSource` interface. We should revisit whether `stat` should be
     // part of that interface in the first place, or whether we could compute it
     // downstream when needed (maybe using the FS cache as an optimisation).
-    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
+    const stat = (await (0, fs_js_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
     const extension = (0, path_1.extname)(mainFile);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -86,7 +86,7 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
     // If we're building a Go function from source, we call the build method and
     // update `binary` to point to the newly-created binary.
     if (isSource) {
-        const { stat: binaryStat } = await (0, builder_1.build)({ destPath, mainFile, srcDir });
+        const { stat: binaryStat } = await (0, builder_js_1.build)({ destPath, mainFile, srcDir });
         binary = {
             path: destPath,
             stat: binaryStat,
@@ -101,7 +101,7 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
             filename: (0, path_1.basename)(destPath),
             runtime,
         };
-        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
+        await (0, zip_binary_js_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
         return { config, path: zipPath };
     }
     // We don't need to zip the binary, so we can just copy it to the right path.

package/dist/runtimes/index.d.ts

@@ -1,6 +1,6 @@
-import { Config } from '../config';
-import { FeatureFlags } from '../feature_flags';
-import { FunctionSource } from '../function';
+import { Config } from '../config.js';
+import { FeatureFlags } from '../feature_flags.js';
+import { FunctionSource } from '../function.js';
 declare type FunctionMap = Map<string, FunctionSource>;
 /**
  * Gets a list of functions found in a list of paths.

package/dist/runtimes/index.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFunctionFromPath = exports.getFunctionsFromPaths = void 0;
 const path_1 = require("path");
-const config_1 = require("../config");
-const feature_flags_1 = require("../feature_flags");
-const go_1 = __importDefault(require("./go"));
-const node_1 = __importDefault(require("./node"));
-const rust_1 = __importDefault(require("./rust"));
+const config_js_1 = require("../config.js");
+const feature_flags_js_1 = require("../feature_flags.js");
+const index_js_1 = __importDefault(require("./go/index.js"));
+const index_js_2 = __importDefault(require("./node/index.js"));
+const index_js_3 = __importDefault(require("./rust/index.js"));
 /**
  * Finds functions for a list of paths using a specific runtime. The return
  * value is an object containing an array of the functions found (`functions`)
@@ -43,11 +43,11 @@ const makeFsCache = () => ({});
 // The order of this array determines the priority of the runtimes. If a path
 // is used by the first time, it won't be made available to the subsequent
 // runtimes.
-const RUNTIMES = [node_1.default, go_1.default, rust_1.default];
+const RUNTIMES = [index_js_2.default, index_js_1.default, index_js_3.default];
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFlags = feature_flags_1.defaultFlags, } = {}) => {
+const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFlags = feature_flags_js_1.defaultFlags, } = {}) => {
     const fsCache = makeFsCache();
     // We cycle through the ordered array of runtimes, passing each one of them
     // through `findFunctionsInRuntime`. For each iteration, we collect all the
@@ -69,7 +69,7 @@ const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFla
     }, Promise.resolve({ functions: [], remainingPaths: paths }));
     const functionsWithConfig = functions.map(([name, func]) => [
         name,
-        { ...func, config: (0, config_1.getConfigForFunction)({ config, func }) },
+        { ...func, config: (0, config_js_1.getConfigForFunction)({ config, func }) },
     ]);
     return new Map(functionsWithConfig);
 };
@@ -77,7 +77,7 @@ exports.getFunctionsFromPaths = getFunctionsFromPaths;
 /**
  * Gets a list of functions found in a list of paths.
  */
-const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => {
+const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_js_1.defaultFlags } = {}) => {
     const fsCache = makeFsCache();
     for (const runtime of RUNTIMES) {
         const func = await runtime.findFunctionInPath({ path, fsCache, featureFlags });
@@ -85,7 +85,7 @@ const getFunctionFromPath = async (path, { config, featureFlags = feature_flags_
             return {
                 ...func,
                 runtime,
-                config: (0, config_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
+                config: (0, config_js_1.getConfigForFunction)({ config, func: { ...func, runtime } }),
             };
         }
     }

package/dist/runtimes/node/bundlers/esbuild/bundler.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionConfig } from '../../../../config';
+import type { FunctionConfig } from '../../../../config.js';
 export declare const ESBUILD_LOG_LIMIT = 10;
 export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;

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

@@ -4,11 +4,11 @@ exports.bundleJsFile = exports.ESBUILD_LOG_LIMIT = void 0;
 const path_1 = require("path");
 const esbuild_1 = require("@netlify/esbuild");
 const tmp_promise_1 = require("tmp-promise");
-const fs_1 = require("../../../../utils/fs");
-const bundler_target_1 = require("./bundler_target");
-const plugin_dynamic_imports_1 = require("./plugin_dynamic_imports");
-const plugin_native_modules_1 = require("./plugin_native_modules");
-const plugin_node_builtin_1 = require("./plugin_node_builtin");
+const fs_js_1 = require("../../../../utils/fs.js");
+const bundler_target_js_1 = require("./bundler_target.js");
+const plugin_dynamic_imports_js_1 = require("./plugin_dynamic_imports.js");
+const plugin_native_modules_js_1 = require("./plugin_native_modules.js");
+const plugin_node_builtin_js_1 = require("./plugin_node_builtin.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.
@@ -35,9 +35,9 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
     const dynamicImportsIncludedPaths = new Set();
     // The list of esbuild plugins to enable for this build.
     const plugins = [
-        (0, plugin_node_builtin_1.getNodeBuiltinPlugin)(),
-        (0, plugin_native_modules_1.getNativeModulesPlugin)(nativeNodeModules),
-        (0, plugin_dynamic_imports_1.getDynamicImportsPlugin)({
+        (0, plugin_node_builtin_js_1.getNodeBuiltinPlugin)(),
+        (0, plugin_native_modules_js_1.getNativeModulesPlugin)(nativeNodeModules),
+        (0, plugin_dynamic_imports_js_1.getDynamicImportsPlugin)({
             basePath,
             includedPaths: dynamicImportsIncludedPaths,
             moduleNames: nodeModulesWithDynamicImports,
@@ -47,7 +47,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, 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);
     // esbuild will format `sources` relative to the sourcemap file, which lives
     // in `destFolder`. We use `sourceRoot` to establish that relation. They are
     // URLs, not paths, so even on Windows they should use forward slashes.
@@ -116,7 +116,7 @@ const getBundlePaths = ({ destFolder, outputs, srcFile, }) => {
         const absolutePath = (0, path_1.join)(destFolder, filename);
         if (output.entryPoint && (0, path_1.basename)(output.entryPoint) === (0, path_1.basename)(srcFile)) {
             // Ensuring the main file has a `.js` extension.
-            const normalizedSrcFile = (0, fs_1.getPathWithExtension)(srcFile, '.js');
+            const normalizedSrcFile = (0, fs_js_1.getPathWithExtension)(srcFile, '.js');
             bundlePaths.set(absolutePath, normalizedSrcFile);
         }
         else if (extension === '.js' || filename === `${bundleFilename}.map`) {
@@ -126,6 +126,6 @@ const getBundlePaths = ({ destFolder, outputs, srcFile, }) => {
     return bundlePaths;
 };
 const getCleanupFunction = (paths) => async () => {
-    await Promise.all(paths.filter(Boolean).map(fs_1.safeUnlink));
+    await Promise.all(paths.filter(Boolean).map(fs_js_1.safeUnlink));
 };
 //# sourceMappingURL=bundler.js.map

package/dist/runtimes/node/bundlers/esbuild/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/esbuild/index.js

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
-const fs_1 = require("../../../../utils/fs");
-const non_nullable_1 = require("../../../../utils/non_nullable");
-const base_path_1 = require("../../utils/base_path");
-const bundler_1 = require("./bundler");
-const special_cases_1 = require("./special_cases");
-const src_files_1 = require("./src_files");
+const fs_js_1 = require("../../../../utils/fs.js");
+const non_nullable_js_1 = require("../../../../utils/non_nullable.js");
+const base_path_js_1 = require("../../utils/base_path.js");
+const bundler_js_1 = require("./bundler.js");
+const special_cases_js_1 = require("./special_cases.js");
+const src_files_js_1 = require("./src_files.js");
 const getFunctionBasePath = ({ basePathFromConfig, mainFile, repositoryRoot, supportingSrcFiles, }) => {
     // If there is a base path defined in the config, we use that. To account for
     // paths outside of `basePathFromConfig` but inside `repositoryRoot`, we use
     // the common path prefix between the two.
     if (basePathFromConfig !== undefined) {
-        return (0, base_path_1.getBasePath)([basePathFromConfig, repositoryRoot].filter(non_nullable_1.nonNullable));
+        return (0, base_path_js_1.getBasePath)([basePathFromConfig, repositoryRoot].filter(non_nullable_js_1.nonNullable));
     }
     // If not, the base path is the common path prefix between all the supporting
     // files and the main file.
     const dirnames = [...supportingSrcFiles, mainFile].map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath)));
-    return (0, base_path_1.getBasePath)(dirnames);
+    return (0, base_path_js_1.getBasePath)(dirnames);
 };
 // Convenience method for retrieving external and ignored modules from
 // different places and merging them together.
 const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
     const { externalNodeModules: externalModulesFromConfig = [], ignoredNodeModules: ignoredModulesFromConfig = [] } = config;
-    const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } = await (0, special_cases_1.getExternalAndIgnoredModulesFromSpecialCases)({ srcDir });
+    const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } = await (0, special_cases_js_1.getExternalAndIgnoredModulesFromSpecialCases)({ srcDir });
     const externalModules = [...new Set([...externalModulesFromConfig, ...externalModulesFromSpecialCases])];
     const ignoredModules = [...ignoredModulesFromConfig, ...ignoredModulesFromSpecialCases];
     return { externalModules, ignoredModules };
 };
 const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => {
     const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await (0, bundler_1.bundleJsFile)({
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await (0, bundler_js_1.bundleJsFile)({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,
@@ -41,7 +41,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         srcFile: mainFile,
     });
     const bundlerWarnings = warnings.length === 0 ? undefined : warnings;
-    const srcFiles = await (0, src_files_1.getSrcFiles)({
+    const srcFiles = await (0, src_files_js_1.getSrcFiles)({
         basePath,
         config: {
             ...config,
@@ -64,7 +64,7 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
     // path of the original, pre-bundling function file. We'll add the actual
     // bundled file further below.
     const supportingSrcFiles = srcFiles.filter((path) => path !== mainFile);
-    const normalizedMainFile = (0, fs_1.getPathWithExtension)(mainFile, '.js');
+    const normalizedMainFile = (0, fs_js_1.getPathWithExtension)(mainFile, '.js');
     const functionBasePath = getFunctionBasePath({
         basePathFromConfig: basePath,
         mainFile,
@@ -84,6 +84,6 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],
     };
 };
-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/esbuild/plugin_dynamic_imports.js

@@ -8,7 +8,7 @@ const path_1 = require("path");
 const find_up_1 = __importDefault(require("find-up"));
 const read_package_json_fast_1 = __importDefault(require("read-package-json-fast"));
 const unixify_1 = __importDefault(require("unixify"));
-const parser_1 = require("../../parser");
+const index_js_1 = require("../../parser/index.js");
 // This plugin intercepts module imports using dynamic expressions and does a
 // couple of things with them. First of all, it figures out whether the call
 // is being made from within a Node module, and if so it adds the name of the
@@ -28,7 +28,7 @@ const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, process
             // Also don't parse the expression if we're not interested in processing
             // the dynamic import expressions.
             if (basePath && processImports) {
-                const { includedPathsGlob, type: expressionType } = (0, parser_1.parseExpression)({ basePath, expression, resolveDir }) || {};
+                const { includedPathsGlob, type: expressionType } = (0, index_js_1.parseExpression)({ basePath, expression, resolveDir }) || {};
                 if (includedPathsGlob) {
                     // The parser has found a glob of paths that should be included in the
                     // bundle to make this import work, so we add it to `includedPaths`.

package/dist/runtimes/node/bundlers/esbuild/plugin_native_modules.d.ts

@@ -1,3 +1,3 @@
 import type { Plugin } from '@netlify/esbuild';
-import type { NativeNodeModules } from '..';
+import type { NativeNodeModules } from '../index.js';
 export declare const getNativeModulesPlugin: (externalizedModules: NativeNodeModules) => Plugin;

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNativeModulesPlugin = void 0;
 const path_1 = __importDefault(require("path"));
 const read_package_json_fast_1 = __importDefault(require("read-package-json-fast"));
-const detect_native_module_1 = require("../../utils/detect_native_module");
+const detect_native_module_js_1 = require("../../utils/detect_native_module.js");
 // Filters out relative or absolute file paths.
 const packageFilter = /^([^./]*)$/;
 // Filters valid package names and extracts the base directory.
@@ -14,7 +14,7 @@ const packageName = /^([^@][^/]*|@[^/]*\/[^/]+)(?:\/|$)/;
 const findNativeModule = (packageJsonPath, cache) => {
     if (cache[packageJsonPath] === undefined) {
         // eslint-disable-next-line no-param-reassign, promise/prefer-await-to-then
-        cache[packageJsonPath] = (0, read_package_json_fast_1.default)(packageJsonPath).then((data) => [Boolean((0, detect_native_module_1.isNativeModule)(data)), data], () => [undefined, {}]);
+        cache[packageJsonPath] = (0, read_package_json_fast_1.default)(packageJsonPath).then((data) => [Boolean((0, detect_native_module_js_1.isNativeModule)(data)), data], () => [undefined, {}]);
     }
     return cache[packageJsonPath];
 };

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExternalAndIgnoredModulesFromSpecialCases = void 0;
-const package_json_1 = require("../../utils/package_json");
+const package_json_js_1 = require("../../utils/package_json.js");
 const EXTERNAL_MODULES = ['@prisma/client'];
 const IGNORED_MODULES = ['aws-sdk'];
 const getModulesForNextJs = ({ dependencies, devDependencies }) => {
@@ -14,7 +14,7 @@ const getModulesForNextJs = ({ dependencies, devDependencies }) => {
     };
 };
 const getExternalAndIgnoredModulesFromSpecialCases = async ({ srcDir }) => {
-    const { dependencies = {}, devDependencies = {} } = await (0, package_json_1.getPackageJsonIfAvailable)(srcDir);
+    const { dependencies = {}, devDependencies = {} } = await (0, package_json_js_1.getPackageJsonIfAvailable)(srcDir);
     const { externalModules: nextJsExternalModules, ignoredModules: nextJsIgnoredModules } = getModulesForNextJs({
         dependencies,
         devDependencies,

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

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

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

@@ -1,27 +1,27 @@
 "use strict";
 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 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 traverse_js_1 = require("../zisi/traverse.js");
 const getSrcFiles = async ({ config, mainFile, pluginsModulesPath, srcDir }) => {
     const { externalNodeModules = [], 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 dependencyPaths = await getSrcFilesForDependencies({
         dependencies: externalNodeModules,
         basedir: srcDir,
         pluginsModulesPath,
     });
-    const includedPaths = (0, included_files_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
+    const includedPaths = (0, included_files_js_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
     return [...includedPaths, mainFile];
 };
 exports.getSrcFiles = getSrcFiles;
-const getSrcFilesForDependencies = async function ({ dependencies: dependencyNames, basedir, state = (0, traversal_cache_1.getNewCache)(), pluginsModulesPath, }) {
+const getSrcFilesForDependencies = async function ({ dependencies: dependencyNames, basedir, state = (0, traversal_cache_js_1.getNewCache)(), pluginsModulesPath, }) {
     if (dependencyNames.length === 0) {
         return [];
     }
-    const packageJson = await (0, package_json_1.getPackageJson)(basedir);
+    const packageJson = await (0, package_json_js_1.getPackageJson)(basedir);
     const dependencies = await Promise.all(dependencyNames.map((dependencyName) => getSrcFilesForDependency({
         dependency: dependencyName,
         basedir,
@@ -32,9 +32,9 @@ const getSrcFilesForDependencies = async function ({ dependencies: dependencyNam
     const paths = new Set(dependencies.flat());
     return [...paths];
 };
-const getSrcFilesForDependency = async function ({ dependency, basedir, state = (0, traversal_cache_1.getNewCache)(), packageJson, pluginsModulesPath, }) {
+const getSrcFilesForDependency = async function ({ dependency, basedir, state = (0, traversal_cache_js_1.getNewCache)(), packageJson, pluginsModulesPath, }) {
     try {
-        const paths = await (0, traverse_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
+        const paths = await (0, traverse_js_1.getDependencyPathsForDependency)({ dependency, basedir, state, packageJson, pluginsModulesPath });
         return paths;
     }
     catch (error) {

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

@@ -1,8 +1,8 @@
 import type { Message } from '@netlify/esbuild';
-import { FunctionConfig } from '../../../config';
-import { FeatureFlag, FeatureFlags } from '../../../feature_flags';
-import { FunctionSource } from '../../../function';
-import { ModuleFormat } from '../utils/module_format';
+import { FunctionConfig } from '../../../config.js';
+import { FeatureFlag, FeatureFlags } from '../../../feature_flags.js';
+import { FunctionSource } from '../../../function.js';
+import { ModuleFormat } from '../utils/module_format.js';
 export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
 declare type BundlerWarning = Message;
 declare type CleanupFunction = () => Promise<void>;