@cspell/url 8.17.0 → 8.17.2

package/dist/FileUrlBuilder.d.mts

@@ -1,86 +0,0 @@
-import Path from 'node:path';
-export declare const percentRegEx: RegExp;
-export declare const backslashRegEx: RegExp;
-export declare const newlineRegEx: RegExp;
-export declare const carriageReturnRegEx: RegExp;
-export declare const tabRegEx: RegExp;
-export declare const questionRegex: RegExp;
-export declare const hashRegex: RegExp;
-export interface PathInterface {
-    sep: string;
-    resolve(...paths: string[]): string;
-    parse(path: string): Path.ParsedPath;
-    normalize(path: string): string;
-    relative(from: string, to: string): string;
-    isAbsolute(path: string): boolean;
-}
-export interface BuilderOptions {
-    windows?: boolean | undefined;
-    path?: PathInterface | undefined;
-    cwd?: URL | undefined;
-}
-export 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;
-}
-//# sourceMappingURL=FileUrlBuilder.d.mts.map

package/dist/FileUrlBuilder.mjs

@@ -1,199 +0,0 @@
-import assert from 'node:assert';
-import Path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { isFileURL, isWindows, isWindowsFileUrl, isWindowsPathnameWithDriveLatter, pathWindowsDriveLetterToUpper, regExpWindowsPathDriveLetter, toFilePathOrHref, } from './fileUrl.mjs';
-import { addTrailingSlash, isUrlLike, normalizeWindowsUrl, regExpWindowsPath, urlParent, urlToUrlRelative, } from './url.mjs';
-const isWindowsPathRegEx = regExpWindowsPathDriveLetter;
-const isWindowsPathname = regExpWindowsPath;
-export const percentRegEx = /%/g;
-export const backslashRegEx = /\\/g;
-export const newlineRegEx = /\n/g;
-export const carriageReturnRegEx = /\r/g;
-export const tabRegEx = /\t/g;
-export const questionRegex = /\?/g;
-export const hashRegex = /#/g;
-const ProtocolFile = 'file:';
-export class FileUrlBuilder {
-    windows;
-    path;
-    cwd;
-    constructor(options = {}) {
-        const sep = options.path?.sep;
-        this.windows = options.windows ?? (sep ? sep === '\\' : undefined) ?? isWindows;
-        this.path = options.path ?? (this.windows ? Path.win32 : Path.posix);
-        // note: `this.path.resolve() + '/'` is used on purpose instead of `'./'`
-        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');
-        // In posix, backslash is a valid character in paths:
-        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 = this.normalizeFilePathForUrl(filenameOrUrl);
-            if (isWindowsFileUrl(relativeTo) && !isWindowsPathnameWithDriveLatter(pathname)) {
-                const relFilePrefix = relativeTo.toString().slice(0, 10);
-                return normalizeWindowsUrl(new URL(relFilePrefix + pathname));
-            }
-            return normalizeWindowsUrl(new URL('file://' + pathname));
-        }
-        if (isUrlLike(relativeTo)) {
-            const pathname = this.normalizeFilePathForUrl(filenameOrUrl);
-            return normalizeWindowsUrl(new URL(pathname, relativeTo));
-        }
-        // Resolve removes the trailing slash, so we need to add it back.
-        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);
-    }
-}
-//# sourceMappingURL=FileUrlBuilder.mjs.map

package/dist/dataUrl.d.mts

@@ -1,8 +0,0 @@
-/**
- * Try to determine the base name of a URL.
- * @param url
- * @returns the base name of a URL, including the trailing `/` if present.
- */
-export declare function urlBasename(url: string | URL): string;
-export declare function isDataURL(url: string | URL): boolean;
-//# sourceMappingURL=dataUrl.d.mts.map

package/dist/dataUrl.mjs

@@ -1,25 +0,0 @@
-import { basenameOfUrlPathname, hasProtocol, toURL } from './url.mjs';
-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.
- */
-export 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);
-}
-export function isDataURL(url) {
-    return hasProtocol(url, 'data:');
-}
-//# sourceMappingURL=dataUrl.mjs.map

package/dist/defaultFileUrlBuilder.d.mts

@@ -1,27 +0,0 @@
-export 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.
- */
-export 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
- */
-export 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
- */
-export declare function toFileDirURL(dir: string | URL): URL;
-//# sourceMappingURL=defaultFileUrlBuilder.d.mts.map

package/dist/defaultFileUrlBuilder.mjs

@@ -1,37 +0,0 @@
-import { FileUrlBuilder } from './FileUrlBuilder.mjs';
-const fileUrlBuilder = new FileUrlBuilder();
-export function 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.
- */
-export function 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
- */
-export function 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
- */
-export function toFileDirURL(dir) {
-    return fileUrlBuilder.toFileDirURL(dir);
-}
-//# sourceMappingURL=defaultFileUrlBuilder.mjs.map

package/dist/fileUrl.d.mts

