@vercel/build-utils 7.1.0 → 7.1.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @vercel/build-utils
 
+## 7.1.1
+
+### Patch Changes
+
+- add descriptions to NodeVersion properties ([#10403](https://github.com/vercel/vercel/pull/10403))
+
+- Updated semver dependency ([#10411](https://github.com/vercel/vercel/pull/10411))
+
 ## 7.1.0
 
 ### Minor Changes

package/build.mjs

@@ -0,0 +1,3 @@
+import { tsc, esbuild } from '../../utils/build.mjs';
+
+await Promise.all([tsc(), esbuild().then(() => esbuild({ bundle: true }))]);

package/dist/clone-env.js

@@ -1,34 +1,43 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cloneEnv = void 0;
+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 clone_env_exports = {};
+__export(clone_env_exports, {
+  cloneEnv: () => cloneEnv
+});
+module.exports = __toCommonJS(clone_env_exports);
 const { hasOwnProperty } = Object.prototype;
-/**
- * Clones zero or more objects into a single new object while ensuring that the
- * `PATH` environment variable is defined when the `PATH` or `Path` environment
- * variables are defined.
- *
- * @param {Object} [...envs] Objects and/or `process.env` to clone and merge
- * @returns {Object} The new object
- */
 function cloneEnv(...envs) {
-    return envs.reduce((obj, env) => {
-        if (env === undefined || env === null) {
-            return obj;
-        }
-        // mixin the env first
-        obj = Object.assign(obj, env);
-        if (hasOwnProperty.call(env, 'Path')) {
-            // the system path is called `Path` on Windows and Node.js will
-            // automatically return the system path when accessing `PATH`,
-            // however we lose this proxied value when we destructure and
-            // thus we must explicitly copy it, but we must also remove the
-            // `Path` property since we can't have both a `PATH` and `Path`
-            if (obj.Path !== undefined) {
-                obj.PATH = obj.Path;
-            }
-            delete obj.Path;
-        }
-        return obj;
-    }, {});
+  return envs.reduce((obj, env) => {
+    if (env === void 0 || env === null) {
+      return obj;
+    }
+    obj = Object.assign(obj, env);
+    if (hasOwnProperty.call(env, "Path")) {
+      if (obj.Path !== void 0) {
+        obj.PATH = obj.Path;
+      }
+      delete obj.Path;
+    }
+    return obj;
+  }, {});
 }
-exports.cloneEnv = cloneEnv;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloneEnv
+});

package/dist/debug.js

@@ -1,12 +1,31 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_platform_env_1 = require("./get-platform-env");
+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 debug_exports = {};
+__export(debug_exports, {
+  default: () => debug
+});
+module.exports = __toCommonJS(debug_exports);
+var import_get_platform_env = require("./get-platform-env");
 function debug(message, ...additional) {
-    if ((0, get_platform_env_1.getPlatformEnv)('BUILDER_DEBUG')) {
-        console.log(message, ...additional);
-    }
-    else if (process.env.VERCEL_DEBUG_PREFIX) {
-        console.log(`${process.env.VERCEL_DEBUG_PREFIX}${message}`, ...additional);
-    }
+  if ((0, import_get_platform_env.getPlatformEnv)("BUILDER_DEBUG")) {
+    console.log(message, ...additional);
+  } else if (process.env.VERCEL_DEBUG_PREFIX) {
+    console.log(`${process.env.VERCEL_DEBUG_PREFIX}${message}`, ...additional);
+  }
 }
-exports.default = debug;

package/dist/edge-function.js

@@ -1,19 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeFunction = void 0;
-/**
- * An Edge Functions output
- */
+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 edge_function_exports = {};
+__export(edge_function_exports, {
+  EdgeFunction: () => EdgeFunction
+});
+module.exports = __toCommonJS(edge_function_exports);
 class EdgeFunction {
-    constructor(params) {
-        this.type = 'EdgeFunction';
-        this.name = params.name;
-        this.deploymentTarget = params.deploymentTarget;
-        this.entrypoint = params.entrypoint;
-        this.files = params.files;
-        this.assets = params.assets;
-        this.regions = params.regions;
-        this.framework = params.framework;
-    }
+  constructor(params) {
+    this.type = "EdgeFunction";
+    this.name = params.name;
+    this.deploymentTarget = params.deploymentTarget;
+    this.entrypoint = params.entrypoint;
+    this.files = params.files;
+    this.assets = params.assets;
+    this.regions = params.regions;
+    this.framework = params.framework;
+  }
 }
-exports.EdgeFunction = EdgeFunction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EdgeFunction
+});

