// Copyright the Browserify authors. MIT License.
// Ported from https://github.com/browserify/path-browserify/
// This module is browser compatible.
import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./_constants.ts";
import { _format, assertPath, encodeWhitespace, isPosixPathSeparator, normalizeString } from "./_util.ts";
export const sep = "/";
export const delimiter = ":";
// path.resolve([from ...], to)
/**
 * Resolves `pathSegments` into an absolute path.
 * @param pathSegments an array of path segments
 */ export function resolve(...pathSegments) {
    let resolvedPath = "";
    let resolvedAbsolute = false;
    for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){
        let path;
        if (i >= 0) path = pathSegments[i];
        else {
            if (globalThis.Deno == null) {
                throw new TypeError("Resolved a relative path without a CWD.");
            }
            path = Deno.cwd();
        }
        assertPath(path);
        // Skip empty entries
        if (path.length === 0) {
            continue;
        }
        resolvedPath = `${path}/${resolvedPath}`;
        resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    }
    // At this point the path should be resolved to a full absolute path, but
    // handle relative paths to be safe (might happen when process.cwd() fails)
    // Normalize the path
    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
    if (resolvedAbsolute) {
        if (resolvedPath.length > 0) return `/${resolvedPath}`;
        else return "/";
    } else if (resolvedPath.length > 0) return resolvedPath;
    else return ".";
}
/**
 * Normalize the `path`, resolving `'..'` and `'.'` segments.
 * @param path to be normalized
 */ export function normalize(path) {
    assertPath(path);
    if (path.length === 0) return ".";
    const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
    // Normalize the path
    path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
    if (path.length === 0 && !isAbsolute) path = ".";
    if (path.length > 0 && trailingSeparator) path += "/";
    if (isAbsolute) return `/${path}`;
    return path;
}
/**
 * Verifies whether provided path is absolute
 * @param path to be verified as absolute
 */ export function isAbsolute(path) {
    assertPath(path);
    return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
}
/**
 * Join all given a sequence of `paths`,then normalizes the resulting path.
 * @param paths to be joined and normalized
 */ export function join(...paths) {
    if (paths.length === 0) return ".";
    let joined;
    for(let i = 0, len = paths.length; i < len; ++i){
        const path = paths[i];
        assertPath(path);
        if (path.length > 0) {
            if (!joined) joined = path;
            else joined += `/${path}`;
        }
    }
    if (!joined) return ".";
    return normalize(joined);
}
/**
 * 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 function relative(from, to) {
    assertPath(from);
    assertPath(to);
    if (from === to) return "";
    from = resolve(from);
    to = resolve(to);
    if (from === to) return "";
    // Trim any leading backslashes
    let fromStart = 1;
    const fromEnd = from.length;
    for(; fromStart < fromEnd; ++fromStart){
        if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;
    }
    const fromLen = fromEnd - fromStart;
    // Trim any leading backslashes
    let toStart = 1;
    const toEnd = to.length;
    for(; toStart < toEnd; ++toStart){
        if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;
    }
    const toLen = toEnd - toStart;
    // Compare paths to find the longest common path from root
    const length = fromLen < toLen ? fromLen : toLen;
    let lastCommonSep = -1;
    let i = 0;
    for(; i <= length; ++i){
        if (i === length) {
            if (toLen > length) {
                if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
                    // We get here if `from` is the exact base path for `to`.
                    // For example: from='/foo/bar'; to='/foo/bar/baz'
                    return to.slice(toStart + i + 1);
                } else if (i === 0) {
                    // We get here if `from` is the root
                    // For example: from='/'; to='/foo'
                    return to.slice(toStart + i);
                }
            } else if (fromLen > length) {
                if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
                    // We get here if `to` is the exact base path for `from`.
                    // For example: from='/foo/bar/baz'; to='/foo/bar'
                    lastCommonSep = i;
                } else if (i === 0) {
                    // We get here if `to` is the root.
                    // For example: from='/foo'; to='/'
                    lastCommonSep = 0;
                }
            }
            break;
        }
        const fromCode = from.charCodeAt(fromStart + i);
        const toCode = to.charCodeAt(toStart + i);
        if (fromCode !== toCode) break;
        else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
    }
    let out = "";
    // Generate the relative path based on the path difference between `to`
    // and `from`
    for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){
        if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
            if (out.length === 0) out += "..";
            else out += "/..";
        }
    }
    // Lastly, append the rest of the destination (`to`) path that comes after
    // the common path parts
    if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
    else {
        toStart += lastCommonSep;
        if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;
        return to.slice(toStart);
    }
}
/**
 * Resolves path to a namespace path
 * @param path to resolve to namespace
 */ export function toNamespacedPath(path) {
    // Non-op on posix systems
    return path;
}
/**
 * Return the directory name of a `path`.
 * @param path to determine name for
 */ export function dirname(path) {
    assertPath(path);
    if (path.length === 0) return ".";
    const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    let end = -1;
    let matchedSlash = true;
    for(let i = path.length - 1; i >= 1; --i){
        if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
            if (!matchedSlash) {
                end = i;
                break;
            }
        } else {
            // We saw the first non-path separator
            matchedSlash = false;
        }
    }
    if (end === -1) return hasRoot ? "/" : ".";
    if (hasRoot && end === 1) return "//";
    return path.slice(0, end);
}
/**
 * Return the last portion of a `path`. Trailing directory separators are ignored.
 * @param path to process
 * @param ext of path directory
 */ export function basename(path, ext = "") {
    if (ext !== undefined && typeof ext !== "string") {
        throw new TypeError('"ext" argument must be a string');
    }
    assertPath(path);
    let start = 0;
    let end = -1;
    let matchedSlash = true;
    let i;
    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
        if (ext.length === path.length && ext === path) return "";
        let extIdx = ext.length - 1;
        let firstNonSlashEnd = -1;
        for(i = path.length - 1; i >= 0; --i){
            const code = path.charCodeAt(i);
            if (code === CHAR_FORWARD_SLASH) {
                // If we reached a path separator that was not part of a set of path
                // separators at the end of the string, stop now
                if (!matchedSlash) {
                    start = i + 1;
                    break;
                }
            } else {
                if (firstNonSlashEnd === -1) {
                    // We saw the first non-path separator, remember this index in case
                    // we need it if the extension ends up not matching
                    matchedSlash = false;
                    firstNonSlashEnd = i + 1;
                }
                if (extIdx >= 0) {
                    // Try to match the explicit extension
                    if (code === ext.charCodeAt(extIdx)) {
                        if (--extIdx === -1) {
                            // We matched the extension, so mark this as the end of our path
                            // component
                            end = i;
                        }
                    } else {
                        // Extension does not match, so our result is the entire path
                        // component
                        extIdx = -1;
                        end = firstNonSlashEnd;
                    }
                }
            }
        }
        if (start === end) end = firstNonSlashEnd;
        else if (end === -1) end = path.length;
        return path.slice(start, end);
    } else {
        for(i = path.length - 1; i >= 0; --i){
            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
                // If we reached a path separator that was not part of a set of path
                // separators at the end of the string, stop now
                if (!matchedSlash) {
                    start = i + 1;
                    break;
                }
            } else if (end === -1) {
                // We saw the first non-path separator, mark this as the end of our
                // path component
                matchedSlash = false;
                end = i + 1;
            }
        }
        if (end === -1) return "";
        return path.slice(start, end);
    }
}
/**
 * Return the extension of the `path`.
 * @param path with extension
 */ export function extname(path) {
    assertPath(path);
    let startDot = -1;
    let startPart = 0;
    let end = -1;
    let matchedSlash = true;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    let preDotState = 0;
    for(let i = path.length - 1; i >= 0; --i){
        const code = path.charCodeAt(i);
        if (code === CHAR_FORWARD_SLASH) {
            // If we reached a path separator that was not part of a set of path
            // separators at the end of the string, stop now
            if (!matchedSlash) {
                startPart = i + 1;
                break;
            }
            continue;
        }
        if (end === -1) {
            // We saw the first non-path separator, mark this as the end of our
            // extension
            matchedSlash = false;
            end = i + 1;
        }
        if (code === CHAR_DOT) {
            // If this is our first dot, mark it as the start of our extension
            if (startDot === -1) startDot = i;
            else if (preDotState !== 1) preDotState = 1;
        } else if (startDot !== -1) {
            // We saw a non-dot and non-path separator before our dot, so we should
            // have a good chance at having a non-empty extension
            preDotState = -1;
        }
    }
    if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
    preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
        return "";
    }
    return path.slice(startDot, end);
}
/**
 * Generate a path from `FormatInputPathObject` object.
 * @param pathObject with path
 */ export function format(pathObject) {
    if (pathObject === null || typeof pathObject !== "object") {
        throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`);
    }
    return _format("/", pathObject);
}
/**
 * Return a `ParsedPath` object of the `path`.
 * @param path to process
 */ export function parse(path) {
    assertPath(path);
    const ret = {
        root: "",
        dir: "",
        base: "",
        ext: "",
        name: ""
    };
    if (path.length === 0) return ret;
    const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    let start;
    if (isAbsolute) {
        ret.root = "/";
        start = 1;
    } else {
        start = 0;
    }
    let startDot = -1;
    let startPart = 0;
    let end = -1;
    let matchedSlash = true;
    let i = path.length - 1;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    let preDotState = 0;
    // Get non-dir info
    for(; i >= start; --i){
        const code = path.charCodeAt(i);
        if (code === CHAR_FORWARD_SLASH) {
            // If we reached a path separator that was not part of a set of path
            // separators at the end of the string, stop now
            if (!matchedSlash) {
                startPart = i + 1;
                break;
            }
            continue;
        }
        if (end === -1) {
            // We saw the first non-path separator, mark this as the end of our
            // extension
            matchedSlash = false;
            end = i + 1;
        }
        if (code === CHAR_DOT) {
            // If this is our first dot, mark it as the start of our extension
            if (startDot === -1) startDot = i;
            else if (preDotState !== 1) preDotState = 1;
        } else if (startDot !== -1) {
            // We saw a non-dot and non-path separator before our dot, so we should
            // have a good chance at having a non-empty extension
            preDotState = -1;
        }
    }
    if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
    preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
        if (end !== -1) {
            if (startPart === 0 && isAbsolute) {
                ret.base = ret.name = path.slice(1, end);
            } else {
                ret.base = ret.name = path.slice(startPart, end);
            }
        }
    } else {
        if (startPart === 0 && isAbsolute) {
            ret.name = path.slice(1, startDot);
            ret.base = path.slice(1, end);
        } else {
            ret.name = path.slice(startPart, startDot);
            ret.base = path.slice(startPart, end);
        }
        ret.ext = path.slice(startDot, end);
    }
    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
    else if (isAbsolute) ret.dir = "/";
    return ret;
}
/**
 * Converts a file URL to a path string.
 *
 *      fromFileUrl("file:///home/foo"); // "/home/foo"
 * @param url of a file URL
 */ export function fromFileUrl(url) {
    url = url instanceof URL ? url : new URL(url);
    if (url.protocol != "file:") {
        throw new TypeError("Must be a file URL.");
    }
    return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"));
}
/**
 * Converts a path string to a file URL.
 *
 *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
 * @param path to convert to file URL
 */ export function toFileUrl(path) {
    if (!isAbsolute(path)) {
        throw new TypeError("Must be an absolute path.");
    }
    const url = new URL("file:///");
    url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C"));
    return url;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.92.0/path/posix.ts"],"sourcesContent":["// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport { CHAR_DOT, CHAR_FORWARD_SLASH } from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPosixPathSeparator,\n  normalizeString,\n} from \"./_util.ts\";\n\nexport const sep = \"/\";\nexport const delimiter = \":\";\n\n// path.resolve([from ...], to)\n/**\n * Resolves `pathSegments` into an absolute path.\n * @param pathSegments an array of path segments\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    let path: string;\n\n    if (i >= 0) path = pathSegments[i];\n    else {\n      if (globalThis.Deno == null) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n    }\n\n    assertPath(path);\n\n    // Skip empty entries\n    if (path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(\n    resolvedPath,\n    !resolvedAbsolute,\n    \"/\",\n    isPosixPathSeparator,\n  );\n\n  if (resolvedAbsolute) {\n    if (resolvedPath.length > 0) return `/${resolvedPath}`;\n    else return \"/\";\n  } else if (resolvedPath.length > 0) return resolvedPath;\n  else return \".\";\n}\n\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * @param path to be normalized\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n\n  if (path.length === 0) return \".\";\n\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  const trailingSeparator =\n    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n\n  // Normalize the path\n  path = normalizeString(path, !isAbsolute, \"/\", isPosixPathSeparator);\n\n  if (path.length === 0 && !isAbsolute) path = \".\";\n  if (path.length > 0 && trailingSeparator) path += \"/\";\n\n  if (isAbsolute) return `/${path}`;\n  return path;\n}\n\n/**\n * Verifies whether provided path is absolute\n * @param path to be verified as absolute\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  if (paths.length === 0) return \".\";\n  let joined: string | undefined;\n  for (let i = 0, len = paths.length; i < len; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `/${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalize(joined);\n}\n\n/**\n * Return the relative path from `from` to `to` based on current working directory.\n * @param from path in current working directory\n * @param to path in current working directory\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  from = resolve(from);\n  to = resolve(to);\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 1;\n  const fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 1;\n  const toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='/foo/bar'; to='/foo/bar/baz'\n          return to.slice(toStart + i + 1);\n        } else if (i === 0) {\n          // We get here if `from` is the root\n          // For example: from='/'; to='/foo'\n          return to.slice(toStart + i);\n        }\n      } else if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='/foo/bar/baz'; to='/foo/bar'\n          lastCommonSep = i;\n        } else if (i === 0) {\n          // We get here if `to` is the root.\n          // For example: from='/foo'; to='/'\n          lastCommonSep = 0;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;\n  }\n\n  let out = \"\";\n  // Generate the relative path based on the path difference between `to`\n  // and `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"/..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);\n  else {\n    toStart += lastCommonSep;\n    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;\n    return to.slice(toStart);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Non-op on posix systems\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  if (path.length === 0) return \".\";\n  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let end = -1;\n  let matchedSlash = true;\n  for (let i = path.length - 1; i >= 1; --i) {\n    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? \"/\" : \".\";\n  if (hasRoot && end === 1) return \"//\";\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= 0; --i) {\n      const code = path.charCodeAt(i);\n      if (code === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= 0; --i) {\n      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path`.\n * @param path with extension\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n  for (let i = path.length - 1; i >= 0; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"/\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n  if (path.length === 0) return ret;\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let start: number;\n  if (isAbsolute) {\n    ret.root = \"/\";\n    start = 1;\n  } else {\n    start = 0;\n  }\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      if (startPart === 0 && isAbsolute) {\n        ret.base = ret.name = path.slice(1, end);\n      } else {\n        ret.base = ret.name = path.slice(startPart, end);\n      }\n    }\n  } else {\n    if (startPart === 0 && isAbsolute) {\n      ret.name = path.slice(1, startDot);\n      ret.base = path.slice(1, end);\n    } else {\n      ret.name = path.slice(startPart, startDot);\n      ret.base = path.slice(startPart, end);\n    }\n    ret.ext = path.slice(startDot, end);\n  }\n\n  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);\n  else if (isAbsolute) ret.dir = \"/\";\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n *      fromFileUrl(\"file:///home/foo\"); // \"/home/foo\"\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  return decodeURIComponent(\n    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  );\n}\n\n/**\n * Converts a path string to a file URL.\n *\n *      toFileUrl(\"/home/foo\"); // new URL(\"file:///home/foo\")\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(\n    path.replace(/%/g, \"%25\").replace(/\\\\/g, \"%5C\"),\n  );\n  return url;\n}\n"],"names":[],"mappings":"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"}