track-cli 3.0.0-rc

package/esm/deps/deno.land/std@0.195.0/path/common.js

@@ -0,0 +1,36 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { SEP } from "./separator.js";
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ * ```ts
+ *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ * ```
+ */
+export function common(paths, sep = SEP) {
+    const [first = "", ...remaining] = paths;
+    if (first === "" || remaining.length === 0) {
+        return first.substring(0, first.lastIndexOf(sep) + 1);
+    }
+    const parts = first.split(sep);
+    let endOfPrefix = parts.length;
+    for (const path of remaining) {
+        const compare = path.split(sep);
+        for (let i = 0; i < endOfPrefix; i++) {
+            if (compare[i] !== parts[i]) {
+                endOfPrefix = i;
+            }
+        }
+        if (endOfPrefix === 0) {
+            return "";
+        }
+    }
+    const prefix = parts.slice(0, endOfPrefix).join(sep);
+    return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+}

package/esm/deps/deno.land/std@0.195.0/path/glob.d.ts

@@ -0,0 +1,83 @@
+import type { OSType } from "../_util/os.js";
+export interface GlobOptions {
+    /** Extended glob syntax.
+     * See https://www.linuxjournal.com/content/bash-extended-globbing.
+     *
+     * @default {true}
+     */
+    extended?: boolean;
+    /** Globstar syntax.
+     * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+     * If false, `**` is treated like `*`.
+     *
+     * @default {true}
+     */
+    globstar?: boolean;
+    /** Whether globstar should be case-insensitive. */
+    caseInsensitive?: boolean;
+    /** Operating system. Defaults to the native OS. */
+    os?: OSType;
+}
+export type GlobToRegExpOptions = GlobOptions;
+/** Convert a glob string to a regular expression.
+ *
+ * Tries to match bash glob expansion as closely as possible.
+ *
+ * Basic glob syntax:
+ * - `*` - Matches everything without leaving the path segment.
+ * - `?` - Matches any single character.
+ * - `{foo,bar}` - Matches `foo` or `bar`.
+ * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
+ * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
+ * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
+ * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
+ *     - `[[:alnum:]]` - Matches any digit or letter.
+ *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
+ *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
+ *       for a complete list of supported character classes.
+ * - `\` - Escapes the next character for an `os` other than `"windows"`.
+ * - \` - Escapes the next character for `os` set to `"windows"`.
+ * - `/` - Path separator.
+ * - `\` - Additional path separator only for `os` set to `"windows"`.
+ *
+ * Extended syntax:
+ * - Requires `{ extended: true }`.
+ * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
+ * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
+ * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
+ * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
+ * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
+ * - See https://www.linuxjournal.com/content/bash-extended-globbing.
+ *
+ * Globstar syntax:
+ * - Requires `{ globstar: true }`.
+ * - `**` - Matches any number of any path segments.
+ *     - Must comprise its entire path segment in the provided glob.
+ * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+ *
+ * Note the following properties:
+ * - The generated `RegExp` is anchored at both start and end.
+ * - Repeating and trailing separators are tolerated. Trailing separators in the
+ *   provided glob have no meaning and are discarded.
+ * - Absolute globs will only match absolute paths, etc.
+ * - Empty globs will match nothing.
+ * - Any special glob syntax must be contained to one path segment. For example,
+ *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
+ *   first segment ends with an unclosed group.
+ * - If a path segment ends with unclosed groups or a dangling escape prefix, a
+ *   parse error has occurred. Every character for that segment is taken
+ *   literally in this event.
+ *
+ * Limitations:
+ * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
+ *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
+ *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
+ *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
+ *   the group occurs not nested at the end of the segment. */
+export declare function globToRegExp(glob: string, { extended, globstar: globstarOption, os, caseInsensitive, }?: GlobToRegExpOptions): RegExp;
+/** Test whether the given string is a glob */
+export declare function isGlob(str: string): boolean;
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function normalizeGlob(glob: string, { globstar }?: GlobOptions): string;
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function joinGlobs(globs: string[], { extended, globstar }?: GlobOptions): string;

package/esm/deps/deno.land/std@0.195.0/path/glob.js