package/dist/errors.js

@@ -1,86 +1,95 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrettyError = exports.NowBuildError = void 0;
-/**
- * This error should be thrown from a Builder in
- * order to stop the build and print a message.
- * This is necessary to avoid printing a stack trace.
- */
+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 errors_exports = {};
+__export(errors_exports, {
+  NowBuildError: () => NowBuildError,
+  getPrettyError: () => getPrettyError
+});
+module.exports = __toCommonJS(errors_exports);
 class NowBuildError extends Error {
-    constructor({ message, code, link, action }) {
-        super(message);
-        this.hideStackTrace = true;
-        this.code = code;
-        this.link = link;
-        this.action = action;
-    }
+  constructor({ message, code, link, action }) {
+    super(message);
+    this.hideStackTrace = true;
+    this.code = code;
+    this.link = link;
+    this.action = action;
+  }
 }
-exports.NowBuildError = NowBuildError;
 function getPrettyError(obj) {
-    const docsUrl = 'https://vercel.com/docs/concepts/projects/project-configuration';
-    try {
-        const { dataPath, params, message: ajvMessage } = obj;
-        const prop = getTopLevelPropertyName(dataPath);
-        let message = dataPath && dataPath.startsWith('.') ? `\`${dataPath.slice(1)}\` ` : '';
-        if (params && typeof params.additionalProperty === 'string') {
-            const suggestion = getSuggestion(prop, params.additionalProperty);
-            message += `should NOT have additional property \`${params.additionalProperty}\`. ${suggestion}`;
-        }
-        else if (params && typeof params.missingProperty === 'string') {
-            message += `missing required property \`${params.missingProperty}\`.`;
-        }
-        else {
-            message += `${ajvMessage}.`;
-        }
-        return new NowBuildError({
-            code: 'INVALID_VERCEL_CONFIG',
-            message: message,
-            link: prop ? `${docsUrl}#${prop.toLowerCase()}` : docsUrl,
-            action: 'View Documentation',
-        });
-    }
-    catch (e) {
-        return new NowBuildError({
-            code: 'INVALID_VERCEL_CONFIG',
-            message: `Failed to validate configuration.`,
-            link: docsUrl,
-            action: 'View Documentation',
-        });
+  const docsUrl = "https://vercel.com/docs/concepts/projects/project-configuration";
+  try {
+    const { dataPath, params, message: ajvMessage } = obj;
+    const prop = getTopLevelPropertyName(dataPath);
+    let message = dataPath && dataPath.startsWith(".") ? `\`${dataPath.slice(1)}\` ` : "";
+    if (params && typeof params.additionalProperty === "string") {
+      const suggestion = getSuggestion(prop, params.additionalProperty);
+      message += `should NOT have additional property \`${params.additionalProperty}\`. ${suggestion}`;
+    } else if (params && typeof params.missingProperty === "string") {
+      message += `missing required property \`${params.missingProperty}\`.`;
+    } else {
+      message += `${ajvMessage}.`;
     }
+    return new NowBuildError({
+      code: "INVALID_VERCEL_CONFIG",
+      message,
+      link: prop ? `${docsUrl}#${prop.toLowerCase()}` : docsUrl,
+      action: "View Documentation"
+    });
+  } catch (e) {
+    return new NowBuildError({
+      code: "INVALID_VERCEL_CONFIG",
+      message: `Failed to validate configuration.`,
+      link: docsUrl,
+      action: "View Documentation"
+    });
+  }
 }
-exports.getPrettyError = getPrettyError;
-/**
- * Get the top level property from the dataPath.
- * `.cleanUrls` => `cleanUrls`
- * `.headers[0].source` => `headers`
- * `.headers[0].headers[0]` => `headers`
- * `` => ``
- */
 function getTopLevelPropertyName(dataPath) {
-    if (dataPath && dataPath.startsWith('.')) {
-        const lastIndex = dataPath.indexOf('[');
-        return lastIndex > -1 ? dataPath.slice(1, lastIndex) : dataPath.slice(1);
-    }
-    return '';
+  if (dataPath && dataPath.startsWith(".")) {
+    const lastIndex = dataPath.indexOf("[");
+    return lastIndex > -1 ? dataPath.slice(1, lastIndex) : dataPath.slice(1);
+  }
+  return "";
 }
 const mapTypoToSuggestion = {
-    '': {
-        builder: 'builds',
-        'build.env': '{ "build": { "env": {"name": "value"} } }',
-        'builds.env': '{ "build": { "env": {"name": "value"} } }',
-    },
-    rewrites: { src: 'source', dest: 'destination' },
-    redirects: { src: 'source', dest: 'destination', status: 'statusCode' },
-    headers: { src: 'source', header: 'headers' },
-    routes: {
-        source: 'src',
-        destination: 'dest',
-        header: 'headers',
-        method: 'methods',
-    },
+  "": {
+    builder: "builds",
+    "build.env": '{ "build": { "env": {"name": "value"} } }',
+    "builds.env": '{ "build": { "env": {"name": "value"} } }'
+  },
+  rewrites: { src: "source", dest: "destination" },
+  redirects: { src: "source", dest: "destination", status: "statusCode" },
+  headers: { src: "source", header: "headers" },
+  routes: {
+    source: "src",
+    destination: "dest",
+    header: "headers",
+    method: "methods"
+  }
 };
 function getSuggestion(topLevelProp, additionalProperty) {
-    const choices = mapTypoToSuggestion[topLevelProp];
-    const choice = choices ? choices[additionalProperty] : undefined;
-    return choice ? `Did you mean \`${choice}\`?` : 'Please remove it.';
+  const choices = mapTypoToSuggestion[topLevelProp];
+  const choice = choices ? choices[additionalProperty] : void 0;
+  return choice ? `Did you mean \`${choice}\`?` : "Please remove it.";
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NowBuildError,
+  getPrettyError
+});

