@cspell/url 9.0.1 → 9.1.0

package/dist/index.d.ts

@@ -1,234 +1,262 @@
+//#region src/dataUrl.d.mts
 /**
- * Try to determine the base name of a URL.
- * @param url
- * @returns the base name of a URL, including the trailing `/` if present.
- */
+* Try to determine the base name of a URL.
+* @param url
+* @returns the base name of a URL, including the trailing `/` if present.
+*/
 declare function urlBasename(url: string | URL): string;
 declare function isDataURL(url: string | URL): boolean;
-
+//#endregion
+//#region src/defaultFileUrlBuilder.d.mts
 declare function encodePathChars(filepath: string): string;
 /**
- * Normalize a file path for use in a URL.
- * ```js
- * const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
- * // Result: file:///Users/user/path/to/file.txt
- * ```
- * @param filePath
- * @returns a normalized file path for use as a relative path in a URL.
- */
+* Normalize a file path for use in a URL.
+* ```js
+* const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
+* // Result: file:///Users/user/path/to/file.txt
+* ```
+* @param filePath
+* @returns a normalized file path for use as a relative path in a URL.
+*/
 declare function normalizeFilePathForUrl(filePath: string): string;
 /**
- * Try to make a file URL.
- * - if filenameOrUrl is already a URL, it is returned as is.
- * -
- * @param filenameOrUrl
- * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
- * @returns a URL
- */
+* Try to make a file URL.
+* - if filenameOrUrl is already a URL, it is returned as is.
+* -
+* @param filenameOrUrl
+* @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+* @returns a URL
+*/
 declare function toFileURL(filenameOrUrl: string | URL, relativeTo?: string | URL): URL;
 /**
- * Converts a file path to a URL and adds a trailing slash.
- * @param dir - url to a directory
- * @returns a URL
- */
+* Converts a file path to a URL and adds a trailing slash.
+* @param dir - url to a directory
+* @returns a URL
+*/
 declare function toFileDirURL(dir: string | URL): URL;
-
+//#endregion
+//#region src/fileUrl.d.mts
 /**
- * @param url - URL or string to check if it is a file URL.
- * @returns true if the URL is a file URL.
- */
+* @param url - URL or string to check if it is a file URL.
+* @returns true if the URL is a file URL.
+*/
 declare function isFileURL(url: URL | string): boolean;
 /**
- * Convert a URL into a string. If it is a file URL, convert it to a path.
- * @param url - URL
- * @returns path or href
- */
+* Convert a URL into a string. If it is a file URL, convert it to a path.
+* @param url - URL
+* @returns path or href
+*/
 declare function toFilePathOrHref(url: URL | string): string;
-
+//#endregion
+//#region src/FileUrlBuilder.d.mts
 interface ParsedPath {
-    /**
-     * The root of the path such as '/' or 'c:\'
-     */
-    root: string;
-    /**
-     * The full directory path such as '/home/user/dir' or 'c:\path\dir'
-     */
-    dir: string;
-    /**
-     * The file name including extension (if any) such as 'index.html'
-     */
-    base: string;
-    /**
-     * The file extension (if any) such as '.html'
-     */
-    ext: string;
-    /**
-     * The file name without extension (if any) such as 'index'
-     */
-    name: string;
+  /**
+  * The root of the path such as '/' or 'c:\'
+  */
+  root: string;
+  /**
+  * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+  */
+  dir: string;
+  /**
+  * The file name including extension (if any) such as 'index.html'
+  */
+  base: string;
+  /**
+  * The file extension (if any) such as '.html'
+  */
+  ext: string;
+  /**
+  * The file name without extension (if any) such as 'index'
+  */
+  name: string;
 }
 interface PathInterface {
-    sep: string;
-    resolve(...paths: string[]): string;
-    parse(path: string): ParsedPath;
-    normalize(path: string): string;
-    relative(from: string, to: string): string;
-    isAbsolute(path: string): boolean;
+  sep: string;
+  resolve(...paths: string[]): string;
+  parse(path: string): ParsedPath;
+  normalize(path: string): string;
+  relative(from: string, to: string): string;
+  isAbsolute(path: string): boolean;
 }
 interface BuilderOptions {
-    windows?: boolean | undefined;
-    path?: PathInterface | undefined;
-    cwd?: URL | undefined;
+  windows?: boolean | undefined;
+  path?: PathInterface | undefined;
+  cwd?: URL | undefined;
 }
 declare class FileUrlBuilder {
-    #private;
-    private windows;
-    readonly path: PathInterface;
-    readonly cwd: URL;
-    constructor(options?: BuilderOptions);
-    /**
-     * Encode special characters in a file path to use in a URL.
-     * @param filepath
-     * @returns
-     */
-    encodePathChars(filepath: string): string;
-    /**
-     * Normalize a file path for use in a URL.
-     * ```js
-     * const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
-     * // Result: file:///Users/user/path/to/file.txt
-     * ```
-     * @param filePath
-     * @returns a normalized file path for use as a relative path in a URL.
-     */
-    normalizeFilePathForUrl(filePath: string): string;
-    /**
-     * Try to make a file URL.
-     * - if filenameOrUrl is already a URL, it is returned as is.
-     * @param filenameOrUrl
-     * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
-     * @returns a URL
-     */
-    toFileURL(filenameOrUrl: string | URL, relativeTo?: string | URL): URL;
-    /**
-     * Try to make a URL for a directory.
-     * - if dirOrUrl is already a URL, a slash is appended to the pathname.
-     * @param dirOrUrl - directory path to convert to a file URL.
-     * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
-     * @returns a URL
-     */
-    toFileDirURL(dirOrUrl: string | URL, relativeTo?: string | URL): URL;
-    urlToFilePathOrHref(url: URL | string): string;
-    /**
-     * Calculate the relative path to go from `urlFrom` to `urlTo`.
-     * The protocol is not evaluated. Only the `url.pathname` is used.
-     * The result: `new URL(relative(urlFrom, urlTo), urlFrom).pathname === urlTo.pathname`
-     * @param urlFrom
-     * @param urlTo
-     * @returns the relative path
-     */
-    relative(urlFrom: URL, urlTo: URL): string;
-    /**
-     * Get the parent directory of a URL.
-     * @param url
-     */
-    urlDirname(url: URL | string): URL;
-    pathToFileURL(pathname: string, relativeToURL?: URL | string): URL;
-    rootFileURL(filePath?: string): URL;
-    /**
-     * Determine if a filePath is absolute.
-     *
-     * @param filePath
-     * @returns true if `URL` or `path.isAbsolute(filePath)`
-     */
-    isAbsolute(filePath: string): boolean;
-    isUrlLike(url: string | URL): boolean;
+  #private;
+  private windows;
+  readonly path: PathInterface;
+  readonly cwd: URL;
+  constructor(options?: BuilderOptions);
+  /**
+  * Encode special characters in a file path to use in a URL.
+  * @param filepath
+  * @returns
+  */
+  encodePathChars(filepath: string): string;
+  /**
+  * Normalize a file path for use in a URL.
+  * ```js
+  * const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
+  * // Result: file:///Users/user/path/to/file.txt
+  * ```
+  * @param filePath
+  * @returns a normalized file path for use as a relative path in a URL.
+  */
+  normalizeFilePathForUrl(filePath: string): string;
+  /**
+  * Try to make a file URL.
+  * - if filenameOrUrl is already a URL, it is returned as is.
+  * @param filenameOrUrl
+  * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+  * @returns a URL
+  */
+  toFileURL(filenameOrUrl: string | URL, relativeTo?: string | URL): URL;
+  /**
+  * Try to make a URL for a directory.
+  * - if dirOrUrl is already a URL, a slash is appended to the pathname.
+  * @param dirOrUrl - directory path to convert to a file URL.
+  * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+  * @returns a URL
+  */
+  toFileDirURL(dirOrUrl: string | URL, relativeTo?: string | URL): URL;
+  urlToFilePathOrHref(url: URL | string): string;
+  /**
+  * Calculate the relative path to go from `urlFrom` to `urlTo`.
+  * The protocol is not evaluated. Only the `url.pathname` is used.
+  * The result: `new URL(relative(urlFrom, urlTo), urlFrom).pathname === urlTo.pathname`
+  * @param urlFrom
+  * @param urlTo
+  * @returns the relative path
+  */
+  relative(urlFrom: URL, urlTo: URL): string;
+  /**
+  * Get the parent directory of a URL.
+  * @param url
+  */
+  urlDirname(url: URL | string): URL;
+  pathToFileURL(pathname: string, relativeToURL?: URL | string): URL;
+  rootFileURL(filePath?: string): URL;
+  /**
+  * Determine if a filePath is absolute.
+  *
+  * @param filePath
+  * @returns true if `URL` or `path.isAbsolute(filePath)`
+  */
+  isAbsolute(filePath: string): boolean;
+  isUrlLike(url: string | URL): boolean;
 }