@@ -0,0 +1,361 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { isWindows, osType } from "../_util/os.js";
+import { SEP, SEP_PATTERN } from "./separator.js";
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+const path = isWindows ? _win32 : _posix;
+const { join, normalize } = path;
+const regExpEscapeChars = [
+    "!",
+    "$",
+    "(",
+    ")",
+    "*",
+    "+",
+    ".",
+    "=",
+    "?",
+    "[",
+    "\\",
+    "^",
+    "{",
+    "|",
+];
+const rangeEscapeChars = ["-", "\\", "]"];
+/** Convert a glob string to a regular expression.
+ *
+ * Tries to match bash glob expansion as closely as possible.
+ *
+ * Basic glob syntax:
+ * - `*` - Matches everything without leaving the path segment.
+ * - `?` - Matches any single character.
+ * - `{foo,bar}` - Matches `foo` or `bar`.
+ * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
+ * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
+ * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
+ * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
+ *     - `[[:alnum:]]` - Matches any digit or letter.
+ *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
+ *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
+ *       for a complete list of supported character classes.
+ * - `\` - Escapes the next character for an `os` other than `"windows"`.
+ * - \` - Escapes the next character for `os` set to `"windows"`.
+ * - `/` - Path separator.
+ * - `\` - Additional path separator only for `os` set to `"windows"`.
+ *
+ * Extended syntax:
+ * - Requires `{ extended: true }`.
+ * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
+ * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
+ * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
+ * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
+ * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
+ * - See https://www.linuxjournal.com/content/bash-extended-globbing.
+ *
+ * Globstar syntax:
+ * - Requires `{ globstar: true }`.
+ * - `**` - Matches any number of any path segments.
+ *     - Must comprise its entire path segment in the provided glob.
+ * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+ *
+ * Note the following properties:
+ * - The generated `RegExp` is anchored at both start and end.
+ * - Repeating and trailing separators are tolerated. Trailing separators in the
+ *   provided glob have no meaning and are discarded.
+ * - Absolute globs will only match absolute paths, etc.
+ * - Empty globs will match nothing.
+ * - Any special glob syntax must be contained to one path segment. For example,
+ *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
+ *   first segment ends with an unclosed group.
+ * - If a path segment ends with unclosed groups or a dangling escape prefix, a
+ *   parse error has occurred. Every character for that segment is taken
+ *   literally in this event.
+ *
+ * Limitations:
+ * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
+ *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
+ *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
+ *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
+ *   the group occurs not nested at the end of the segment. */
+export function globToRegExp(glob, { extended = true, globstar: globstarOption = true, os = osType, caseInsensitive = false, } = {}) {
+    if (glob == "") {
+        return /(?!)/;
+    }
+    const sep = os == "windows" ? "(?:\\\\|/)+" : "/+";
+    const sepMaybe = os == "windows" ? "(?:\\\\|/)*" : "/*";
+    const seps = os == "windows" ? ["\\", "/"] : ["/"];
+    const globstar = os == "windows"
+        ? "(?:[^\\\\/]*(?:\\\\|/|$)+)*"
+        : "(?:[^/]*(?:/|$)+)*";
+    const wildcard = os == "windows" ? "[^\\\\/]*" : "[^/]*";
+    const escapePrefix = os == "windows" ? "`" : "\\";
+    // Remove trailing separators.
+    let newLength = glob.length;
+    for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--)
+        ;
+    glob = glob.slice(0, newLength);
+    let regExpString = "";
+    // Terminates correctly. Trust that `j` is incremented every iteration.
+    for (let j = 0; j < glob.length;) {
+        let segment = "";
+        const groupStack = [];
+        let inRange = false;
+        let inEscape = false;
+        let endsWithSep = false;
+        let i = j;
+        // Terminates with `i` at the non-inclusive end of the current segment.
+        for (; i < glob.length && !seps.includes(glob[i]); i++) {
+            if (inEscape) {
+                inEscape = false;
+                const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;
+                segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+                continue;
+            }
+            if (glob[i] == escapePrefix) {
+                inEscape = true;
+                continue;
+            }
+            if (glob[i] == "[") {
+                if (!inRange) {
+                    inRange = true;
+                    segment += "[";
+                    if (glob[i + 1] == "!") {
+                        i++;
+                        segment += "^";
+                    }
+                    else if (glob[i + 1] == "^") {
+                        i++;
+                        segment += "\\^";
+                    }
+                    continue;
+                }
+                else if (glob[i + 1] == ":") {
+                    let k = i + 1;
+                    let value = "";
+                    while (glob[k + 1] != null && glob[k + 1] != ":") {
+                        value += glob[k + 1];
+                        k++;
+                    }
+                    if (glob[k + 1] == ":" && glob[k + 2] == "]") {
+                        i = k + 2;
+                        if (value == "alnum")
+                            segment += "\\dA-Za-z";
+                        else if (value == "alpha")
+                            segment += "A-Za-z";
+                        else if (value == "ascii")
+                            segment += "\x00-\x7F";
+                        else if (value == "blank")
+                            segment += "\t ";
+                        else if (value == "cntrl")
+                            segment += "\x00-\x1F\x7F";
+                        else if (value == "digit")
+                            segment += "\\d";
+                        else if (value == "graph")
+                            segment += "\x21-\x7E";
+                        else if (value == "lower")
+                            segment += "a-z";
+                        else if (value == "print")
+                            segment += "\x20-\x7E";
+                        else if (value == "punct") {
+                            segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~";
+                        }
+                        else if (value == "space")
+                            segment += "\\s\v";
+                        else if (value == "upper")
+                            segment += "A-Z";
+                        else if (value == "word")
+                            segment += "\\w";
+                        else if (value == "xdigit")
+                            segment += "\\dA-Fa-f";
+                        continue;
+                    }
+                }
+            }
+            if (glob[i] == "]" && inRange) {
+                inRange = false;
+                segment += "]";
+                continue;
+            }
+            if (inRange) {
+                if (glob[i] == "\\") {
+                    segment += `\\\\`;
+                }
+                else {
+                    segment += glob[i];
+                }
+                continue;
+            }
+            if (glob[i] == ")" && groupStack.length > 0 &&
+                groupStack[groupStack.length - 1] != "BRACE") {
+                segment += ")";
+                const type = groupStack.pop();
+                if (type == "!") {
+                    segment += wildcard;
+                }
+                else if (type != "@") {
+                    segment += type;
+                }
+                continue;
+            }
+            if (glob[i] == "|" && groupStack.length > 0 &&
+                groupStack[groupStack.length - 1] != "BRACE") {
+                segment += "|";
+                continue;
+            }
+            if (glob[i] == "+" && extended && glob[i + 1] == "(") {
+                i++;
+                groupStack.push("+");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] == "@" && extended && glob[i + 1] == "(") {
+                i++;
+                groupStack.push("@");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] == "?") {
+                if (extended && glob[i + 1] == "(") {
+                    i++;
+                    groupStack.push("?");
+                    segment += "(?:";
+                }
+                else {
+                    segment += ".";
+                }
+                continue;
+            }
+            if (glob[i] == "!" && extended && glob[i + 1] == "(") {
+                i++;
+                groupStack.push("!");
+                segment += "(?!";
+                continue;
+            }
+            if (glob[i] == "{") {
+                groupStack.push("BRACE");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] == "}" && groupStack[groupStack.length - 1] == "BRACE") {
+                groupStack.pop();
+                segment += ")";
+                continue;
+            }
+            if (glob[i] == "," && groupStack[groupStack.length - 1] == "BRACE") {
+                segment += "|";
+                continue;
+            }
+            if (glob[i] == "*") {
+                if (extended && glob[i + 1] == "(") {
+                    i++;
+                    groupStack.push("*");
+                    segment += "(?:";
+                }
+                else {
+                    const prevChar = glob[i - 1];
+                    let numStars = 1;
+                    while (glob[i + 1] == "*") {
+                        i++;
+                        numStars++;
+                    }
+                    const nextChar = glob[i + 1];
+                    if (globstarOption && numStars == 2 &&
+                        [...seps, undefined].includes(prevChar) &&
+                        [...seps, undefined].includes(nextChar)) {
+                        segment += globstar;
+                        endsWithSep = true;
+                    }
+                    else {
+                        segment += wildcard;
+                    }
+                }
+                continue;
+            }
+            segment += regExpEscapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+        }
+        // Check for unclosed groups or a dangling backslash.
+        if (groupStack.length > 0 || inRange || inEscape) {
+            // Parse failure. Take all characters from this segment literally.
+            segment = "";
+            for (const c of glob.slice(j, i)) {
+                segment += regExpEscapeChars.includes(c) ? `\\${c}` : c;
+                endsWithSep = false;
+            }
+        }
+        regExpString += segment;
+        if (!endsWithSep) {
+            regExpString += i < glob.length ? sep : sepMaybe;
+            endsWithSep = true;
+        }
+        // Terminates with `i` at the start of the next segment.
+        while (seps.includes(glob[i]))
+            i++;
+        // Check that the next value of `j` is indeed higher than the current value.
+        if (!(i > j)) {
+            throw new Error("Assertion failure: i > j (potential infinite loop)");
+        }
+        j = i;
+    }
+    regExpString = `^${regExpString}$`;
+    return new RegExp(regExpString, caseInsensitive ? "i" : "");
+}
+/** Test whether the given string is a glob */
+export function isGlob(str) {
+    const chars = { "{": "}", "(": ")", "[": "]" };
+    const regex = /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+    if (str === "") {
+        return false;
+    }
+    let match;
+    while ((match = regex.exec(str))) {
+        if (match[2])
+            return true;
+        let idx = match.index + match[0].length;
+        // if an open bracket/brace/paren is escaped,
+        // set the index to the next closing character
+        const open = match[1];
+        const close = open ? chars[open] : null;
+        if (open && close) {
+            const n = str.indexOf(close, idx);
+            if (n !== -1) {
+                idx = n + 1;
+            }
+        }
+        str = str.slice(idx);
+    }
+    return false;
+}
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function normalizeGlob(glob, { globstar = false } = {}) {
+    if (glob.match(/\0/g)) {
+        throw new Error(`Glob contains invalid characters: "${glob}"`);
+    }
+    if (!globstar) {
+        return normalize(glob);
+    }
+    const s = SEP_PATTERN.source;
+    const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
+    return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+}
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function joinGlobs(globs, { extended = true, globstar = false } = {}) {
+    if (!globstar || globs.length == 0) {
+        return join(...globs);
+    }
+    if (globs.length === 0)
+        return ".";
+    let joined;
+    for (const glob of globs) {
+        const path = glob;
+        if (path.length > 0) {
+            if (!joined)
+                joined = path;
+            else
+                joined += `${SEP}${path}`;
+        }
+    }
+    if (!joined)
+        return ".";
+    return normalizeGlob(joined, { extended, globstar });
+}

