@vercel/build-utils 2.12.3-canary.3 → 2.12.3-canary.33

package/dist/convert-runtime-to-plugin.d.ts

@@ -0,0 +1,65 @@
+import { Lambda } from './lambda';
+import type { BuildOptions } from './types';
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param packageName - the name of the package, for example `vercel-plugin-python`
+ * @param ext - the file extension, for example `.py`
+ */
+export declare function convertRuntimeToPlugin(buildRuntime: (options: BuildOptions) => Promise<{
+    output: Lambda;
+}>, packageName: string, ext: string): ({ workPath }: {
+    workPath: string;
+}) => Promise<void>;
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file.
+ */
+export declare function updateFunctionsManifest({ workPath, pages, }: {
+    workPath: string;
+    pages: {
+        [key: string]: any;
+    };
+}): Promise<void>;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+export declare function updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }: {
+    workPath: string;
+    redirects?: {
+        source: string;
+        destination: string;
+        statusCode: number;
+        regex: string;
+    }[];
+    rewrites?: {
+        source: string;
+        destination: string;
+        regex: string;
+    }[];
+    headers?: {
+        source: string;
+        headers: {
+            key: string;
+            value: string;
+        }[];
+        regex: string;
+    }[];
+    dynamicRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+    staticRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+}): Promise<void>;

package/dist/convert-runtime-to-plugin.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateRoutesManifest = exports.updateFunctionsManifest = exports.convertRuntimeToPlugin = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const glob_1 = __importDefault(require("./fs/glob"));
+const normalize_path_1 = require("./fs/normalize-path");
+const lambda_1 = require("./lambda");
+const _1 = require(".");
+// `.output` was already created by the Build Command, so we have
+// to ensure its contents don't get bundled into the Lambda. Similarily,
+// we don't want to bundle anything from `.vercel` either. Lastly,
+// Builders/Runtimes didn't have `vercel.json` or `now.json`.
+const ignoredPaths = ['.output', '.vercel', 'vercel.json', 'now.json'];
+const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
+    const isNative = ignoredPaths.some(item => {
+        return file.startsWith(item);
+    });
+    if (!ignoreFile) {
+        return isNative;
+    }
+    return isNative || ignoreFilter(file);
+};
+const getSourceFiles = async (workPath, ignoreFilter) => {
+    const list = await glob_1.default('**', {
+        cwd: workPath,
+    });
+    // We're not passing this as an `ignore` filter to the `glob` function above,
+    // so that we can re-use exactly the same `getIgnoreFilter` method that the
+    // Build Step uses (literally the same code). Note that this exclusion only applies
+    // when deploying. Locally, another exclusion is needed, which is handled
+    // further below in the `convertRuntimeToPlugin` function.
+    for (const file in list) {
+        if (shouldIgnorePath(file, ignoreFilter, true)) {
+            delete list[file];
+        }
+    }
+    return list;
+};
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param packageName - the name of the package, for example `vercel-plugin-python`
+ * @param ext - the file extension, for example `.py`
+ */
+function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
+    // This `build()` signature should match `plugin.build()` signature in `vercel build`.
+    return async function build({ workPath }) {
+        // We also don't want to provide any files to Runtimes that were ignored
+        // through `.vercelignore` or `.nowignore`, because the Build Step does the same.
+        const ignoreFilter = await _1.getIgnoreFilter(workPath);
+        // Retrieve the files that are currently available on the File System,
+        // before the Legacy Runtime has even started to build.
+        const sourceFilesPreBuild = await getSourceFiles(workPath, ignoreFilter);
+        // Instead of doing another `glob` to get all the matching source files,
+        // we'll filter the list of existing files down to only the ones
+        // that are matching the entrypoint pattern, so we're first creating
+        // a clean new list to begin.
+        const entrypoints = Object.assign({}, sourceFilesPreBuild);
+        const entrypointMatch = new RegExp(`^api/.*${ext}$`);
+        // Up next, we'll strip out the files from the list of entrypoints
+        // that aren't actually considered entrypoints.
+        for (const file in entrypoints) {
+            if (!entrypointMatch.test(file)) {
+                delete entrypoints[file];
+            }
+        }
+        const pages = {};
+        const pluginName = packageName.replace('vercel-plugin-', '');
+        const traceDir = path_1.join(workPath, `.output`, `inputs`, 
+        // Legacy Runtimes can only provide API Routes, so that's
+        // why we can use this prefix for all of them. Here, we have to
+        // make sure to not use a cryptic hash name, because people
+        // need to be able to easily inspect the output.
+        `api-routes-${pluginName}`);
+        await fs_extra_1.default.ensureDir(traceDir);
+        let newPathsRuntime = new Set();
+        let linkersRuntime = [];
+        for (const entrypoint of Object.keys(entrypoints)) {
+            const { output } = await buildRuntime({
+                files: sourceFilesPreBuild,
+                entrypoint,
+                workPath,
+                config: {
+                    zeroConfig: true,
+                },
+                meta: {
+                    avoidTopLevelInstall: true,
+                },
+            });
+            // Legacy Runtimes tend to pollute the `workPath` with compiled results,
+            // because the `workPath` used to be a place that was a place where they could
+            // just put anything, but nowadays it's the working directory of the `vercel build`
+            // command, which is the place where the developer keeps their source files,
+            // so we don't want to pollute this space unnecessarily. That means we have to clean
+            // up files that were created by the build, which is done further below.
+            const sourceFilesAfterBuild = await getSourceFiles(workPath, ignoreFilter);
+            // Further down, we will need the filename of the Lambda handler
+            // for placing it inside `server/pages/api`, but because Legacy Runtimes
+            // don't expose the filename directly, we have to construct it
+            // from the handler name, and then find the matching file further below,
+            // because we don't yet know its extension here.
+            const handler = output.handler;
+            const handlerMethod = handler.split('.').reverse()[0];
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
+            pages[entrypoint] = {
+                handler: handler,
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
+            // @ts-ignore This symbol is a private API
+            const lambdaFiles = output[lambda_1.FILES_SYMBOL];
+            // When deploying, the `files` that are passed to the Legacy Runtimes already
+            // have certain files that are ignored stripped, but locally, that list of
+            // files isn't used by the Legacy Runtimes, so we need to apply the filters
+            // to the outputs that they are returning instead.
+            for (const file in lambdaFiles) {
+                if (shouldIgnorePath(file, ignoreFilter, false)) {
+                    delete lambdaFiles[file];
+                }
+            }
+            const handlerFilePath = Object.keys(lambdaFiles).find(item => {
+                return path_1.parse(item).name === handlerFileName;
+            });
+            const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
+            if (!handlerFileOrigin) {
+                throw new Error(`Could not find a handler file. Please ensure that the list of \`files\` defined for the returned \`Lambda\` contains a file with the name ${handlerFileName} (+ any extension).`);
+            }
+            const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            await fs_extra_1.default.ensureDir(path_1.dirname(entry));
+            await linkOrCopy(handlerFileOrigin, entry);
+            const newFilesEntrypoint = [];
+            const newDirectoriesEntrypoint = [];
+            const preBuildFiles = Object.values(sourceFilesPreBuild).map(file => {
+                return file.fsPath;
+            });
+            // Generate a list of directories and files that weren't present
+            // before the entrypoint was processed by the Legacy Runtime, so
+            // that we can perform a cleanup later. We need to divide into files
+            // and directories because only cleaning up files might leave empty
+            // directories, and listing directories separately also speeds up the
+            // build because we can just delete them, which wipes all of their nested
+            // paths, instead of iterating through all files that should be deleted.
+            for (const file in sourceFilesAfterBuild) {
+                if (!sourceFilesPreBuild[file]) {
+                    const path = sourceFilesAfterBuild[file].fsPath;
+                    const dirPath = path_1.dirname(path);
+                    // If none of the files that were present before the entrypoint
+                    // was processed are contained within the directory we're looking
+                    // at right now, then we know it's a newly added directory
+                    // and it can therefore be removed later on.
+                    const isNewDir = !preBuildFiles.some(filePath => {
+                        return path_1.dirname(filePath).startsWith(dirPath);
+                    });
+                    // Check out the list of tracked directories that were
+                    // newly added and see if one of them contains the path
+                    // we're looking at.
+                    const hasParentDir = newDirectoriesEntrypoint.some(dir => {
+                        return path.startsWith(dir);
+                    });
+                    // If we have already tracked a directory that was newly
+                    // added that sits above the file or directory that we're
+                    // looking at, we don't need to add more entries to the list
+                    // because when the parent will get removed in the future,
+                    // all of its children (and therefore the path we're looking at)
+                    // will automatically get removed anyways.
+                    if (hasParentDir) {
+                        continue;
+                    }
+                    if (isNewDir) {
+                        newDirectoriesEntrypoint.push(dirPath);
+                    }
+                    else {
+                        newFilesEntrypoint.push(path);
+                    }
+                }
+            }
+            const tracedFiles = [];
+            const linkers = Object.entries(lambdaFiles).map(async ([relPath, file]) => {
+                const newPath = path_1.join(traceDir, relPath);
+                // The handler was already moved into position above.
+                if (relPath === handlerFilePath) {
+                    return;
+                }
+                tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
+                const { fsPath, type } = file;
+                if (fsPath) {
+                    await fs_extra_1.default.ensureDir(path_1.dirname(newPath));
+                    const isNewFile = newFilesEntrypoint.includes(fsPath);
+                    const isInsideNewDirectory = newDirectoriesEntrypoint.some(dirPath => {
+                        return fsPath.startsWith(dirPath);
+                    });
+                    // With this, we're making sure that files in the `workPath` that existed
+                    // before the Legacy Runtime was invoked (source files) are linked from
+                    // `.output` instead of copying there (the latter only happens if linking fails),
+                    // which is the fastest solution. However, files that are created fresh
+                    // by the Legacy Runtimes are always copied, because their link destinations
+                    // are likely to be overwritten every time an entrypoint is processed by
+                    // the Legacy Runtime. This is likely to overwrite the destination on subsequent
+                    // runs, but that's also how `workPath` used to work originally, without
+                    // the File System API (meaning that there was one `workPath` for all entrypoints).
+                    if (isNewFile || isInsideNewDirectory) {
+                        _1.debug(`Copying from ${fsPath} to ${newPath}`);
+                        await fs_extra_1.default.copy(fsPath, newPath);
+                    }
+                    else {
+                        await linkOrCopy(fsPath, newPath);
+                    }
+                }
+                else if (type === 'FileBlob') {
+                    const { data, mode } = file;
+                    await fs_extra_1.default.writeFile(newPath, data, { mode });
+                }
+                else {
+                    throw new Error(`Unknown file type: ${type}`);
+                }
+            });
+            linkersRuntime = linkersRuntime.concat(linkers);
+            const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
+            const json = JSON.stringify({
+                version: 1,
+                files: tracedFiles.map(file => ({
+                    input: normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), file.absolutePath)),
+                    output: normalize_path_1.normalizePath(file.relativePath),
+                })),
+            });
+            await fs_extra_1.default.ensureDir(path_1.dirname(nft));
+            await fs_extra_1.default.writeFile(nft, json);
+            // Extend the list of directories and files that were created by the
+            // Legacy Runtime with the list of directories and files that were
+            // created for the entrypoint that was just processed above.
+            newPathsRuntime = new Set([
+                ...newPathsRuntime,
+                ...newFilesEntrypoint,
+                ...newDirectoriesEntrypoint,
+            ]);
+        }
+        // Instead of of waiting for all of the linking to be done for every
+        // entrypoint before processing the next one, we immediately handle all
+        // of them one after the other, while then waiting for the linking
+        // to finish right here, before we clean up newly created files below.
+        await Promise.all(linkersRuntime);
+        // A list of all the files that were created by the Legacy Runtime,
+        // which we'd like to remove from the File System.
+        const toRemove = Array.from(newPathsRuntime).map(path => {
+            _1.debug(`Removing ${path} as part of cleanup`);
+            return fs_extra_1.default.remove(path);
+        });
+        // Once all the entrypoints have been processed, we'd like to
+        // remove all the files from `workPath` that originally weren't present
+        // before the Legacy Runtime began running, because the `workPath`
+        // is nowadays the directory in which the user keeps their source code, since
+        // we're no longer running separate parallel builds for every Legacy Runtime.
+        await Promise.all(toRemove);
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
+        await updateFunctionsManifest({ workPath, pages });
+    };
+}
+exports.convertRuntimeToPlugin = convertRuntimeToPlugin;
+async function linkOrCopy(existingPath, newPath) {
+    try {
+        await fs_extra_1.default.createLink(existingPath, newPath);
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST') {
+            await fs_extra_1.default.copyFile(existingPath, newPath);
+        }
+    }
+}
+async function readJson(filePath) {
+    try {
+        const str = await fs_extra_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(str);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file.
+ */
+async function updateFunctionsManifest({ workPath, pages, }) {
+    const functionsManifestPath = path_1.join(workPath, '.output', 'functions-manifest.json');
+    const functionsManifest = await readJson(functionsManifestPath);
+    if (!functionsManifest.version)
+        functionsManifest.version = 1;
+    if (!functionsManifest.pages)
+        functionsManifest.pages = {};
+    for (const [pageKey, pageConfig] of Object.entries(pages)) {
+        functionsManifest.pages[pageKey] = { ...pageConfig };
+    }
+    await fs_extra_1.default.writeFile(functionsManifestPath, JSON.stringify(functionsManifest));
+}
+exports.updateFunctionsManifest = updateFunctionsManifest;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+async function updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }) {
+    const routesManifestPath = path_1.join(workPath, '.output', 'routes-manifest.json');
+    const routesManifest = await readJson(routesManifestPath);
+    if (!routesManifest.version)
+        routesManifest.version = 3;
+    if (routesManifest.pages404 === undefined)
+        routesManifest.pages404 = true;
+    if (redirects) {
+        if (!routesManifest.redirects)
+            routesManifest.redirects = [];
+        routesManifest.redirects.push(...redirects);
+    }
+    if (rewrites) {
+        if (!routesManifest.rewrites)
+            routesManifest.rewrites = [];
+        routesManifest.rewrites.push(...rewrites);
+    }
+    if (headers) {
+        if (!routesManifest.headers)
+            routesManifest.headers = [];
+        routesManifest.headers.push(...headers);
+    }
+    if (dynamicRoutes) {
+        if (!routesManifest.dynamicRoutes)
+            routesManifest.dynamicRoutes = [];
+        routesManifest.dynamicRoutes.push(...dynamicRoutes);
+    }
+    if (staticRoutes) {
+        if (!routesManifest.staticRoutes)
+            routesManifest.staticRoutes = [];
+        routesManifest.staticRoutes.push(...staticRoutes);
+    }
+    await fs_extra_1.default.writeFile(routesManifestPath, JSON.stringify(routesManifest));
+}
+exports.updateRoutesManifest = updateRoutesManifest;

package/dist/detect-builders.d.ts

@@ -34,5 +34,11 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
+    limitedRoutes: LimitedRoutes | null;
 }>;
+interface LimitedRoutes {
+    defaultRoutes: Route[];
+    redirectRoutes: Route[];
+    rewriteRoutes: Route[];
+}
 export {};

package/dist/detect-builders.js

@@ -66,6 +66,7 @@ async function detectBuilders(files, pkg, options = {}) {
             redirectRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const sortedFiles = files.sort(sortFiles);
@@ -113,6 +114,7 @@ async function detectBuilders(files, pkg, options = {}) {
                     redirectRoutes: null,
                     rewriteRoutes: null,
                     errorRoutes: null,
+                    limitedRoutes: null,
                 };
             }
             if (apiRoute) {
@@ -167,6 +169,7 @@ async function detectBuilders(files, pkg, options = {}) {
                 defaultRoutes: null,
                 rewriteRoutes: null,
                 errorRoutes: null,
+                limitedRoutes: null,
             };
         }
         // If `outputDirectory` is an empty string,
@@ -203,6 +206,7 @@ async function detectBuilders(files, pkg, options = {}) {
             defaultRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const builders = [];
@@ -221,7 +225,7 @@ async function detectBuilders(files, pkg, options = {}) {
             });
         }
     }