-
+//#endregion
+//#region src/url.d.mts
 /**
- * Try to make a URL.
- * @param url
- * @param relativeTo - optional URL, if given, url will be parsed as relative.
- * @returns a URL
- */
+* Try to make a URL.
+* @param url
+* @param relativeTo - optional URL, if given, url will be parsed as relative.
+* @returns a URL
+*/
 declare function toURL(url: string | URL, relativeTo?: string | URL): URL;
 /**
- * Try to determine the parent directory URL of the uri.
- * If it is not a hierarchical URL, then it will return the URL.
- * @param url - url to extract the dirname from.
- * @returns a URL
- */
+* Try to determine the parent directory URL of the uri.
+* If it is not a hierarchical URL, then it will return the URL.
+* @param url - url to extract the dirname from.
+* @returns a URL
+*/
 declare function urlParent(url: string | URL): URL;
 /**
- * Alias of {@link urlParent}
- * Try to determine the parent directory URL of the uri.
- * If it is not a hierarchical URL, then it will return the URL.
- * @param url - url to extract the dirname from.
- * @returns a URL
- */
+* Alias of {@link urlParent}
+* Try to determine the parent directory URL of the uri.
+* If it is not a hierarchical URL, then it will return the URL.
+* @param url - url to extract the dirname from.
+* @returns a URL
+*/
 declare const urlDirname: typeof urlParent;
 /**
- * return the basename (last portion of the URL pathname) of a path. It does NOT remove the trailing slash.
- * @param path - URL pathname to extract the basename from.
- */
+* Remove the file portion of the URL and return the directory portion.
+* If the URL pathname ends with a `/`, it is considered a directory and the URL is returned as is.
+* @param url - url to extract the dirname from.
+*/
+
+/**
+* return the basename (last portion of the URL pathname) of a path. It does NOT remove the trailing slash.
+* @param path - URL pathname to extract the basename from.
+*/
 declare function basenameOfUrlPathname(path: string): string;
 /**
- * @param filename - filename to check if it is a string containing a URL.
- */
+* @param filename - filename to check if it is a string containing a URL.
+*/
 declare function isUrlLike(filename: string): boolean;
 declare function isUrlLike(filename: URL): true;
 /**
- * @param filename - filename to check if it is a string containing a URL or a URL object.
- */
+* @param filename - filename to check if it is a string containing a URL or a URL object.
+*/
 declare function isUrlLike(filename: string | URL): boolean;
 /**
- * @param filename - filename to check if it is a string containing a URL.
- */
+* @param filename - filename to check if it is a string containing a URL.
+*/
 declare function isNotUrlLike(filename: string): boolean;
 declare function isNotUrlLike(filename: URL): false;
 /**
- * @param filename - filename to check if it is a string containing a URL or a URL object.
- */
+* @param filename - filename to check if it is a string containing a URL or a URL object.
+*/
 declare function isNotUrlLike(filename: string | URL): filename is string;
 /**
- * Check if `url` is a URL instance.
- * @returns
- */
+* Check if `url` is a URL instance.
+* @returns
+*/
 declare function isURL(url: unknown): url is URL;
 /**
- *
- * @param url - url to check
- * @param protocol - protocol to check against - e.g. 'file:', 'http:', 'https:'
- * @returns
- */
+*
+* @param url - url to check
+* @param protocol - protocol to check against - e.g. 'file:', 'http:', 'https:'
+* @returns
+*/
 declare function hasProtocol(url: string | URL, protocol: string): boolean;
 /**
- * Attempts to add a trailing slash to the URL pathname if it does not already have one.
- * Some If the pathname doesn't start with a `/`, a trailing slash is not added.
- * @param url - a URL
- * @returns
- */
+* Attempts to add a trailing slash to the URL pathname if it does not already have one.
+* Some If the pathname doesn't start with a `/`, a trailing slash is not added.
+* @param url - a URL
+* @returns
+*/
 declare function addTrailingSlash(url: URL): URL;
 /**
- * Calculate the relative path to go from `urlFrom` to `urlTo`.
- * The protocol is not evaluated. Only the `url.pathname` is used.
- * @param urlFrom
- * @param urlTo
- * @returns the relative path
- */
+* Remove the filename at the end of the URL pathname.
+* If the URL pathname ends with a `/`, it is considered a directory and the URL is returned as is.
+* If the URL pathname does not start with a `/`, it is considered an non-regular URL and the URL is returned as is.
+* @param url
+* @returns
+*/
+
+/**
+* Calculate the relative path to go from `urlFrom` to `urlTo`.
+* The protocol is not evaluated. Only the `url.pathname` is used.
+* @param urlFrom
+* @param urlTo
+* @returns the relative path
+*/
 declare function urlRelative(urlFrom: string | URL, urlTo: string | URL): string;
 /**
- * Ensure that a windows file url is correctly formatted with a capitol letter for the drive.
- *
- * @param url - URL to check.
- * @returns a new URL if modified or converted from a string.
- */
+* Calculate the relative path to go from `urlFrom` to `urlTo`.
+* The protocol is not evaluated. Only the `url.pathname` is used.
+* @param urlFrom
+* @param urlTo
+* @returns the relative path
+*/
+
+/**
+* Ensure that a windows file url is correctly formatted with a capitol letter for the drive.
+*
+* @param url - URL to check.
+* @returns a new URL if modified or converted from a string.
+*/
 declare function normalizeWindowsUrl(url: URL | string): URL;
 /**
- * There is a bug is NodeJS that sometimes causes UNC paths converted to a URL to be prefixed with `file:////`.
- * @param url - URL to check.
- * @returns fixed URL if needed.
- */
+* There is a bug is NodeJS that sometimes causes UNC paths converted to a URL to be prefixed with `file:////`.
+* @param url - URL to check.
+* @returns fixed URL if needed.
+*/
 declare function fixUncUrl(url: URL): URL;
