@photostructure/fs-metadata 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -1,1396 +0,0 @@
-// node_modules/tsup/assets/esm_shims.js
-import { fileURLToPath } from "url";
-import path from "path";
-var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path.dirname(getFilename());
-var __dirname = /* @__PURE__ */ getDirname();
-
-// src/index.ts
-import NodeGypBuild from "node-gyp-build";
-
-// src/debuglog.ts
-import { debuglog, format } from "node:util";
-function defer(thunk) {
-  let t;
-  return () => t ??= thunk();
-}
-var debugLogContext = defer(() => {
-  for (const ea of ["fs-metadata", "fs-meta"]) {
-    if (debuglog(ea).enabled) {
-      return ea;
-    }
-    if (debuglog(ea.toUpperCase()).enabled) {
-      return ea;
-    }
-  }
-  return "photostructure:fs-metadata";
-});
-var isDebugEnabled = defer(() => {
-  return 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 + 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
-import { dirname } from "node:path";
-
-// src/platform.ts
-import { arch, platform } from "node:process";
-var isLinux = platform === "linux";
-var isWindows = platform === "win32";
-var isMacOS = platform === "darwin";
-var isArm = isLinux && 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 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 path2 = g["path"];
-        if (MaybeUrlRE.test(path2)) {
-          try {
-            return new URL(path2).pathname;
-          } catch {
-          }
-        }
-        return path2;
-      }
-    }
-  }
-  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
-import { opendir, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
-
-// src/async.ts
-import { availableParallelism } from "node:os";
-import { env } from "node: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 (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 = 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(path2, options) {
-  return stat(path2, options);
-}
-async function canStatAsync(path2) {
-  try {
-    return null != await statAsync(path2);
-  } catch {
-    return false;
-  }
-}
-async function findAncestorDir(dir, file) {
-  dir = resolve(dir);
-  try {
-    const s = await statAsync(join(dir, file));
-    if (s.isFile()) return dir;
-  } catch {
-  }
-  const parent = 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 opendir(dir)).close();
-  return true;
-}
-
-// src/hidden.ts
-import { rename } from "node:fs/promises";
-import { basename, dirname as dirname3, join as join2 } from "node: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
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
-function normalizePath(mountPoint) {
-  if (isBlank(mountPoint)) return void 0;
-  const result = isWindows ? normalizeWindowsPath(mountPoint) : normalizePosixPath(mountPoint);
-  return result != null ? resolve2(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(path2) {
-  const n = normalizePath(path2);
-  return n == null ? false : isWindows ? dirname2(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(path2, nativeFn2) {
-  let norm = normalizePath(path2);
-  if (norm == null) {
-    throw new Error("Invalid path: " + JSON.stringify(path2));
-  }
-  while (!isRootDirectory(norm)) {
-    if (await isHiddenImpl(norm, nativeFn2)) {
-      return true;
-    }
-    norm = dirname3(norm);
-  }
-  return false;
-}
-function createHiddenPosixPath(pathname, hidden) {
-  const norm = normalizePath(pathname);
-  if (norm == null) {
-    throw new Error("Invalid pathname: " + JSON.stringify(pathname));
-  }
-  const dir = dirname3(norm);
-  const srcBase = basename(norm).replace(/^\./, "");
-  const dest = join2(dir, (hidden ? "." : "") + srcBase);
-  return dest;
-}
-async function setHiddenPosix(pathname, hidden) {
-  if (LocalSupport.dotPrefix) {
-    const dest = createHiddenPosixPath(pathname, hidden);
-    if (pathname !== dest) await rename(pathname, dest);
-    return dest;
-  }
-  throw new Error("Unsupported platform");
-}
-function isPosixHidden(pathname) {
-  if (!LocalSupport.dotPrefix) return false;
-  const b = 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
-import { availableParallelism as availableParallelism2 } from "node: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: availableParallelism2(),
-  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
-import { readdir, readlink } from "node:fs/promises";
-import { join as join3, resolve as resolve3 } from "node:path";
-async function getUuidFromDevDisk(devicePath) {
-  try {
-    const result = await getBasenameLinkedTo(
-      "/dev/disk/by-uuid",
-      resolve3(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",
-      resolve3(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 readdir(directory, { withFileTypes: true })) {
-    if (dirent.isSymbolicLink()) {
-      try {
-        const linkTarget = resolve3(
-          directory,
-          await readlink(join3(directory, dirent.name))
-        );
-        yield { dirent, linkTarget };
-      } catch {
-      }
-    }
-  }
-}
-
-// src/linux/mount_points.ts
-import { readFile } from "node: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 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 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(path2) {
-  if (path2 == null || isBlank(path2) || !isString(path2)) {
-    return;
-  }
-  if (!path2.startsWith("\\\\") && !path2.startsWith("//")) {
-    return;
-  }
-  const isForwardSlash = path2.startsWith("//");
-  const slashChar = isForwardSlash ? "/" : "\\";
-  const parts = path2.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 (path2.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 = NodeGypBuild(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);
-}
-export {
-  IncludeSystemVolumesDefault,
-  LinuxMountTablePathsDefault,
-  OptionsDefault,
-  SystemFsTypesDefault,
-  SystemPathPatternsDefault,
-  TimeoutMsDefault,
-  VolumeHealthStatuses,
-  getAllVolumeMetadata,
-  getHiddenMetadata,
-  getVolumeMetadata,
-  getVolumeMountPoints,
-  isHidden,
-  isHiddenRecursive,
-  optionsWithDefaults,
-  setHidden
-};
-//# sourceMappingURL=index.mjs.map