@dsherret/path 0.3.3

package/esm/mod.js

@@ -0,0 +1,2559 @@
+// npm/esm/_dnt.shims.js
+var dntGlobalThis = globalThis;
+
+// npm/esm/deps/jsr.io/@std/internal/1.0.14/_os.js
+function checkWindows() {
+  const global = dntGlobalThis;
+  const platform = global.process?.platform;
+  if (typeof platform === "string")
+    return platform.startsWith("win");
+  const os = global.Deno?.build?.os;
+  if (typeof os === "string")
+    return os === "windows";
+  return global.navigator?.platform?.startsWith("Win") ?? false;
+}
+
+// npm/esm/deps/jsr.io/@std/internal/1.0.14/os.js
+var isWindows = checkWindows();
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/assert_path.js
+function assertPath(path2) {
+  if (typeof path2 !== "string") {
+    throw new TypeError(`Path must be a string, received "${JSON.stringify(path2)}"`);
+  }
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/basename.js
+function stripSuffix(name, suffix) {
+  if (suffix.length >= name.length) {
+    return name;
+  }
+  const lenDiff = name.length - suffix.length;
+  for (let i = suffix.length - 1; i >= 0; --i) {
+    if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+      return name;
+    }
+  }
+  return name.slice(0, -suffix.length);
+}
+function lastPathSegment(path2, isSep, start = 0) {
+  let matchedNonSeparator = false;
+  let end = path2.length;
+  for (let i = path2.length - 1; i >= start; --i) {
+    if (isSep(path2.charCodeAt(i))) {
+      if (matchedNonSeparator) {
+        start = i + 1;
+        break;
+      }
+    } else if (!matchedNonSeparator) {
+      matchedNonSeparator = true;
+      end = i + 1;
+    }
+  }
+  return path2.slice(start, end);
+}
+function assertArgs(path2, suffix) {
+  assertPath(path2);
+  if (path2.length === 0)
+    return path2;
+  if (typeof suffix !== "string") {
+    throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
+  }
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/from_file_url.js
+function assertArg(url) {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol !== "file:") {
+    throw new TypeError(`URL must be a file URL: received "${url.protocol}"`);
+  }
+  return url;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/from_file_url.js
+function fromFileUrl(url) {
+  url = assertArg(url);
+  return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"));
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/strip_trailing_separators.js
+function stripTrailingSeparators(segment, isSep) {
+  if (segment.length <= 1) {
+    return segment;
+  }
+  let end = segment.length;
+  for (let i = segment.length - 1; i > 0; i--) {
+    if (isSep(segment.charCodeAt(i))) {
+      end = i;
+    } else {
+      break;
+    }
+  }
+  return segment.slice(0, end);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/constants.js
+var CHAR_UPPERCASE_A = 65;
+var CHAR_LOWERCASE_A = 97;
+var CHAR_UPPERCASE_Z = 90;
+var CHAR_LOWERCASE_Z = 122;
+var CHAR_DOT = 46;
+var CHAR_FORWARD_SLASH = 47;
+var CHAR_BACKWARD_SLASH = 92;
+var CHAR_COLON = 58;
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/_util.js
+function isPosixPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/basename.js
+function basename(path2, suffix = "") {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl(path2);
+  }
+  assertArgs(path2, suffix);
+  const lastSegment = lastPathSegment(path2, isPosixPathSeparator);
+  const strippedSegment = stripTrailingSeparators(lastSegment, isPosixPathSeparator);
+  return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/_util.js
+function isPosixPathSeparator2(code) {
+  return code === CHAR_FORWARD_SLASH;
+}
+function isPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+  return code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z || code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/from_file_url.js
+function fromFileUrl2(url) {
+  url = assertArg(url);
+  let path2 = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+  if (url.hostname !== "") {
+    path2 = `\\\\${url.hostname}${path2}`;
+  }
+  return path2;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/basename.js
+function basename2(path2, suffix = "") {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl2(path2);
+  }
+  assertArgs(path2, suffix);
+  let start = 0;
+  if (path2.length >= 2) {
+    const drive = path2.charCodeAt(0);
+    if (isWindowsDeviceRoot(drive)) {
+      if (path2.charCodeAt(1) === CHAR_COLON)
+        start = 2;
+    }
+  }
+  const lastSegment = lastPathSegment(path2, isPathSeparator, start);
+  const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
+  return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/basename.js
+function basename3(path2, suffix = "") {
+  return isWindows ? basename2(path2, suffix) : basename(path2, suffix);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/dirname.js
+function assertArg2(path2) {
+  assertPath(path2);
+  if (path2.length === 0)
+    return ".";
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/dirname.js
+function dirname(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl(path2);
+  }
+  assertArg2(path2);
+  let end = -1;
+  let matchedNonSeparator = false;
+  for (let i = path2.length - 1; i >= 1; --i) {
+    if (isPosixPathSeparator(path2.charCodeAt(i))) {
+      if (matchedNonSeparator) {
+        end = i;
+        break;
+      }
+    } else {
+      matchedNonSeparator = true;
+    }
+  }
+  if (end === -1) {
+    return isPosixPathSeparator(path2.charCodeAt(0)) ? "/" : ".";
+  }
+  return stripTrailingSeparators(path2.slice(0, end), isPosixPathSeparator);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/dirname.js
+function dirname2(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl2(path2);
+  }
+  assertArg2(path2);
+  const len = path2.length;
+  let rootEnd = -1;
+  let end = -1;
+  let matchedSlash = true;
+  let offset = 0;
+  const code = path2.charCodeAt(0);
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      rootEnd = offset = 1;
+      if (isPathSeparator(path2.charCodeAt(1))) {
+        let j = 2;
+        let last = j;
+        for (; j < len; ++j) {
+          if (isPathSeparator(path2.charCodeAt(j)))
+            break;
+        }
+        if (j < len && j !== last) {
+          last = j;
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path2.charCodeAt(j)))
+              break;
+          }
+          if (j < len && j !== last) {
+            last = j;
+            for (; j < len; ++j) {
+              if (isPathSeparator(path2.charCodeAt(j)))
+                break;
+            }
+            if (j === len) {
+              return path2;
+            }
+            if (j !== last) {
+              rootEnd = offset = j + 1;
+            }
+          }
+        }
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      if (path2.charCodeAt(1) === CHAR_COLON) {
+        rootEnd = offset = 2;
+        if (len > 2) {
+          if (isPathSeparator(path2.charCodeAt(2)))
+            rootEnd = offset = 3;
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    return path2;
+  }
+  for (let i = len - 1; i >= offset; --i) {
+    if (isPathSeparator(path2.charCodeAt(i))) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      matchedSlash = false;
+    }
+  }
+  if (end === -1) {
+    if (rootEnd === -1)
+      return ".";
+    else
+      end = rootEnd;
+  }
+  return stripTrailingSeparators(path2.slice(0, end), isPosixPathSeparator2);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/dirname.js
+function dirname3(path2) {
+  return isWindows ? dirname2(path2) : dirname(path2);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/extname.js
+function extname(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl(path2);
+  }
+  assertPath(path2);
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let preDotState = 0;
+  for (let i = path2.length - 1; i >= 0; --i) {
+    const code = path2.charCodeAt(i);
+    if (isPosixPathSeparator(code)) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+  preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    return "";
+  }
+  return path2.slice(startDot, end);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/extname.js
+function extname2(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl2(path2);
+  }
+  assertPath(path2);
+  let start = 0;
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let preDotState = 0;
+  if (path2.length >= 2 && path2.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path2.charCodeAt(0))) {
+    start = startPart = 2;
+  }
+  for (let i = path2.length - 1; i >= start; --i) {
+    const code = path2.charCodeAt(i);
+    if (isPathSeparator(code)) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+  preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    return "";
+  }
+  return path2.slice(startDot, end);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/extname.js
+function extname3(path2) {
+  return isWindows ? extname2(path2) : extname(path2);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/from_file_url.js
+function fromFileUrl3(url) {
+  return isWindows ? fromFileUrl2(url) : fromFileUrl(url);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/is_absolute.js
+function isAbsolute(path2) {
+  assertPath(path2);
+  return path2.length > 0 && isPosixPathSeparator(path2.charCodeAt(0));
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/is_absolute.js
+function isAbsolute2(path2) {
+  assertPath(path2);
+  const len = path2.length;
+  if (len === 0)
+    return false;
+  const code = path2.charCodeAt(0);
+  if (isPathSeparator(code)) {
+    return true;
+  } else if (isWindowsDeviceRoot(code)) {
+    if (len > 2 && path2.charCodeAt(1) === CHAR_COLON) {
+      if (isPathSeparator(path2.charCodeAt(2)))
+        return true;
+    }
+  }
+  return false;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/is_absolute.js
+function isAbsolute3(path2) {
+  return isWindows ? isAbsolute2(path2) : isAbsolute(path2);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/normalize.js
+function assertArg4(path2) {
+  assertPath(path2);
+  if (path2.length === 0)
+    return ".";
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/normalize_string.js
+function normalizeString(path2, allowAboveRoot, separator, isPathSeparator2) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length)
+      code = path2.charCodeAt(i);
+    else if (isPathSeparator2(code))
+      break;
+    else
+      code = CHAR_FORWARD_SLASH;
+    if (isPathSeparator2(code)) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf(separator);
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += `${separator}..`;
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += separator + path2.slice(lastSlash + 1, i);
+        else
+          res = path2.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === CHAR_DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/normalize.js
+function normalize(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl(path2);
+  }
+  assertArg4(path2);
+  const isAbsolute4 = isPosixPathSeparator(path2.charCodeAt(0));
+  const trailingSeparator = isPosixPathSeparator(path2.charCodeAt(path2.length - 1));
+  path2 = normalizeString(path2, !isAbsolute4, "/", isPosixPathSeparator);
+  if (path2.length === 0 && !isAbsolute4)
+    path2 = ".";
+  if (path2.length > 0 && trailingSeparator)
+    path2 += "/";
+  if (isAbsolute4)
+    return `/${path2}`;
+  return path2;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/join.js
+function join(path2, ...paths) {
+  if (path2 === void 0)
+    return ".";
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl(path2);
+  }
+  paths = path2 ? [path2, ...paths] : paths;
+  paths.forEach((path3) => assertPath(path3));
+  const joined = paths.filter((path3) => path3.length > 0).join("/");
+  return joined === "" ? "." : normalize(joined);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/normalize.js
+function normalize2(path2) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl2(path2);
+  }
+  assertArg4(path2);
+  const len = path2.length;
+  let rootEnd = 0;
+  let device;
+  let isAbsolute4 = false;
+  const code = path2.charCodeAt(0);
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      isAbsolute4 = true;
+      if (isPathSeparator(path2.charCodeAt(1))) {
+        let j = 2;
+        let last = j;
+        for (; j < len; ++j) {
+          if (isPathSeparator(path2.charCodeAt(j)))
+            break;
+        }
+        if (j < len && j !== last) {
+          const firstPart = path2.slice(last, j);
+          last = j;
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path2.charCodeAt(j)))
+              break;
+          }
+          if (j < len && j !== last) {
+            last = j;
+            for (; j < len; ++j) {
+              if (isPathSeparator(path2.charCodeAt(j)))
+                break;
+            }
+            if (j === len) {
+              return `\\\\${firstPart}\\${path2.slice(last)}\\`;
+            } else if (j !== last) {
+              device = `\\\\${firstPart}\\${path2.slice(last, j)}`;
+              rootEnd = j;
+            }
+          }
+        }
+      } else {
+        rootEnd = 1;
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      if (path2.charCodeAt(1) === CHAR_COLON) {
+        device = path2.slice(0, 2);
+        rootEnd = 2;
+        if (len > 2) {
+          if (isPathSeparator(path2.charCodeAt(2))) {
+            isAbsolute4 = true;
+            rootEnd = 3;
+          }
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    return "\\";
+  }
+  let tail;
+  if (rootEnd < len) {
+    tail = normalizeString(path2.slice(rootEnd), !isAbsolute4, "\\", isPathSeparator);
+  } else {
+    tail = "";
+  }
+  if (tail.length === 0 && !isAbsolute4)
+    tail = ".";
+  if (tail.length > 0 && isPathSeparator(path2.charCodeAt(len - 1))) {
+    tail += "\\";
+  }
+  if (device === void 0) {
+    if (isAbsolute4) {
+      if (tail.length > 0)
+        return `\\${tail}`;
+      else
+        return "\\";
+    }
+    return tail;
+  } else if (isAbsolute4) {
+    if (tail.length > 0)
+      return `${device}\\${tail}`;
+    else
+      return `${device}\\`;
+  }
+  return device + tail;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/join.js
+function join2(path2, ...paths) {
+  if (path2 instanceof URL) {
+    path2 = fromFileUrl2(path2);
+  }
+  paths = path2 ? [path2, ...paths] : paths;
+  paths.forEach((path3) => assertPath(path3));
+  paths = paths.filter((path3) => path3.length > 0);
+  if (paths.length === 0)
+    return ".";
+  let needsReplace = true;
+  let slashCount = 0;
+  const firstPart = paths[0];
+  if (isPathSeparator(firstPart.charCodeAt(0))) {
+    ++slashCount;
+    const firstLen = firstPart.length;
+    if (firstLen > 1) {
+      if (isPathSeparator(firstPart.charCodeAt(1))) {
+        ++slashCount;
+        if (firstLen > 2) {
+          if (isPathSeparator(firstPart.charCodeAt(2)))
+            ++slashCount;
+          else {
+            needsReplace = false;
+          }
+        }
+      }
+    }
+  }
+  let joined = paths.join("\\");
+  if (needsReplace) {
+    for (; slashCount < joined.length; ++slashCount) {
+      if (!isPathSeparator(joined.charCodeAt(slashCount)))
+        break;
+    }
+    if (slashCount >= 2)
+      joined = `\\${joined.slice(slashCount)}`;
+  }
+  return normalize2(joined);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/join.js
+function join3(path2, ...paths) {
+  return isWindows ? join2(path2, ...paths) : join(path2, ...paths);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/normalize.js
+function normalize3(path2) {
+  return isWindows ? normalize2(path2) : normalize(path2);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/env.js
+function cwd(errorMessage) {
+  const global = dntGlobalThis;
+  const getCwd = global.process?.cwd ?? global.Deno?.cwd;
+  if (typeof getCwd !== "function") {
+    throw new TypeError(errorMessage);
+  }
+  return getCwd();
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/resolve.js
+function resolve(...pathSegments) {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path2;
+    if (i >= 0)
+      path2 = pathSegments[i];
+    else {
+      path2 = cwd("Resolved a relative path without a current working directory (CWD)");
+    }
+    assertPath(path2);
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isPosixPathSeparator(path2.charCodeAt(0));
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0)
+      return `/${resolvedPath}`;
+    else
+      return "/";
+  } else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/relative.js
+function assertArgs2(from, to) {
+  assertPath(from);
+  assertPath(to);
+  if (from === to)
+    return "";
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/relative.js
+function relative(from, to) {
+  assertArgs2(from, to);
+  from = resolve(from);
+  to = resolve(to);
+  if (from === to)
+    return "";
+  let fromStart = 1;
+  const fromEnd = from.length;
+  for (; fromStart < fromEnd; ++fromStart) {
+    if (!isPosixPathSeparator(from.charCodeAt(fromStart)))
+      break;
+  }
+  const fromLen = fromEnd - fromStart;
+  let toStart = 1;
+  const toEnd = to.length;
+  for (; toStart < toEnd; ++toStart) {
+    if (!isPosixPathSeparator(to.charCodeAt(toStart)))
+      break;
+  }
+  const toLen = toEnd - toStart;
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (isPosixPathSeparator(to.charCodeAt(toStart + i))) {
+          return to.slice(toStart + i + 1);
+        } else if (i === 0) {
+          return to.slice(toStart + i);
+        }
+      } else if (fromLen > length) {
+        if (isPosixPathSeparator(from.charCodeAt(fromStart + i))) {
+          lastCommonSep = i;
+        } else if (i === 0) {
+          lastCommonSep = 0;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (isPosixPathSeparator(fromCode))
+      lastCommonSep = i;
+  }
+  let out = "";
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || isPosixPathSeparator(from.charCodeAt(i))) {
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+    }
+  }
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    toStart += lastCommonSep;
+    if (isPosixPathSeparator(to.charCodeAt(toStart)))
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/resolve.js
+function resolve2(...pathSegments) {
+  let resolvedDevice = "";
+  let resolvedTail = "";
+  let resolvedAbsolute = false;
+  for (let i = pathSegments.length - 1; i >= -1; i--) {
+    let path2;
+    if (i >= 0) {
+      path2 = pathSegments[i];
+    } else if (!resolvedDevice) {
+      path2 = cwd("Resolved a drive-letter-less path without a current working directory (CWD)");
+    } else {
+      path2 = cwd("Resolved a relative path without a current working directory (CWD)");
+      if (path2 === void 0 || path2.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) {
+        path2 = `${resolvedDevice}\\`;
+      }
+    }
+    assertPath(path2);
+    const len = path2.length;
+    if (len === 0)
+      continue;
+    let rootEnd = 0;
+    let device = "";
+    let isAbsolute4 = false;
+    const code = path2.charCodeAt(0);
+    if (len > 1) {
+      if (isPathSeparator(code)) {
+        isAbsolute4 = true;
+        if (isPathSeparator(path2.charCodeAt(1))) {
+          let j = 2;
+          let last = j;
+          for (; j < len; ++j) {
+            if (isPathSeparator(path2.charCodeAt(j)))
+              break;
+          }
+          if (j < len && j !== last) {
+            const firstPart = path2.slice(last, j);
+            last = j;
+            for (; j < len; ++j) {
+              if (!isPathSeparator(path2.charCodeAt(j)))
+                break;
+            }
+            if (j < len && j !== last) {
+              last = j;
+              for (; j < len; ++j) {
+                if (isPathSeparator(path2.charCodeAt(j)))
+                  break;
+              }
+              if (j === len) {
+                device = `\\\\${firstPart}\\${path2.slice(last)}`;
+                rootEnd = j;
+              } else if (j !== last) {
+                device = `\\\\${firstPart}\\${path2.slice(last, j)}`;
+                rootEnd = j;
+              }
+            }
+          }
+        } else {
+          rootEnd = 1;
+        }
+      } else if (isWindowsDeviceRoot(code)) {
+        if (path2.charCodeAt(1) === CHAR_COLON) {
+          device = path2.slice(0, 2);
+          rootEnd = 2;
+          if (len > 2) {
+            if (isPathSeparator(path2.charCodeAt(2))) {
+              isAbsolute4 = true;
+              rootEnd = 3;
+            }
+          }
+        }
+      }
+    } else if (isPathSeparator(code)) {
+      rootEnd = 1;
+      isAbsolute4 = true;
+    }
+    if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+      continue;
+    }
+    if (resolvedDevice.length === 0 && device.length > 0) {
+      resolvedDevice = device;
+    }
+    if (!resolvedAbsolute) {
+      resolvedTail = `${path2.slice(rootEnd)}\\${resolvedTail}`;
+      resolvedAbsolute = isAbsolute4;
+    }
+    if (resolvedAbsolute && resolvedDevice.length > 0)
+      break;
+  }
+  resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
+  return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/relative.js
+function relative2(from, to) {
+  assertArgs2(from, to);
+  const fromOrig = resolve2(from);
+  const toOrig = resolve2(to);
+  if (fromOrig === toOrig)
+    return "";
+  from = fromOrig.toLowerCase();
+  to = toOrig.toLowerCase();
+  if (from === to)
+    return "";
+  let fromStart = 0;
+  let fromEnd = from.length;
+  for (; fromStart < fromEnd; ++fromStart) {
+    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH)
+      break;
+  }
+  for (; fromEnd - 1 > fromStart; --fromEnd) {
+    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH)
+      break;
+  }
+  const fromLen = fromEnd - fromStart;
+  let toStart = 0;
+  let toEnd = to.length;
+  for (; toStart < toEnd; ++toStart) {
+    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH)
+      break;
+  }
+  for (; toEnd - 1 > toStart; --toEnd) {
+    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH)
+      break;
+  }
+  const toLen = toEnd - toStart;
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+          return toOrig.slice(toStart + i + 1);
+        } else if (i === 2) {
+          return toOrig.slice(toStart + i);
+        }
+      }
+      if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
+          lastCommonSep = i;
+        } else if (i === 2) {
+          lastCommonSep = 3;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === CHAR_BACKWARD_SLASH)
+      lastCommonSep = i;
+  }
+  if (i !== length && lastCommonSep === -1) {
+    return toOrig;
+  }
+  let out = "";
+  if (lastCommonSep === -1)
+    lastCommonSep = 0;
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "\\..";
+    }
+  }
+  if (out.length > 0) {
+    return out + toOrig.slice(toStart + lastCommonSep, toEnd);
+  } else {
+    toStart += lastCommonSep;
+    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH)
+      ++toStart;
+    return toOrig.slice(toStart, toEnd);
+  }
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/relative.js
+function relative3(from, to) {
+  return isWindows ? relative2(from, to) : relative(from, to);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/resolve.js
+function resolve3(...pathSegments) {
+  return isWindows ? resolve2(...pathSegments) : resolve(...pathSegments);
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/_common/to_file_url.js
+var WHITESPACE_ENCODINGS = {
+  "	": "%09",
+  "\n": "%0A",
+  "\v": "%0B",
+  "\f": "%0C",
+  "\r": "%0D",
+  " ": "%20"
+};
+function encodeWhitespace(string) {
+  return string.replaceAll(/[\s]/g, (c) => {
+    return WHITESPACE_ENCODINGS[c] ?? c;
+  });
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/posix/to_file_url.js
+function toFileUrl(path2) {
+  if (!isAbsolute(path2)) {
+    throw new TypeError(`Path must be absolute: received "${path2}"`);
+  }
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(path2.replace(/^\/+/, "/").replace(/%/g, "%25").replace(/\\/g, "%5C"));
+  return url;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/windows/to_file_url.js
+function toFileUrl2(path2) {
+  if (!isAbsolute2(path2)) {
+    throw new TypeError(`Path must be absolute: received "${path2}"`);
+  }
+  const [, hostname, pathname] = path2.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+  if (hostname !== void 0 && hostname !== "localhost") {
+    url.hostname = hostname;
+    if (!url.hostname) {
+      throw new TypeError(`Invalid hostname: "${url.hostname}"`);
+    }
+  }
+  return url;
+}
+
+// npm/esm/deps/jsr.io/@std/path/1.1.6/to_file_url.js
+function toFileUrl3(path2) {
+  return isWindows ? toFileUrl2(path2) : toFileUrl(path2);
+}
+
+// npm/esm/_fs.js
+var nodeProcess = globalThis.process;
+var nodeFs;
+function getNodeFs() {
+  return nodeFs ??= nodeProcess.getBuiltinModule("node:fs");
+}
+var nodeFsPromises;
+function getNodeFsPromises() {
+  return nodeFsPromises ??= nodeProcess.getBuiltinModule("node:fs/promises");
+}
+function isNotFoundError(err) {
+  return err?.code === "ENOENT";
+}
+function createNotFoundError(message) {
+  const err = new Error(message);
+  err.code = "ENOENT";
+  return err;
+}
+function isWindows2() {
+  return process.platform === "win32";
+}
+var FsFile = class {
+  /** @internal */
+  _fd;
+  /** @internal */
+  constructor(fd) {
+    this._fd = fd;
+  }
+  /** Writes data to the file, resolving to the number of bytes written.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  write(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return new Promise((resolve4, reject) => {
+      getNodeFs().write(this._fd, bytes, 0, bytes.length, null, (err, written) => {
+        if (err)
+          reject(err);
+        else
+          resolve4(written);
+      });
+    });
+  }
+  /** Synchronously writes data to the file, returning the number of bytes written.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  writeSync(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return getNodeFs().writeSync(this._fd, bytes, 0, bytes.length);
+  }
+  /** Reads into `buf`, resolving to the number of bytes read (0 at EOF). */
+  read(buf) {
+    return new Promise((resolve4, reject) => {
+      getNodeFs().read(this._fd, buf, 0, buf.length, null, (err, bytesRead) => {
+        if (err)
+          reject(err);
+        else
+          resolve4(bytesRead);
+      });
+    });
+  }
+  /** Synchronously reads into `buf`, returning the number of bytes read (0 at EOF). */
+  readSync(buf) {
+    return getNodeFs().readSync(this._fd, buf, 0, buf.length, null);
+  }
+  /** Closes the file handle. */
+  close() {
+    getNodeFs().closeSync(this._fd);
+  }
+  /** A writable stream that writes to this file. */
+  get writable() {
+    const fd = this._fd;
+    return new WritableStream({
+      write(chunk) {
+        return new Promise((resolve4, reject) => {
+          getNodeFs().write(fd, chunk, 0, chunk.length, null, (err) => {
+            if (err)
+              reject(err);
+            else
+              resolve4();
+          });
+        });
+      }
+    });
+  }
+  /** A readable stream that reads from this file. */
+  get readable() {
+    const fd = this._fd;
+    return new ReadableStream({
+      pull(controller) {
+        return new Promise((resolve4, reject) => {
+          const buf = new Uint8Array(16384);
+          getNodeFs().read(fd, buf, 0, buf.length, null, (err, bytesRead) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+            if (bytesRead === 0) {
+              controller.close();
+            } else {
+              controller.enqueue(buf.subarray(0, bytesRead));
+            }
+            resolve4();
+          });
+        });
+      }
+    });
+  }
+};
+function stat(path2) {
+  return getNodeFsPromises().stat(path2);
+}
+function statSync(path2) {
+  return getNodeFs().statSync(path2);
+}
+function lstat(path2) {
+  return getNodeFsPromises().lstat(path2);
+}
+function lstatSync(path2) {
+  return getNodeFs().lstatSync(path2);
+}
+function realPath(path2) {
+  return getNodeFsPromises().realpath(path2);
+}
+function realPathSync(path2) {
+  return getNodeFs().realpathSync(path2);
+}
+async function mkdirFn(path2, options) {
+  await getNodeFsPromises().mkdir(path2, options);
+}
+function mkdirSyncFn(path2, options) {
+  getNodeFs().mkdirSync(path2, options);
+}
+async function linkFn(oldPath, newPath) {
+  await getNodeFsPromises().link(oldPath, newPath);
+}
+function linkSyncFn(oldPath, newPath) {
+  getNodeFs().linkSync(oldPath, newPath);
+}
+async function symlinkFn(target, path2, type) {
+  await getNodeFsPromises().symlink(target, path2, type?.type);
+}
+function symlinkSyncFn(target, path2, type) {
+  getNodeFs().symlinkSync(target, path2, type?.type);
+}
+async function* readDir(path2) {
+  const entries = await getNodeFsPromises().readdir(path2, {
+    withFileTypes: true
+  });
+  yield* entries;
+}
+function* readDirSync(path2) {
+  yield* getNodeFs().readdirSync(path2, { withFileTypes: true });
+}
+async function readFile(path2, options) {
+  return new Uint8Array(await getNodeFsPromises().readFile(path2, { signal: options?.signal }));
+}
+function readFileSync(path2) {
+  return new Uint8Array(getNodeFs().readFileSync(path2));
+}
+function readTextFile(path2, options) {
+  return getNodeFsPromises().readFile(path2, {
+    encoding: "utf8",
+    signal: options?.signal
+  });
+}
+function readTextFileSync(path2) {
+  return getNodeFs().readFileSync(path2, "utf8");
+}
+async function chmod(path2, mode) {
+  await getNodeFsPromises().chmod(path2, mode);
+}
+function chmodSync(path2, mode) {
+  getNodeFs().chmodSync(path2, mode);
+}
+async function chown(path2, uid, gid) {
+  await getNodeFsPromises().chown(path2, uid ?? -1, gid ?? -1);
+}
+function chownSync(path2, uid, gid) {
+  getNodeFs().chownSync(path2, uid ?? -1, gid ?? -1);
+}
+function openFile(path2, options) {
+  return new Promise((resolve4, reject) => {
+    getNodeFs().open(path2, openOptionsToFlags(options), options?.mode, (err, fd) => {
+      if (err)
+        reject(err);
+      else
+        resolve4(new FsFile(fd));
+    });
+  });
+}
+function openFileSync(path2, options) {
+  const fd = getNodeFs().openSync(path2, openOptionsToFlags(options), options?.mode);
+  return new FsFile(fd);
+}
+function createFile(path2) {
+  return openFile(path2, {
+    write: true,
+    create: true,
+    truncate: true,
+    read: true
+  });
+}
+function createFileSync(path2) {
+  return openFileSync(path2, {
+    write: true,
+    create: true,
+    truncate: true,
+    read: true
+  });
+}
+async function remove(path2, options) {
+  if (options?.recursive) {
+    await getNodeFsPromises().rm(path2, { recursive: true });
+    return;
+  }
+  const info = await getNodeFsPromises().lstat(path2);
+  if (info.isDirectory()) {
+    await getNodeFsPromises().rmdir(path2);
+  } else {
+    await getNodeFsPromises().unlink(path2);
+  }
+}
+function removeSync(path2, options) {
+  if (options?.recursive) {
+    getNodeFs().rmSync(path2, { recursive: true });
+    return;
+  }
+  const info = getNodeFs().lstatSync(path2);
+  if (info.isDirectory()) {
+    getNodeFs().rmdirSync(path2);
+  } else {
+    getNodeFs().unlinkSync(path2);
+  }
+}
+async function copyFileFn(src, dest) {
+  await getNodeFsPromises().copyFile(src, dest);
+}
+function copyFileSyncFn(src, dest) {
+  getNodeFs().copyFileSync(src, dest);
+}
+async function renameFn(oldPath, newPath) {
+  await getNodeFsPromises().rename(oldPath, newPath);
+}
+function renameSyncFn(oldPath, newPath) {
+  getNodeFs().renameSync(oldPath, newPath);
+}
+async function ensureDir(path2) {
+  await mkdirFn(path2, { recursive: true });
+}
+function ensureDirSync(path2) {
+  mkdirSyncFn(path2, { recursive: true });
+}
+async function ensureFile(path2) {
+  const info = await lstatOrUndefined(path2);
+  if (info != null) {
+    if (info.isFile())
+      return;
+    throw new Error(`Path '${path2}' already exists and is not a file.`);
+  }
+  await mkdirFn(dirname3(path2), { recursive: true });
+  (await createFile(path2)).close();
+}
+function ensureFileSync(path2) {
+  const info = lstatOrUndefinedSync(path2);
+  if (info != null) {
+    if (info.isFile())
+      return;
+    throw new Error(`Path '${path2}' already exists and is not a file.`);
+  }
+  mkdirSyncFn(dirname3(path2), { recursive: true });
+  createFileSync(path2).close();
+}
+async function emptyDir(path2) {
+  try {
+    const entries = [];
+    for await (const entry of readDir(path2)) {
+      entries.push(entry);
+    }
+    for (const entry of entries) {
+      await remove(join3(path2, entry.name), { recursive: true });
+    }
+  } catch (err) {
+    if (!isNotFoundError(err))
+      throw err;
+    await mkdirFn(path2, { recursive: true });
+  }
+}
+function emptyDirSync(path2) {
+  try {
+    const entries = [...readDirSync(path2)];
+    for (const entry of entries) {
+      removeSync(join3(path2, entry.name), { recursive: true });
+    }
+  } catch (err) {
+    if (!isNotFoundError(err))
+      throw err;
+    mkdirSyncFn(path2, { recursive: true });
+  }
+}
+async function copy(src, dest, options) {
+  const overwrite = options?.overwrite ?? false;
+  const srcInfo = await stat(src);
+  await copyRecursive(src, dest, srcInfo, overwrite);
+}
+function copySync(src, dest, options) {
+  const overwrite = options?.overwrite ?? false;
+  const srcInfo = statSync(src);
+  copyRecursiveSync(src, dest, srcInfo, overwrite);
+}
+async function copyRecursive(src, dest, srcInfo, overwrite) {
+  let destInfo = await lstatOrUndefined(dest);
+  if (destInfo != null && !overwrite) {
+    throw new Error(`'${dest}' already exists.`);
+  }
+  if (srcInfo.isDirectory()) {
+    if (destInfo != null && !destInfo.isDirectory()) {
+      await remove(dest);
+      destInfo = void 0;
+    }
+    if (destInfo == null) {
+      await mkdirFn(dest, { recursive: true });
+    }
+    for await (const entry of readDir(src)) {
+      const srcChild = join3(src, entry.name);
+      const destChild = join3(dest, entry.name);
+      const childInfo = await stat(srcChild);
+      await copyRecursive(srcChild, destChild, childInfo, overwrite);
+    }
+  } else {
+    if (destInfo != null && destInfo.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with file '${src}'.`);
+    }
+    await copyFileFn(src, dest);
+  }
+}
+function copyRecursiveSync(src, dest, srcInfo, overwrite) {
+  let destInfo = lstatOrUndefinedSync(dest);
+  if (destInfo != null && !overwrite) {
+    throw new Error(`'${dest}' already exists.`);
+  }
+  if (srcInfo.isDirectory()) {
+    if (destInfo != null && !destInfo.isDirectory()) {
+      removeSync(dest);
+      destInfo = void 0;
+    }
+    if (destInfo == null) {
+      mkdirSyncFn(dest, { recursive: true });
+    }
+    for (const entry of readDirSync(src)) {
+      const srcChild = join3(src, entry.name);
+      const destChild = join3(dest, entry.name);
+      const childInfo = statSync(srcChild);
+      copyRecursiveSync(srcChild, destChild, childInfo, overwrite);
+    }
+  } else {
+    if (destInfo != null && destInfo.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with file '${src}'.`);
+    }
+    copyFileSyncFn(src, dest);
+  }
+}
+async function lstatOrUndefined(path2) {
+  try {
+    return await lstat(path2);
+  } catch (err) {
+    if (isNotFoundError(err))
+      return void 0;
+    throw err;
+  }
+}
+function lstatOrUndefinedSync(path2) {
+  try {
+    return lstatSync(path2);
+  } catch (err) {
+    if (isNotFoundError(err))
+      return void 0;
+    throw err;
+  }
+}
+function openOptionsToFlags(options) {
+  const C = getNodeFs().constants;
+  if (!options)
+    return C.O_RDONLY;
+  const { read, write, append, truncate, create, createNew } = options;
+  const needsWrite = write || append || create || createNew;
+  let flags;
+  if (read && needsWrite)
+    flags = C.O_RDWR;
+  else if (needsWrite)
+    flags = C.O_WRONLY;
+  else
+    flags = C.O_RDONLY;
+  if (append)
+    flags |= C.O_APPEND;
+  if (truncate)
+    flags |= C.O_TRUNC;
+  if (createNew)
+    flags |= C.O_CREAT | C.O_EXCL;
+  else if (create)
+    flags |= C.O_CREAT;
+  return flags;
+}
+
+// npm/esm/mod.js
+function path(path2) {
+  return new Path(path2);
+}
+var mod_default = path;
+var Path = class _Path {
+  #path;
+  #knownResolved = false;
+  /** This is a special symbol that allows different versions of
+   * `Path` API to match on `instanceof` checks. Ideally
+   * people shouldn't be mixing versions, but if it happens then
+   * this will maybe reduce some bugs.
+   * @internal
+   */
+  static instanceofSymbol = /* @__PURE__ */ Symbol.for("@david/path.Path");
+  /** Creates a new path from the provided string, URL, or another Path. */
+  constructor(path2) {
+    if (path2 instanceof URL) {
+      this.#path = fromFileUrl3(path2);
+    } else if (path2 instanceof _Path) {
+      this.#path = path2.toString();
+    } else if (typeof path2 === "string") {
+      if (path2.startsWith("file://")) {
+        this.#path = fromFileUrl3(path2);
+      } else {
+        this.#path = path2;
+      }
+    } else {
+      throw new Error(`Invalid path argument: ${path2}
+
+Provide a URL, string, or another Path.`);
+    }
+  }
+  /** @internal */
+  static [Symbol.hasInstance](instance) {
+    return instance?.constructor?.instanceofSymbol === _Path.instanceofSymbol;
+  }
+  /** @internal */
+  [/* @__PURE__ */ Symbol.for("Deno.customInspect")]() {
+    return `Path("${this.#path}")`;
+  }
+  /** @internal */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Path("${this.#path}")`;
+  }
+  /** Gets the string representation of this path. */
+  toString() {
+    return this.#path;
+  }
+  /** Resolves the path and gets the file URL. */
+  toFileUrl() {
+    const resolvedPath = this.resolve();
+    return toFileUrl3(resolvedPath.toString());
+  }
+  /** If this path reference is the same as another one. */
+  equals(otherPath) {
+    return this.resolve().toString() === otherPath.resolve().toString();
+  }
+  /** Follows symlinks and gets if this path is a directory. */
+  isDirSync() {
+    return this.statSync()?.isDirectory() ?? false;
+  }
+  /** Follows symlinks and gets if this path is a file. */
+  isFileSync() {
+    return this.statSync()?.isFile() ?? false;
+  }
+  /** Gets if this path is a symlink. */
+  isSymlinkSync() {
+    return this.lstatSync()?.isSymbolicLink() ?? false;
+  }
+  /** Gets if this path is an absolute path. */
+  isAbsolute() {
+    return isAbsolute3(this.#path);
+  }
+  /** Gets if this path is relative. */
+  isRelative() {
+    return !this.isAbsolute();
+  }
+  /** Joins the provided path segments onto this path. */
+  join(...pathSegments) {
+    return new _Path(join3(this.#path, ...pathSegments));
+  }
+  /** Resolves this path to an absolute path along with the provided path segments. */
+  resolve(...pathSegments) {
+    if (this.#knownResolved && pathSegments.length === 0) {
+      return this;
+    }
+    const resolvedPath = resolve3(this.#path, ...pathSegments);
+    if (pathSegments.length === 0 && resolvedPath === this.#path) {
+      this.#knownResolved = true;
+      return this;
+    } else {
+      const pathRef = new _Path(resolvedPath);
+      pathRef.#knownResolved = true;
+      return pathRef;
+    }
+  }
+  /**
+   * Normalizes the `path`, resolving `'..'` and `'.'` segments.
+   * Note that resolving these segments does not necessarily mean that all will be eliminated.
+   * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+   */
+  normalize() {
+    return new _Path(normalize3(this.#path));
+  }
+  /** Resolves the file info of this path following symlinks. */
+  async stat() {
+    try {
+      return await stat(this.#path);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /** Synchronously resolves the file info of this path following symlinks. */
+  statSync() {
+    try {
+      return statSync(this.#path);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /** Resolves the file info of this path without following symlinks. */
+  async lstat() {
+    try {
+      return await lstat(this.#path);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /** Synchronously resolves the file info of this path without following symlinks. */
+  lstatSync() {
+    try {
+      return lstatSync(this.#path);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Gets the directory path. In most cases, it is recommended
+   * to use `.parent()` instead since it will give you a `PathRef`.
+   */
+  dirname() {
+    return dirname3(this.#path);
+  }
+  /** Gets the file or directory name of the path. */
+  basename() {
+    return basename3(this.#path);
+  }
+  /** Resolves the path getting all its ancestor directories in order. */
+  *ancestors() {
+    let ancestor = this.parent();
+    while (ancestor != null) {
+      yield ancestor;
+      ancestor = ancestor.parent();
+    }
+  }
+  /** Iterates over the components of a path. */
+  *components() {
+    const path2 = this.normalize();
+    let last_index = 0;
+    if (path2.#path.startsWith("\\\\?\\")) {
+      last_index = nextSlash(path2.#path, 4);
+      if (last_index === -1) {
+        yield path2.#path;
+        return;
+      } else {
+        yield path2.#path.substring(0, last_index);
+        last_index += 1;
+      }
+    } else if (path2.#path.startsWith("/")) {
+      last_index += 1;
+    }
+    while (true) {
+      const index = nextSlash(path2.#path, last_index);
+      if (index < 0) {
+        const part = path2.#path.substring(last_index);
+        if (part.length > 0) {
+          yield part;
+        }
+        return;
+      }
+      yield path2.#path.substring(last_index, index);
+      last_index = index + 1;
+    }
+    function nextSlash(path3, start) {
+      for (let i = start; i < path3.length; i++) {
+        const c = path3.charCodeAt(i);
+        if (c === 47 || c === 92) {
+          return i;
+        }
+      }
+      return -1;
+    }
+  }
+  // This is private because this doesn't handle stuff like `\\?\` at the start
+  // so it's only used internally with #endsWith for perf. API consumers should
+  // use .components()
+  *#rcomponents() {
+    const path2 = this.normalize();
+    let last_index = void 0;
+    while (last_index == null || last_index > 0) {
+      const index = nextSlash(path2.#path, last_index == null ? void 0 : last_index - 1);
+      if (index < 0) {
+        const part2 = path2.#path.substring(0, last_index);
+        if (part2.length > 0) {
+          yield part2;
+        }
+        return;
+      }
+      const part = path2.#path.substring(index + 1, last_index);
+      if (last_index != null || part.length > 0) {
+        yield part;
+      }
+      last_index = index;
+    }
+    function nextSlash(path3, start) {
+      for (let i = start ?? path3.length - 1; i >= 0; i--) {
+        const c = path3.charCodeAt(i);
+        if (c === 47 || c === 92) {
+          return i;
+        }
+      }
+      return -1;
+    }
+  }
+  /** Gets if the provided path starts with the specified Path, URL, or string.
+   *
+   * This verifies based on matching the components.
+   *
+   * ```
+   * assert(new Path("/a/b/c").startsWith("/a/b"));
+   * assert(!new Path("/example").endsWith("/exam"));
+   * ```
+   */
+  startsWith(path2) {
+    const startsWithComponents = ensurePath(path2).components();
+    for (const component of this.components()) {
+      const next = startsWithComponents.next();
+      if (next.done) {
+        return true;
+      }
+      if (next.value !== component) {
+        return false;
+      }
+    }
+    return startsWithComponents.next().done ?? true;
+  }
+  /** Gets if the provided path ends with the specified Path, URL, or string.
+   *
+   * This verifies based on matching the components.
+   *
+   * ```
+   * assert(new Path("/a/b/c").endsWith("b/c"));
+   * assert(!new Path("/a/b/example").endsWith("ple"));
+   * ```
+   */
+  endsWith(path2) {
+    const endsWithComponents = ensurePath(path2).#rcomponents();
+    for (const component of this.#rcomponents()) {
+      const next = endsWithComponents.next();
+      if (next.done) {
+        return true;
+      }
+      if (next.value !== component) {
+        return false;
+      }
+    }
+    return endsWithComponents.next().done ?? true;
+  }
+  /** Gets the parent directory or returns undefined if the parent is the root directory. */
+  parent() {
+    const resolvedPath = this.resolve();
+    const dirname4 = resolvedPath.dirname();
+    if (dirname4 === resolvedPath.#path) {
+      return void 0;
+    } else {
+      return new _Path(dirname4);
+    }
+  }
+  /** Gets the parent or throws if the current directory was the root. */
+  parentOrThrow() {
+    const parent = this.parent();
+    if (parent == null) {
+      throw new Error(`Cannot get the parent directory of '${this.#path}'.`);
+    }
+    return parent;
+  }
+  /**
+   * Returns the extension of the path with leading period or undefined
+   * if there is no extension.
+   */
+  extname() {
+    const extName = extname3(this.#path);
+    return extName.length === 0 ? void 0 : extName;
+  }
+  /** Gets a new path reference with the provided extension. */
+  withExtname(ext) {
+    const currentExt = this.extname();
+    const hasLeadingPeriod = ext.charCodeAt(0) === /* period */
+    46;
+    if (!hasLeadingPeriod && ext.length !== 0) {
+      ext = "." + ext;
+    }
+    return new _Path(this.#path.substring(0, this.#path.length - (currentExt?.length ?? 0)) + ext);
+  }
+  /** Gets a new path reference with the provided file or directory name. */
+  withBasename(basename4) {
+    const currentBaseName = this.basename();
+    return new _Path(this.#path.substring(0, this.#path.length - currentBaseName.length) + basename4);
+  }
+  /** Gets the relative path from this path to the specified path. */
+  relative(to) {
+    const toPathRef = ensurePath(to);
+    return relative3(this.resolve().#path, toPathRef.resolve().toString());
+  }
+  /** Gets if the path exists. Beware of TOCTOU issues. */
+  exists() {
+    return this.lstat().then((info) => info != null);
+  }
+  /** Synchronously gets if the path exists. Beware of TOCTOU issues. */
+  existsSync() {
+    return this.lstatSync() != null;
+  }
+  /** Resolves to the absolute normalized path, with symbolic links resolved. */
+  realPath() {
+    return realPath(this.#path).then((path2) => new _Path(path2));
+  }
+  /** Synchronously resolves to the absolute normalized path, with symbolic links resolved. */
+  realPathSync() {
+    return new _Path(realPathSync(this.#path));
+  }
+  /** Creates a directory at this path.
+   * @remarks By default, this is recursive.
+   */
+  async mkdir(options) {
+    await mkdirFn(this.#path, {
+      recursive: true,
+      ...options
+    });
+    return this;
+  }
+  /** Synchronously creates a directory at this path.
+   * @remarks By default, this is recursive.
+   */
+  mkdirSync(options) {
+    mkdirSyncFn(this.#path, {
+      recursive: true,
+      ...options
+    });
+    return this;
+  }
+  async symlinkTo(target, opts) {
+    await createSymlink(this.#resolveCreateSymlinkOpts(target, opts));
+  }
+  symlinkToSync(target, opts) {
+    createSymlinkSync(this.#resolveCreateSymlinkOpts(target, opts));
+  }
+  #resolveCreateSymlinkOpts(target, opts) {
+    if (opts?.kind == null) {
+      if (typeof target === "string") {
+        return {
+          fromPath: this.resolve(),
+          targetPath: ensurePath(target),
+          text: target,
+          type: opts?.type
+        };
+      } else {
+        throw new Error("Please specify if this symlink is absolute or relative. Otherwise provide the target text.");
+      }
+    }
+    const targetPath = ensurePath(target).resolve();
+    if (opts?.kind === "relative") {
+      const fromPath = this.resolve();
+      const relativePath = fromPath.parentOrThrow().relative(targetPath);
+      return {
+        fromPath,
+        targetPath,
+        text: relativePath,
+        type: opts?.type
+      };
+    } else {
+      return {
+        fromPath: this.resolve(),
+        targetPath,
+        text: targetPath.toString(),
+        type: opts?.type
+      };
+    }
+  }
+  /**
+   * Creates a hardlink to the provided target path.
+   */
+  async linkTo(targetPath) {
+    const targetPathRef = ensurePath(targetPath).resolve();
+    await linkFn(targetPathRef.toString(), this.resolve().toString());
+  }
+  /**
+   * Synchronously creates a hardlink to the provided target path.
+   */
+  linkToSync(targetPath) {
+    const targetPathRef = ensurePath(targetPath).resolve();
+    linkSyncFn(targetPathRef.toString(), this.resolve().toString());
+  }
+  /** Reads the entries in the directory. */
+  async *readDir() {
+    const dir = this.resolve();
+    for await (const entry of readDir(dir.#path)) {
+      const out = entry;
+      out.path = dir.join(entry.name);
+      yield out;
+    }
+  }
+  /** Synchronously reads the entries in the directory. */
+  *readDirSync() {
+    const dir = this.resolve();
+    for (const entry of readDirSync(dir.#path)) {
+      const out = entry;
+      out.path = dir.join(entry.name);
+      yield out;
+    }
+  }
+  /** Reads only the directory file paths, not including symlinks. */
+  async *readDirFilePaths() {
+    const dir = this.resolve();
+    for await (const entry of readDir(dir.#path)) {
+      if (entry.isFile()) {
+        yield dir.join(entry.name);
+      }
+    }
+  }
+  /** Synchronously reads only the directory file paths, not including symlinks. */
+  *readDirFilePathsSync() {
+    const dir = this.resolve();
+    for (const entry of readDirSync(dir.#path)) {
+      if (entry.isFile()) {
+        yield dir.join(entry.name);
+      }
+    }
+  }
+  /** Reads the bytes from the file. */
+  readBytes(options) {
+    return readFile(this.#path, options);
+  }
+  /** Synchronously reads the bytes from the file. */
+  readBytesSync() {
+    return readFileSync(this.#path);
+  }
+  /** Calls `.readBytes()`, but returns undefined if the path doesn't exist. */
+  readMaybeBytes(options) {
+    return notFoundToUndefined(() => this.readBytes(options));
+  }
+  /** Calls `.readBytesSync()`, but returns undefined if the path doesn't exist. */
+  readMaybeBytesSync() {
+    return notFoundToUndefinedSync(() => this.readBytesSync());
+  }
+  /** Reads the text from the file. */
+  readText(options) {
+    return readTextFile(this.#path, options);
+  }
+  /** Synchronously reads the text from the file. */
+  readTextSync() {
+    return readTextFileSync(this.#path);
+  }
+  /** Calls `.readText()`, but returns undefined when the path doesn't exist.
+   * @remarks This still errors for other kinds of errors reading a file.
+   */
+  readMaybeText(options) {
+    return notFoundToUndefined(() => this.readText(options));
+  }
+  /** Calls `.readTextSync()`, but returns undefined when the path doesn't exist.
+   * @remarks This still errors for other kinds of errors reading a file.
+   */
+  readMaybeTextSync() {
+    return notFoundToUndefinedSync(() => this.readTextSync());
+  }
+  /** Reads the file's text and returns an array of its lines.
+   *
+   * Lines are split at `\n` or `\r\n`. Line terminators are not included.
+   * A trailing blank line caused by a final line ending is excluded (matches
+   * [Rust's `str::lines`](https://doc.rust-lang.org/std/primitive.str.html#method.lines)).
+   */
+  async lines(options) {
+    return [...splitLines(await this.readText(options))];
+  }
+  /** Synchronously reads the file's text and returns an array of its lines.
+   *
+   * See `.lines()` for the splitting semantics.
+   */
+  linesSync() {
+    return [...splitLines(this.readTextSync())];
+  }
+  /** Streams the file and iterates over its lines without loading it all into memory.
+   *
+   * See `.lines()` for the splitting semantics.
+   */
+  async *linesIter(options) {
+    const file = await openFile(this.#path, { read: true });
+    try {
+      const decoder = new TextDecoder();
+      const chunk = new Uint8Array(16384);
+      let buffer = "";
+      while (true) {
+        options?.signal?.throwIfAborted();
+        const n = await file.read(chunk);
+        if (n === 0)
+          break;
+        buffer += decoder.decode(chunk.subarray(0, n), { stream: true });
+        let start = 0;
+        while (true) {
+          const nl = buffer.indexOf("\n", start);
+          if (nl === -1)
+            break;
+          const end = nl > start && buffer.charCodeAt(nl - 1) === 13 ? nl - 1 : nl;
+          yield buffer.substring(start, end);
+          start = nl + 1;
+        }
+        if (start > 0)
+          buffer = buffer.substring(start);
+      }
+      buffer += decoder.decode();
+      if (buffer !== "")
+        yield buffer;
+    } finally {
+      try {
+        file.close();
+      } catch {
+      }
+    }
+  }
+  /** Synchronously streams the file and iterates over its lines without
+   * loading it all into memory.
+   *
+   * See `.lines()` for the splitting semantics.
+   */
+  *linesIterSync() {
+    const file = openFileSync(this.#path, { read: true });
+    try {
+      const decoder = new TextDecoder();
+      const chunk = new Uint8Array(16384);
+      let buffer = "";
+      while (true) {
+        const n = file.readSync(chunk);
+        if (n === 0)
+          break;
+        buffer += decoder.decode(chunk.subarray(0, n), { stream: true });
+        let start = 0;
+        while (true) {
+          const nl = buffer.indexOf("\n", start);
+          if (nl === -1)
+            break;
+          const end = nl > start && buffer.charCodeAt(nl - 1) === 13 ? nl - 1 : nl;
+          yield buffer.substring(start, end);
+          start = nl + 1;
+        }
+        if (start > 0)
+          buffer = buffer.substring(start);
+      }
+      buffer += decoder.decode();
+      if (buffer !== "")
+        yield buffer;
+    } finally {
+      try {
+        file.close();
+      } catch {
+      }
+    }
+  }
+  /** Reads and parses the file as JSON, throwing if it doesn't exist or is not valid JSON. */
+  async readJson(options) {
+    return this.#parseJson(await this.readText(options));
+  }
+  /** Synchronously reads and parses the file as JSON, throwing if it doesn't
+   * exist or is not valid JSON. */
+  readJsonSync() {
+    return this.#parseJson(this.readTextSync());
+  }
+  #parseJson(text) {
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new Error(`Failed parsing JSON in '${this.toString()}'.`, {
+        cause: err
+      });
+    }
+  }
+  /**
+   * Calls `.readJson()`, but returns undefined if the file doesn't exist.
+   * @remarks This method will still throw if the file cannot be parsed as JSON.
+   */
+  readMaybeJson(options) {
+    return notFoundToUndefined(() => this.readJson(options));
+  }
+  /**
+   * Calls `.readJsonSync()`, but returns undefined if the file doesn't exist.
+   * @remarks This method will still throw if the file cannot be parsed as JSON.
+   */
+  readMaybeJsonSync() {
+    return notFoundToUndefinedSync(() => this.readJsonSync());
+  }
+  /** Writes out the provided bytes or text to the file.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  async write(data, options) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    await this.#withFileForWriting(options, (file) => {
+      return writeAll(file, bytes, options?.signal);
+    });
+    return this;
+  }
+  /** Synchronously writes out the provided bytes or text to the file.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  writeSync(data, options) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    this.#withFileForWritingSync(options, (file) => {
+      writeAllSync(file, bytes, options?.signal);
+    });
+    return this;
+  }
+  /** Writes the provided text to the file.
+   * @deprecated Use `.write(text)` instead — `write` now accepts strings.
+   */
+  writeText(text, options) {
+    return this.write(text, options);
+  }
+  /** Synchronously writes the provided text to the file.
+   * @deprecated Use `.writeSync(text)` instead — `writeSync` now accepts strings.
+   */
+  writeTextSync(text, options) {
+    return this.writeSync(text, options);
+  }
+  /** Writes out the provided object as compact JSON. */
+  async writeJson(obj, options) {
+    await this.write(JSON.stringify(obj) + "\n", options);
+    return this;
+  }
+  /** Synchronously writes out the provided object as compact JSON. */
+  writeJsonSync(obj, options) {
+    this.writeSync(JSON.stringify(obj) + "\n", options);
+    return this;
+  }
+  /** Writes out the provided object as formatted JSON. */
+  async writeJsonPretty(obj, options) {
+    await this.write(JSON.stringify(obj, void 0, 2) + "\n", options);
+    return this;
+  }
+  /** Synchronously writes out the provided object as formatted JSON. */
+  writeJsonPrettySync(obj, options) {
+    this.writeSync(JSON.stringify(obj, void 0, 2) + "\n", options);
+    return this;
+  }
+  /** Appends the provided bytes or text to the file.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  async append(data, options) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    await this.#withFileForAppending(options, (file) => writeAll(file, bytes, options?.signal));
+    return this;
+  }
+  /** Synchronously appends the provided bytes or text to the file.
+   *
+   * Strings are encoded as UTF-8.
+   */
+  appendSync(data, options) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    this.#withFileForAppendingSync(options, (file) => {
+      writeAllSync(file, bytes, options?.signal);
+    });
+    return this;
+  }
+  #withFileForAppending(options, action) {
+    return this.#withFileForWriting({
+      append: true,
+      ...options
+    }, action);
+  }
+  async #withFileForWriting(options, action) {
+    const file = await this.#openFileMaybeCreatingDirectory({
+      write: true,
+      create: true,
+      truncate: options?.append !== true,
+      ...options
+    });
+    try {
+      return await action(file);
+    } finally {
+      try {
+        file.close();
+      } catch {
+      }
+    }
+  }
+  /** Opens a file, but handles if the directory does not exist. */
+  async #openFileMaybeCreatingDirectory(options) {
+    const resolvedPath = this.resolve();
+    try {
+      return await resolvedPath.open(options);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        const parent = resolvedPath.parent();
+        if (parent != null) {
+          try {
+            await parent.mkdir();
+          } catch {
+            throw err;
+          }
+        }
+        return await resolvedPath.open(options);
+      } else {
+        throw err;
+      }
+    }
+  }
+  #withFileForAppendingSync(options, action) {
+    return this.#withFileForWritingSync({
+      append: true,
+      ...options
+    }, action);
+  }
+  #withFileForWritingSync(options, action) {
+    const file = this.#openFileForWritingSync(options);
+    try {
+      return action(file);
+    } finally {
+      try {
+        file.close();
+      } catch {
+      }
+    }
+  }
+  /** Opens a file for writing, but handles if the directory does not exist. */
+  #openFileForWritingSync(options) {
+    return this.#openFileMaybeCreatingDirectorySync({
+      write: true,
+      create: true,
+      truncate: options?.append !== true,
+      ...options
+    });
+  }
+  /** Opens a file for writing, but handles if the directory does not exist. */
+  #openFileMaybeCreatingDirectorySync(options) {
+    try {
+      return this.openSync(options);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        const parent = this.resolve().parent();
+        if (parent != null) {
+          try {
+            parent.mkdirSync();
+          } catch {
+            throw err;
+          }
+        }
+        return this.openSync(options);
+      } else {
+        throw err;
+      }
+    }
+  }
+  /** Changes the permissions of the file or directory. */
+  async chmod(mode) {
+    await chmod(this.#path, mode);
+    return this;
+  }
+  /** Synchronously changes the permissions of the file or directory. */
+  chmodSync(mode) {
+    chmodSync(this.#path, mode);
+    return this;
+  }
+  /** Changes the ownership permissions of the file. */
+  async chown(uid, gid) {
+    await chown(this.#path, uid, gid);
+    return this;
+  }
+  /** Synchronously changes the ownership permissions of the file. */
+  chownSync(uid, gid) {
+    chownSync(this.#path, uid, gid);
+    return this;
+  }
+  /** Creates a new file or opens the existing one. */
+  create() {
+    return createFile(this.#path).then((file) => createFsFileWrapper(file));
+  }
+  /** Synchronously creates a new file or opens the existing one. */
+  createSync() {
+    return createFsFileWrapper(createFileSync(this.#path));
+  }
+  /** Creates a file throwing if a file previously existed. */
+  createNew() {
+    return this.open({
+      createNew: true,
+      read: true,
+      write: true
+    });
+  }
+  /** Synchronously creates a file throwing if a file previously existed. */
+  createNewSync() {
+    return this.openSync({
+      createNew: true,
+      read: true,
+      write: true
+    });
+  }
+  /** Opens a file. */
+  open(options) {
+    return openFile(this.#path, options).then((file) => createFsFileWrapper(file));
+  }
+  /** Opens a file synchronously. */
+  openSync(options) {
+    return createFsFileWrapper(openFileSync(this.#path, options));
+  }
+  /** Removes the file or directory from the file system. */
+  async remove(options) {
+    await remove(this.#path, options);
+    return this;
+  }
+  /** Removes the file or directory from the file system synchronously. */
+  removeSync(options) {
+    removeSync(this.#path, options);
+    return this;
+  }
+  /** Removes the file or directory from the file system, but doesn't throw
+   * when the file doesn't exist.
+   */
+  async ensureRemove(options) {
+    try {
+      return await this.remove(options);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return this;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /** Removes the file or directory from the file system, but doesn't throw
+   * when the file doesn't exist.
+   */
+  ensureRemoveSync(options) {
+    try {
+      return this.removeSync(options);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return this;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Ensures that a directory is empty.
+   * Deletes directory contents if the directory is not empty.
+   * If the directory does not exist, it is created.
+   * The directory itself is not deleted.
+   */
+  async emptyDir() {
+    await emptyDir(this.toString());
+    return this;
+  }
+  /** Synchronous version of `emptyDir()` */
+  emptyDirSync() {
+    emptyDirSync(this.toString());
+    return this;
+  }
+  /** Ensures that the directory exists.
+   * If the directory structure does not exist, it is created. Like mkdir -p.
+   */
+  async ensureDir() {
+    await ensureDir(this.toString());
+    return this;
+  }
+  /** Synchronously ensures that the directory exists.
+   * If the directory structure does not exist, it is created. Like mkdir -p.
+   */
+  ensureDirSync() {
+    ensureDirSync(this.toString());
+    return this;
+  }
+  /**
+   * Ensures that the file exists.
+   * If the file that is requested to be created is in directories that do
+   * not exist these directories are created. If the file already exists,
+   * it is NOTMODIFIED.
+   */
+  async ensureFile() {
+    await ensureFile(this.toString());
+    return this;
+  }
+  /**
+   * Synchronously ensures that the file exists.
+   * If the file that is requested to be created is in directories that do
+   * not exist these directories are created. If the file already exists,
+   * it is NOTMODIFIED.
+   */
+  ensureFileSync() {
+    ensureFileSync(this.toString());
+    return this;
+  }
+  /** Copies a file or directory to the provided destination.
+   * @returns The destination path.
+   */
+  async copy(destinationPath, options) {
+    const pathRef = ensurePath(destinationPath);
+    await copy(this.#path, pathRef.toString(), options);
+    return pathRef;
+  }
+  /** Copies a file or directory to the provided destination synchronously.
+   * @returns The destination path.
+   */
+  copySync(destinationPath, options) {
+    const pathRef = ensurePath(destinationPath);
+    copySync(this.#path, pathRef.toString(), options);
+    return pathRef;
+  }
+  /**
+   * Copies the file or directory to the specified directory.
+   * @returns The destination path.
+   */
+  copyToDir(destinationDirPath, options) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.copy(destinationPath, options);
+  }
+  /**
+   * Copies the file or directory to the specified directory synchronously.
+   * @returns The destination path.
+   */
+  copyToDirSync(destinationDirPath, options) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.copySync(destinationPath, options);
+  }
+  /**
+   * Copies the file to the specified destination path.
+   * @returns The destination path.
+   */
+  copyFile(destinationPath) {
+    const pathRef = ensurePath(destinationPath);
+    return copyFileFn(this.#path, pathRef.toString()).then(() => pathRef);
+  }
+  /**
+   * Copies the file to the destination path synchronously.
+   * @returns The destination path.
+   */
+  copyFileSync(destinationPath) {
+    const pathRef = ensurePath(destinationPath);
+    copyFileSyncFn(this.#path, pathRef.toString());
+    return pathRef;
+  }
+  /**
+   * Copies the file to the specified directory.
+   * @returns The destination path.
+   */
+  copyFileToDir(destinationDirPath) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.copyFile(destinationPath);
+  }
+  /**
+   * Copies the file to the specified directory synchronously.
+   * @returns The destination path.
+   */
+  copyFileToDirSync(destinationDirPath) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.copyFileSync(destinationPath);
+  }
+  /**
+   * Moves the file or directory returning a promise that resolves to
+   * the renamed path.
+   * @returns The destination path.
+   */
+  rename(newPath) {
+    const pathRef = ensurePath(newPath);
+    return renameFn(this.#path, pathRef.toString()).then(() => pathRef);
+  }
+  /**
+   * Moves the file or directory returning the renamed path synchronously.
+   * @returns The destination path.
+   */
+  renameSync(newPath) {
+    const pathRef = ensurePath(newPath);
+    renameSyncFn(this.#path, pathRef.toString());
+    return pathRef;
+  }
+  /**
+   * Moves the file or directory to the specified directory.
+   * @returns The destination path.
+   */
+  renameToDir(destinationDirPath) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.rename(destinationPath);
+  }
+  /**
+   * Moves the file or directory to the specified directory synchronously.
+   * @returns The destination path.
+   */
+  renameToDirSync(destinationDirPath) {
+    const destinationPath = ensurePath(destinationDirPath).join(this.basename());
+    return this.renameSync(destinationPath);
+  }
+  /** Opens the file and pipes it to the writable stream. */
+  async pipeTo(dest, options) {
+    const file = await openFile(this.#path, { read: true });
+    try {
+      await file.readable.pipeTo(dest, options);
+    } finally {
+      try {
+        file.close();
+      } catch {
+      }
+    }
+    return this;
+  }
+};
+function ensurePath(path2) {
+  return path2 instanceof Path ? path2 : new Path(path2);
+}
+function createFsFileWrapper(file) {
+  Object.setPrototypeOf(file, FsFileWrapper.prototype);
+  return file;
+}
+var FsFileWrapper = class extends FsFile {
+  /** Writes the provided text to this file, looping to handle partial writes. */
+  writeText(text) {
+    return this.writeBytes(new TextEncoder().encode(text));
+  }
+  /** Synchronously writes the provided text to this file, looping to handle partial writes. */
+  writeTextSync(text) {
+    return this.writeBytesSync(new TextEncoder().encode(text));
+  }
+  /** Writes all the provided bytes to this file, looping to handle partial writes. */
+  async writeBytes(bytes) {
+    let nwritten = 0;
+    while (nwritten < bytes.length) {
+      nwritten += await this.write(bytes.subarray(nwritten));
+    }
+    return this;
+  }
+  /** Synchronously writes all the provided bytes to this file, looping to handle partial writes. */
+  writeBytesSync(bytes) {
+    let nwritten = 0;
+    while (nwritten < bytes.length) {
+      nwritten += this.writeSync(bytes.subarray(nwritten));
+    }
+    return this;
+  }
+  /** Writes all the provided data to this file, dispatching to `.writeText` or `.writeBytes` based on input type. */
+  writeAll(data) {
+    return typeof data === "string" ? this.writeText(data) : this.writeBytes(data);
+  }
+  /** Synchronously writes all the provided data to this file, dispatching to `.writeTextSync` or `.writeBytesSync` based on input type. */
+  writeAllSync(data) {
+    return typeof data === "string" ? this.writeTextSync(data) : this.writeBytesSync(data);
+  }
+};
+async function createSymlink(opts) {
+  let kind = opts.type;
+  if (kind == null && isWindows2()) {
+    const info = await opts.targetPath.lstat();
+    if (info?.isDirectory()) {
+      kind = "dir";
+    } else if (info?.isFile()) {
+      kind = "file";
+    } else {
+      throw createNotFoundError(`The target path '${opts.targetPath}' did not exist or path kind could not be determined. When the path doesn't exist, you need to specify a symlink type on Windows.`);
+    }
+  }
+  await symlinkFn(opts.text, opts.fromPath.toString(), kind == null ? void 0 : {
+    type: kind
+  });
+}
+function createSymlinkSync(opts) {
+  let kind = opts.type;
+  if (kind == null && isWindows2()) {
+    const info = opts.targetPath.lstatSync();
+    if (info?.isDirectory()) {
+      kind = "dir";
+    } else if (info?.isFile()) {
+      kind = "file";
+    } else {
+      throw createNotFoundError(`The target path '${opts.targetPath}' did not exist or path kind could not be determined. When the path doesn't exist, you need to specify a symlink type on Windows.`);
+    }
+  }
+  symlinkSyncFn(opts.text, opts.fromPath.toString(), kind == null ? void 0 : {
+    type: kind
+  });
+}
+async function notFoundToUndefined(action) {
+  try {
+    return await action();
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      return void 0;
+    } else {
+      throw err;
+    }
+  }
+}
+function notFoundToUndefinedSync(action) {
+  try {
+    return action();
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      return void 0;
+    } else {
+      throw err;
+    }
+  }
+}
+async function writeAll(writer, data, signal) {
+  let nwritten = 0;
+  while (nwritten < data.length) {
+    signal?.throwIfAborted();
+    nwritten += await writer.write(data.subarray(nwritten));
+  }
+}
+function writeAllSync(writer, data, signal) {
+  let nwritten = 0;
+  while (nwritten < data.length) {
+    signal?.throwIfAborted();
+    nwritten += writer.writeSync(data.subarray(nwritten));
+  }
+}
+function* splitLines(text) {
+  if (text === "")
+    return;
+  let start = 0;
+  while (true) {
+    const nl = text.indexOf("\n", start);
+    if (nl === -1) {
+      if (start < text.length)
+        yield text.substring(start);
+      return;
+    }
+    const end = nl > start && text.charCodeAt(nl - 1) === 13 ? nl - 1 : nl;
+    yield text.substring(start, end);
+    start = nl + 1;
+    if (start === text.length)
+      return;
+  }
+}
+export {
+  FsFile,
+  FsFileWrapper,
+  Path,
+  mod_default as default,
+  path
+};