-
-export { type BuilderOptions, FileUrlBuilder, type PathInterface, addTrailingSlash, basenameOfUrlPathname, encodePathChars, fixUncUrl, hasProtocol, isDataURL, isFileURL, isNotUrlLike, isURL, isUrlLike, normalizeFilePathForUrl, normalizeWindowsUrl, toFileDirURL, toFilePathOrHref, toFileURL, toURL, urlBasename, urlDirname, urlParent, urlRelative };
+//#endregion
+export { BuilderOptions, FileUrlBuilder, PathInterface, addTrailingSlash, basenameOfUrlPathname, encodePathChars, fixUncUrl, hasProtocol, isDataURL, isFileURL, isNotUrlLike, isURL, isUrlLike, normalizeFilePathForUrl, normalizeWindowsUrl, toFileDirURL, toFilePathOrHref, toFileURL, toURL, urlBasename, urlDirname, urlParent, urlRelative };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,376 +1,445 @@
-// src/url.mts
-var isURLRegEx = /^(\w[\w-]{1,63}:\/|data:|stdin:)/i;
+import assert from "node:assert";
+import Path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+//#region src/url.mts
+const isURLRegEx = /^(\w[\w-]{1,63}:\/|data:|stdin:)/i;
+/**
+* Try to make a URL.
+* @param url
+* @param relativeTo - optional URL, if given, url will be parsed as relative.
+* @returns a URL
+*/
 function toURL(url, relativeTo) {
-  return normalizeWindowsUrl(url instanceof URL ? url : new URL(url, relativeTo));
+	return normalizeWindowsUrl(url instanceof URL ? url : new URL(url, relativeTo));
 }
+/**
+* Try to determine the parent directory URL of the uri.
+* If it is not a hierarchical URL, then it will return the URL.
+* @param url - url to extract the dirname from.
+* @returns a URL
+*/
 function urlParent(url) {
-  url = toURL(url);
-  if (url.protocol === "data:") {
-    return url;
-  }
-  const hasTrailingSlash = url.pathname.endsWith("/");
-  if (!url.pathname.startsWith("/")) {
-    if (!url.pathname) return url;
-    const parts = url.pathname.split("/").slice(0, hasTrailingSlash ? -2 : -1);
-    const pathname = parts.join("/") + "/";
-    return new URL(url.protocol + (url.host ? "//" + url.host : "") + pathname + url.search + url.hash);
-  }
-  return new URL(hasTrailingSlash ? ".." : ".", url);
+	url = toURL(url);
+	if (url.protocol === "data:") return url;
+	const hasTrailingSlash = url.pathname.endsWith("/");
+	if (!url.pathname.startsWith("/")) {
+		if (!url.pathname) return url;
+		const parts = url.pathname.split("/").slice(0, hasTrailingSlash ? -2 : -1);
+		const pathname = parts.join("/") + "/";
+		return new URL(url.protocol + (url.host ? "//" + url.host : "") + pathname + url.search + url.hash);
+	}
+	return new URL(hasTrailingSlash ? ".." : ".", url);
 }
-var urlDirname = urlParent;
+/**
+* Alias of {@link urlParent}
+* Try to determine the parent directory URL of the uri.
+* If it is not a hierarchical URL, then it will return the URL.
+* @param url - url to extract the dirname from.
+* @returns a URL
+*/
+const urlDirname = urlParent;
+/**
+* return the basename (last portion of the URL pathname) of a path. It does NOT remove the trailing slash.
+* @param path - URL pathname to extract the basename from.
+*/
 function basenameOfUrlPathname(path) {
-  const adj = path.endsWith("/") ? 2 : 0;
-  const idx = path.lastIndexOf("/", path.length - adj);
-  return idx >= 0 ? path.slice(idx + 1) : path;
+	const adj = path.endsWith("/") ? 2 : 0;
+	const idx = path.lastIndexOf("/", path.length - adj);
+	return idx >= 0 ? path.slice(idx + 1) : path;
 }
 function isUrlLike(filename) {
-  return filename instanceof URL || isURLRegEx.test(filename);
+	return filename instanceof URL || isURLRegEx.test(filename);
 }
 function isNotUrlLike(filename) {
-  return !isUrlLike(filename);
+	return !isUrlLike(filename);
 }
+/**
+* Check if `url` is a URL instance.
+* @returns
+*/
 function isURL(url) {
-  return url instanceof URL;
+	return url instanceof URL;
 }