package/dist/file-blob.js

@@ -1,36 +1,67 @@
 "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 into_stream_1 = __importDefault(require("into-stream"));
+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_blob_exports = {};
+__export(file_blob_exports, {
+  default: () => FileBlob
+});
+module.exports = __toCommonJS(file_blob_exports);
+var import_assert = __toESM(require("assert"));
+var import_into_stream = __toESM(require("into-stream"));
 class FileBlob {
-    constructor({ mode = 0o100644, contentType, data }) {
-        (0, assert_1.default)(typeof mode === 'number');
-        (0, assert_1.default)(typeof data === 'string' || Buffer.isBuffer(data));
-        this.type = 'FileBlob';
-        this.mode = mode;
-        this.contentType = contentType;
-        this.data = data;
-    }
-    static async fromStream({ mode = 0o100644, contentType, stream, }) {
-        (0, assert_1.default)(typeof mode === 'number');
-        (0, assert_1.default)(typeof stream.pipe === 'function'); // is-stream
-        const chunks = [];
-        await new Promise((resolve, reject) => {
-            stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
-            stream.on('error', error => reject(error));
-            stream.on('end', () => resolve());
-        });
-        const data = Buffer.concat(chunks);
-        return new FileBlob({ mode, contentType, data });
-    }
-    async toStreamAsync() {
-        return this.toStream();
-    }
-    toStream() {
-        return (0, into_stream_1.default)(this.data);
-    }
+  constructor({ mode = 33188, contentType, data }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof data === "string" || Buffer.isBuffer(data));
+    this.type = "FileBlob";
+    this.mode = mode;
+    this.contentType = contentType;
+    this.data = data;
+  }
+  static async fromStream({
+    mode = 33188,
+    contentType,
+    stream
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof stream.pipe === "function");
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      stream.on("error", (error) => reject(error));
+      stream.on("end", () => resolve());
+    });
+    const data = Buffer.concat(chunks);
+    return new FileBlob({ mode, contentType, data });
+  }
+  async toStreamAsync() {
+    return this.toStream();
+  }
+  toStream() {
+    return (0, import_into_stream.default)(this.data);
+  }
 }
-exports.default = FileBlob;