@@ -1,22 +0,0 @@
-export declare const isWindows: boolean;
-export declare function isWindowsPathnameWithDriveLatter(pathname: string): boolean;
-/**
- * @param url - URL or string to check if it is a file URL.
- * @returns true if the URL is a file URL.
- */
-export 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
- */
-export declare function toFilePathOrHref(url: URL | string): string;
-export declare const regExpWindowsPathDriveLetter: RegExp;
-export declare function pathWindowsDriveLetterToUpper(absoluteFilePath: string): string;
-/**
- * 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.
- */
-export declare function isWindowsFileUrl(url: URL | string): boolean;
-//# sourceMappingURL=fileUrl.d.mts.map

package/dist/fileUrl.mjs

@@ -1,58 +0,0 @@
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { hasProtocol } from './url.mjs';
-export const isWindows = process.platform === 'win32';
-const windowsUrlPathRegExp = /^\/[a-zA-Z]:\//;
-export function isWindowsPathnameWithDriveLatter(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.
- */
-export function isFileURL(url) {
-    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
- */
-export function toFilePathOrHref(url) {
-    return isFileURL(url) && url.toString().startsWith('file:///') ? toFilePath(url) : url.toString();
-}
-function toFilePath(url) {
-    try {
-        // Fix drive letter if necessary.
-        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 {
-        // console.error('Failed to convert URL to path', url);
-        return url.toString();
-    }
-}
-export const regExpWindowsPathDriveLetter = /^([a-zA-Z]):[\\/]/;
-export function pathWindowsDriveLetterToUpper(absoluteFilePath) {
-    return absoluteFilePath.replace(regExpWindowsPathDriveLetter, (s) => s.toUpperCase());
-}
-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.
- */
-export function isWindowsFileUrl(url) {
-    return regExpWindowsFileUrl.test(url.toString());
-}
-//# sourceMappingURL=fileUrl.mjs.map

package/dist/index.d.mts

@@ -1,7 +0,0 @@
-export { isDataURL, urlBasename } from './dataUrl.mjs';
-export { encodePathChars, normalizeFilePathForUrl, toFileDirURL, toFileURL } from './defaultFileUrlBuilder.mjs';
-export { isFileURL, toFilePathOrHref } from './fileUrl.mjs';
-export type { BuilderOptions, PathInterface } from './FileUrlBuilder.mjs';
-export { FileUrlBuilder } from './FileUrlBuilder.mjs';
-export { addTrailingSlash, basenameOfUrlPathname, fixUncUrl, hasProtocol, isNotUrlLike, isURL, isUrlLike, normalizeWindowsUrl, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
-//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,6 +0,0 @@
-export { isDataURL, urlBasename } from './dataUrl.mjs';
-export { encodePathChars, normalizeFilePathForUrl, toFileDirURL, toFileURL } from './defaultFileUrlBuilder.mjs';
-export { isFileURL, toFilePathOrHref } from './fileUrl.mjs';
-export { FileUrlBuilder } from './FileUrlBuilder.mjs';
-export { addTrailingSlash, basenameOfUrlPathname, fixUncUrl, hasProtocol, isNotUrlLike, isURL, isUrlLike, normalizeWindowsUrl, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
-//# sourceMappingURL=index.mjs.map

package/dist/url.d.mts

@@ -1,114 +0,0 @@
-/**
- * Try to make a URL.
- * @param url
- * @param relativeTo - optional URL, if given, url will be parsed as relative.
- * @returns a URL
- */
-export 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
- */
-export 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
- */
-export 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.
- */
-export declare function basenameOfUrlPathname(path: string): string;
-/**
- * @param filename - filename to check if it is a string containing a URL.
- */
-export declare function isUrlLike(filename: string): boolean;
-export declare function isUrlLike(filename: URL): true;
-/**
- * @param filename - filename to check if it is a string containing a URL or a URL object.
- */
-export declare function isUrlLike(filename: string | URL): boolean;
-/**
- * @param filename - filename to check if it is a string containing a URL.
- */
-export declare function isNotUrlLike(filename: string): boolean;
-export declare function isNotUrlLike(filename: URL): false;
-/**
- * @param filename - filename to check if it is a string containing a URL or a URL object.
- */
-export declare function isNotUrlLike(filename: string | URL): filename is string;
-/**
- * Check if `url` is a URL instance.
- * @returns
- */
-export 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
- */
-export 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
- */
-export declare function addTrailingSlash(url: URL): URL;
-/**
- * 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
- */
-export declare function urlRemoveFilename(url: URL): URL;
-/**
- * Extract the filename from the URL pathname.
- *
- * ```ts
- * url.href === new URL(urlFilename(url), urlRemoveFilename(url)).href
- * ```
- * @param url - URL to extract the filename from.
- * @returns the filename or empty string if the URL pathname ends with a `/`.
- */
-export declare function urlFilename(url: URL): 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
- */
-export declare function urlRelative(urlFrom: string | URL, urlTo: string | URL): 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
- */
-export declare function urlToUrlRelative(urlFrom: URL, urlTo: URL): string;
-export declare const regExpWindowsPath: RegExp;
-export declare const regExpEncodedColon: RegExp;
-/**
- * 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.
- */
-export 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.
- */
-export declare function fixUncUrl(url: URL): URL;
-//# sourceMappingURL=url.d.mts.map