+/**
+*
+* @param url - url to check
+* @param protocol - protocol to check against - e.g. 'file:', 'http:', 'https:'
+* @returns
+*/
 function hasProtocol(url, protocol) {
-  protocol = protocol.endsWith(":") ? protocol : protocol + ":";
-  return typeof url === "string" ? url.startsWith(protocol) : url.protocol === protocol;
+	protocol = protocol.endsWith(":") ? protocol : protocol + ":";
+	return typeof url === "string" ? url.startsWith(protocol) : url.protocol === protocol;
 }
+/**
+* Attempts to add a trailing slash to the URL pathname if it does not already have one.
+* Some If the pathname doesn't start with a `/`, a trailing slash is not added.
+* @param url - a URL
+* @returns
+*/
 function addTrailingSlash(url) {
-  if (url.pathname.endsWith("/")) return url;
-  const urlWithSlash = new URL(url.href);
-  urlWithSlash.pathname += "/";
-  return urlWithSlash;
+	if (url.pathname.endsWith("/")) return url;
+	const urlWithSlash = new URL(url.href);
+	urlWithSlash.pathname += "/";
+	return urlWithSlash;
 }
+/**
+* Calculate the relative path to go from `urlFrom` to `urlTo`.
+* The protocol is not evaluated. Only the `url.pathname` is used.
+* @param urlFrom
+* @param urlTo
+* @returns the relative path
+*/
 function urlRelative(urlFrom, urlTo) {
-  return urlToUrlRelative(toURL(urlFrom), toURL(urlTo));
+	return urlToUrlRelative(toURL(urlFrom), toURL(urlTo));
 }
+/**
+* Calculate the relative path to go from `urlFrom` to `urlTo`.
+* The protocol is not evaluated. Only the `url.pathname` is used.
+* @param urlFrom
+* @param urlTo
+* @returns the relative path
+*/
 function urlToUrlRelative(urlFrom, urlTo) {
-  let pFrom = urlFrom.pathname;
-  const pTo = urlTo.pathname;
-  if (pFrom === pTo) return "";
-  pFrom = pFrom.endsWith("/") ? pFrom : new URL("./", urlFrom).pathname;
-  if (pTo.startsWith(pFrom)) return decodeURIComponent(pTo.slice(pFrom.length));
-  const p0 = pFrom;
-  const p1 = pTo;
-  if (p1.startsWith(p0)) {
-    return decodeURIComponent(p0 === p1 ? "" : p1.slice(p0.lastIndexOf("/") + 1));
-  }
-  const p0Parts = p0.split("/").slice(0, -1);
-  const p1Parts = p1.split("/");
-  let i = 0;
-  for (i = 0; i < p0Parts.length && i < p1Parts.length - 1 && p0Parts[i] === p1Parts[i]; ++i) {
-  }
-  const rel = "../".repeat(p0Parts.length - i) + p1Parts.slice(i).join("/");
-  return decodeURIComponent(rel.length < p1.length ? rel : p1);
+	let pFrom = urlFrom.pathname;
+	const pTo = urlTo.pathname;
+	if (pFrom === pTo) return "";
+	pFrom = pFrom.endsWith("/") ? pFrom : new URL("./", urlFrom).pathname;
+	if (pTo.startsWith(pFrom)) return decodeURIComponent(pTo.slice(pFrom.length));
+	const p0 = pFrom;
+	const p1 = pTo;
+	if (p1.startsWith(p0)) return decodeURIComponent(p0 === p1 ? "" : p1.slice(p0.lastIndexOf("/") + 1));
+	const p0Parts = p0.split("/").slice(0, -1);
+	const p1Parts = p1.split("/");
+	let i = 0;
+	for (i = 0; i < p0Parts.length && i < p1Parts.length - 1 && p0Parts[i] === p1Parts[i]; ++i);
+	const rel = "../".repeat(p0Parts.length - i) + p1Parts.slice(i).join("/");
+	return decodeURIComponent(rel.length < p1.length ? rel : p1);
 }
-var regExpWindowsPath = /^[\\/]([a-zA-Z]:[\\/])/;
-var badUncLocalhostUrl = /^(\/+[a-zA-Z])\$/;
+const regExpWindowsPath = /^[\\/]([a-zA-Z]:[\\/])/;
+const badUncLocalhostUrl = /^(\/+[a-zA-Z])\$/;
+/**
+* Ensure that a windows file url is correctly formatted with a capitol letter for the drive.
+*
+* @param url - URL to check.
+* @returns a new URL if modified or converted from a string.
+*/
 function normalizeWindowsUrl(url) {
-  url = typeof url === "string" ? new URL(url) : url;
-  if (url.protocol === "file:") {
-    let pathname = url.pathname.replaceAll("%3A", ":").replaceAll("%3a", ":").replaceAll("%24", "$");
-    if (!url.host) {
-      pathname = pathname.replace(badUncLocalhostUrl, "$1:");
-    }
-    pathname = pathname.replace(regExpWindowsPath, (d) => d.toUpperCase());
-    if (pathname !== url.pathname) {
-      url = new URL(url);
-      url.pathname = pathname;
-      return fixUncUrl(url);
-    }
-  }
-  return fixUncUrl(url);
+	url = typeof url === "string" ? new URL(url) : url;
+	if (url.protocol === "file:") {
+		let pathname = url.pathname.replaceAll("%3A", ":").replaceAll("%3a", ":").replaceAll("%24", "$");
+		if (!url.host) pathname = pathname.replace(badUncLocalhostUrl, "$1:");
+		pathname = pathname.replace(regExpWindowsPath, (d) => d.toUpperCase());
+		if (pathname !== url.pathname) {
+			url = new URL(url);
+			url.pathname = pathname;
+			return fixUncUrl(url);
+		}
+	}
+	return fixUncUrl(url);
 }
+/**
+* There is a bug is NodeJS that sometimes causes UNC paths converted to a URL to be prefixed with `file:////`.
+* @param url - URL to check.
+* @returns fixed URL if needed.
+*/
 function fixUncUrl(url) {
-  if (url.href.startsWith("file:////")) {
-    return new URL(url.href.replace(/^file:\/{4}/, "file://"));
-  }
-  return url;
+	if (url.href.startsWith("file:////")) return new URL(url.href.replace(/^file:\/{4}/, "file://"));
+	return url;
 }
 
