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

package/README.md

@@ -32,15 +32,11 @@ npm install @netlify/zip-it-and-ship-it
 - _Return value_: `Promise<object[]>`
 
 ```js
-const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
+import { zipFunctions } from '@netlify/zip-it-and-ship-it'
 
-const zipNetlifyFunctions = async function () {
-  const archives = await zipFunctions('functions', 'functions-dist', {
-    archiveFormat: 'zip',
-  })
-
-  return archives
-}
+const archives = await zipFunctions('functions', 'functions-dist', {
+  archiveFormat: 'zip',
+})
 ```
 
 Creates Zip `archives` from Node.js, Go, and Rust programs. Those `archives` are ready to be uploaded to AWS Lambda.
@@ -258,13 +254,9 @@ Additionally, the following properties also exist for Node.js functions:
 - _Return value_: `object | undefined`
 
 ```js
-const { zipFunction } = require('@netlify/zip-it-and-ship-it')
-
-const zipNetlifyFunctions = async function () {
-  const archive = await zipFunctions('functions/function.js', 'functions-dist')
+import { zipFunction } from '@netlify/zip-it-and-ship-it'
 
-  return archive
-}
+const archive = await zipFunctions('functions/function.js', 'functions-dist')
 ```
 
 This is like [`zipFunctions()`](#zipfunctionssrcfolder-destfolder-options) except it bundles a single Function.
@@ -276,13 +268,9 @@ The return value is `undefined` if the function is invalid.
 Returns the list of functions to bundle.
 
 ```js
-const { listFunctions } = require('@netlify/zip-it-and-ship-it')
-
-const listNetlifyFunctions = async function () {
-  const functions = await listFunctions('functions/function.js')
+import { listFunctions } from '@netlify/zip-it-and-ship-it'
 
-  return functions
-}
+const functions = await listFunctions('functions/function.js')
 ```
 
 ### `srcFolders`
@@ -326,12 +314,9 @@ Like [`listFunctions()`](#listfunctionssrcfolder), except it returns not only th
 their required files. This is much slower.
 
 ```js
-const { listFunctionsFiles } = require('@netlify/zip-it-and-ship-it')
+import { listFunctionsFiles } from '@netlify/zip-it-and-ship-it'
 
-const listNetlifyFunctionsFiles = async function () {
-  const functions = await listFunctionsFiles('functions/function.js')
-  return functions
-}
+const functions = await listFunctionsFiles('functions/function.js')
 ```
 
 ### `srcFolders`
@@ -400,20 +385,16 @@ included in the bundle.
 You can enable esbuild by setting the [`config` option](#config) when calling `zipFunction` or `zipFunctions`:
 
 ```js
-const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
-
-const zipNetlifyFunctions = async function () {
-  const archives = await zipFunctions('functions', 'functions-dist', {
-    config: {
-      // Applying these settings to all functions.
-      '*': {
-        nodeBundler: 'esbuild',
-      },
-    },
-  })
+import { zipFunctions } from '@netlify/zip-it-and-ship-it'
 
-  return archives
-}
+const archives = await zipFunctions('functions', 'functions-dist', {
+  config: {
+    // Applying these settings to all functions.
+    '*': {
+      nodeBundler: 'esbuild',
+    },
+  },
+})
 ```
 
 # Feature flags

package/dist/archive.d.ts

@@ -2,14 +2,12 @@ import { Buffer } from 'buffer';
 import { Stats } from 'fs';
 import { Writable } from 'stream';
 import { Archiver } from 'archiver';
-declare type ArchiveFormat = 'none' | 'zip';
-declare const startZip: (destPath: string) => {
+export { Archiver as ZipArchive } from 'archiver';
+export declare type ArchiveFormat = 'none' | 'zip';
+export declare const startZip: (destPath: string) => {
     archive: Archiver;
     output: Writable;
 };
-declare const addZipFile: (archive: Archiver, file: string, name: string, stat: Stats) => void;
-declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
-declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;
-export { startZip, addZipFile, addZipContent, endZip };
-export type { ArchiveFormat };
-export { Archiver as ZipArchive } from 'archiver';
+export declare const addZipFile: (archive: Archiver, file: string, name: string, stat: Stats) => void;
+export declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
+export declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;

package/dist/config.d.ts

@@ -1,7 +1,7 @@
 import { FunctionSource } from './function';
 import type { NodeVersionString } from './runtimes/node';
 import type { NodeBundlerName } from './runtimes/node/bundlers';
-interface FunctionConfig {
+export interface FunctionConfig {
     externalNodeModules?: string[];
     includedFiles?: string[];
     includedFilesBasePath?: string;
@@ -15,10 +15,9 @@ interface FunctionConfig {
     zipGo?: boolean;
 }
 declare type GlobPattern = string;
-declare type Config = Record<GlobPattern, FunctionConfig>;
-declare const getConfigForFunction: ({ config, func, }: {
+export declare type Config = Record<GlobPattern, FunctionConfig>;
+export declare const getConfigForFunction: ({ config, func, }: {
     config?: Config | undefined;
     func: Omit<FunctionSource, 'config'>;
 }) => FunctionConfig;
-export { getConfigForFunction };
-export type { Config, FunctionConfig };
+export {};

package/dist/feature_flags.d.ts

@@ -1,6 +1,4 @@
-declare const FLAGS: Record<string, boolean>;
-declare type FeatureFlag = keyof typeof FLAGS;
-declare type FeatureFlags = Record<FeatureFlag, boolean>;
-declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => {};
-export { FLAGS as defaultFlags, getFlags };
-export type { FeatureFlag, FeatureFlags };
+export declare const defaultFlags: Record<string, boolean>;
+export declare type FeatureFlag = keyof typeof defaultFlags;
+export declare type FeatureFlags = Record<FeatureFlag, boolean>;
+export declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => {};

package/dist/feature_flags.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFlags = exports.defaultFlags = void 0;
 const process_1 = require("process");
-const FLAGS = {
+exports.defaultFlags = {
     buildGoSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
     buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
     defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
@@ -10,9 +10,8 @@ const FLAGS = {
     traceWithNft: false,
     zisi_pure_esm: false,
 };
-exports.defaultFlags = FLAGS;
 // List of supported flags and their default value.
-const getFlags = (input = {}, flags = FLAGS) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
+const getFlags = (input = {}, flags = exports.defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,
     [key]: input[key] === undefined ? defaultValue : input[key],
 }), {});

package/dist/function.d.ts

@@ -2,13 +2,13 @@
 import { Stats } from 'fs';
 import type { FunctionConfig } from './config';
 import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
-declare type FunctionArchive = ZipFunctionResult & {
+export declare type FunctionArchive = ZipFunctionResult & {
     mainFile: string;
     name: string;
     runtime: Runtime;
     size?: number;
 };
-interface SourceFile {
+export interface SourceFile {
     extension: string;
     filename: string;
     mainFile: string;
@@ -17,8 +17,7 @@ interface SourceFile {
     srcPath: string;
     stat: Stats;
 }
-declare type FunctionSource = SourceFile & {
+export declare type FunctionSource = SourceFile & {
     config: FunctionConfig;
     runtime: Runtime;
 };
-export { FunctionArchive, FunctionSource, SourceFile };

package/dist/main.d.ts

@@ -1,6 +1,7 @@
 import { Config } from './config';
 import { FeatureFlags } from './feature_flags';
 import { RuntimeName } from './runtimes/runtime';
+export { zipFunction, zipFunctions } from './zip';
 interface ListedFunction {
     name: string;
     mainFile: string;
@@ -17,16 +18,14 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction | undefined>;
-declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
-export { listFunctions, listFunction, listFunctionsFiles };
-export { zipFunction, zipFunctions } from './zip';
+export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/main.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = void 0;
+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 augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
     if (func.runtime.name !== 'js') {
@@ -68,7 +71,4 @@ const getSrcFiles = async function ({ extension, runtime, srcPath, ...args }) {
         ...args,
     });
 };
-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; } });
 //# sourceMappingURL=main.js.map

package/dist/manifest.d.ts

@@ -6,7 +6,7 @@ interface ManifestFunction {
     runtime: string;
     schedule?: string;
 }
-interface Manifest {
+export interface Manifest {
     functions: ManifestFunction[];
     system: {
         arch: string;
@@ -15,9 +15,8 @@ interface Manifest {
     timestamp: number;
     version: number;
 }
-declare const createManifest: ({ functions, path }: {
+export declare const createManifest: ({ functions, path }: {
     functions: FunctionResult[];
     path: string;
 }) => Promise<void>;
-export { createManifest };
-export type { Manifest };
+export {};

package/dist/runtimes/detect_runtime.d.ts

@@ -1,7 +1,6 @@
 import { FsCache } from '../utils/fs';
 import type { RuntimeName } from './runtime';
-declare const detectBinaryRuntime: ({ fsCache, path, }: {
+export declare const detectBinaryRuntime: ({ fsCache, path, }: {
     fsCache: FsCache;
     path: string;
 }) => Promise<RuntimeName | undefined>;
-export { detectBinaryRuntime };

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-declare const build: ({ destPath, mainFile, srcDir }: {
+export declare const build: ({ destPath, mainFile, srcDir }: {
     destPath: string;
     mainFile: string;
     srcDir: string;
@@ -10,4 +10,3 @@ declare const build: ({ destPath, mainFile, srcDir }: {
     srcPath: string;
     stat: import("fs").Stats;
 }>;
-export { build };

package/dist/runtimes/index.d.ts

@@ -5,7 +5,7 @@ declare type FunctionMap = Map<string, FunctionSource>;
 /**
  * Gets a list of functions found in a list of paths.
  */
-declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, featureFlags, }?: {
+export declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, featureFlags, }?: {
     config?: Config | undefined;
     dedupe?: boolean | undefined;
     featureFlags?: FeatureFlags | undefined;
@@ -13,8 +13,8 @@ declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, feature
 /**
  * Gets a list of functions found in a list of paths.
  */
-declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
+export declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
     config?: Config | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionSource | undefined>;
-export { getFunctionsFromPaths, getFunctionFromPath };
+export {};

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

@@ -1,6 +1,6 @@
 import type { FunctionConfig } from '../../../../config';
-declare const ESBUILD_LOG_LIMIT = 10;
-declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
+export declare const ESBUILD_LOG_LIMIT = 10;
+export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, ignoredModules, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;
     basePath?: string | undefined;
     config: FunctionConfig;
@@ -18,4 +18,3 @@ declare const bundleJsFile: ({ additionalModulePaths, basePath, config, external
     nodeModulesWithDynamicImports: string[];
     warnings: import("@netlify/esbuild").Message[];
 }>;
-export { bundleJsFile, ESBUILD_LOG_LIMIT };

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ESBUILD_LOG_LIMIT = exports.bundleJsFile = void 0;
+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");
@@ -12,8 +12,7 @@ const plugin_node_builtin_1 = require("./plugin_node_builtin");
 // 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.
-const ESBUILD_LOG_LIMIT = 10;
-exports.ESBUILD_LOG_LIMIT = ESBUILD_LOG_LIMIT;
+exports.ESBUILD_LOG_LIMIT = 10;
 // When resolving imports with no extension (e.g. require('./foo')), these are
 // the extensions that esbuild will look for, in this order.
 const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.json'];
@@ -59,7 +58,7 @@ const bundleJsFile = async function ({ additionalModulePaths, basePath, config,
             entryPoints: [srcFile],
             external,
             logLevel: 'warning',
-            logLimit: ESBUILD_LOG_LIMIT,
+            logLimit: exports.ESBUILD_LOG_LIMIT,
             metafile: true,
             nodePaths: additionalModulePaths,
             outdir: targetDirectory,

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

@@ -6,5 +6,5 @@ declare const versionMap: {
 };
 declare type VersionKeys = keyof typeof versionMap;
 declare type VersionValues = typeof versionMap[VersionKeys];
-declare const getBundlerTarget: (suppliedVersion?: string | undefined) => VersionValues;
-export { getBundlerTarget };
+export declare const getBundlerTarget: (suppliedVersion?: string | undefined) => VersionValues;
+export {};

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

@@ -1,9 +1,8 @@
 import type { Plugin } from '@netlify/esbuild';
-declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, }: {
+export declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, }: {
     basePath?: string | undefined;
     includedPaths: Set<string>;
     moduleNames: Set<string>;
     processImports: boolean;
     srcDir: string;
 }) => Plugin;
-export { getDynamicImportsPlugin };

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

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

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

@@ -1,3 +1,2 @@
 import type { Plugin } from '@netlify/esbuild';
-declare const getNodeBuiltinPlugin: () => Plugin;
-export { getNodeBuiltinPlugin };
+export declare const getNodeBuiltinPlugin: () => Plugin;

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

@@ -1,7 +1,6 @@
-declare const getExternalAndIgnoredModulesFromSpecialCases: ({ srcDir }: {
+export declare const getExternalAndIgnoredModulesFromSpecialCases: ({ srcDir }: {
     srcDir: string;
 }) => Promise<{
     externalModules: string[];
     ignoredModules: string[];
 }>;
-export { getExternalAndIgnoredModulesFromSpecialCases };

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

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

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

@@ -6,8 +6,8 @@ import { ModuleFormat } from '../utils/module_format';
 export declare type NodeBundlerName = 'esbuild' | 'esbuild_zisi' | 'nft' | 'zisi';
 declare type BundlerWarning = Message;
 declare type CleanupFunction = () => Promise<void>;
-declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
-declare type BundleFunction = (args: {
+export declare type NativeNodeModules = Record<string, Record<string, string | undefined>>;
+export declare type BundleFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: Record<FeatureFlag, boolean>;
@@ -26,7 +26,7 @@ declare type BundleFunction = (args: {
     nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
 }>;
-declare type GetSrcFilesFunction = (args: {
+export declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;
@@ -37,11 +37,10 @@ interface NodeBundler {
     bundle: BundleFunction;
     getSrcFiles: GetSrcFilesFunction;
 }
-declare const getBundler: (name: NodeBundlerName) => NodeBundler;
-declare const getDefaultBundler: ({ extension, mainFile, featureFlags, }: {
+export declare const getBundler: (name: NodeBundlerName) => NodeBundler;
+export declare const getDefaultBundler: ({ extension, mainFile, featureFlags, }: {
     extension: string;
     mainFile: string;
     featureFlags: FeatureFlags;
 }) => Promise<NodeBundlerName>;
-export { getBundler, getDefaultBundler };
-export type { BundleFunction, GetSrcFilesFunction, NativeNodeModules };
+export {};

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

@@ -3,7 +3,7 @@ import type { FunctionConfig } from '../../../../config';
 import { FeatureFlags } from '../../../../feature_flags';
 import { FsCache } from '../../../../utils/fs';
 import { ModuleFormat } from '../../utils/module_format';
-declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }: {
+export declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache, mainFile, reasons, }: {
     basePath: string | undefined;
     config: FunctionConfig;
     esmPaths: Set<string>;
@@ -15,4 +15,3 @@ declare const processESM: ({ basePath, config, esmPaths, featureFlags, fsCache,
     rewrites?: Map<string, string> | undefined;
     moduleFormat: ModuleFormat;
 }>;
-export { processESM };

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 };
+export declare const transpile: (path: string, config: FunctionConfig) => Promise<string>;

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

@@ -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

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, }: {
+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/src_files.d.ts

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

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, }: {
+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,6 +1,7 @@
 "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");
@@ -42,8 +43,7 @@ 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),
@@ -56,7 +56,7 @@ const isExcludedModule = function (moduleName) {
 };
 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 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/finder.d.ts

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

package/dist/runtimes/node/finder.js

@@ -20,7 +20,7 @@ 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) => {
         // We first sort the functions array to put directories first. This is so

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 {
+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,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPath = void 0;
+exports.findISCDeclarationsInPath = exports.IN_SOURCE_CONFIG_MODULE = 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.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.
@@ -16,9 +15,9 @@ const findISCDeclarationsInPath = async (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_1.getImports)(node, exports.IN_SOURCE_CONFIG_MODULE));
+    const mainExports = (0, exports_1.getMainExport)(ast.body);
+    const iscExports = mainExports
         .map(({ args, local: exportName }) => {
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
         if (matchingImport === undefined) {

package/dist/runtimes/node/parser/exports.d.ts

@@ -1,4 +1,3 @@
 import { Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config';
-declare const getMainExport: (nodes: Statement[]) => ISCExport[];
-export { getMainExport };
+export declare const getMainExport: (nodes: Statement[]) => ISCExport[];

package/dist/runtimes/node/parser/helpers.d.ts

@@ -1,7 +1,6 @@
 import { AssignmentExpression, Expression, ExpressionStatement, ImportDeclaration, Statement } from '@babel/types';
-declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
-declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
+export declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
+export declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
     expression: AssignmentExpression;
 };
-declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;
-export { isImport, isModuleExports, isRequire };
+export declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;

package/dist/runtimes/node/parser/imports.d.ts

@@ -1,6 +1,5 @@
 import { Statement } from '@babel/types';
-declare const getImports: (node: Statement, importPath: string) => {
+export declare const getImports: (node: Statement, importPath: string) => {
     imported: string;
     local: string;
 }[];
-export { getImports };

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

@@ -1,4 +1,4 @@
-declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
+export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
     basePath: string;
     expression: string;
     resolveDir: string;
@@ -6,5 +6,4 @@ declare const parseExpression: ({ basePath, expression: rawExpression, resolveDi
     includedPathsGlob: string | null | undefined;
     type: string;
 } | undefined;
-declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;
-export { parseExpression, safelyParseFile };
+export declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;

package/dist/runtimes/node/utils/base_path.d.ts

@@ -1,2 +1 @@
-declare const getBasePath: (dirnames: string[]) => string;
-export { getBasePath };
+export declare const getBasePath: (dirnames: string[]) => string;

package/dist/runtimes/node/utils/detect_es_module.d.ts

@@ -1,4 +1,3 @@
-declare const detectEsModule: ({ mainFile }: {
+export declare const detectEsModule: ({ mainFile }: {
     mainFile: string;
 }) => Promise<boolean>;
-export { detectEsModule };

package/dist/runtimes/node/utils/detect_native_module.d.ts

@@ -1,3 +1,2 @@
 import { PackageJson } from './package_json';
-declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;
-export { isNativeModule };
+export declare const isNativeModule: ({ binary, dependencies, devDependencies, files, gypfile, }: PackageJson) => boolean;

package/dist/runtimes/node/utils/entry_file.d.ts

@@ -1,13 +1,12 @@
 import type { ModuleFormat } from './module_format';
-interface EntryFile {
+export interface EntryFile {
     contents: string;
     filename: string;
 }
-declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
+export declare const getEntryFile: ({ commonPrefix, filename, mainFile, moduleFormat, userNamespace, }: {
     commonPrefix: string;
     filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;
     userNamespace: string;
 }) => EntryFile;
-export { EntryFile, getEntryFile };

package/dist/runtimes/node/utils/included_files.d.ts

@@ -1,6 +1,5 @@
-declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
-declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
+export declare const filterExcludedPaths: (paths: string[], exclude?: string[]) => string[];
+export declare const getPathsOfIncludedFiles: (includedFiles: string[], basePath?: string | undefined) => Promise<{
     exclude: string[];
     paths: string[];
 }>;
-export { filterExcludedPaths, getPathsOfIncludedFiles };

package/dist/runtimes/node/utils/module.d.ts

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

package/dist/runtimes/node/utils/node_version.d.ts

@@ -1,10 +1,10 @@
 declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
-declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
-interface NodeVersionSupport {
+export declare type NodeVersionString = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+export interface NodeVersionSupport {
     esm: boolean;
 }
-declare const DEFAULT_NODE_VERSION = 14;
-declare const getNodeVersion: (configVersion?: string | undefined) => number;
-declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
-declare const parseVersion: (input: string | undefined) => number | undefined;
-export { DEFAULT_NODE_VERSION, getNodeSupportMatrix, getNodeVersion, NodeVersionString, NodeVersionSupport, parseVersion, };
+export declare const DEFAULT_NODE_VERSION = 14;
+export declare const getNodeVersion: (configVersion?: string | undefined) => number;
+export declare const getNodeSupportMatrix: (configVersion?: string | undefined) => NodeVersionSupport;
+export declare const parseVersion: (input: string | undefined) => number | undefined;
+export {};

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

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVersion = exports.getNodeVersion = exports.getNodeSupportMatrix = exports.DEFAULT_NODE_VERSION = void 0;
+exports.parseVersion = exports.getNodeSupportMatrix = exports.getNodeVersion = exports.DEFAULT_NODE_VERSION = void 0;
 // Must match the default version used in Bitballoon.
-const DEFAULT_NODE_VERSION = 14;
-exports.DEFAULT_NODE_VERSION = DEFAULT_NODE_VERSION;
+exports.DEFAULT_NODE_VERSION = 14;
 const VERSION_REGEX = /(nodejs)?(\d+)\.x/;
-const getNodeVersion = (configVersion) => { var _a; return (_a = parseVersion(configVersion)) !== null && _a !== void 0 ? _a : DEFAULT_NODE_VERSION; };
+const getNodeVersion = (configVersion) => { var _a; return (_a = (0, exports.parseVersion)(configVersion)) !== null && _a !== void 0 ? _a : exports.DEFAULT_NODE_VERSION; };
 exports.getNodeVersion = getNodeVersion;
 const getNodeSupportMatrix = (configVersion) => {
-    const versionNumber = getNodeVersion(configVersion);
+    const versionNumber = (0, exports.getNodeVersion)(configVersion);
     return {
         esm: versionNumber >= 14,
     };

package/dist/runtimes/node/utils/normalize_path.d.ts

@@ -1,6 +1,5 @@
-declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
+export declare const normalizeFilePath: ({ commonPrefix, path, userNamespace, }: {
     commonPrefix: string;
     path: string;
     userNamespace: string;
 }) => string;
-export { normalizeFilePath };

package/dist/runtimes/node/utils/package_json.d.ts

@@ -1,4 +1,4 @@
-interface PackageJson {
+export interface PackageJson {
     name?: string;
     version?: string;
     dependencies?: Record<string, string>;
@@ -13,7 +13,6 @@ interface PackageJson {
     binary?: boolean;
     type?: string;
 }
-declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;
-declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
-declare const getPackageJsonIfAvailable: (srcDir: string) => Promise<PackageJson>;
-export { getPackageJson, getPackageJsonIfAvailable, PackageJson, sanitisePackageJson };
+export declare const sanitisePackageJson: (packageJson: Record<string, unknown>) => PackageJson;
+export declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
+export declare const getPackageJsonIfAvailable: (srcDir: string) => Promise<PackageJson>;

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

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitisePackageJson = exports.getPackageJsonIfAvailable = exports.getPackageJson = void 0;
+exports.getPackageJsonIfAvailable = exports.getPackageJson = exports.sanitisePackageJson = void 0;
+const fs_1 = require("fs");
 const pkg_dir_1 = __importDefault(require("pkg-dir"));
 const sanitiseFiles = (files) => {
     if (!Array.isArray(files)) {
@@ -25,9 +26,8 @@ const getPackageJson = async function (srcDir) {
     const packageJsonPath = `${packageRoot}/package.json`;
     try {
         // The path depends on the user's build, i.e. must be dynamic
-        // eslint-disable-next-line import/no-dynamic-require, node/global-require, @typescript-eslint/no-var-requires
-        const packageJson = require(packageJsonPath);
-        return sanitisePackageJson(packageJson);
+        const packageJson = JSON.parse(await fs_1.promises.readFile(packageJsonPath, 'utf8'));
+        return (0, exports.sanitisePackageJson)(packageJson);
     }
     catch (error) {
         throw new Error(`${packageJsonPath} is invalid JSON: ${error.message}`);
@@ -36,7 +36,7 @@ const getPackageJson = async function (srcDir) {
 exports.getPackageJson = getPackageJson;
 const getPackageJsonIfAvailable = async (srcDir) => {
     try {
-        const packageJson = await getPackageJson(srcDir);
+        const packageJson = await (0, exports.getPackageJson)(srcDir);
         return packageJson;
     }
     catch {

package/dist/runtimes/node/utils/plugin_modules_path.d.ts

@@ -1,3 +1,2 @@
-declare const createAliases: (paths: string[], pluginsModulesPath: string | undefined, aliases: Map<string, string>, basePath: string) => void;
-declare const getPluginsModulesPath: (srcDir: string) => Promise<string | undefined>;
-export { createAliases, getPluginsModulesPath };
+export declare const createAliases: (paths: string[], pluginsModulesPath: string | undefined, aliases: Map<string, string>, basePath: string) => void;
+export declare const getPluginsModulesPath: (srcDir: string) => Promise<string | undefined>;

package/dist/runtimes/node/utils/traversal_cache.d.ts

@@ -1,7 +1,6 @@
-interface TraversalCache {
+export interface TraversalCache {
     localFiles: Set<string>;
     moduleNames: Set<string>;
     modulePaths: Set<string>;
 }
-declare const getNewCache: () => TraversalCache;
-export { TraversalCache, getNewCache };
+export declare const getNewCache: () => TraversalCache;

package/dist/runtimes/node/utils/zip.d.ts

@@ -1,5 +1,5 @@
 import type { ModuleFormat } from './module_format';
-declare type ArchiveFormat = 'none' | 'zip';
+export declare type ArchiveFormat = 'none' | 'zip';
 interface ZipNodeParameters {
     aliases?: Map<string, string>;
     basePath: string;
@@ -11,7 +11,7 @@ interface ZipNodeParameters {
     rewrites?: Map<string, string>;
     srcFiles: string[];
 }
-declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {
+export declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {
     archiveFormat: ArchiveFormat;
 }) => Promise<string>;
-export { ArchiveFormat, zipNodeJs };
+export {};

package/dist/runtimes/runtime.d.ts

@@ -5,24 +5,24 @@ import { FunctionSource, SourceFile } from '../function';
 import { FsCache } from '../utils/fs';
 import type { NodeBundlerName } from './node/bundlers';
 import type { ISCValues } from './node/in_source_config';
-declare type RuntimeName = 'go' | 'js' | 'rs';
-declare type FindFunctionsInPathsFunction = (args: {
+export declare type RuntimeName = 'go' | 'js' | 'rs';
+export declare type FindFunctionsInPathsFunction = (args: {
     featureFlags: FeatureFlags;
     fsCache: FsCache;
     paths: string[];
 }) => Promise<SourceFile[]>;
-declare type FindFunctionInPathFunction = (args: {
+export declare type FindFunctionInPathFunction = (args: {
     featureFlags: FeatureFlags;
     fsCache: FsCache;
     path: string;
 }) => Promise<SourceFile | undefined>;
-declare type GetSrcFilesFunction = (args: {
+export declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<string[]>;
-interface ZipFunctionResult {
+export interface ZipFunctionResult {
     bundler?: NodeBundlerName;
     bundlerErrors?: object[];
     bundlerWarnings?: object[];
@@ -33,7 +33,7 @@ interface ZipFunctionResult {
     nodeModulesWithDynamicImports?: string[];
     path: string;
 }
-declare type ZipFunction = (args: {
+export declare type ZipFunction = (args: {
     archiveFormat: ArchiveFormat;
     basePath?: string;
     config: FunctionConfig;
@@ -41,11 +41,10 @@ declare type ZipFunction = (args: {
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<ZipFunctionResult>;
-interface Runtime {
+export interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;
     findFunctionInPath: FindFunctionInPathFunction;
     getSrcFiles?: GetSrcFilesFunction;
     name: RuntimeName;
     zipFunction: ZipFunction;
 }
-export { FindFunctionInPathFunction, FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult, };

package/dist/runtimes/rust/builder.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { FunctionConfig } from '../../config';
-declare const build: ({ config, name, srcDir }: {
+export declare const build: ({ config, name, srcDir }: {
     config: FunctionConfig;
     name: string;
     srcDir: string;
@@ -8,4 +8,3 @@ declare const build: ({ config, name, srcDir }: {
     path: string;
     stat: import("fs").Stats;
 }>;
-export { build };

package/dist/runtimes/rust/cargo_manifest.d.ts

@@ -1,6 +1,5 @@
-interface CargoManifest {
+export interface CargoManifest {
     package: {
         name: string;
     };
 }
-export { CargoManifest };

package/dist/runtimes/rust/constants.d.ts

@@ -1,3 +1,2 @@
-declare const BUILD_TARGET = "x86_64-unknown-linux-musl";
-declare const MANIFEST_NAME = "Cargo.toml";
-export { BUILD_TARGET, MANIFEST_NAME };
+export declare const BUILD_TARGET = "x86_64-unknown-linux-musl";
+export declare const MANIFEST_NAME = "Cargo.toml";

package/dist/runtimes/rust/constants.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MANIFEST_NAME = exports.BUILD_TARGET = void 0;
-const BUILD_TARGET = 'x86_64-unknown-linux-musl';
-exports.BUILD_TARGET = BUILD_TARGET;
-const MANIFEST_NAME = 'Cargo.toml';
-exports.MANIFEST_NAME = MANIFEST_NAME;
+exports.BUILD_TARGET = 'x86_64-unknown-linux-musl';
+exports.MANIFEST_NAME = 'Cargo.toml';
 //# sourceMappingURL=constants.js.map

package/dist/utils/archive_size.d.ts

@@ -1,3 +1,2 @@
 import type { FunctionArchive } from '../function';
-declare const addArchiveSize: (result: FunctionArchive) => Promise<FunctionArchive>;
-export { addArchiveSize };
+export declare const addArchiveSize: (result: FunctionArchive) => Promise<FunctionArchive>;

package/dist/utils/format_result.d.ts

@@ -1,9 +1,7 @@
 import { FunctionArchive } from '../function';
 import { RuntimeName } from '../runtimes/runtime';
-declare type FunctionResult = Omit<FunctionArchive, 'runtime'> & {
+export declare type FunctionResult = Omit<FunctionArchive, 'runtime'> & {
     runtime: RuntimeName;
     schedule?: string;
 };
-declare const formatZipResult: (archive: FunctionArchive) => FunctionResult;
-export { formatZipResult };
-export type { FunctionResult };
+export declare const formatZipResult: (archive: FunctionArchive) => FunctionResult;

package/dist/utils/fs.d.ts

@@ -1,18 +1,16 @@
 /// <reference types="node" />
 import { promises as fs } from 'fs';
-declare type FsCache = Record<string, unknown>;
-declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
-declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
+export declare type FsCache = Record<string, unknown>;
+export declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
+export declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
     withFileTypes: true;
 }) => Promise<import("fs").Dirent[]>;
-declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
+export declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
     flag?: import("fs").OpenMode | undefined;
 }) | null | undefined) => Promise<string | Buffer>;
-declare const getPathWithExtension: (path: string, extension: string) => string;
-declare const safeUnlink: (path: string) => Promise<void>;
-declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;
-declare const listFunctionsDirectory: (srcFolder: string) => Promise<string[]>;
-declare const resolveFunctionsDirectories: (input: string | string[]) => string[];
-declare const mkdirAndWriteFile: typeof fs.writeFile;
-export { cachedLstat, cachedReaddir, cachedReadFile, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, mkdirAndWriteFile, };
-export type { FsCache };
+export declare const getPathWithExtension: (path: string, extension: string) => string;
+export declare const safeUnlink: (path: string) => Promise<void>;
+export declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;
+export declare const listFunctionsDirectory: (srcFolder: string) => Promise<string[]>;
+export declare const resolveFunctionsDirectories: (input: string | string[]) => string[];
+export declare const mkdirAndWriteFile: typeof fs.writeFile;

package/dist/utils/fs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdirAndWriteFile = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
+exports.mkdirAndWriteFile = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.safeUnlink = exports.getPathWithExtension = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const non_nullable_1 = require("./non_nullable");
@@ -18,12 +18,9 @@ const makeCachedFunction = (func) => (cache, path, ...args) => {
     }
     return cache[key];
 };
-const cachedLstat = makeCachedFunction(fs_1.promises.lstat);
-exports.cachedLstat = cachedLstat;
-const cachedReaddir = makeCachedFunction(fs_1.promises.readdir);
-exports.cachedReaddir = cachedReaddir;
-const cachedReadFile = makeCachedFunction(fs_1.promises.readFile);
-exports.cachedReadFile = cachedReadFile;
+exports.cachedLstat = makeCachedFunction(fs_1.promises.lstat);
+exports.cachedReaddir = makeCachedFunction(fs_1.promises.readdir);
+exports.cachedReadFile = makeCachedFunction(fs_1.promises.readFile);
 const getPathWithExtension = (path, extension) => (0, path_1.format)({ ...(0, path_1.parse)(path), base: undefined, ext: extension });
 exports.getPathWithExtension = getPathWithExtension;
 const safeUnlink = async (path) => {
@@ -39,7 +36,7 @@ exports.safeUnlink = safeUnlink;
 const listFunctionsDirectories = async function (srcFolders) {
     const filenamesByDirectory = await Promise.all(srcFolders.map(async (srcFolder) => {
         try {
-            const filenames = await listFunctionsDirectory(srcFolder);
+            const filenames = await (0, exports.listFunctionsDirectory)(srcFolder);
             return filenames;
         }
         catch {

package/dist/utils/non_nullable.d.ts

@@ -1,2 +1 @@
-declare const nonNullable: <T>(value: T) => value is NonNullable<T>;
-export { nonNullable };
+export declare const nonNullable: <T>(value: T) => value is NonNullable<T>;

package/dist/utils/remove_undefined.d.ts

@@ -1,2 +1 @@
-declare const removeUndefined: <T>(obj: T) => T;
-export { removeUndefined };
+export declare const removeUndefined: <T>(obj: T) => T;

package/dist/zip.d.ts

@@ -13,9 +13,9 @@ declare type ZipFunctionsOptions = ZipFunctionOptions & {
     manifest?: string;
     parallelLimit?: number;
 };
-declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function").FunctionArchive, "runtime"> & {
+export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function").FunctionArchive, "runtime"> & {
     runtime: import("./runtimes/runtime").RuntimeName;
     schedule?: string | undefined;
 })[]>;
-declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result").FunctionResult | undefined>;
-export { zipFunction, zipFunctions };
+export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result").FunctionResult | undefined>;
+export {};

package/dist/zip.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zipFunctions = exports.zipFunction = void 0;
+exports.zipFunction = exports.zipFunctions = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const p_map_1 = __importDefault(require("p-map"));

package/dist/zip_binary.d.ts

@@ -1,10 +1,9 @@
 import type { Stats } from 'fs';
 import { Runtime } from './runtimes/runtime';
-declare const zipBinary: ({ destPath, filename, runtime, srcPath, stat, }: {
+export declare const zipBinary: ({ destPath, filename, runtime, srcPath, stat, }: {
     destPath: string;
     filename: string;
     runtime: Runtime;
     srcPath: string;
     stat: Stats;
 }) => Promise<void>;
-export { zipBinary };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.7.2",
+  "version": "5.7.3",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {