@vercel/build-utils 7.0.0 → 7.1.1

package/dist/file-ref.js

@@ -1,85 +1,105 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = __importDefault(require("assert"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const multistream_1 = __importDefault(require("multistream"));
-const async_retry_1 = __importDefault(require("async-retry"));
-const async_sema_1 = __importDefault(require("async-sema"));
-const semaToDownloadFromS3 = new async_sema_1.default(5);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_ref_exports = {};
+__export(file_ref_exports, {
+  default: () => FileRef
+});
+module.exports = __toCommonJS(file_ref_exports);
+var import_assert = __toESM(require("assert"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_multistream = __toESM(require("multistream"));
+var import_async_retry = __toESM(require("async-retry"));
+var import_async_sema = __toESM(require("async-sema"));
+const semaToDownloadFromS3 = new import_async_sema.default(5);
 class BailableError extends Error {
-    constructor(...args) {
-        super(...args);
-        this.bail = false;
-    }
+  constructor(...args) {
+    super(...args);
+    this.bail = false;
+  }
 }
 class FileRef {
-    constructor({ mode = 0o100644, digest, contentType, mutable = false, }) {
-        (0, assert_1.default)(typeof mode === 'number');
-        (0, assert_1.default)(typeof digest === 'string');
-        this.type = 'FileRef';
-        this.mode = mode;
-        this.digest = digest;
-        this.contentType = contentType;
-        this.mutable = mutable;
-    }
-    async toStreamAsync() {
-        let url = '';
-        // sha:24be087eef9fac01d61b30a725c1a10d7b45a256
-        const [digestType, digestHash] = this.digest.split(':');
-        if (digestType === 'sha') {
-            // This CloudFront URL edge caches the `now-files` S3 bucket to prevent
-            // overloading it. Mutable files cannot be cached.
-            // `https://now-files.s3.amazonaws.com/${digestHash}`
-            url = this.mutable
-                ? `https://now-files.s3.amazonaws.com/${digestHash}`
-                : `https://dmmcy0pwk6bqi.cloudfront.net/${digestHash}`;
-        }
-        else if (digestType === 'sha+ephemeral') {
-            // This URL is currently only used for cache files that constantly
-            // change. We shouldn't cache it on CloudFront because it'd always be a
-            // MISS.
-            url = `https://now-ephemeral-files.s3.amazonaws.com/${digestHash}`;
-        }
-        else {
-            throw new Error('Expected digest to be sha');
-        }
-        await semaToDownloadFromS3.acquire();
-        // console.time(`downloading ${url}`);
-        try {
-            return await (0, async_retry_1.default)(async () => {
-                const resp = await (0, node_fetch_1.default)(url);
-                if (!resp.ok) {
-                    const error = new BailableError(`download: ${resp.status} ${resp.statusText} for ${url}`);
-                    if (resp.status === 403)
-                        error.bail = true;
-                    throw error;
-                }
-                return resp.body;
-            }, { factor: 1, retries: 3 });
-        }
-        finally {
-            // console.timeEnd(`downloading ${url}`);
-            semaToDownloadFromS3.release();
-        }
+  constructor({
+    mode = 33188,
+    digest,
+    contentType,
+    mutable = false
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof digest === "string");
+    this.type = "FileRef";
+    this.mode = mode;
+    this.digest = digest;
+    this.contentType = contentType;
+    this.mutable = mutable;
+  }
+  async toStreamAsync() {
+    let url = "";
+    const [digestType, digestHash] = this.digest.split(":");
+    if (digestType === "sha") {
+      url = this.mutable ? `https://now-files.s3.amazonaws.com/${digestHash}` : `https://dmmcy0pwk6bqi.cloudfront.net/${digestHash}`;
+    } else if (digestType === "sha+ephemeral") {
+      url = `https://now-ephemeral-files.s3.amazonaws.com/${digestHash}`;
+    } else {
+      throw new Error("Expected digest to be sha");
     }
-    toStream() {
-        let flag = false;
-        // eslint-disable-next-line consistent-return
-        return (0, multistream_1.default)(cb => {
-            if (flag)
-                return cb(null, null);
-            flag = true;
-            this.toStreamAsync()
-                .then(stream => {
-                cb(null, stream);
-            })
-                .catch(error => {
-                cb(error, null);
-            });
-        });
+    await semaToDownloadFromS3.acquire();
+    try {
+      return await (0, import_async_retry.default)(
+        async () => {
+          const resp = await (0, import_node_fetch.default)(url);
+          if (!resp.ok) {
+            const error = new BailableError(
+              `download: ${resp.status} ${resp.statusText} for ${url}`
+            );
+            if (resp.status === 403)
+              error.bail = true;
+            throw error;
+          }
+          return resp.body;
+        },
+        { factor: 1, retries: 3 }
+      );
+    } finally {
+      semaToDownloadFromS3.release();
     }
+  }
+  toStream() {
+    let flag = false;
+    return (0, import_multistream.default)((cb) => {
+      if (flag)
+        return cb(null, null);
+      flag = true;
+      this.toStreamAsync().then((stream) => {
+        cb(null, stream);
+      }).catch((error) => {
+        cb(error, null);
+      });
+    });
+  }
 }
-exports.default = FileRef;

package/dist/fs/download.js

@@ -1,106 +1,136 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFile = exports.isSymbolicLink = exports.isDirectory = void 0;
-const path_1 = __importDefault(require("path"));
-const debug_1 = __importDefault(require("../debug"));
-const file_fs_ref_1 = __importDefault(require("../file-fs-ref"));
-const fs_extra_1 = require("fs-extra");
-const stream_to_buffer_1 = __importDefault(require("./stream-to-buffer"));
-const S_IFDIR = 16384; /* 0040000 directory */
-const S_IFLNK = 40960; /* 0120000 symbolic link */
-const S_IFMT = 61440; /* 0170000 type of file */
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var download_exports = {};
+__export(download_exports, {
+  default: () => download,
+  downloadFile: () => downloadFile,
+  isDirectory: () => isDirectory,
+  isSymbolicLink: () => isSymbolicLink
+});
+module.exports = __toCommonJS(download_exports);
+var import_path = __toESM(require("path"));
+var import_debug = __toESM(require("../debug"));
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+var import_fs_extra = require("fs-extra");
+var import_stream_to_buffer = __toESM(require("./stream-to-buffer"));
+const S_IFDIR = 16384;
+const S_IFLNK = 40960;
+const S_IFMT = 61440;
 function isDirectory(mode) {
-    return (mode & S_IFMT) === S_IFDIR;
+  return (mode & S_IFMT) === S_IFDIR;
 }
-exports.isDirectory = isDirectory;
 function isSymbolicLink(mode) {
-    return (mode & S_IFMT) === S_IFLNK;
+  return (mode & S_IFMT) === S_IFLNK;
 }
-exports.isSymbolicLink = isSymbolicLink;
 async function prepareSymlinkTarget(file, fsPath) {
-    const mkdirPromise = (0, fs_extra_1.mkdirp)(path_1.default.dirname(fsPath));
-    if (file.type === 'FileFsRef') {
-        const [target] = await Promise.all([(0, fs_extra_1.readlink)(file.fsPath), mkdirPromise]);
-        return target;
-    }
-    if (file.type === 'FileRef' || file.type === 'FileBlob') {
-        const targetPathBufferPromise = (0, stream_to_buffer_1.default)(await file.toStreamAsync());
-        const [targetPathBuffer] = await Promise.all([
-            targetPathBufferPromise,
-            mkdirPromise,
-        ]);
-        return targetPathBuffer.toString('utf8');
-    }
-    throw new Error(`file.type "${file.type}" not supported for symlink`);
+  const mkdirPromise = (0, import_fs_extra.mkdirp)(import_path.default.dirname(fsPath));
+  if (file.type === "FileFsRef") {
+    const [target] = await Promise.all([(0, import_fs_extra.readlink)(file.fsPath), mkdirPromise]);
+    return target;
+  }
+  if (file.type === "FileRef" || file.type === "FileBlob") {
+    const targetPathBufferPromise = (0, import_stream_to_buffer.default)(await file.toStreamAsync());
+    const [targetPathBuffer] = await Promise.all([
+      targetPathBufferPromise,
+      mkdirPromise
+    ]);
+    return targetPathBuffer.toString("utf8");
+  }
+  throw new Error(
+    `file.type "${file.type}" not supported for symlink`
+  );
 }
 async function downloadFile(file, fsPath) {
-    const { mode } = file;
-    if (isDirectory(mode)) {
-        await (0, fs_extra_1.mkdirp)(fsPath);
-        await (0, fs_extra_1.chmod)(fsPath, mode);
-        return file_fs_ref_1.default.fromFsPath({ mode, fsPath });
-    }
-    // If the source is a symlink, try to create it instead of copying the file.
-    // Note: creating symlinks on Windows requires admin priviliges or symlinks
-    // enabled in the group policy. We may want to improve the error message.
-    if (isSymbolicLink(mode)) {
-        const target = await prepareSymlinkTarget(file, fsPath);
-        await (0, fs_extra_1.symlink)(target, fsPath);
-        return file_fs_ref_1.default.fromFsPath({ mode, fsPath });
-    }
-    const stream = file.toStream();
-    return file_fs_ref_1.default.fromStream({ mode, stream, fsPath });
+  const { mode } = file;
+  if (isDirectory(mode)) {
+    await (0, import_fs_extra.mkdirp)(fsPath);
+    await (0, import_fs_extra.chmod)(fsPath, mode);
+    return import_file_fs_ref.default.fromFsPath({ mode, fsPath });
+  }
+  if (isSymbolicLink(mode)) {
+    const target = await prepareSymlinkTarget(file, fsPath);
+    await (0, import_fs_extra.symlink)(target, fsPath);
+    return import_file_fs_ref.default.fromFsPath({ mode, fsPath });
+  }
+  const stream = file.toStream();
+  return import_file_fs_ref.default.fromStream({ mode, stream, fsPath });
 }
-exports.downloadFile = downloadFile;
 async function removeFile(basePath, fileMatched) {
-    const file = path_1.default.join(basePath, fileMatched);
-    await (0, fs_extra_1.remove)(file);
+  const file = import_path.default.join(basePath, fileMatched);
+  await (0, import_fs_extra.remove)(file);
 }
 async function download(files, basePath, meta) {
-    const { isDev = false, skipDownload = false, filesChanged = null, filesRemoved = null, } = meta || {};
-    if (isDev || skipDownload) {
-        // In `vercel dev`, the `download()` function is a no-op because
-        // the `basePath` matches the `cwd` of the dev server, so the
-        // source files are already available.
-        return files;
-    }
-    (0, debug_1.default)('Downloading deployment source files...');
-    const start = Date.now();
-    const files2 = {};
-    const filenames = Object.keys(files);
-    await Promise.all(filenames.map(async (name) => {
-        // If the file does not exist anymore, remove it.
-        if (Array.isArray(filesRemoved) && filesRemoved.includes(name)) {
-            await removeFile(basePath, name);
-            return;
-        }
-        // If a file didn't change, do not re-download it.
-        if (Array.isArray(filesChanged) && !filesChanged.includes(name)) {
-            return;
-        }
-        // Some builders resolve symlinks and return both
-        // a file, node_modules/<symlink>/package.json, and
-        // node_modules/<symlink>, a symlink.
-        // Removing the file matches how the yazl lambda zip
-        // behaves so we can use download() with `vercel build`.
-        const parts = name.split('/');
-        for (let i = 1; i < parts.length; i++) {
-            const dir = parts.slice(0, i).join('/');
-            const parent = files[dir];
-            if (parent && isSymbolicLink(parent.mode)) {
-                console.warn(`Warning: file "${name}" is within a symlinked directory "${dir}" and will be ignored`);
-                return;
-            }
+  const {
+    isDev = false,
+    skipDownload = false,
+    filesChanged = null,
+    filesRemoved = null
+  } = meta || {};
+  if (isDev || skipDownload) {
+    return files;
+  }
+  (0, import_debug.default)("Downloading deployment source files...");
+  const start = Date.now();
+  const files2 = {};
+  const filenames = Object.keys(files);
+  await Promise.all(
+    filenames.map(async (name) => {
+      if (Array.isArray(filesRemoved) && filesRemoved.includes(name)) {
+        await removeFile(basePath, name);
+        return;
+      }
+      if (Array.isArray(filesChanged) && !filesChanged.includes(name)) {
+        return;
+      }
+      const parts = name.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join("/");
+        const parent = files[dir];
+        if (parent && isSymbolicLink(parent.mode)) {
+          console.warn(
+            `Warning: file "${name}" is within a symlinked directory "${dir}" and will be ignored`
+          );
+          return;
         }
-        const file = files[name];
-        const fsPath = path_1.default.join(basePath, name);
-        files2[name] = await downloadFile(file, fsPath);
-    }));
-    const duration = Date.now() - start;
-    (0, debug_1.default)(`Downloaded ${filenames.length} source files: ${duration}ms`);
-    return files2;
+      }
+      const file = files[name];
+      const fsPath = import_path.default.join(basePath, name);
+      files2[name] = await downloadFile(file, fsPath);
+    })
+  );
+  const duration = Date.now() - start;
+  (0, import_debug.default)(`Downloaded ${filenames.length} source files: ${duration}ms`);
+  return files2;
 }
-exports.default = download;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadFile,
+  isDirectory,
+  isSymbolicLink
+});

package/dist/fs/get-writable-directory.js

@@ -1,12 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const os_1 = require("os");
-const fs_extra_1 = require("fs-extra");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_writable_directory_exports = {};
+__export(get_writable_directory_exports, {
+  default: () => getWritableDirectory
+});
+module.exports = __toCommonJS(get_writable_directory_exports);
+var import_path = require("path");
+var import_os = require("os");
+var import_fs_extra = require("fs-extra");
 async function getWritableDirectory() {
-    const name = Math.floor(Math.random() * 0x7fffffff).toString(16);
-    const directory = (0, path_1.join)((0, os_1.tmpdir)(), name);
-    await (0, fs_extra_1.mkdirp)(directory);
-    return directory;
+  const name = Math.floor(Math.random() * 2147483647).toString(16);
+  const directory = (0, import_path.join)((0, import_os.tmpdir)(), name);
+  await (0, import_fs_extra.mkdirp)(directory);
+  return directory;
 }
-exports.default = getWritableDirectory;

package/dist/fs/glob.js

@@ -1,84 +1,111 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-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 = (0, util_1.promisify)(glob_1.default);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var glob_exports = {};
+__export(glob_exports, {
+  default: () => glob
+});
+module.exports = __toCommonJS(glob_exports);
+var import_path = __toESM(require("path"));
+var import_assert = __toESM(require("assert"));
+var import_glob = __toESM(require("glob"));
+var import_util = require("util");
+var import_fs_extra = require("fs-extra");
+var import_normalize_path = require("./normalize-path");
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+const vanillaGlob = (0, import_util.promisify)(import_glob.default);
 async function glob(pattern, opts, mountpoint) {
-    const options = typeof opts === 'string' ? { cwd: opts } : opts;
-    if (!options.cwd) {
-        throw new Error('Second argument (basePath) must be specified for names of resulting files');
-    }
-    if (!path_1.default.isAbsolute(options.cwd)) {
-        throw new Error(`basePath/cwd must be an absolute path (${options.cwd})`);
+  const options = typeof opts === "string" ? { cwd: opts } : opts;
+  if (!options.cwd) {
+    throw new Error(
+      "Second argument (basePath) must be specified for names of resulting files"
+    );
+  }
+  if (!import_path.default.isAbsolute(options.cwd)) {
+    throw new Error(`basePath/cwd must be an absolute path (${options.cwd})`);
+  }
+  const results = {};
+  const statCache = {};
+  const symlinks = {};
+  const files = await vanillaGlob(pattern, {
+    ...options,
+    symlinks,
+    statCache,
+    stat: true,
+    dot: true
+  });
+  const dirs = /* @__PURE__ */ new Set();
+  const dirsWithEntries = /* @__PURE__ */ new Set();
+  for (const relativePath of files) {
+    const absPath = import_path.default.join(options.cwd, relativePath);
+    const fsPath = (0, import_normalize_path.normalizePath)(absPath);
+    let stat = statCache[fsPath];
+    (0, import_assert.default)(
+      stat,
+      `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`
+    );
+    const isSymlink = symlinks[fsPath];
+    if (options.follow && (isSymlink || (await (0, import_fs_extra.lstat)(fsPath)).isSymbolicLink())) {
+      const target = await (0, import_fs_extra.readlink)(absPath);
+      const absTarget = import_path.default.resolve(import_path.default.dirname(absPath), target);
+      if (import_path.default.relative(options.cwd, absTarget).startsWith(`..${import_path.default.sep}`)) {
+        continue;
+      }
     }
-    const results = {};
-    const statCache = {};
-    const symlinks = {};
-    const files = await vanillaGlob(pattern, {
-        ...options,
-        symlinks,
-        statCache,
-        stat: true,
-        dot: true,
-    });
-    const dirs = new Set();
-    const dirsWithEntries = new Set();
-    for (const relativePath of files) {
-        const absPath = path_1.default.join(options.cwd, relativePath);
-        const fsPath = (0, normalize_path_1.normalizePath)(absPath);
-        let stat = statCache[fsPath];
-        (0, assert_1.default)(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
-        const isSymlink = symlinks[fsPath];
-        // When `follow` mode is enabled, ensure that the entry is not a symlink
-        // that points to outside of `cwd`
-        if (options.follow &&
-            (isSymlink || (await (0, fs_extra_1.lstat)(fsPath)).isSymbolicLink())) {
-            const target = await (0, fs_extra_1.readlink)(absPath);
-            const absTarget = path_1.default.resolve(path_1.default.dirname(absPath), target);
-            if (path_1.default.relative(options.cwd, absTarget).startsWith(`..${path_1.default.sep}`)) {
-                continue;
-            }
-        }
-        if (isSymlink || stat.isFile() || stat.isDirectory()) {
-            if (isSymlink) {
-                stat = await (0, fs_extra_1.lstat)(absPath);
-            }
-            // Some bookkeeping to track which directories already have entries within
-            const dirname = path_1.default.dirname(relativePath);
-            dirsWithEntries.add(dirname);
-            if (stat.isDirectory()) {
-                dirs.add(relativePath);
-                continue;
-            }
-            let finalPath = relativePath;
-            if (mountpoint) {
-                finalPath = path_1.default.join(mountpoint, finalPath);
-            }
-            results[finalPath] = new file_fs_ref_1.default({ mode: stat.mode, fsPath });
-        }
+    if (isSymlink || stat.isFile() || stat.isDirectory()) {
+      if (isSymlink) {
+        stat = await (0, import_fs_extra.lstat)(absPath);
+      }
+      const dirname = import_path.default.dirname(relativePath);
+      dirsWithEntries.add(dirname);
+      if (stat.isDirectory()) {
+        dirs.add(relativePath);
+        continue;
+      }
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = import_path.default.join(mountpoint, finalPath);
+      }
+      results[finalPath] = new import_file_fs_ref.default({ mode: stat.mode, fsPath });
     }
-    // Add empty directory entries
-    if (options.includeDirectories) {
-        for (const relativePath of dirs) {
-            if (dirsWithEntries.has(relativePath))
-                continue;
-            let finalPath = relativePath;
-            if (mountpoint) {
-                finalPath = path_1.default.join(mountpoint, finalPath);
-            }
-            const fsPath = (0, normalize_path_1.normalizePath)(path_1.default.join(options.cwd, relativePath));
-            const stat = statCache[fsPath];
-            results[finalPath] = new file_fs_ref_1.default({ mode: stat.mode, fsPath });
-        }
+  }
+  if (options.includeDirectories) {
+    for (const relativePath of dirs) {
+      if (dirsWithEntries.has(relativePath))
+        continue;
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = import_path.default.join(mountpoint, finalPath);
+      }
+      const fsPath = (0, import_normalize_path.normalizePath)(import_path.default.join(options.cwd, relativePath));
+      const stat = statCache[fsPath];
+      results[finalPath] = new import_file_fs_ref.default({ mode: stat.mode, fsPath });
     }
-    return results;
+  }
+  return results;
 }
-exports.default = glob;