-// src/dataUrl.mts
-var regMatchFilename = /filename=([^;,]*)/;
+//#endregion
+//#region src/dataUrl.mts
+const regMatchFilename = /filename=([^;,]*)/;
+/**
+* Try to determine the base name of a URL.
+* @param url
+* @returns the base name of a URL, including the trailing `/` if present.
+*/
 function urlBasename(url) {
-  function guessDataUrlName(header) {
-    const filenameMatch = header.match(regMatchFilename);
-    if (filenameMatch) return filenameMatch[1];
-    const mime = header.split(";", 1)[0];
-    return mime.replaceAll(/\W/g, ".");
-  }
-  url = toURL(url);
-  if (url.protocol === "data:") {
-    return guessDataUrlName(url.pathname.split(",", 1)[0]);
-  }
-  return basenameOfUrlPathname(url.pathname);
+	function guessDataUrlName(header) {
+		const filenameMatch = header.match(regMatchFilename);
+		if (filenameMatch) return filenameMatch[1];
+		const mime = header.split(";", 1)[0];
+		return mime.replaceAll(/\W/g, ".");
+	}
+	url = toURL(url);
+	if (url.protocol === "data:") return guessDataUrlName(url.pathname.split(",", 1)[0]);
+	return basenameOfUrlPathname(url.pathname);
 }
 function isDataURL(url) {
-  return hasProtocol(url, "data:");
+	return hasProtocol(url, "data:");
 }
 
-// src/FileUrlBuilder.mts
-import assert from "node:assert";
-import Path from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-
-// src/fileUrl.mts
-import { fileURLToPath, pathToFileURL } from "node:url";
-var isWindows = process.platform === "win32";
-var windowsUrlPathRegExp = /^\/[a-zA-Z]:\//;
+//#endregion
+//#region src/fileUrl.mts
+const isWindows = process.platform === "win32";
+const windowsUrlPathRegExp = /^\/[a-zA-Z]:\//;
 function isWindowsPathnameWithDriveLatter(pathname) {
-  return windowsUrlPathRegExp.test(pathname);
+	return windowsUrlPathRegExp.test(pathname);
 }
+/**
+* @param url - URL or string to check if it is a file URL.
+* @returns true if the URL is a file URL.
+*/
 function isFileURL(url) {
-  return hasProtocol(url, "file:");
+	return hasProtocol(url, "file:");
 }
+/**
+* Convert a URL into a string. If it is a file URL, convert it to a path.
+* @param url - URL
+* @returns path or href
+*/
 function toFilePathOrHref(url) {
-  return isFileURL(url) && url.toString().startsWith("file:///") ? toFilePath(url) : url.toString();
+	return isFileURL(url) && url.toString().startsWith("file:///") ? toFilePath(url) : url.toString();
 }
 function toFilePath(url) {
-  try {
-    if (isWindows) {
-      const u = new URL(url);
-      if (!isWindowsPathnameWithDriveLatter(u.pathname)) {
-        const cwdUrl = pathToFileURL(process.cwd());
-        if (cwdUrl.hostname) {
-          return fileURLToPath(new URL(u.pathname, cwdUrl));
-        }
-        const drive = cwdUrl.pathname.split("/")[1];
-        u.pathname = `/${drive}${u.pathname}`;
-        return fileURLToPath(u);
-      }
-    }
-    return pathWindowsDriveLetterToUpper(fileURLToPath(url));
-  } catch {
-    return url.toString();
-  }
+	try {
+		if (isWindows) {
+			const u = new URL(url);
+			if (!isWindowsPathnameWithDriveLatter(u.pathname)) {
+				const cwdUrl = pathToFileURL(process.cwd());
+				if (cwdUrl.hostname) return fileURLToPath(new URL(u.pathname, cwdUrl));
+				const drive = cwdUrl.pathname.split("/")[1];
+				u.pathname = `/${drive}${u.pathname}`;
+				return fileURLToPath(u);
+			}
+		}
+		return pathWindowsDriveLetterToUpper(fileURLToPath(url));
+	} catch {
+		return url.toString();
+	}
 }
-var regExpWindowsPathDriveLetter = /^([a-zA-Z]):[\\/]/;
+const regExpWindowsPathDriveLetter = /^([a-zA-Z]):[\\/]/;
 function pathWindowsDriveLetterToUpper(absoluteFilePath) {
-  return absoluteFilePath.replace(regExpWindowsPathDriveLetter, (s) => s.toUpperCase());
+	return absoluteFilePath.replace(regExpWindowsPathDriveLetter, (s) => s.toUpperCase());
 }
-var regExpWindowsFileUrl = /^file:\/\/\/[a-zA-Z]:\//;
+const regExpWindowsFileUrl = /^file:\/\/\/[a-zA-Z]:\//;
+/**
+* Test if a url is a file url with a windows path. It does check for UNC paths.
+* @param url - the url
+* @returns true if the url is a file url with a windows path with a drive letter.
+*/
 function isWindowsFileUrl(url) {
-  return regExpWindowsFileUrl.test(url.toString());
+	return regExpWindowsFileUrl.test(url.toString());
 }
 
