@photostructure/fs-metadata 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -0,0 +1,1440 @@
+"use strict";
+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 });
+};
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  IncludeSystemVolumesDefault: () => IncludeSystemVolumesDefault,
+  LinuxMountTablePathsDefault: () => LinuxMountTablePathsDefault,
+  OptionsDefault: () => OptionsDefault,
+  SystemFsTypesDefault: () => SystemFsTypesDefault,
+  SystemPathPatternsDefault: () => SystemPathPatternsDefault,
+  TimeoutMsDefault: () => TimeoutMsDefault,
+  VolumeHealthStatuses: () => VolumeHealthStatuses,
+  getAllVolumeMetadata: () => getAllVolumeMetadata,
+  getHiddenMetadata: () => getHiddenMetadata,
+  getVolumeMetadata: () => getVolumeMetadata,
+  getVolumeMountPoints: () => getVolumeMountPoints,
+  isHidden: () => isHidden,
+  isHiddenRecursive: () => isHiddenRecursive,
+  optionsWithDefaults: () => optionsWithDefaults,
+  setHidden: () => setHidden
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_gyp_build = __toESM(require("node-gyp-build"));
+
+// src/debuglog.ts
+var import_node_util = require("util");
+function defer(thunk) {
+  let t;
+  return () => t ??= thunk();
+}
+var debugLogContext = defer(() => {
+  for (const ea of ["fs-metadata", "fs-meta"]) {
+    if ((0, import_node_util.debuglog)(ea).enabled) {
+      return ea;
+    }
+    if ((0, import_node_util.debuglog)(ea.toUpperCase()).enabled) {
+      return ea;
+    }
+  }
+  return "photostructure:fs-metadata";
+});
+var isDebugEnabled = defer(() => {
+  return (0, import_node_util.debuglog)(debugLogContext()).enabled ?? false;
+});
+function debug(msg, ...args) {
+  if (!isDebugEnabled()) return;
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = `[${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now.getMilliseconds().toString().padStart(3, "0")}] ${debugLogContext()} `;
+  process.stderr.write(timestamp + (0, import_node_util.format)(msg, ...args) + "\n");
+}
+
+// src/defer.ts
+function defer2(thunk) {
+  let computed = false;
+  let value;
+  const fn = () => {
+    if (!computed) {
+      computed = true;
+      value = thunk();
+    }
+    return value;
+  };
+  fn.reset = () => {
+    computed = false;
+  };
+  return fn;
+}
+
+// src/stack_path.ts
+var import_node_path = require("path");
+
+// src/platform.ts
+var import_node_fs = require("fs");
+var import_node_process = require("process");
+var isLinux = import_node_process.platform === "linux";
+var isWindows = import_node_process.platform === "win32";
+var isMacOS = import_node_process.platform === "darwin";
+var isArm = isLinux && import_node_process.arch.startsWith("arm");
+
+// src/string.ts
+function isString(input) {
+  return typeof input === "string";
+}
+function toS(input) {
+  return isString(input) ? input : input == null ? "" : String(input);
+}
+function isNotBlank(input) {
+  return typeof input === "string" && input.trim().length > 0;
+}
+function isBlank(input) {
+  return !isNotBlank(input);
+}
+function toNotBlank(input) {
+  return isNotBlank(input) ? input : void 0;
+}
+function decodeEscapeSequences(input) {
+  const escapeRegex = /\\(?:([0-7]{2,6})|x([0-9a-fA-F]{2,4}))/g;
+  return input.replace(escapeRegex, (match, octal, hex) => {
+    if (octal != null) {
+      return String.fromCharCode(parseInt(octal, 8));
+    }
+    if (hex != null) {
+      return String.fromCharCode(parseInt(hex, 16));
+    }
+    throw new Error(`Invalid escape sequence: ${match}`);
+  });
+}
+function sortObjectsByLocale(arr, fn, locales, options) {
+  return arr.sort((a, b) => fn(a).localeCompare(fn(b), locales, options));
+}
+
+// src/stack_path.ts
+function getCallerDirname() {
+  const e = new Error();
+  if (e.stack == null) {
+    Error.captureStackTrace(e);
+  }
+  return (0, import_node_path.dirname)(extractCallerPath(e.stack));
+}
+var patterns = isWindows ? [
+  // Standard: "at functionName (C:\path\file.js:1:1)"
+  /\bat\s.+?\((?<path>[A-Z]:\\.+):\d+:\d+\)$/,
+  // direct: "at C:\path\file.js:1:1"
+  /\bat\s(?<path>[A-Z]:\\.+):\d+:\d+$/,
+  // UNC: "at functionName (\\server\share\path\file.js:1:1)"
+  /\bat\s.+?\((?<path>\\\\.+):\d+:\d+\)$/,
+  // direct: "at \\server\share\path\file.js:1:1"
+  /\bat\s(?<path>\\\\.+):\d+:\d+$/
+] : [
+  // Standard: "at functionName (/path/file.js:1:1)"
+  /\bat\s.+?\((?<path>\/.+?):\d+:\d+\)$/,
+  // Anonymous or direct: "at /path/file.js:1:1"
+  /\bat\s(.+[^/]\s)?(?<path>\/.+?):\d+:\d+$/
+];
+var MaybeUrlRE = /^[a-z]{2,5}:\/\//i;
+function extractCallerPath(stack) {
+  const frames = stack.split("\n").filter(Boolean);
+  const callerFrame = frames.findIndex(
+    (frame) => frame.includes("getCallerDirname")
+  );
+  if (callerFrame === -1) {
+    throw new Error("Invalid stack trace format: missing caller frame");
+  }
+  for (let i = callerFrame + 1; i < frames.length; i++) {
+    const frame = frames[i];
+    for (const pattern of patterns) {
+      const g = toS(frame).trim().match(pattern)?.groups;
+      if (g != null && isNotBlank(g["path"])) {
+        const path = g["path"];
+        if (MaybeUrlRE.test(path)) {
+          try {
+            return new URL(path).pathname;
+          } catch {
+          }
+        }
+        return path;
+      }
+    }
+  }
+  throw new Error("Invalid stack trace format: no parsable frames");
+}
+
+// src/dirname.ts
+function _dirname() {
+  try {
+    if (typeof __dirname !== "undefined") return __dirname;
+  } catch {
+  }
+  return getCallerDirname();
+}
+
+// src/fs.ts
+var import_node_fs2 = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/async.ts
+var import_node_os = require("os");
+var import_node_process2 = require("process");
+
+// src/number.ts
+function isNumber(value) {
+  return typeof value === "number" && isFinite(value);
+}
+var INTEGER_REGEX = /^-?\d+$/;
+function toInt(value) {
+  try {
+    if (value == null) return;
+    const s = String(value).trim();
+    return INTEGER_REGEX.test(s) ? parseInt(s) : void 0;
+  } catch {
+    return;
+  }
+}
+function gt0(value) {
+  return isNumber(value) && value > 0;
+}
+
+// src/units.ts
+var SecondMs = 1e3;
+var MinuteMs = 60 * SecondMs;
+var HourMs = 60 * MinuteMs;
+var DayMs = 24 * HourMs;
+var KiB = 1024;
+var MiB = 1024 * KiB;
+var GiB = 1024 * MiB;
+var TiB = 1024 * GiB;
+var f = 1023.995 / 1024;
+
+// src/async.ts
+var TimeoutError = class extends Error {
+  constructor(message, captureStackTrace = true) {
+    super(message);
+    this.name = "TimeoutError";
+    if (captureStackTrace && Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+async function withTimeout(opts) {
+  const desc = isBlank(opts.desc) ? "thenOrTimeout()" : opts.desc;
+  if (!isNumber(opts.timeoutMs)) {
+    throw new TypeError(
+      desc + ": Expected timeoutMs to be numeric, but got " + JSON.stringify(opts.timeoutMs)
+    );
+  }
+  const timeoutMs = Math.floor(opts.timeoutMs);
+  if (timeoutMs < 0) {
+    throw new TypeError(
+      desc + ": Expected timeoutMs to be > 0, but got " + timeoutMs
+    );
+  }
+  if (timeoutMs > DayMs) {
+    throw new TypeError(
+      desc + ": Invalid timeoutMs is too large: must be less than one day, but got " + timeoutMs
+    );
+  }
+  if (timeoutMs === 0) {
+    return opts.promise;
+  }
+  const timeoutError = new TimeoutError(
+    `${desc}: timeout after ${timeoutMs}ms`
+  );
+  if (import_node_process2.env["NODE_ENV"] === "test" && timeoutMs === 1) {
+    timeoutError.message += "(timeout test)";
+    opts.promise.catch(() => {
+    });
+    throw timeoutError;
+  }
+  let timeoutId;
+  opts.promise.catch(() => {
+  }).finally(() => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
+  });
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      if (timeoutId != null) {
+        timeoutError.message += "(timeout callback)";
+        reject(timeoutError);
+      }
+      timeoutId = void 0;
+    }, timeoutMs);
+  });
+  return Promise.race([opts.promise, timeoutPromise]);
+}
+async function mapConcurrent({
+  items,
+  fn,
+  maxConcurrency = (0, import_node_os.availableParallelism)()
+}) {
+  if (!gt0(maxConcurrency)) {
+    throw new Error(
+      `maxConcurrency must be a positive integer, got: ${maxConcurrency}`
+    );
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError(`fn must be a function, got: ${typeof fn}`);
+  }
+  const results = [];
+  const executing = /* @__PURE__ */ new Set();
+  for (const [index, item] of items.entries()) {
+    while (executing.size >= maxConcurrency) {
+      await Promise.race(executing);
+    }
+    const p = results[index] = fn(item).catch((error) => error);
+    executing.add(p);
+    p.finally(() => executing.delete(p));
+  }
+  return Promise.all(results);
+}
+
+// src/fs.ts
+async function statAsync(path, options) {
+  return (0, import_promises.stat)(path, options);
+}
+async function canStatAsync(path) {
+  try {
+    return null != await statAsync(path);
+  } catch {
+    return false;
+  }
+}
+async function findAncestorDir(dir, file) {
+  dir = (0, import_node_path2.resolve)(dir);
+  try {
+    const s = await statAsync((0, import_node_path2.join)(dir, file));
+    if (s.isFile()) return dir;
+  } catch {
+  }
+  const parent = (0, import_node_path2.resolve)(dir, "..");
+  return parent === dir ? void 0 : findAncestorDir(parent, file);
+}
+async function canReaddir(dir, timeoutMs) {
+  return withTimeout({
+    desc: "canReaddir()",
+    promise: _canReaddir(dir),
+    timeoutMs
+  });
+}
+async function _canReaddir(dir) {
+  await (await (0, import_promises.opendir)(dir)).close();
+  return true;
+}
+
+// src/hidden.ts
+var import_promises2 = require("fs/promises");
+var import_node_path4 = require("path");
+
+// src/object.ts
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function map(obj, fn) {
+  return obj == null ? void 0 : fn(obj);
+}
+function omit(obj, ...keys) {
+  const result = {};
+  const keysSet = new Set(keys);
+  for (const key of Object.keys(obj)) {
+    if (!keysSet.has(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function compactValues(obj) {
+  const result = {};
+  if (obj == null || !isObject(obj)) return {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value != null && (!isString(value) || isNotBlank(value))) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/error.ts
+function toMessage(context, cause) {
+  const causeStr = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : cause ? JSON.stringify(cause) : "";
+  return context + (isBlank(causeStr) ? "" : ": " + causeStr);
+}
+var WrappedError = class extends Error {
+  errno;
+  code;
+  syscall;
+  path;
+  constructor(context, options) {
+    super(toMessage(context, options?.cause));
+    const cause = map(options?.cause, toError);
+    const opts = { ...compactValues(cause), ...compactValues(options) };
+    if (isNotBlank(options?.name)) {
+      this.name = options.name;
+    }
+    if (cause != null) {
+      this.cause = cause;
+      if (cause instanceof Error) {
+        this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+      }
+    }
+    if (isNumber(opts.errno)) {
+      this.errno = opts.errno;
+    }
+    if (isNotBlank(opts.code)) {
+      this.code = opts.code;
+    }
+    if (isNotBlank(opts.syscall)) {
+      this.syscall = opts.syscall;
+    }
+    if (isNotBlank(options?.path)) {
+      this.path = options.path;
+    }
+  }
+  get details() {
+    return compactValues(omit(this, "name", "message", "cause"));
+  }
+  toString() {
+    const details = this.details;
+    const detailsStr = Object.keys(details).length === 0 ? "" : " " + JSON.stringify(details);
+    return `${super.toString()}${detailsStr}`;
+  }
+};
+function toError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+// src/path.ts
+var import_node_path3 = require("path");
+function normalizePath(mountPoint) {
+  if (isBlank(mountPoint)) return void 0;
+  const result = isWindows ? normalizeWindowsPath(mountPoint) : normalizePosixPath(mountPoint);
+  return result != null ? (0, import_node_path3.resolve)(result) : void 0;
+}
+function normalizePosixPath(mountPoint) {
+  if (isBlank(mountPoint)) return void 0;
+  if (mountPoint === "/") return mountPoint;
+  if (mountPoint[mountPoint.length - 1] !== "/") return mountPoint;
+  let end = mountPoint.length - 1;
+  while (end > 0 && mountPoint[end] === "/") {
+    end--;
+  }
+  return mountPoint.slice(0, end + 1);
+}
+function normalizeWindowsPath(mountPoint) {
+  return /^[a-z]:$/i.test(mountPoint) ? mountPoint.toUpperCase() + "\\" : mountPoint;
+}
+function isRootDirectory(path) {
+  const n = normalizePath(path);
+  return n == null ? false : isWindows ? (0, import_node_path3.dirname)(n) === n : n === "/";
+}
+
+// src/hidden.ts
+var HiddenSupportByPlatform = {
+  win32: {
+    supported: {
+      dotPrefix: false,
+      systemFlag: true
+    }
+  },
+  darwin: {
+    supported: {
+      dotPrefix: true,
+      systemFlag: true
+    }
+  },
+  linux: {
+    supported: {
+      dotPrefix: true,
+      systemFlag: false
+    }
+  }
+};
+var LocalSupport = HiddenSupportByPlatform[process.platform]?.supported ?? {
+  dotPrefix: false,
+  systemFlag: false
+};
+async function isHiddenImpl(pathname, nativeFn2) {
+  const norm = normalizePath(pathname);
+  if (norm == null) {
+    throw new Error("Invalid pathname: " + JSON.stringify(pathname));
+  }
+  return LocalSupport.dotPrefix && isPosixHidden(norm) || LocalSupport.systemFlag && isSystemHidden(norm, nativeFn2);
+}
+async function isHiddenRecursiveImpl(path, nativeFn2) {
+  let norm = normalizePath(path);
+  if (norm == null) {
+    throw new Error("Invalid path: " + JSON.stringify(path));
+  }
+  while (!isRootDirectory(norm)) {
+    if (await isHiddenImpl(norm, nativeFn2)) {
+      return true;
+    }
+    norm = (0, import_node_path4.dirname)(norm);
+  }
+  return false;
+}
+function createHiddenPosixPath(pathname, hidden) {
+  const norm = normalizePath(pathname);
+  if (norm == null) {
+    throw new Error("Invalid pathname: " + JSON.stringify(pathname));
+  }
+  const dir = (0, import_node_path4.dirname)(norm);
+  const srcBase = (0, import_node_path4.basename)(norm).replace(/^\./, "");
+  const dest = (0, import_node_path4.join)(dir, (hidden ? "." : "") + srcBase);
+  return dest;
+}
+async function setHiddenPosix(pathname, hidden) {
+  if (LocalSupport.dotPrefix) {
+    const dest = createHiddenPosixPath(pathname, hidden);
+    if (pathname !== dest) await (0, import_promises2.rename)(pathname, dest);
+    return dest;
+  }
+  throw new Error("Unsupported platform");
+}
+function isPosixHidden(pathname) {
+  if (!LocalSupport.dotPrefix) return false;
+  const b = (0, import_node_path4.basename)(pathname);
+  return b.startsWith(".") && b !== "." && b !== "..";
+}
+async function isSystemHidden(pathname, nativeFn2) {
+  if (!LocalSupport.systemFlag) {
+    return false;
+  }
+  if (isWindows && isRootDirectory(pathname)) {
+    return false;
+  }
+  return await canStatAsync(pathname) && await (await nativeFn2()).isHidden(pathname);
+}
+async function getHiddenMetadataImpl(pathname, nativeFn2) {
+  const norm = normalizePath(pathname);
+  if (norm == null) {
+    throw new Error("Invalid pathname: " + JSON.stringify(pathname));
+  }
+  const dotPrefix = isPosixHidden(norm);
+  const systemFlag = await isSystemHidden(norm, nativeFn2);
+  return {
+    hidden: dotPrefix || systemFlag,
+    dotPrefix,
+    systemFlag,
+    supported: LocalSupport
+  };
+}
+async function setHiddenImpl(pathname, hide, method, nativeFn2) {
+  let norm = normalizePath(pathname);
+  if (norm == null) {
+    throw new Error("Invalid pathname: " + JSON.stringify(pathname));
+  }
+  if (method === "dotPrefix" && !LocalSupport.dotPrefix) {
+    throw new Error("Dot prefix hiding is not supported on this platform");
+  }
+  if (method === "systemFlag" && !LocalSupport.systemFlag) {
+    throw new Error("System flag hiding is not supported on this platform");
+  }
+  try {
+    await statAsync(norm);
+  } catch (cause) {
+    throw new WrappedError("setHidden()", { cause });
+  }
+  if (isWindows && isRootDirectory(norm)) {
+    throw new Error("Cannot hide root directory on Windows");
+  }
+  const actions = {
+    dotPrefix: false,
+    systemFlag: false
+  };
+  let acted = false;
+  if (LocalSupport.dotPrefix && ["auto", "all", "dotPrefix"].includes(method)) {
+    if (isPosixHidden(norm) !== hide) {
+      norm = await setHiddenPosix(norm, hide);
+      actions.dotPrefix = true;
+    }
+    acted = true;
+  }
+  if (LocalSupport.systemFlag && (["all", "systemFlag"].includes(method) || !acted && method === "auto")) {
+    await (await nativeFn2()).setHidden(norm, hide);
+    actions.systemFlag = true;
+  }
+  return { pathname: norm, actions };
+}
+
+// src/options.ts
+var import_node_os2 = require("os");
+var TimeoutMsDefault = 5e3;
+var SystemPathPatternsDefault = [
+  "/boot",
+  "/boot/efi",
+  "/dev",
+  "/dev/**",
+  "/proc/**",
+  "/run",
+  "/run/credentials/**",
+  "/run/lock",
+  "/run/snapd/**",
+  "/run/user/*/doc",
+  "/run/user/*/gvfs",
+  "/snap/**",
+  "/sys/**",
+  "/tmp",
+  "/var/tmp",
+  // we aren't including /tmp/**, as some people temporarily mount volumes there, like /tmp/project.
+  "**/#snapshot",
+  // Synology and Kubernetes volume snapshots
+  // windows for linux:
+  "/mnt/wslg/distro",
+  "/mnt/wslg/doc",
+  "/mnt/wslg/versions.txt",
+  "/usr/lib/wsl/drivers",
+  // MacOS stuff:
+  "/private/var/vm",
+  // macOS swap
+  "/System/Volumes/Hardware",
+  "/System/Volumes/iSCPreboot",
+  "/System/Volumes/Preboot",
+  "/System/Volumes/Recovery",
+  "/System/Volumes/Reserved",
+  "/System/Volumes/Update",
+  "/System/Volumes/VM",
+  "/System/Volumes/xarts"
+];
+var SystemFsTypesDefault = [
+  "autofs",
+  "binfmt_misc",
+  "cgroup",
+  "cgroup2",
+  "configfs",
+  "debugfs",
+  "devpts",
+  "devtmpfs",
+  "efivarfs",
+  "fusectl",
+  "fuse.snapfuse",
+  "hugetlbfs",
+  "mqueue",
+  "none",
+  "proc",
+  "pstore",
+  "rootfs",
+  "securityfs",
+  "snap*",
+  "squashfs",
+  "sysfs",
+  "tmpfs"
+];
+var LinuxMountTablePathsDefault = [
+  "/proc/self/mounts",
+  "/proc/mounts",
+  "/etc/mtab"
+];
+var IncludeSystemVolumesDefault = isWindows;
+var OptionsDefault = {
+  timeoutMs: TimeoutMsDefault,
+  maxConcurrency: (0, import_node_os2.availableParallelism)(),
+  systemPathPatterns: [...SystemPathPatternsDefault],
+  systemFsTypes: [...SystemFsTypesDefault],
+  linuxMountTablePaths: [...LinuxMountTablePathsDefault],
+  includeSystemVolumes: IncludeSystemVolumesDefault
+};
+function optionsWithDefaults(overrides = {}) {
+  if (!isObject(overrides)) {
+    throw new TypeError(
+      "options(): expected an object, got " + typeof overrides + ": " + JSON.stringify(overrides)
+    );
+  }
+  return {
+    ...OptionsDefault,
+    ...compactValues(overrides)
+  };
+}
+
+// src/string_enum.ts
+function stringEnum(...o) {
+  const set = new Set(o);
+  const dict = {};
+  for (const key of o) {
+    dict[key] = key;
+  }
+  return {
+    ...dict,
+    values: Object.freeze([...set]),
+    size: set.size,
+    get: (s) => s != null && set.has(s) ? s : void 0
+  };
+}
+
+// src/volume_health_status.ts
+var VolumeHealthStatuses = stringEnum(
+  "healthy",
+  "timeout",
+  "inaccessible",
+  "disconnected",
+  "unknown"
+);
+async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
+  try {
+    if (await canReaddirImpl(dir, timeoutMs)) {
+      return { status: VolumeHealthStatuses.healthy };
+    }
+  } catch (error) {
+    debug("[directoryStatus] %s: %s", dir, error);
+    let status = VolumeHealthStatuses.unknown;
+    if (error instanceof TimeoutError) {
+      status = VolumeHealthStatuses.timeout;
+    } else if (isObject(error) && error instanceof Error && "code" in error) {
+      if (error.code === "EPERM" || error.code === "EACCES") {
+        status = VolumeHealthStatuses.inaccessible;
+      }
+    }
+    return { status, error: toError(error) };
+  }
+  return { status: VolumeHealthStatuses.unknown };
+}
+
+// src/linux/dev_disk.ts
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+async function getUuidFromDevDisk(devicePath) {
+  try {
+    const result = await getBasenameLinkedTo(
+      "/dev/disk/by-uuid",
+      (0, import_node_path5.resolve)(devicePath)
+    );
+    debug("[getUuidFromDevDisk] result: %o", result);
+    return result;
+  } catch (error) {
+    debug("[getUuidFromDevDisk] failed: " + error);
+    return;
+  }
+}
+async function getLabelFromDevDisk(devicePath) {
+  try {
+    const result = await getBasenameLinkedTo(
+      "/dev/disk/by-label",
+      (0, import_node_path5.resolve)(devicePath)
+    );
+    debug("[getLabelFromDevDisk] result: %o", result);
+    return result;
+  } catch (error) {
+    debug("[getLabelFromDevDisk] failed: " + error);
+    return;
+  }
+}
+async function getBasenameLinkedTo(linkDir, linkPath) {
+  for await (const ea of readLinks(linkDir)) {
+    if (ea.linkTarget === linkPath) {
+      return decodeEscapeSequences(ea.dirent.name);
+    }
+  }
+  return;
+}
+async function* readLinks(directory) {
+  for (const dirent of await (0, import_promises3.readdir)(directory, { withFileTypes: true })) {
+    if (dirent.isSymbolicLink()) {
+      try {
+        const linkTarget = (0, import_node_path5.resolve)(
+          directory,
+          await (0, import_promises3.readlink)((0, import_node_path5.join)(directory, dirent.name))
+        );
+        yield { dirent, linkTarget };
+      } catch {
+      }
+    }
+  }
+}
+
+// src/linux/mount_points.ts
+var import_promises4 = require("fs/promises");
+
+// src/mount_point.ts
+function isMountPoint(obj) {
+  return isObject(obj) && "mountPoint" in obj && isNotBlank(obj.mountPoint);
+}
+
+// src/remote_info.ts
+function isRemoteInfo(obj) {
+  if (!isObject(obj)) return false;
+  const { remoteHost, remoteShare } = obj;
+  return isNotBlank(remoteHost) && isNotBlank(remoteShare);
+}
+var NETWORK_FS_TYPE_ARRAY = [
+  "9p",
+  "afp",
+  "afs",
+  "beegfs",
+  "ceph",
+  "cifs",
+  "ftp",
+  "fuse",
+  "gfs2",
+  "glusterfs",
+  "lustre",
+  "ncpfs",
+  "nfs",
+  "nfs4",
+  "smb",
+  "smbfs",
+  "sshfs",
+  "webdav"
+];
+var NETWORK_FS_TYPES = new Set(NETWORK_FS_TYPE_ARRAY);
+var FS_TYPE_ALIASES = /* @__PURE__ */ new Map([
+  ["nfs1", "nfs"],
+  ["nfs2", "nfs"],
+  ["nfs3", "nfs"],
+  ["nfs4", "nfs4"],
+  ["fuse.sshfs", "sshfs"],
+  ["sshfs.fuse", "sshfs"],
+  ["davfs2", "webdav"],
+  ["davfs", "webdav"],
+  ["cifs.smb", "cifs"],
+  ["smbfs", "cifs"],
+  ["cephfs", "ceph"],
+  ["fuse.ceph", "ceph"],
+  ["fuse.cephfs", "ceph"],
+  ["rbd", "ceph"],
+  ["fuse.glusterfs", "glusterfs"]
+]);
+function normalizeFsType(fstype) {
+  const norm = toS(fstype).toLowerCase().replace(/:$/, "");
+  return FS_TYPE_ALIASES.get(norm) ?? norm;
+}
+function isRemoteFsType(fstype) {
+  return isNotBlank(fstype) && NETWORK_FS_TYPES.has(normalizeFsType(fstype));
+}
+function parseURL(s) {
+  try {
+    return isBlank(s) ? void 0 : new URL(s);
+  } catch {
+    return;
+  }
+}
+function extractRemoteInfo(fsSpec) {
+  if (fsSpec == null || isBlank(fsSpec)) return;
+  if (isWindows) {
+    fsSpec = fsSpec.replace(/\\/g, "/");
+  }
+  const url = parseURL(fsSpec);
+  if (url?.protocol === "file:") {
+    return {
+      remote: false,
+      uri: fsSpec
+    };
+  }
+  const patterns2 = [
+    {
+      // CIFS/SMB pattern: //hostname/share or //user@host/share
+      regex: /^\/\/(?:(?<remoteUser>[^/@]+)@)?(?<remoteHost>[^/@]+)\/(?<remoteShare>.+)$/
+    },
+    {
+      // sshfs pattern: sshfs#USER@HOST:REMOTE_PATH
+      regex: /^(?:(?<protocol>\w+)#)?(?<remoteUser>[^@]+)@(?<remoteHost>[^:]+):(?<remoteShare>.+)$/
+    },
+    {
+      // NFS pattern: hostname:/share
+      protocol: "nfs",
+      regex: /^(?<remoteHost>[^:]+):\/(?!\/)(?<remoteShare>.+)$/
+    }
+  ];
+  for (const { protocol, regex } of patterns2) {
+    const o = compactValues({
+      protocol,
+      remote: true,
+      ...fsSpec.match(regex)?.groups ?? {}
+    });
+    if (isRemoteInfo(o)) {
+      debug("[extractRemoteInfo] matched pattern: %o", o);
+      return o;
+    }
+  }
+  try {
+    const parsed = new URL(fsSpec);
+    if (parsed != null) {
+      debug("[extractRemoteInfo] parsed URL: %o", parsed);
+      const fstype = normalizeFsType(parsed.protocol);
+      if (!isRemoteFsType(fstype)) {
+        return {
+          uri: fsSpec,
+          remote: false
+        };
+      } else {
+        return compactValues({
+          uri: fsSpec,
+          protocol: fstype,
+          remote: true,
+          remoteUser: parsed.username,
+          remoteHost: parsed.hostname,
+          // URL pathname includes leading slash:
+          remoteShare: parsed.pathname.replace(/^\//, "")
+        });
+      }
+    }
+  } catch {
+  }
+  return;
+}
+
+// src/glob.ts
+var cache = /* @__PURE__ */ new Map();
+function compileGlob(patterns2) {
+  if (patterns2 == null || patterns2.length === 0) {
+    return NeverMatchRE;
+  }
+  const patternsKey = JSON.stringify(patterns2);
+  {
+    const prior = cache.get(patternsKey);
+    if (prior != null) {
+      return prior;
+    }
+  }
+  const sorted = patterns2.slice().filter(isNotBlank).sort();
+  const sortedKey = JSON.stringify(sorted);
+  {
+    const prior = cache.get(sortedKey);
+    if (prior != null) {
+      cache.set(patternsKey, prior);
+      return prior;
+    }
+  }
+  const result = _compileGlob(sorted);
+  if (cache.size > 256) {
+    cache.clear();
+  }
+  cache.set(patternsKey, result);
+  cache.set(sortedKey, result);
+  return result;
+}
+function _compileGlob(patterns2) {
+  const regexPatterns = patterns2.map((pattern) => {
+    let regex = "";
+    let i = 0;
+    while (i < pattern.length) {
+      if (pattern[i] === "*" && pattern[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (pattern[i] === "/") {
+          i++;
+        }
+        continue;
+      }
+      if (pattern[i] === "*") {
+        regex += "[^/]*";
+        i++;
+        continue;
+      }
+      if (pattern[i] === "?") {
+        regex += "[^/]";
+        i++;
+        continue;
+      }
+      if (pattern[i] === ".") {
+        regex += "\\.";
+        i++;
+        continue;
+      }
+      if (pattern[i] === "/") {
+        if (i === pattern.length - 1) {
+          regex += "(?:/|$)";
+          i++;
+          continue;
+        } else if (isWindows) {
+          regex += "[\\/\\\\]";
+          i++;
+          continue;
+        }
+      }
+      if (/[+^${}()|[\]\\]/.test(pattern[i])) {
+        regex += "\\" + pattern[i];
+        i++;
+        continue;
+      }
+      regex += pattern[i];
+      i++;
+    }
+    return regex;
+  });
+  const final = regexPatterns.filter((ea) => ea.length > 0);
+  return final.length === 0 ? (
+    // Empty pattern matches nothing
+    NeverMatchRE
+  ) : new RegExp(`^(?:${final.join("|")})$`, "i");
+}
+var NeverMatchRE = /(?!)/;
+
+// src/system_volume.ts
+function isSystemVolume(mountPoint, fstype, config = {}) {
+  if (isWindows) {
+    const systemDrive = normalizePath(process.env["SystemDrive"]);
+    if (systemDrive != null && mountPoint === systemDrive) {
+      debug("[isSystemVolume] %s is the Windows system drive", mountPoint);
+      return true;
+    }
+  }
+  const isSystemFsType = isNotBlank(fstype) && (config.systemFsTypes ?? SystemFsTypesDefault).includes(
+    fstype
+  );
+  const hasSystemPath = compileGlob(
+    config.systemPathPatterns ?? SystemPathPatternsDefault
+  ).test(mountPoint);
+  const result = isSystemFsType || hasSystemPath;
+  debug("[isSystemVolume]", {
+    mountPoint,
+    fstype,
+    result,
+    isSystemFsType,
+    hasSystemPath
+  });
+  return result;
+}
+function assignSystemVolume(mp, config) {
+  const result = isSystemVolume(mp.mountPoint, mp.fstype, config);
+  if (isWindows) {
+    mp.isSystemVolume ??= result;
+  } else {
+    mp.isSystemVolume = result;
+  }
+}
+
+// src/linux/mtab.ts
+function mountEntryToMountPoint(entry) {
+  const mountPoint = normalizePosixPath(entry.fs_file);
+  const fstype = toNotBlank(entry.fs_vfstype) ?? toNotBlank(entry.fs_spec);
+  return mountPoint == null || fstype == null ? void 0 : {
+    mountPoint,
+    fstype
+  };
+}
+function mountEntryToPartialVolumeMetadata(entry, options = {}) {
+  return {
+    mountPoint: entry.fs_file,
+    fstype: entry.fs_vfstype,
+    mountFrom: entry.fs_spec,
+    isSystemVolume: isSystemVolume(entry.fs_file, entry.fs_vfstype, options),
+    remote: false,
+    // < default to false, but it may be overridden by extractRemoteInfo
+    ...extractRemoteInfo(entry.fs_spec)
+  };
+}
+function parseMtab(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    if (isBlank(line) || line.trim().startsWith("#")) {
+      continue;
+    }
+    const fields = line.trim().match(/(?:[^\s\\]|\\.)+/g)?.map(decodeEscapeSequences);
+    if (!fields || fields.length < 3) {
+      continue;
+    }
+    const fs_file = normalizePosixPath(fields[1]);
+    if (fs_file != null) {
+      entries.push({
+        fs_spec: fields[0],
+        // normalizeLinuxPath DOES NOT resolve()!
+        fs_file,
+        fs_vfstype: fields[2],
+        fs_mntops: fields[3],
+        fs_freq: toInt(fields[4]),
+        fs_passno: toInt(fields[5])
+      });
+    }
+  }
+  return entries;
+}
+
+// src/linux/mount_points.ts
+async function getLinuxMountPoints(native, opts) {
+  const o = optionsWithDefaults(opts);
+  const raw = [];
+  try {
+    const arr = await (await native()).getGioMountPoints?.();
+    debug("[getLinuxMountPoints] GIO mount points: %o", arr);
+    if (arr != null) raw.push(...arr);
+  } catch (error) {
+    debug("Failed to get GIO mount points: %s", error);
+  }
+  let cause;
+  for (const input of o.linuxMountTablePaths) {
+    try {
+      const mtabContent = await (0, import_promises4.readFile)(input, "utf8");
+      const arr = parseMtab(mtabContent).map((ea) => mountEntryToMountPoint(ea)).filter((ea) => ea != null);
+      debug("[getLinuxMountPoints] %s mount points: %o", input, arr);
+      if (arr.length > 0) {
+        raw.push(...arr);
+        break;
+      }
+    } catch (error) {
+      cause ??= toError(error);
+    }
+  }
+  const byMountPoint = /* @__PURE__ */ new Map();
+  for (const ea of raw) {
+    const prior = byMountPoint.get(ea.mountPoint);
+    const merged = { ...compactValues(prior), ...compactValues(ea) };
+    if (isMountPoint(merged)) {
+      byMountPoint.set(merged.mountPoint, merged);
+    }
+  }
+  if (byMountPoint.size === 0) {
+    throw new WrappedError(
+      `Failed to find any mount points (tried: ${JSON.stringify(o.linuxMountTablePaths)})`,
+      { cause }
+    );
+  }
+  const results = [...byMountPoint.values()];
+  debug("[getLinuxMountPoints] %o", {
+    results: results.map((ea) => ea.mountPoint)
+  });
+  return results;
+}
+async function getLinuxMtabMetadata(mountPoint, opts) {
+  let caughtError;
+  const inputs = optionsWithDefaults(opts).linuxMountTablePaths;
+  for (const input of inputs) {
+    try {
+      const mtabContent = await (0, import_promises4.readFile)(input, "utf8");
+      for (const ea of parseMtab(mtabContent)) {
+        if (ea.fs_file === mountPoint) {
+          return ea;
+        }
+      }
+    } catch (error) {
+      caughtError ??= toError(error);
+    }
+  }
+  throw new WrappedError(
+    `Failed to find mount point ${mountPoint} in an linuxMountTablePaths (tried: ${JSON.stringify(inputs)})`,
+    caughtError
+  );
+}
+
+// src/unc.ts
+function parseUNCPath(path) {
+  if (path == null || isBlank(path) || !isString(path)) {
+    return;
+  }
+  if (!path.startsWith("\\\\") && !path.startsWith("//")) {
+    return;
+  }
+  const isForwardSlash = path.startsWith("//");
+  const slashChar = isForwardSlash ? "/" : "\\";
+  const parts = path.slice(2).split(slashChar);
+  if (parts.length < 2) {
+    return;
+  }
+  const [remoteHost, remoteShare] = parts;
+  if (remoteHost == null || isBlank(remoteHost) || remoteShare == null || isBlank(remoteShare)) {
+    return;
+  }
+  const invalidChars = /[<>:"|?*]/;
+  if (invalidChars.test(remoteHost) || invalidChars.test(remoteShare)) {
+    return;
+  }
+  const wrongSlash = isForwardSlash ? "\\" : "/";
+  if (path.includes(wrongSlash)) {
+    return;
+  }
+  return { remoteHost, remoteShare, remote: true };
+}
+
+// src/uuid.ts
+var uuidRegex = /[a-z0-9][a-z0-9-]{7,}/i;
+function extractUUID(uuid) {
+  return toS(uuid).match(uuidRegex)?.[0];
+}
+
+// src/array.ts
+function uniqBy(arr, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const key = keyFn(item);
+    if (key == null || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/volume_mount_points.ts
+async function getVolumeMountPointsImpl(opts, nativeFn2) {
+  const p = _getVolumeMountPoints(opts, nativeFn2);
+  return isWindows ? p : withTimeout({ desc: "getVolumeMountPoints", ...opts, promise: p });
+}
+async function _getVolumeMountPoints(o, nativeFn2) {
+  debug("[getVolumeMountPoints] gathering mount points with options: %o", o);
+  const raw = await (isWindows || isMacOS ? (async () => {
+    debug("[getVolumeMountPoints] using native implementation");
+    const points = await (await nativeFn2()).getVolumeMountPoints(o);
+    debug(
+      "[getVolumeMountPoints] native returned %d mount points",
+      points.length
+    );
+    return points;
+  })() : getLinuxMountPoints(nativeFn2, o));
+  debug("[getVolumeMountPoints] raw mount points: %o", raw);
+  const compacted = raw.map((ea) => compactValues(ea)).filter((ea) => isNotBlank(ea.mountPoint));
+  for (const ea of compacted) {
+    assignSystemVolume(ea, o);
+  }
+  const filtered = o.includeSystemVolumes ? compacted : compacted.filter((ea) => !ea.isSystemVolume);
+  const uniq = uniqBy(filtered, (ea) => toNotBlank(ea.mountPoint));
+  debug("[getVolumeMountPoints] found %d unique mount points", uniq.length);
+  const results = sortObjectsByLocale(uniq, (ea) => ea.mountPoint);
+  debug(
+    "[getVolumeMountPoints] getting status for %d mount points",
+    results.length
+  );
+  await mapConcurrent({
+    maxConcurrency: o.maxConcurrency,
+    items: results.filter(
+      // trust but verify
+      (ea) => isBlank(ea.status) || ea.status === "healthy"
+    ),
+    fn: async (mp) => {
+      debug("[getVolumeMountPoints] checking status of %s", mp.mountPoint);
+      mp.status = (await directoryStatus(mp.mountPoint, o.timeoutMs)).status;
+      debug(
+        "[getVolumeMountPoints] status for %s: %s",
+        mp.mountPoint,
+        mp.status
+      );
+    }
+  });
+  debug(
+    "[getVolumeMountPoints] completed with %d mount points",
+    results.length
+  );
+  return results;
+}
+
+// src/volume_metadata.ts
+async function getVolumeMetadataImpl(o, nativeFn2) {
+  if (isBlank(o.mountPoint)) {
+    throw new TypeError(
+      "Invalid mountPoint: got " + JSON.stringify(o.mountPoint)
+    );
+  }
+  const p = _getVolumeMetadata(o, nativeFn2);
+  return isWindows ? p : withTimeout({
+    desc: "getVolumeMetadata()",
+    timeoutMs: o.timeoutMs,
+    promise: p
+  });
+}
+async function _getVolumeMetadata(o, nativeFn2) {
+  o = optionsWithDefaults(o);
+  const norm = normalizePath(o.mountPoint);
+  if (norm == null) {
+    throw new Error("Invalid mountPoint: " + JSON.stringify(o.mountPoint));
+  }
+  o.mountPoint = norm;
+  debug(
+    "[getVolumeMetadata] starting metadata collection for %s",
+    o.mountPoint
+  );
+  debug("[getVolumeMetadata] options: %o", o);
+  const { status, error } = await directoryStatus(o.mountPoint, o.timeoutMs);
+  if (status !== VolumeHealthStatuses.healthy) {
+    debug("[getVolumeMetadata] directoryStatus error: %s", error);
+    throw error ?? new Error("Volume not healthy: " + status);
+  }
+  debug("[getVolumeMetadata] readdir status: %s", status);
+  let remote = false;
+  let mtabInfo;
+  let device;
+  if (isLinux) {
+    debug("[getVolumeMetadata] collecting Linux mtab info");
+    try {
+      const m = await getLinuxMtabMetadata(o.mountPoint, o);
+      mtabInfo = mountEntryToPartialVolumeMetadata(m, o);
+      debug("[getVolumeMetadata] mtab info: %o", mtabInfo);
+      if (mtabInfo.remote) {
+        remote = true;
+      }
+      if (isNotBlank(m.fs_spec)) {
+        device = m.fs_spec;
+      }
+    } catch (err) {
+      debug("[getVolumeMetadata] failed to get mtab info: " + err);
+    }
+  }
+  if (isNotBlank(device)) {
+    o.device = device;
+    debug("[getVolumeMetadata] using device: %s", device);
+  }
+  debug("[getVolumeMetadata] requesting native metadata");
+  const metadata = await (await nativeFn2()).getVolumeMetadata(o);
+  debug("[getVolumeMetadata] native metadata: %o", metadata);
+  const remoteInfo = mtabInfo ?? extractRemoteInfo(metadata.uri) ?? extractRemoteInfo(metadata.mountFrom) ?? (isWindows ? parseUNCPath(o.mountPoint) : void 0);
+  debug("[getVolumeMetadata] extracted remote info: %o", remoteInfo);
+  remote ||= isRemoteFsType(metadata.fstype) || (remoteInfo?.remote ?? metadata.remote ?? false);
+  debug("[getVolumeMetadata] assembling: %o", {
+    status,
+    mtabInfo,
+    remoteInfo,
+    metadata,
+    mountPoint: o.mountPoint,
+    remote
+  });
+  const result = compactValues({
+    status,
+    // < let the implementation's status win by having this first
+    ...compactValues(remoteInfo),
+    ...compactValues(metadata),
+    ...compactValues(mtabInfo),
+    mountPoint: o.mountPoint,
+    remote
+  });
+  if (isLinux && isNotBlank(device)) {
+    result.uuid ??= await getUuidFromDevDisk(device) ?? "";
+    result.label ??= await getLabelFromDevDisk(device) ?? "";
+  }
+  assignSystemVolume(result, o);
+  result.uuid = extractUUID(result.uuid) ?? result.uuid ?? "";
+  debug("[getVolumeMetadata] final result for %s: %o", o.mountPoint, result);
+  return compactValues(result);
+}
+async function getAllVolumeMetadataImpl(opts, nativeFn2) {
+  const o = optionsWithDefaults(opts);
+  debug("[getAllVolumeMetadata] starting with options: %o", o);
+  const arr = await getVolumeMountPointsImpl(o, nativeFn2);
+  debug("[getAllVolumeMetadata] found %d mount points", arr.length);
+  const unhealthyMountPoints = arr.filter(
+    (ea) => ea.status != null && ea.status !== VolumeHealthStatuses.healthy
+  ).map((ea) => ({
+    mountPoint: ea.mountPoint,
+    error: new WrappedError("volume not healthy: " + ea.status, {
+      name: "Skipped"
+    })
+  }));
+  const includeSystemVolumes = opts?.includeSystemVolumes ?? IncludeSystemVolumesDefault;
+  const systemMountPoints = includeSystemVolumes ? [] : arr.filter((ea) => ea.isSystemVolume).map((ea) => ({
+    mountPoint: ea.mountPoint,
+    error: new WrappedError("system volume", { name: "Skipped" })
+  }));
+  const healthy = arr.filter(
+    (ea) => ea.status == null || ea.status === VolumeHealthStatuses.healthy
+  );
+  debug("[getAllVolumeMetadata] ", {
+    allMountPoints: arr.map((ea) => ea.mountPoint),
+    healthyMountPoints: healthy.map((ea) => ea.mountPoint)
+  });
+  debug(
+    "[getAllVolumeMetadata] processing %d healthy volumes with max concurrency %d",
+    healthy.length,
+    o.maxConcurrency
+  );
+  const results = await mapConcurrent({
+    maxConcurrency: o.maxConcurrency,
+    items: opts?.includeSystemVolumes ?? IncludeSystemVolumesDefault ? healthy : healthy.filter((ea) => !ea.isSystemVolume),
+    fn: async (mp) => getVolumeMetadataImpl({ ...mp, ...o }, nativeFn2).catch((error) => ({
+      mountPoint: mp.mountPoint,
+      error
+    }))
+  });
+  debug("[getAllVolumeMetadata] completed processing all volumes");
+  return arr.map(
+    (result) => results.find((ea) => ea.mountPoint === result.mountPoint) ?? unhealthyMountPoints.find(
+      (ea) => ea.mountPoint === result.mountPoint
+    ) ?? systemMountPoints.find((ea) => ea.mountPoint === result.mountPoint) ?? {
+      ...result,
+      error: new WrappedError("Mount point metadata not retrieved", {
+        name: "NotApplicableError"
+      })
+    }
+  );
+}
+
+// src/index.ts
+var nativeFn = defer2(async () => {
+  const start = Date.now();
+  try {
+    const dirname4 = _dirname();
+    const dir = await findAncestorDir(dirname4, "binding.gyp");
+    if (dir == null) {
+      throw new Error(
+        "Could not find bindings.gyp in any ancestor directory of " + dirname4
+      );
+    }
+    const bindings = (0, import_node_gyp_build.default)(dir);
+    bindings.setDebugLogging(isDebugEnabled());
+    bindings.setDebugPrefix(debugLogContext() + ":native");
+    return bindings;
+  } catch (error) {
+    debug("Loading native bindings failed: %s", error);
+    throw error;
+  } finally {
+    debug(`Native bindings took %d ms to load`, Date.now() - start);
+  }
+});
+function getVolumeMountPoints(opts) {
+  return getVolumeMountPointsImpl(optionsWithDefaults(opts), nativeFn);
+}
+function getVolumeMetadata(mountPoint, opts) {
+  return getVolumeMetadataImpl(
+    { ...optionsWithDefaults(opts), mountPoint },
+    nativeFn
+  );
+}
+function getAllVolumeMetadata(opts) {
+  return getAllVolumeMetadataImpl(optionsWithDefaults(opts), nativeFn);
+}
+function isHidden(pathname) {
+  return isHiddenImpl(pathname, nativeFn);
+}
+function isHiddenRecursive(pathname) {
+  return isHiddenRecursiveImpl(pathname, nativeFn);
+}
+function getHiddenMetadata(pathname) {
+  return getHiddenMetadataImpl(pathname, nativeFn);
+}
+function setHidden(pathname, hidden, method = "auto") {
+  return setHiddenImpl(pathname, hidden, method, nativeFn);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IncludeSystemVolumesDefault,
+  LinuxMountTablePathsDefault,
+  OptionsDefault,
+  SystemFsTypesDefault,
+  SystemPathPatternsDefault,
+  TimeoutMsDefault,
+  VolumeHealthStatuses,
+  getAllVolumeMetadata,
+  getHiddenMetadata,
+  getVolumeMetadata,
+  getVolumeMountPoints,
+  isHidden,
+  isHiddenRecursive,
+  optionsWithDefaults,
+  setHidden
+});
+//# sourceMappingURL=index.cjs.map