package/dist/file-fs-ref.js

@@ -1,70 +1,104 @@
 "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 fs_extra_1 = __importDefault(require("fs-extra"));
-const multistream_1 = __importDefault(require("multistream"));
-const path_1 = __importDefault(require("path"));
-const async_sema_1 = __importDefault(require("async-sema"));
-const semaToPreventEMFILE = new async_sema_1.default(20);
+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_fs_ref_exports = {};
+__export(file_fs_ref_exports, {
+  default: () => file_fs_ref_default
+});
+module.exports = __toCommonJS(file_fs_ref_exports);
+var import_assert = __toESM(require("assert"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_multistream = __toESM(require("multistream"));
+var import_path = __toESM(require("path"));
+var import_async_sema = __toESM(require("async-sema"));
+const semaToPreventEMFILE = new import_async_sema.default(20);
 class FileFsRef {
-    constructor({ mode = 0o100644, contentType, fsPath }) {
-        (0, assert_1.default)(typeof mode === 'number');
-        (0, assert_1.default)(typeof fsPath === 'string');
-        this.type = 'FileFsRef';
-        this.mode = mode;
-        this.contentType = contentType;
-        this.fsPath = fsPath;
-    }
-    static async fromFsPath({ mode, contentType, fsPath, }) {
-        let m = mode;
-        if (!m) {
-            const stat = await fs_extra_1.default.lstat(fsPath);
-            m = stat.mode;
-        }
-        return new FileFsRef({ mode: m, contentType, fsPath });
-    }
-    static async fromStream({ mode = 0o100644, contentType, stream, fsPath, }) {
-        (0, assert_1.default)(typeof mode === 'number');
-        (0, assert_1.default)(typeof stream.pipe === 'function'); // is-stream
-        (0, assert_1.default)(typeof fsPath === 'string');
-        await fs_extra_1.default.mkdirp(path_1.default.dirname(fsPath));
-        await new Promise((resolve, reject) => {
-            const dest = fs_extra_1.default.createWriteStream(fsPath, {
-                mode: mode & 0o777,
-            });
-            stream.pipe(dest);
-            stream.on('error', reject);
-            dest.on('finish', resolve);
-            dest.on('error', reject);
-        });
-        return new FileFsRef({ mode, contentType, fsPath });
-    }
-    async toStreamAsync() {
-        await semaToPreventEMFILE.acquire();
-        const release = () => semaToPreventEMFILE.release();
-        const stream = fs_extra_1.default.createReadStream(this.fsPath);
-        stream.on('close', release);
-        stream.on('error', release);
-        return stream;
-    }
-    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);
-            });
-        });
+  constructor({ mode = 33188, contentType, fsPath }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof fsPath === "string");
+    this.type = "FileFsRef";
+    this.mode = mode;
+    this.contentType = contentType;
+    this.fsPath = fsPath;
+  }
+  static async fromFsPath({
+    mode,
+    contentType,
+    fsPath
+  }) {
+    let m = mode;
+    if (!m) {
+      const stat = await import_fs_extra.default.lstat(fsPath);
+      m = stat.mode;
     }
+    return new FileFsRef({ mode: m, contentType, fsPath });
+  }
+  static async fromStream({
+    mode = 33188,
+    contentType,
+    stream,
+    fsPath
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof stream.pipe === "function");
+    (0, import_assert.default)(typeof fsPath === "string");
+    await import_fs_extra.default.mkdirp(import_path.default.dirname(fsPath));
+    await new Promise((resolve, reject) => {
+      const dest = import_fs_extra.default.createWriteStream(fsPath, {
+        mode: mode & 511
+      });
+      stream.pipe(dest);
+      stream.on("error", reject);
+      dest.on("finish", resolve);
+      dest.on("error", reject);
+    });
+    return new FileFsRef({ mode, contentType, fsPath });
+  }
+  async toStreamAsync() {
+    await semaToPreventEMFILE.acquire();
+    const release = () => semaToPreventEMFILE.release();
+    const stream = import_fs_extra.default.createReadStream(this.fsPath);
+    stream.on("close", release);
+    stream.on("error", release);
+    return stream;
+  }
+  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 = FileFsRef;
+var file_fs_ref_default = FileFsRef;