-// src/FileUrlBuilder.mts
-var isWindowsPathRegEx = regExpWindowsPathDriveLetter;
-var isWindowsPathname = regExpWindowsPath;
-var percentRegEx = /%/g;
-var backslashRegEx = /\\/g;
-var newlineRegEx = /\n/g;
-var carriageReturnRegEx = /\r/g;
-var tabRegEx = /\t/g;
-var questionRegex = /\?/g;
-var hashRegex = /#/g;
-var ProtocolFile = "file:";
+//#endregion
+//#region src/FileUrlBuilder.mts
+const isWindowsPathRegEx = regExpWindowsPathDriveLetter;
+const isWindowsPathname = regExpWindowsPath;
+const percentRegEx = /%/g;
+const backslashRegEx = /\\/g;
+const newlineRegEx = /\n/g;
+const carriageReturnRegEx = /\r/g;
+const tabRegEx = /\t/g;
+const questionRegex = /\?/g;
+const hashRegex = /#/g;
+const ProtocolFile = "file:";
 var FileUrlBuilder = class {
-  windows;
-  path;
-  cwd;
-  constructor(options = {}) {
-    const sep = options.path?.sep;
-    this.windows = options.windows ?? (sep ? sep === "\\" : void 0) ?? isWindows;
-    this.path = options.path ?? (this.windows ? Path.win32 : Path.posix);
-    this.cwd = options.cwd ?? this.pathToFileURL(this.path.resolve() + "/", this.rootFileURL());
-    assert(
-      this.path.sep === (this.windows ? "\\" : "/"),
-      `Path separator should match OS type Windows: ${this.windows === true ? "true" : (this.windows ?? "undefined") || "false"}, sep: ${this.path.sep}, options: ` + JSON.stringify({
-        isWindows,
-        sep: `${sep}`,
-        windows: options.windows,
-        pathSep: options.path?.sep,
-        n: options.path?.normalize("path/file.txt"),
-        cwd: options.cwd?.href,
-        win32: this.path === Path.win32,
-        posix: this.path === Path.posix,
-        "win32.normalize": this.path.normalize === Path.win32.normalize,
-        "posix.normalize": this.path.normalize === Path.posix.normalize
-      })
-    );
-  }
-  /**
-   * Encode special characters in a file path to use in a URL.
-   * @param filepath
-   * @returns
-   */
-  encodePathChars(filepath) {
-    filepath = filepath.replaceAll(percentRegEx, "%25");
-    if (!this.windows && !isWindows && filepath.includes("\\")) {
-      filepath = filepath.replaceAll(backslashRegEx, "%5C");
-    }
-    filepath = filepath.replaceAll(newlineRegEx, "%0A");
-    filepath = filepath.replaceAll(carriageReturnRegEx, "%0D");
-    filepath = filepath.replaceAll(tabRegEx, "%09");
-    return filepath;
-  }
-  /**
-   * Normalize a file path for use in a URL.
-   * ```js
-   * const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
-   * // Result: file:///Users/user/path/to/file.txt
-   * ```
-   * @param filePath
-   * @returns a normalized file path for use as a relative path in a URL.
-   */
-  normalizeFilePathForUrl(filePath) {
-    filePath = this.encodePathChars(filePath);
-    filePath = filePath.replaceAll(questionRegex, "%3F");
-    filePath = filePath.replaceAll(hashRegex, "%23");
-    const pathname = filePath.replaceAll("\\", "/");
-    return pathname.replace(isWindowsPathRegEx, (drive) => `/${drive}`.toUpperCase());
-  }
-  /**
-   * Try to make a file URL.
-   * - if filenameOrUrl is already a URL, it is returned as is.
-   * @param filenameOrUrl
-   * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
-   * @returns a URL
-   */
-  toFileURL(filenameOrUrl, relativeTo) {
-    return normalizeWindowsUrl(this.#toFileURL(filenameOrUrl, relativeTo));
-  }
-  /**
-   * Try to make a file URL.
-   * - if filenameOrUrl is already a URL, it is returned as is.
-   * @param filenameOrUrl
-   * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
-   * @returns a URL
-   */
-  #toFileURL(filenameOrUrl, relativeTo) {
-    if (typeof filenameOrUrl !== "string") return filenameOrUrl;
-    if (isUrlLike(filenameOrUrl)) return normalizeWindowsUrl(new URL(filenameOrUrl));
-    relativeTo ??= this.cwd;
-    isWindows && (filenameOrUrl = filenameOrUrl.replaceAll("\\", "/"));
-    if (this.isAbsolute(filenameOrUrl) && isFileURL(relativeTo)) {
-      const pathname2 = this.normalizeFilePathForUrl(filenameOrUrl);
-      if (isWindowsFileUrl(relativeTo) && !isWindowsPathnameWithDriveLatter(pathname2)) {
-        const relFilePrefix = relativeTo.toString().slice(0, 10);
-        return normalizeWindowsUrl(new URL(relFilePrefix + pathname2));
-      }
-      return normalizeWindowsUrl(new URL("file://" + pathname2));
-    }
-    if (isUrlLike(relativeTo)) {
-      const pathname2 = this.normalizeFilePathForUrl(filenameOrUrl);
-      return normalizeWindowsUrl(new URL(pathname2, relativeTo));
-    }
-    const appendSlash = filenameOrUrl.endsWith("/") ? "/" : "";
-    const pathname = this.normalizeFilePathForUrl(this.path.resolve(relativeTo.toString(), filenameOrUrl)) + appendSlash;
-    return normalizeWindowsUrl(new URL("file://" + pathname));
-  }
-  /**
-   * Try to make a URL for a directory.
-   * - if dirOrUrl is already a URL, a slash is appended to the pathname.
-   * @param dirOrUrl - directory path to convert to a file URL.
-   * @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
-   * @returns a URL
-   */
-  toFileDirURL(dirOrUrl, relativeTo) {
-    return addTrailingSlash(this.toFileURL(dirOrUrl, relativeTo));
-  }
-  urlToFilePathOrHref(url) {
-    url = this.toFileURL(url);
-    return this.#urlToFilePathOrHref(url);
-  }
-  #urlToFilePathOrHref(url) {
-    if (url.protocol !== ProtocolFile || url.hostname) return url.href;
-    const p = this.path === Path ? toFilePathOrHref(url) : decodeURIComponent(url.pathname.split("/").join(this.path.sep));
-    return pathWindowsDriveLetterToUpper(p.replace(isWindowsPathname, "$1"));
-  }
-  /**
-   * Calculate the relative path to go from `urlFrom` to `urlTo`.
-   * The protocol is not evaluated. Only the `url.pathname` is used.
-   * The result: `new URL(relative(urlFrom, urlTo), urlFrom).pathname === urlTo.pathname`
-   * @param urlFrom
-   * @param urlTo
-   * @returns the relative path
-   */
-  relative(urlFrom, urlTo) {
-    if (urlFrom.protocol === urlTo.protocol && urlFrom.protocol === ProtocolFile) {
-      if (urlFrom.href === urlTo.href) return "";
-      urlFrom = urlFrom.pathname.endsWith("/") ? urlFrom : new URL("./", urlFrom);
-      const fromPath = urlFrom.pathname;
-      const toPath = urlTo.pathname;
-      if (toPath.startsWith(fromPath)) return decodeURIComponent(toPath.slice(fromPath.length));
-      const pFrom = this.#urlToFilePathOrHref(urlFrom);
-      const pTo = this.#urlToFilePathOrHref(urlTo);
-      const toIsDir = urlTo.pathname.endsWith("/");
-      let pathname = this.normalizeFilePathForUrl(this.path.relative(pFrom, pTo));
-      if (toIsDir && !pathname.endsWith("/")) pathname += "/";
-      return decodeURIComponent(pathname);
-    }
-    return decodeURIComponent(urlToUrlRelative(urlFrom, urlTo));
-  }
-  /**
-   * Get the parent directory of a URL.
-   * @param url
-   */
-  urlDirname(url) {
-    return urlParent(this.toFileURL(url));
-  }
-  pathToFileURL(pathname, relativeToURL) {
-    return new URL(this.normalizeFilePathForUrl(pathname), relativeToURL || this.cwd);
-  }
-  rootFileURL(filePath) {
-    const path = this.path;
-    const p = path.parse(path.normalize(path.resolve(filePath ?? ".")));
-    return new URL(this.normalizeFilePathForUrl(p.root), this.#getFsRootURL());
-  }
-  #getFsRootURL() {
-    if (this.path === Path) return pathToFileURL2("/");
-    const p = this.path.resolve("/");
-    return new URL(this.normalizeFilePathForUrl(p), "file:///");
-  }
-  /**
-   * Determine if a filePath is absolute.
-   *
-   * @param filePath
-   * @returns true if `URL` or `path.isAbsolute(filePath)`
-   */
-  isAbsolute(filePath) {
-    return isUrlLike(filePath) || this.path.isAbsolute(filePath);
-  }
-  isUrlLike(url) {
-    return isUrlLike(url);
-  }
+	windows;
+	path;
+	cwd;
+	constructor(options = {}) {
+		const sep = options.path?.sep;
+		this.windows = options.windows ?? (sep ? sep === "\\" : void 0) ?? isWindows;
+		this.path = options.path ?? (this.windows ? Path.win32 : Path.posix);
+		this.cwd = options.cwd ?? this.pathToFileURL(this.path.resolve() + "/", this.rootFileURL());
+		assert(this.path.sep === (this.windows ? "\\" : "/"), `Path separator should match OS type Windows: ${this.windows === true ? "true" : (this.windows ?? "undefined") || "false"}, sep: ${this.path.sep}, options: ` + JSON.stringify({
+			isWindows,
+			sep: `${sep}`,
+			windows: options.windows,
+			pathSep: options.path?.sep,
+			n: options.path?.normalize("path/file.txt"),
+			cwd: options.cwd?.href,
+			win32: this.path === Path.win32,
+			posix: this.path === Path.posix,
+			"win32.normalize": this.path.normalize === Path.win32.normalize,
+			"posix.normalize": this.path.normalize === Path.posix.normalize
+		}) + ``);
+	}
+	/**
+	* Encode special characters in a file path to use in a URL.
+	* @param filepath
+	* @returns
+	*/
+	encodePathChars(filepath) {
+		filepath = filepath.replaceAll(percentRegEx, "%25");
+		if (!this.windows && !isWindows && filepath.includes("\\")) filepath = filepath.replaceAll(backslashRegEx, "%5C");
+		filepath = filepath.replaceAll(newlineRegEx, "%0A");
+		filepath = filepath.replaceAll(carriageReturnRegEx, "%0D");
+		filepath = filepath.replaceAll(tabRegEx, "%09");
+		return filepath;
+	}
+	/**
+	* Normalize a file path for use in a URL.
+	* ```js
+	* const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
+	* // Result: file:///Users/user/path/to/file.txt
+	* ```
+	* @param filePath
+	* @returns a normalized file path for use as a relative path in a URL.
+	*/
+	normalizeFilePathForUrl(filePath) {
+		filePath = this.encodePathChars(filePath);
+		filePath = filePath.replaceAll(questionRegex, "%3F");
+		filePath = filePath.replaceAll(hashRegex, "%23");
+		const pathname = filePath.replaceAll("\\", "/");
+		return pathname.replace(isWindowsPathRegEx, (drive) => `/${drive}`.toUpperCase());
+	}
+	/**
+	* Try to make a file URL.
+	* - if filenameOrUrl is already a URL, it is returned as is.
+	* @param filenameOrUrl
+	* @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+	* @returns a URL
+	*/
+	toFileURL(filenameOrUrl, relativeTo) {
+		return normalizeWindowsUrl(this.#toFileURL(filenameOrUrl, relativeTo));
+	}
+	/**
+	* Try to make a file URL.
+	* - if filenameOrUrl is already a URL, it is returned as is.
+	* @param filenameOrUrl
+	* @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+	* @returns a URL
+	*/
+	#toFileURL(filenameOrUrl, relativeTo) {
+		if (typeof filenameOrUrl !== "string") return filenameOrUrl;
+		if (isUrlLike(filenameOrUrl)) return normalizeWindowsUrl(new URL(filenameOrUrl));
+		relativeTo ??= this.cwd;
+		isWindows && (filenameOrUrl = filenameOrUrl.replaceAll("\\", "/"));
+		if (this.isAbsolute(filenameOrUrl) && isFileURL(relativeTo)) {
+			const pathname$1 = this.normalizeFilePathForUrl(filenameOrUrl);
+			if (isWindowsFileUrl(relativeTo) && !isWindowsPathnameWithDriveLatter(pathname$1)) {
+				const relFilePrefix = relativeTo.toString().slice(0, 10);
+				return normalizeWindowsUrl(new URL(relFilePrefix + pathname$1));
+			}
+			return normalizeWindowsUrl(new URL("file://" + pathname$1));
+		}
+		if (isUrlLike(relativeTo)) {
+			const pathname$1 = this.normalizeFilePathForUrl(filenameOrUrl);
+			return normalizeWindowsUrl(new URL(pathname$1, relativeTo));
+		}
+		const appendSlash = filenameOrUrl.endsWith("/") ? "/" : "";
+		const pathname = this.normalizeFilePathForUrl(this.path.resolve(relativeTo.toString(), filenameOrUrl)) + appendSlash;
+		return normalizeWindowsUrl(new URL("file://" + pathname));
+	}
+	/**
+	* Try to make a URL for a directory.
+	* - if dirOrUrl is already a URL, a slash is appended to the pathname.
+	* @param dirOrUrl - directory path to convert to a file URL.
+	* @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+	* @returns a URL
+	*/
+	toFileDirURL(dirOrUrl, relativeTo) {
+		return addTrailingSlash(this.toFileURL(dirOrUrl, relativeTo));
+	}
+	urlToFilePathOrHref(url) {
+		url = this.toFileURL(url);
+		return this.#urlToFilePathOrHref(url);
+	}
+	#urlToFilePathOrHref(url) {
+		if (url.protocol !== ProtocolFile || url.hostname) return url.href;
+		const p = this.path === Path ? toFilePathOrHref(url) : decodeURIComponent(url.pathname.split("/").join(this.path.sep));
+		return pathWindowsDriveLetterToUpper(p.replace(isWindowsPathname, "$1"));
+	}
+	/**
+	* Calculate the relative path to go from `urlFrom` to `urlTo`.
+	* The protocol is not evaluated. Only the `url.pathname` is used.
+	* The result: `new URL(relative(urlFrom, urlTo), urlFrom).pathname === urlTo.pathname`
+	* @param urlFrom
+	* @param urlTo
+	* @returns the relative path
+	*/
+	relative(urlFrom, urlTo) {
+		if (urlFrom.protocol === urlTo.protocol && urlFrom.protocol === ProtocolFile) {
+			if (urlFrom.href === urlTo.href) return "";
+			urlFrom = urlFrom.pathname.endsWith("/") ? urlFrom : new URL("./", urlFrom);
+			const fromPath = urlFrom.pathname;
+			const toPath = urlTo.pathname;
+			if (toPath.startsWith(fromPath)) return decodeURIComponent(toPath.slice(fromPath.length));
+			const pFrom = this.#urlToFilePathOrHref(urlFrom);
+			const pTo = this.#urlToFilePathOrHref(urlTo);
+			const toIsDir = urlTo.pathname.endsWith("/");
+			let pathname = this.normalizeFilePathForUrl(this.path.relative(pFrom, pTo));
+			if (toIsDir && !pathname.endsWith("/")) pathname += "/";
+			return decodeURIComponent(pathname);
+		}
+		return decodeURIComponent(urlToUrlRelative(urlFrom, urlTo));
+	}
+	/**
+	* Get the parent directory of a URL.
+	* @param url
+	*/
+	urlDirname(url) {
+		return urlParent(this.toFileURL(url));
+	}
+	pathToFileURL(pathname, relativeToURL) {
+		return new URL(this.normalizeFilePathForUrl(pathname), relativeToURL || this.cwd);
+	}
+	rootFileURL(filePath) {
+		const path = this.path;
+		const p = path.parse(path.normalize(path.resolve(filePath ?? ".")));
+		return new URL(this.normalizeFilePathForUrl(p.root), this.#getFsRootURL());
+	}
+	#getFsRootURL() {
+		if (this.path === Path) return pathToFileURL("/");
+		const p = this.path.resolve("/");
+		return new URL(this.normalizeFilePathForUrl(p), "file:///");
+	}
+	/**
+	* Determine if a filePath is absolute.
+	*
+	* @param filePath
+	* @returns true if `URL` or `path.isAbsolute(filePath)`
+	*/
+	isAbsolute(filePath) {
+		return isUrlLike(filePath) || this.path.isAbsolute(filePath);
+	}
+	isUrlLike(url) {
+		return isUrlLike(url);
+	}
 };
 