-    const routesResult = getRouteResult(apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
+    const routesResult = getRouteResult(pkg, apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
     return {
         warnings,
         builders: builders.length ? builders : null,
@@ -230,6 +234,7 @@ async function detectBuilders(files, pkg, options = {}) {
         defaultRoutes: routesResult.defaultRoutes,
         rewriteRoutes: routesResult.rewriteRoutes,
         errorRoutes: routesResult.errorRoutes,
+        limitedRoutes: routesResult.limitedRoutes,
     };
 }
 exports.detectBuilders = detectBuilders;
@@ -670,23 +675,51 @@ function createRouteFromPath(filePath, featHandleMiss, cleanUrls) {
     }
     return { route, isDynamic };
 }
-function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
+function getRouteResult(pkg, apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
     var _a, _b;
+    const deps = Object.assign({}, pkg === null || pkg === void 0 ? void 0 : pkg.dependencies, pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies);
     const defaultRoutes = [];
     const redirectRoutes = [];
     const rewriteRoutes = [];
     const errorRoutes = [];
+    const limitedRoutes = {
+        defaultRoutes: [],
+        redirectRoutes: [],
+        rewriteRoutes: [],
+    };
     const framework = ((_a = frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.config) === null || _a === void 0 ? void 0 : _a.framework) || '';
     const isNextjs = framework === 'nextjs' || _1.isOfficialRuntime('next', frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.use);
     const ignoreRuntimes = (_b = slugToFramework.get(framework)) === null || _b === void 0 ? void 0 : _b.ignoreRuntimes;
     if (apiRoutes && apiRoutes.length > 0) {
         if (options.featHandleMiss) {
+            // Exclude extension names if the corresponding plugin is not found in package.json
+            // detectBuilders({ignoreRoutesForBuilders: ['@vercel/python']})
+            // return a copy of routes.
+            // We should exclud errorRoutes and
             const extSet = detectApiExtensions(apiBuilders);
+            const withTag = options.tag ? `@${options.tag}` : '';
+            const extSetLimited = detectApiExtensions(apiBuilders.filter(b => {
+                if (b.use === `@vercel/python${withTag}` &&
+                    !('vercel-plugin-python' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/go${withTag}` &&
+                    !('vercel-plugin-go' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/ruby${withTag}` &&
+                    !('vercel-plugin-ruby' in deps)) {
+                    return false;
+                }
+                return true;
+            }));
             if (extSet.size > 0) {
-                const exts = Array.from(extSet)
+                const extGroup = `(?:\\.(?:${Array.from(extSet)
                     .map(ext => ext.slice(1))
-                    .join('|');
-                const extGroup = `(?:\\.(?:${exts}))`;
+                    .join('|')}))`;
+                const extGroupLimited = `(?:\\.(?:${Array.from(extSetLimited)
+                    .map(ext => ext.slice(1))
+                    .join('|')}))`;
                 if (options.cleanUrls) {
                     redirectRoutes.push({
                         src: `^/(api(?:.+)?)/index${extGroup}?/?$`,
@@ -700,6 +733,18 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         },
                         status: 308,
                     });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/(api(?:.+)?)/index${extGroupLimited}?/?$`,
+                        headers: { Location: options.trailingSlash ? '/$1/' : '/$1' },
+                        status: 308,
+                    });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}/?$`,
+                        headers: {
+                            Location: options.trailingSlash ? '/api/$1/' : '/api/$1',
+                        },
+                        status: 308,
+                    });
                 }
                 else {
                     defaultRoutes.push({ handle: 'miss' });
@@ -708,9 +753,16 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         dest: '/api/$1',
                         check: true,
                     });
+                    limitedRoutes.defaultRoutes.push({ handle: 'miss' });
+                    limitedRoutes.defaultRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}$`,
+                        dest: '/api/$1',
+                        check: true,
+                    });
                 }
             }
             rewriteRoutes.push(...dynamicRoutes);
+            limitedRoutes.rewriteRoutes.push(...dynamicRoutes);
             if (typeof ignoreRuntimes === 'undefined') {
                 // This route is only necessary to hide the directory listing
                 // to avoid enumerating serverless function names.
@@ -755,6 +807,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
         redirectRoutes,
         rewriteRoutes,
         errorRoutes,
+        limitedRoutes,
     };
 }
 function sortFilesBySegmentCount(fileA, fileB) {

package/dist/fs/glob.js

@@ -8,6 +8,7 @@ const assert_1 = __importDefault(require("assert"));
 const glob_1 = __importDefault(require("glob"));
 const util_1 = require("util");
 const fs_extra_1 = require("fs-extra");
+const normalize_path_1 = require("./normalize-path");
 const file_fs_ref_1 = __importDefault(require("../file-fs-ref"));
 const vanillaGlob = util_1.promisify(glob_1.default);
 async function glob(pattern, opts, mountpoint) {
@@ -31,7 +32,7 @@ async function glob(pattern, opts, mountpoint) {
     options.dot = true;
     const files = await vanillaGlob(pattern, options);
     for (const relativePath of files) {
-        const fsPath = path_1.default.join(options.cwd, relativePath).replace(/\\/g, '/');
+        const fsPath = normalize_path_1.normalizePath(path_1.default.join(options.cwd, relativePath));
         let stat = options.statCache[fsPath];
         assert_1.default(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
         const isSymlink = options.symlinks[fsPath];

package/dist/fs/normalize-path.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert Windows separators to Unix separators.
+ */
+export declare function normalizePath(p: string): string;

package/dist/fs/normalize-path.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = void 0;
+const isWin = process.platform === 'win32';
+/**
+ * Convert Windows separators to Unix separators.
+ */
+function normalizePath(p) {
+    return isWin ? p.replace(/\\/g, '/') : p;
+}
+exports.normalizePath = normalizePath;

package/dist/get-ignore-filter.d.ts

@@ -0,0 +1 @@
+export default function (downloadPath: string, rootDirectory?: string | undefined): Promise<(p: string) => any>;

package/dist/get-ignore-filter.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ignore_1 = __importDefault(require("ignore"));
+function isCodedError(error) {
+    return (error !== null &&
+        error !== undefined &&
+        error.code !== undefined);
+}
+function clearRelative(s) {
+    return s.replace(/(\n|^)\.\//g, '$1');
+}
+async function default_1(downloadPath, rootDirectory) {
+    const readFile = async (p) => {
+        try {
+            return await fs_extra_1.default.readFile(p, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' ||
+                (error instanceof Error && error.message.includes('ENOENT'))) {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+    const vercelIgnorePath = path_1.default.join(downloadPath, rootDirectory || '', '.vercelignore');
+    const nowIgnorePath = path_1.default.join(downloadPath, rootDirectory || '', '.nowignore');
+    const ignoreContents = [];
+    try {
+        ignoreContents.push(...(await Promise.all([readFile(vercelIgnorePath), readFile(nowIgnorePath)])).filter(Boolean));
+    }
+    catch (error) {
+        if (isCodedError(error) && error.code === 'ENOTDIR') {
+            console.log(`Warning: Cannot read ignore file from ${vercelIgnorePath}`);
+        }
+        else {
+            throw error;
+        }
+    }
+    if (ignoreContents.length === 2) {
+        throw new Error('Cannot use both a `.vercelignore` and `.nowignore` file. Please delete the `.nowignore` file.');
+    }
+    if (ignoreContents.length === 0) {
+        return () => false;
+    }
+    const ignoreFilter = ignore_1.default().add(clearRelative(ignoreContents[0]));
+    return function (p) {
+        // we should not ignore now.json and vercel.json if it asked to.
+        // we depend on these files for building the app with sourceless
+        if (p === 'now.json' || p === 'vercel.json')
+            return false;
+        return ignoreFilter.test(p).ignored;
+    };
+}
+exports.default = default_1;