package/esm/deps/deno.land/std@0.195.0/path/mod.d.ts

@@ -0,0 +1,9 @@
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+export declare const win32: typeof _win32;
+export declare const posix: typeof _posix;
+export declare const basename: typeof _posix.basename | typeof _win32.basename, delimiter: string, dirname: typeof _posix.dirname | typeof _win32.dirname, extname: typeof _posix.extname | typeof _win32.extname, format: typeof _posix.format | typeof _win32.format, fromFileUrl: typeof _posix.fromFileUrl | typeof _win32.fromFileUrl, isAbsolute: typeof _win32.isAbsolute | typeof _posix.isAbsolute, join: typeof _posix.join | typeof _win32.join, normalize: typeof _win32.normalize | typeof _posix.normalize, parse: typeof _posix.parse | typeof _win32.parse, relative: typeof _posix.relative | typeof _win32.relative, resolve: typeof _win32.resolve | typeof _posix.resolve, toFileUrl: typeof _posix.toFileUrl | typeof _win32.toFileUrl, toNamespacedPath: typeof _posix.toNamespacedPath | typeof _win32.toNamespacedPath;
+export * from "./common.js";
+export { SEP, SEP_PATTERN } from "./separator.js";
+export * from "./_interface.js";
+export * from "./glob.js";