-// src/defaultFileUrlBuilder.mts
-var fileUrlBuilder = new FileUrlBuilder();
+//#endregion
+//#region src/defaultFileUrlBuilder.mts
+const fileUrlBuilder = new FileUrlBuilder();
 function encodePathChars(filepath) {
-  return fileUrlBuilder.encodePathChars(filepath);
+	return fileUrlBuilder.encodePathChars(filepath);
 }
+/**
+* Normalize a file path for use in a URL.
+* ```js
+* const url = new URL(normalizeFilePathForUrl('path\\to\\file.txt'), 'file:///Users/user/');
+* // Result: file:///Users/user/path/to/file.txt
+* ```
+* @param filePath
+* @returns a normalized file path for use as a relative path in a URL.
+*/
 function normalizeFilePathForUrl(filePath) {
-  return fileUrlBuilder.normalizeFilePathForUrl(filePath);
+	return fileUrlBuilder.normalizeFilePathForUrl(filePath);
 }
+/**
+* Try to make a file URL.
+* - if filenameOrUrl is already a URL, it is returned as is.
+* -
+* @param filenameOrUrl
+* @param relativeTo - optional URL, if given, filenameOrUrl will be parsed as relative.
+* @returns a URL
+*/
 function toFileURL(filenameOrUrl, relativeTo) {
-  return fileUrlBuilder.toFileURL(filenameOrUrl, relativeTo);
+	return fileUrlBuilder.toFileURL(filenameOrUrl, relativeTo);
 }