package/esm/deps/deno.land/std@0.195.0/path/mod.js

@@ -0,0 +1,33 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported mostly from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+/**
+ * Utilities for working with OS-specific file paths.
+ *
+ * Codes in the examples uses POSIX path but it automatically use Windows path
+ * on Windows. Use methods under `posix` or `win32` object instead to handle non
+ * platform specific path like:
+ * ```ts
+ * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ * const p1 = posix.fromFileUrl("file:///home/foo");
+ * const p2 = win32.fromFileUrl("file:///home/foo");
+ * console.log(p1); // "/home/foo"
+ * console.log(p2); // "\\home\\foo"
+ * ```
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+import { isWindows } from "../_util/os.js";
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+const path = isWindows ? _win32 : _posix;
+export const win32 = _win32;
+export const posix = _posix;
+export const { basename, delimiter, dirname, extname, format, fromFileUrl, isAbsolute, join, normalize, parse, relative, resolve, toFileUrl, toNamespacedPath, } = path;
+export * from "./common.js";
+export { SEP, SEP_PATTERN } from "./separator.js";
+export * from "./_interface.js";
+export * from "./glob.js";

package/esm/deps/deno.land/std@0.195.0/path/posix.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
+export declare const sep = "/";
+export declare const delimiter = ":";
+/**
+ * Resolves `pathSegments` into an absolute path.
+ * @param pathSegments an array of path segments
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Normalize 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 `'.'`.
+ * @param path to be normalized
+ */
+export declare function normalize(path: string): string;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function join(...paths: string[]): string;
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ * @param from path in current working directory
+ * @param to path in current working directory
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export declare function toNamespacedPath(path: string): string;
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function dirname(path: string): string;
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export declare function basename(path: string, suffix?: string): string;
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export declare function extname(path: string): string;
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function format(pathObject: FormatInputPathObject): string;
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function parse(path: string): ParsedPath;
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *      fromFileUrl("file:///home/foo"); // "/home/foo"
+ * ```
+ * @param url of a file URL
+ */
+export declare function fromFileUrl(url: string | URL): string;
+/**
+ * Converts a path string to a file URL.
+ *
+ * ```ts
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
+ * ```
+ * @param path to convert to file URL
+ */
+export declare function toFileUrl(path: string): URL;