+/**
+* Converts a file path to a URL and adds a trailing slash.
+* @param dir - url to a directory
+* @returns a URL
+*/
 function toFileDirURL(dir) {
-  return fileUrlBuilder.toFileDirURL(dir);
+	return fileUrlBuilder.toFileDirURL(dir);
 }
-export {
-  FileUrlBuilder,
-  addTrailingSlash,
-  basenameOfUrlPathname,
-  encodePathChars,
-  fixUncUrl,
-  hasProtocol,
-  isDataURL,
-  isFileURL,
-  isNotUrlLike,
-  isURL,
-  isUrlLike,
-  normalizeFilePathForUrl,
-  normalizeWindowsUrl,
-  toFileDirURL,
-  toFilePathOrHref,
-  toFileURL,
-  toURL,
-  urlBasename,
-  urlDirname,
-  urlParent,
-  urlRelative
-};
+
+//#endregion
+export { FileUrlBuilder, addTrailingSlash, basenameOfUrlPathname, encodePathChars, fixUncUrl, hasProtocol, isDataURL, isFileURL, isNotUrlLike, isURL, isUrlLike, normalizeFilePathForUrl, normalizeWindowsUrl, toFileDirURL, toFilePathOrHref, toFileURL, toURL, urlBasename, urlDirname, urlParent, urlRelative };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.0.1",
+  "version": "9.1.0",
   "description": "URL parsing and manipulation utilities for cspell",
   "keywords": [
     "cspell",
@@ -34,7 +34,7 @@
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsup-node",
+    "build": "tsdown",
     "build:clean": "pnpm clean && pnpm build",
     "clean": "shx rm -rf dist coverage",
     "clean-build": "pnpm build:clean",
@@ -58,5 +58,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "bdfabd3686aac9827f3af0ceb4aa74947b5f9d60"
+  "gitHead": "a7ed42a31debbc86faa4a4ac2c686bdffe5b26b6"
 }