.deno/gen/https/deno.land/4e07f5fc21ab1b67b23874d4aec7875cfe6150e248d2e7676c7fad62ad05152b.js

// Copyright the Browserify authors. MIT License.
// Ported from https://github.com/browserify/path-browserify/
// This module is browser compatible.
import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK } from "./_constants.ts";
import { _format, assertPath, encodeWhitespace, isPathSeparator, isWindowsDeviceRoot, normalizeString } from "./_util.ts";
import { assert } from "../_util/assert.ts";
export const sep = "\\";
export const delimiter = ";";
/**
 * Resolves path segments into a `path`
 * @param pathSegments to process to path
 */ export function resolve(...pathSegments) {
    let resolvedDevice = "";
    let resolvedTail = "";
    let resolvedAbsolute = false;
    for(let i = pathSegments.length - 1; i >= -1; i--){
        let path;
        if (i >= 0) {
            path = pathSegments[i];
        } else if (!resolvedDevice) {
            if (globalThis.Deno == null) {
                throw new TypeError("Resolved a drive-letter-less path without a CWD.");
            }
            path = Deno.cwd();
        } else {
            if (globalThis.Deno == null) {
                throw new TypeError("Resolved a relative path without a CWD.");
            }
            // Windows has the concept of drive-specific current working
            // directories. If we've resolved a drive letter but not yet an
            // absolute path, get cwd for that drive, or the process cwd if
            // the drive cwd is not available. We're sure the device is not
            // a UNC path at this points, because UNC paths are always absolute.
            path = Deno.env.get(`=${resolvedDevice}`) || Deno.cwd();
            // Verify that a cwd was found and that it actually points
            // to our drive. If not, default to the drive's root.
            if (path === undefined || path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) {
                path = `${resolvedDevice}\\`;
            }
        }
        assertPath(path);
        const len = path.length;
        // Skip empty entries
        if (len === 0) continue;
        let rootEnd = 0;
        let device = "";
        let isAbsolute = false;
        const code = path.charCodeAt(0);
        // Try to match a root
        if (len > 1) {
            if (isPathSeparator(code)) {
                // Possible UNC root
                // If we started with a separator, we know we at least have an
                // absolute path of some kind (UNC or otherwise)
                isAbsolute = true;
                if (isPathSeparator(path.charCodeAt(1))) {
                    // Matched double path separator at beginning
                    let j = 2;
                    let last = j;
                    // Match 1 or more non-path separators
                    for(; j < len; ++j){
                        if (isPathSeparator(path.charCodeAt(j))) break;
                    }
                    if (j < len && j !== last) {
                        const firstPart = path.slice(last, j);
                        // Matched!
                        last = j;
                        // Match 1 or more path separators
                        for(; j < len; ++j){
                            if (!isPathSeparator(path.charCodeAt(j))) break;
                        }
                        if (j < len && j !== last) {
                            // Matched!
                            last = j;
                            // Match 1 or more non-path separators
                            for(; j < len; ++j){
                                if (isPathSeparator(path.charCodeAt(j))) break;
                            }
                            if (j === len) {
                                // We matched a UNC root only
                                device = `\\\\${firstPart}\\${path.slice(last)}`;
                                rootEnd = j;
                            } else if (j !== last) {
                                // We matched a UNC root with leftovers
                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
                                rootEnd = j;
                            }
                        }
                    }
                } else {
                    rootEnd = 1;
                }
            } else if (isWindowsDeviceRoot(code)) {
                // Possible device root
                if (path.charCodeAt(1) === CHAR_COLON) {
                    device = path.slice(0, 2);
                    rootEnd = 2;
                    if (len > 2) {
                        if (isPathSeparator(path.charCodeAt(2))) {
                            // Treat separator following drive name as an absolute path
                            // indicator
                            isAbsolute = true;
                            rootEnd = 3;
                        }
                    }
                }
            }
        } else if (isPathSeparator(code)) {
            // `path` contains just a path separator
            rootEnd = 1;
            isAbsolute = true;
        }
        if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) {
            continue;
        }
        if (resolvedDevice.length === 0 && device.length > 0) {
            resolvedDevice = device;
        }
        if (!resolvedAbsolute) {
            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
            resolvedAbsolute = isAbsolute;
        }
        if (resolvedAbsolute && resolvedDevice.length > 0) break;
    }
    // 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 tail path
    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
    return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
}
/**
 * Normalizes a `path`
 * @param path to normalize
 */ export function normalize(path) {
    assertPath(path);
    const len = path.length;
    if (len === 0) return ".";
    let rootEnd = 0;
    let device;
    let isAbsolute = false;
    const code = path.charCodeAt(0);
    // Try to match a root
    if (len > 1) {
        if (isPathSeparator(code)) {
            // Possible UNC root
            // If we started with a separator, we know we at least have an absolute
            // path of some kind (UNC or otherwise)
            isAbsolute = true;
            if (isPathSeparator(path.charCodeAt(1))) {
                // Matched double path separator at beginning
                let j = 2;
                let last = j;
                // Match 1 or more non-path separators
                for(; j < len; ++j){
                    if (isPathSeparator(path.charCodeAt(j))) break;
                }
                if (j < len && j !== last) {
                    const firstPart = path.slice(last, j);
                    // Matched!
                    last = j;
                    // Match 1 or more path separators
                    for(; j < len; ++j){
                        if (!isPathSeparator(path.charCodeAt(j))) break;
                    }
                    if (j < len && j !== last) {
                        // Matched!
                        last = j;
                        // Match 1 or more non-path separators
                        for(; j < len; ++j){
                            if (isPathSeparator(path.charCodeAt(j))) break;
                        }
                        if (j === len) {
                            // We matched a UNC root only
                            // Return the normalized version of the UNC root since there
                            // is nothing left to process
                            return `\\\\${firstPart}\\${path.slice(last)}\\`;
                        } else if (j !== last) {
                            // We matched a UNC root with leftovers
                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
                            rootEnd = j;
                        }
                    }
                }
            } else {
                rootEnd = 1;
            }
        } else if (isWindowsDeviceRoot(code)) {
            // Possible device root
            if (path.charCodeAt(1) === CHAR_COLON) {
                device = path.slice(0, 2);
                rootEnd = 2;
                if (len > 2) {
                    if (isPathSeparator(path.charCodeAt(2))) {
                        // Treat separator following drive name as an absolute path
                        // indicator
                        isAbsolute = true;
                        rootEnd = 3;
                    }
                }
            }
        }
    } else if (isPathSeparator(code)) {
        // `path` contains just a path separator, exit early to avoid unnecessary
        // work
        return "\\";
    }
    let tail;
    if (rootEnd < len) {
        tail = normalizeString(path.slice(rootEnd), !isAbsolute, "\\", isPathSeparator);
    } else {
        tail = "";
    }
    if (tail.length === 0 && !isAbsolute) tail = ".";
    if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {
        tail += "\\";
    }
    if (device === undefined) {
        if (isAbsolute) {
            if (tail.length > 0) return `\\${tail}`;
            else return "\\";
        } else if (tail.length > 0) {
            return tail;
        } else {
            return "";
        }
    } else if (isAbsolute) {
        if (tail.length > 0) return `${device}\\${tail}`;
        else return `${device}\\`;
    } else if (tail.length > 0) {
        return device + tail;
    } else {
        return device;
    }
}
/**
 * Verifies whether path is absolute
 * @param path to verify
 */ export function isAbsolute(path) {
    assertPath(path);
    const len = path.length;
    if (len === 0) return false;
    const code = path.charCodeAt(0);
    if (isPathSeparator(code)) {
        return true;
    } else if (isWindowsDeviceRoot(code)) {
        // Possible device root
        if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {
            if (isPathSeparator(path.charCodeAt(2))) return true;
        }
    }
    return false;
}
/**
 * Join all given a sequence of `paths`,then normalizes the resulting path.
 * @param paths to be joined and normalized
 */ export function join(...paths) {
    const pathsCount = paths.length;
    if (pathsCount === 0) return ".";
    let joined;
    let firstPart = null;
    for(let i = 0; i < pathsCount; ++i){
        const path = paths[i];
        assertPath(path);
        if (path.length > 0) {
            if (joined === undefined) joined = firstPart = path;
            else joined += `\\${path}`;
        }
    }
    if (joined === undefined) return ".";
    // Make sure that the joined path doesn't start with two slashes, because
    // normalize() will mistake it for an UNC path then.
    //
    // This step is skipped when it is very clear that the user actually
    // intended to point at an UNC path. This is assumed when the first
    // non-empty string arguments starts with exactly two slashes followed by
    // at least one more non-slash character.
    //
    // Note that for normalize() to treat a path as an UNC path it needs to
    // have at least 2 components, so we don't filter for that here.
    // This means that the user can use join to construct UNC paths from
    // a server name and a share name; for example:
    //   path.join('//server', 'share') -> '\\\\server\\share\\')
    let needsReplace = true;
    let slashCount = 0;
    assert(firstPart != null);
    if (isPathSeparator(firstPart.charCodeAt(0))) {
        ++slashCount;
        const firstLen = firstPart.length;
        if (firstLen > 1) {
            if (isPathSeparator(firstPart.charCodeAt(1))) {
                ++slashCount;
                if (firstLen > 2) {
                    if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;
                    else {
                        // We matched a UNC path in the first part
                        needsReplace = false;
                    }
                }
            }
        }
    }
    if (needsReplace) {
        // Find any more consecutive slashes we need to replace
        for(; slashCount < joined.length; ++slashCount){
            if (!isPathSeparator(joined.charCodeAt(slashCount))) break;
        }
        // Replace the slashes if needed
        if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
    }
    return normalize(joined);
}
/**
 * It will solve the relative path from `from` to `to`, for instance:
 *  from = 'C:\\orandea\\test\\aaa'
 *  to = 'C:\\orandea\\impl\\bbb'
 * The output of the function should be: '..\\..\\impl\\bbb'
 * @param from relative path
 * @param to relative path
 */ export function relative(from, to) {
    assertPath(from);
    assertPath(to);
    if (from === to) return "";
    const fromOrig = resolve(from);
    const toOrig = resolve(to);
    if (fromOrig === toOrig) return "";
    from = fromOrig.toLowerCase();
    to = toOrig.toLowerCase();
    if (from === to) return "";
    // Trim any leading backslashes
    let fromStart = 0;
    let fromEnd = from.length;
    for(; fromStart < fromEnd; ++fromStart){
        if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;
    }
    // Trim trailing backslashes (applicable to UNC paths only)
    for(; fromEnd - 1 > fromStart; --fromEnd){
        if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;
    }
    const fromLen = fromEnd - fromStart;
    // Trim any leading backslashes
    let toStart = 0;
    let toEnd = to.length;
    for(; toStart < toEnd; ++toStart){
        if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;
    }
    // Trim trailing backslashes (applicable to UNC paths only)
    for(; toEnd - 1 > toStart; --toEnd){
        if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_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_BACKWARD_SLASH) {
                    // We get here if `from` is the exact base path for `to`.
                    // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
                    return toOrig.slice(toStart + i + 1);
                } else if (i === 2) {
                    // We get here if `from` is the device root.
                    // For example: from='C:\\'; to='C:\\foo'
                    return toOrig.slice(toStart + i);
                }
            }
            if (fromLen > length) {
                if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
                    // We get here if `to` is the exact base path for `from`.
                    // For example: from='C:\\foo\\bar'; to='C:\\foo'
                    lastCommonSep = i;
                } else if (i === 2) {
                    // We get here if `to` is the device root.
                    // For example: from='C:\\foo\\bar'; to='C:\\'
                    lastCommonSep = 3;
                }
            }
            break;
        }
        const fromCode = from.charCodeAt(fromStart + i);
        const toCode = to.charCodeAt(toStart + i);
        if (fromCode !== toCode) break;
        else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;
    }
    // We found a mismatch before the first common path separator was seen, so
    // return the original `to`.
    if (i !== length && lastCommonSep === -1) {
        return toOrig;
    }
    let out = "";
    if (lastCommonSep === -1) lastCommonSep = 0;
    // 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_BACKWARD_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 + toOrig.slice(toStart + lastCommonSep, toEnd);
    } else {
        toStart += lastCommonSep;
        if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;
        return toOrig.slice(toStart, toEnd);
    }
}
/**
 * Resolves path to a namespace path
 * @param path to resolve to namespace
 */ export function toNamespacedPath(path) {
    // Note: this will *probably* throw somewhere.
    if (typeof path !== "string") return path;
    if (path.length === 0) return "";
    const resolvedPath = resolve(path);
    if (resolvedPath.length >= 3) {
        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
            // Possible UNC root
            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
                const code = resolvedPath.charCodeAt(2);
                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
                    // Matched non-long UNC root, convert the path to a long UNC path
                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
                }
            }
        } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
            // Possible device root
            if (resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
                // Matched device root, convert the path to a long UNC path
                return `\\\\?\\${resolvedPath}`;
            }
        }
    }
    return path;
}
/**
 * Return the directory name of a `path`.
 * @param path to determine name for
 */ export function dirname(path) {
    assertPath(path);
    const len = path.length;
    if (len === 0) return ".";
    let rootEnd = -1;
    let end = -1;
    let matchedSlash = true;
    let offset = 0;
    const code = path.charCodeAt(0);
    // Try to match a root
    if (len > 1) {
        if (isPathSeparator(code)) {
            // Possible UNC root
            rootEnd = offset = 1;
            if (isPathSeparator(path.charCodeAt(1))) {
                // Matched double path separator at beginning
                let j = 2;
                let last = j;
                // Match 1 or more non-path separators
                for(; j < len; ++j){
                    if (isPathSeparator(path.charCodeAt(j))) break;
                }
                if (j < len && j !== last) {
                    // Matched!
                    last = j;
                    // Match 1 or more path separators
                    for(; j < len; ++j){
                        if (!isPathSeparator(path.charCodeAt(j))) break;
                    }
                    if (j < len && j !== last) {
                        // Matched!
                        last = j;
                        // Match 1 or more non-path separators
                        for(; j < len; ++j){
                            if (isPathSeparator(path.charCodeAt(j))) break;
                        }
                        if (j === len) {
                            // We matched a UNC root only
                            return path;
                        }
                        if (j !== last) {
                            // We matched a UNC root with leftovers
                            // Offset by 1 to include the separator after the UNC root to
                            // treat it as a "normal root" on top of a (UNC) root
                            rootEnd = offset = j + 1;
                        }
                    }
                }
            }
        } else if (isWindowsDeviceRoot(code)) {
            // Possible device root
            if (path.charCodeAt(1) === CHAR_COLON) {
                rootEnd = offset = 2;
                if (len > 2) {
                    if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;
                }
            }
        }
    } else if (isPathSeparator(code)) {
        // `path` contains just a path separator, exit early to avoid
        // unnecessary work
        return path;
    }
    for(let i = len - 1; i >= offset; --i){
        if (isPathSeparator(path.charCodeAt(i))) {
            if (!matchedSlash) {
                end = i;
                break;
            }
        } else {
            // We saw the first non-path separator
            matchedSlash = false;
        }
    }
    if (end === -1) {
        if (rootEnd === -1) return ".";
        else end = rootEnd;
    }
    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;
    // Check for a drive letter prefix so as not to mistake the following
    // path separator as an extra separator at the end of the path that can be
    // disregarded
    if (path.length >= 2) {
        const drive = path.charCodeAt(0);
        if (isWindowsDeviceRoot(drive)) {
            if (path.charCodeAt(1) === CHAR_COLON) start = 2;
        }
    }
    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 >= start; --i){
            const code = path.charCodeAt(i);
            if (isPathSeparator(code)) {
                // 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 >= start; --i){
            if (isPathSeparator(path.charCodeAt(i))) {
                // 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 start = 0;
    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;
    // Check for a drive letter prefix so as not to mistake the following
    // path separator as an extra separator at the end of the path that can be
    // disregarded
    if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) {
        start = startPart = 2;
    }
    for(let i = path.length - 1; i >= start; --i){
        const code = path.charCodeAt(i);
        if (isPathSeparator(code)) {
            // 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: ""
    };
    const len = path.length;
    if (len === 0) return ret;
    let rootEnd = 0;
    let code = path.charCodeAt(0);
    // Try to match a root
    if (len > 1) {
        if (isPathSeparator(code)) {
            // Possible UNC root
            rootEnd = 1;
            if (isPathSeparator(path.charCodeAt(1))) {
                // Matched double path separator at beginning
                let j = 2;
                let last = j;
                // Match 1 or more non-path separators
                for(; j < len; ++j){
                    if (isPathSeparator(path.charCodeAt(j))) break;
                }
                if (j < len && j !== last) {
                    // Matched!
                    last = j;
                    // Match 1 or more path separators
                    for(; j < len; ++j){
                        if (!isPathSeparator(path.charCodeAt(j))) break;
                    }
                    if (j < len && j !== last) {
                        // Matched!
                        last = j;
                        // Match 1 or more non-path separators
                        for(; j < len; ++j){
                            if (isPathSeparator(path.charCodeAt(j))) break;
                        }
                        if (j === len) {
                            // We matched a UNC root only
                            rootEnd = j;
                        } else if (j !== last) {
                            // We matched a UNC root with leftovers
                            rootEnd = j + 1;
                        }
                    }
                }
            }
        } else if (isWindowsDeviceRoot(code)) {
            // Possible device root
            if (path.charCodeAt(1) === CHAR_COLON) {
                rootEnd = 2;
                if (len > 2) {
                    if (isPathSeparator(path.charCodeAt(2))) {
                        if (len === 3) {
                            // `path` contains just a drive root, exit early to avoid
                            // unnecessary work
                            ret.root = ret.dir = path;
                            return ret;
                        }
                        rootEnd = 3;
                    }
                } else {
                    // `path` contains just a drive root, exit early to avoid
                    // unnecessary work
                    ret.root = ret.dir = path;
                    return ret;
                }
            }
        }
    } else if (isPathSeparator(code)) {
        // `path` contains just a path separator, exit early to avoid
        // unnecessary work
        ret.root = ret.dir = path;
        return ret;
    }
    if (rootEnd > 0) ret.root = path.slice(0, rootEnd);
    let startDot = -1;
    let startPart = rootEnd;
    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 >= rootEnd; --i){
        code = path.charCodeAt(i);
        if (isPathSeparator(code)) {
            // 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) {
            ret.base = ret.name = path.slice(startPart, end);
        }
    } else {
        ret.name = path.slice(startPart, startDot);
        ret.base = path.slice(startPart, end);
        ret.ext = path.slice(startDot, end);
    }
    // If the directory is the root, use the entire root as the `dir` including
    // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
    // trailing slash (`C:\abc\def` -> `C:\abc`).
    if (startPart > 0 && startPart !== rootEnd) {
        ret.dir = path.slice(0, startPart - 1);
    } else ret.dir = ret.root;
    return ret;
}
/**
 * Converts a file URL to a path string.
 *
 *      fromFileUrl("file:///home/foo"); // "\\home\\foo"
 *      fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
 *      fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\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.");
    }
    let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
    if (url.hostname != "") {
        // Note: The `URL` implementation guarantees that the drive letter and
        // hostname are mutually exclusive. Otherwise it would not have been valid
        // to append the hostname and path like this.
        path = `\\\\${url.hostname}${path}`;
    }
    return path;
}
/**
 * Converts a path string to a file URL.
 *
 *      toFileUrl("\\home\\foo"); // new URL("file:///home/foo")
 *      toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo")
 *      toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/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 [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
    const url = new URL("file:///");
    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
    if (hostname != null && hostname != "localhost") {
        url.hostname = hostname;
        if (!url.hostname) {
            throw new TypeError("Invalid hostname.");
        }
    }
    return url;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.92.0/path/win32.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 {\n  CHAR_BACKWARD_SLASH,\n  CHAR_COLON,\n  CHAR_DOT,\n  CHAR_QUESTION_MARK,\n} from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPathSeparator,\n  isWindowsDeviceRoot,\n  normalizeString,\n} from \"./_util.ts\";\nimport { assert } from \"../_util/assert.ts\";\n\nexport const sep = \"\\\\\";\nexport const delimiter = \";\";\n\n/**\n * Resolves path segments into a `path`\n * @param pathSegments to process to path\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedDevice = \"\";\n  let resolvedTail = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1; i--) {\n    let path: string;\n    if (i >= 0) {\n      path = pathSegments[i];\n    } else if (!resolvedDevice) {\n      if (globalThis.Deno == null) {\n        throw new TypeError(\"Resolved a drive-letter-less path without a CWD.\");\n      }\n      path = Deno.cwd();\n    } else {\n      if (globalThis.Deno == null) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      // Windows has the concept of drive-specific current working\n      // directories. If we've resolved a drive letter but not yet an\n      // absolute path, get cwd for that drive, or the process cwd if\n      // the drive cwd is not available. We're sure the device is not\n      // a UNC path at this points, because UNC paths are always absolute.\n      path = Deno.env.get(`=${resolvedDevice}`) || Deno.cwd();\n\n      // Verify that a cwd was found and that it actually points\n      // to our drive. If not, default to the drive's root.\n      if (\n        path === undefined ||\n        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\\\`\n      ) {\n        path = `${resolvedDevice}\\\\`;\n      }\n    }\n\n    assertPath(path);\n\n    const len = path.length;\n\n    // Skip empty entries\n    if (len === 0) continue;\n\n    let rootEnd = 0;\n    let device = \"\";\n    let isAbsolute = false;\n    const code = path.charCodeAt(0);\n\n    // Try to match a root\n    if (len > 1) {\n      if (isPathSeparator(code)) {\n        // Possible UNC root\n\n        // If we started with a separator, we know we at least have an\n        // absolute path of some kind (UNC or otherwise)\n        isAbsolute = true;\n\n        if (isPathSeparator(path.charCodeAt(1))) {\n          // Matched double path separator at beginning\n          let j = 2;\n          let last = j;\n          // Match 1 or more non-path separators\n          for (; j < len; ++j) {\n            if (isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            const firstPart = path.slice(last, j);\n            // Matched!\n            last = j;\n            // Match 1 or more path separators\n            for (; j < len; ++j) {\n              if (!isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j < len && j !== last) {\n              // Matched!\n              last = j;\n              // Match 1 or more non-path separators\n              for (; j < len; ++j) {\n                if (isPathSeparator(path.charCodeAt(j))) break;\n              }\n              if (j === len) {\n                // We matched a UNC root only\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last)}`;\n                rootEnd = j;\n              } else if (j !== last) {\n                // We matched a UNC root with leftovers\n\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                rootEnd = j;\n              }\n            }\n          }\n        } else {\n          rootEnd = 1;\n        }\n      } else if (isWindowsDeviceRoot(code)) {\n        // Possible device root\n\n        if (path.charCodeAt(1) === CHAR_COLON) {\n          device = path.slice(0, 2);\n          rootEnd = 2;\n          if (len > 2) {\n            if (isPathSeparator(path.charCodeAt(2))) {\n              // Treat separator following drive name as an absolute path\n              // indicator\n              isAbsolute = true;\n              rootEnd = 3;\n            }\n          }\n        }\n      }\n    } else if (isPathSeparator(code)) {\n      // `path` contains just a path separator\n      rootEnd = 1;\n      isAbsolute = true;\n    }\n\n    if (\n      device.length > 0 &&\n      resolvedDevice.length > 0 &&\n      device.toLowerCase() !== resolvedDevice.toLowerCase()\n    ) {\n      // This path points to another device so it is not applicable\n      continue;\n    }\n\n    if (resolvedDevice.length === 0 && device.length > 0) {\n      resolvedDevice = device;\n    }\n    if (!resolvedAbsolute) {\n      resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n      resolvedAbsolute = isAbsolute;\n    }\n\n    if (resolvedAbsolute && resolvedDevice.length > 0) break;\n  }\n\n  // At this point the path should be resolved to a full absolute path,\n  // but handle relative paths to be safe (might happen when process.cwd()\n  // fails)\n\n  // Normalize the tail path\n  resolvedTail = normalizeString(\n    resolvedTail,\n    !resolvedAbsolute,\n    \"\\\\\",\n    isPathSeparator,\n  );\n\n  return resolvedDevice + (resolvedAbsolute ? \"\\\\\" : \"\") + resolvedTail || \".\";\n}\n\n/**\n * Normalizes a `path`\n * @param path to normalize\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = 0;\n  let device: string | undefined;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n\n  let tail: string;\n  if (rootEnd < len) {\n    tail = normalizeString(\n      path.slice(rootEnd),\n      !isAbsolute,\n      \"\\\\\",\n      isPathSeparator,\n    );\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    } else if (tail.length > 0) {\n      return tail;\n    } else {\n      return \"\";\n    }\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  } else if (tail.length > 0) {\n    return device + tail;\n  } else {\n    return device;\n  }\n}\n\n/**\n * Verifies whether path is absolute\n * @param path to verify\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return false;\n\n  const code = path.charCodeAt(0);\n  if (isPathSeparator(code)) {\n    return true;\n  } else if (isWindowsDeviceRoot(code)) {\n    // Possible device root\n\n    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {\n      if (isPathSeparator(path.charCodeAt(2))) return true;\n    }\n  }\n  return false;\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  const pathsCount = paths.length;\n  if (pathsCount === 0) return \".\";\n\n  let joined: string | undefined;\n  let firstPart: string | null = null;\n  for (let i = 0; i < pathsCount; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (joined === undefined) joined = firstPart = path;\n      else joined += `\\\\${path}`;\n    }\n  }\n\n  if (joined === undefined) return \".\";\n\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n  let needsReplace = true;\n  let slashCount = 0;\n  assert(firstPart != null);\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for (; slashCount < joined.length; ++slashCount) {\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n\n  return normalize(joined);\n}\n\n/**\n * It will solve the relative path from `from` to `to`, for instance:\n *  from = 'C:\\\\orandea\\\\test\\\\aaa'\n *  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n * The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n * @param from relative path\n * @param to relative path\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  const fromOrig = resolve(from);\n  const toOrig = resolve(to);\n\n  if (fromOrig === toOrig) return \"\";\n\n  from = fromOrig.toLowerCase();\n  to = toOrig.toLowerCase();\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 0;\n  let fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; fromEnd - 1 > fromStart; --fromEnd) {\n    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 0;\n  let toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; toEnd - 1 > toStart; --toEnd) {\n    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_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_BACKWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n          return toOrig.slice(toStart + i + 1);\n        } else if (i === 2) {\n          // We get here if `from` is the device root.\n          // For example: from='C:\\\\'; to='C:\\\\foo'\n          return toOrig.slice(toStart + i);\n        }\n      }\n      if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n          lastCommonSep = i;\n        } else if (i === 2) {\n          // We get here if `to` is the device root.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n          lastCommonSep = 3;\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_BACKWARD_SLASH) lastCommonSep = i;\n  }\n\n  // We found a mismatch before the first common path separator was seen, so\n  // return the original `to`.\n  if (i !== length && lastCommonSep === -1) {\n    return toOrig;\n  }\n\n  let out = \"\";\n  if (lastCommonSep === -1) lastCommonSep = 0;\n  // Generate the relative path based on the path difference between `to` and\n  // `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_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) {\n    return out + toOrig.slice(toStart + lastCommonSep, toEnd);\n  } else {\n    toStart += lastCommonSep;\n    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;\n    return toOrig.slice(toStart, toEnd);\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  // Note: this will *probably* throw somewhere.\n  if (typeof path !== \"string\") return path;\n  if (path.length === 0) return \"\";\n\n  const resolvedPath = resolve(path);\n\n  if (resolvedPath.length >= 3) {\n    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n      // Possible UNC root\n\n      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n        const code = resolvedPath.charCodeAt(2);\n        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n          // Matched non-long UNC root, convert the path to a long UNC path\n          return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n        }\n      }\n    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {\n      // Possible device root\n\n      if (\n        resolvedPath.charCodeAt(1) === CHAR_COLON &&\n        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH\n      ) {\n        // Matched device root, convert the path to a long UNC path\n        return `\\\\\\\\?\\\\${resolvedPath}`;\n      }\n    }\n  }\n\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  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = -1;\n  let end = -1;\n  let matchedSlash = true;\n  let offset = 0;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = offset = 1;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              return path;\n            }\n            if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              // Offset by 1 to include the separator after the UNC root to\n              // treat it as a \"normal root\" on top of a (UNC) root\n              rootEnd = offset = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = offset = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    return path;\n  }\n\n  for (let i = len - 1; i >= offset; --i) {\n    if (isPathSeparator(path.charCodeAt(i))) {\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) {\n    if (rootEnd === -1) return \".\";\n    else end = rootEnd;\n  }\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\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n  if (path.length >= 2) {\n    const drive = path.charCodeAt(0);\n    if (isWindowsDeviceRoot(drive)) {\n      if (path.charCodeAt(1) === CHAR_COLON) start = 2;\n    }\n  }\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 >= start; --i) {\n      const code = path.charCodeAt(i);\n      if (isPathSeparator(code)) {\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 >= start; --i) {\n      if (isPathSeparator(path.charCodeAt(i))) {\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 start = 0;\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\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n\n  if (\n    path.length >= 2 &&\n    path.charCodeAt(1) === CHAR_COLON &&\n    isWindowsDeviceRoot(path.charCodeAt(0))\n  ) {\n    start = startPart = 2;\n  }\n\n  for (let i = path.length - 1; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\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\n  const len = path.length;\n  if (len === 0) return ret;\n\n  let rootEnd = 0;\n  let code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = 1;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n\n              rootEnd = j;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              rootEnd = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            if (len === 3) {\n              // `path` contains just a drive root, exit early to avoid\n              // unnecessary work\n              ret.root = ret.dir = path;\n              return ret;\n            }\n            rootEnd = 3;\n          }\n        } else {\n          // `path` contains just a drive root, exit early to avoid\n          // unnecessary work\n          ret.root = ret.dir = path;\n          return ret;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    ret.root = ret.dir = path;\n    return ret;\n  }\n\n  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);\n\n  let startDot = -1;\n  let startPart = rootEnd;\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 >= rootEnd; --i) {\n    code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\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      ret.base = ret.name = path.slice(startPart, end);\n    }\n  } else {\n    ret.name = path.slice(startPart, startDot);\n    ret.base = path.slice(startPart, end);\n    ret.ext = path.slice(startDot, end);\n  }\n\n  // If the directory is the root, use the entire root as the `dir` including\n  // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n  // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n  if (startPart > 0 && startPart !== rootEnd) {\n    ret.dir = path.slice(0, startPart - 1);\n  } else ret.dir = ret.root;\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 *      fromFileUrl(\"file:///C:/Users/foo\"); // \"C:\\\\Users\\\\foo\"\n *      fromFileUrl(\"file://localhost/home/foo\"); // \"\\\\\\\\localhost\\\\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  let path = decodeURIComponent(\n    url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  ).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname != \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n\n/**\n * Converts a path string to a file URL.\n *\n *      toFileUrl(\"\\\\home\\\\foo\"); // new URL(\"file:///home/foo\")\n *      toFileUrl(\"C:\\\\Users\\\\foo\"); // new URL(\"file:///C:/Users/foo\")\n *      toFileUrl(\"\\\\\\\\127.0.0.1\\\\home\\\\foo\"); // new URL(\"file://127.0.0.1/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 [, hostname, pathname] = path.match(\n    /^(?:[/\\\\]{2}([^/\\\\]+)(?=[/\\\\](?:[^/\\\\]|$)))?(.*)/,\n  )!;\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(pathname.replace(/%/g, \"%25\"));\n  if (hostname != null && hostname != \"localhost\") {\n    url.hostname = hostname;\n    if (!url.hostname) {\n      throw new TypeError(\"Invalid hostname.\");\n    }\n  }\n  return url;\n}\n"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,6DAA6D;AAC7D,qCAAqC;AAGrC,SACE,mBAAmB,EACnB,UAAU,EACV,QAAQ,EACR,kBAAkB,QACb,kBAAkB;AAEzB,SACE,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,eAAe,QACV,aAAa;AACpB,SAAS,MAAM,QAAQ,qBAAqB;AAE5C,OAAO,MAAM,MAAM,KAAK;AACxB,OAAO,MAAM,YAAY,IAAI;AAE7B;;;CAGC,GACD,OAAO,SAAS,QAAQ,GAAG,YAAsB,EAAU;IACzD,IAAI,iBAAiB;IACrB,IAAI,eAAe;IACnB,IAAI,mBAAmB,KAAK;IAE5B,IAAK,IAAI,IAAI,aAAa,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAK;QAClD,IAAI;QACJ,IAAI,KAAK,GAAG;YACV,OAAO,YAAY,CAAC,EAAE;QACxB,OAAO,IAAI,CAAC,gBAAgB;YAC1B,IAAI,WAAW,IAAI,IAAI,IAAI,EAAE;gBAC3B,MAAM,IAAI,UAAU,oDAAoD;YAC1E,CAAC;YACD,OAAO,KAAK,GAAG;QACjB,OAAO;YACL,IAAI,WAAW,IAAI,IAAI,IAAI,EAAE;gBAC3B,MAAM,IAAI,UAAU,2CAA2C;YACjE,CAAC;YACD,4DAA4D;YAC5D,+DAA+D;YAC/D,+DAA+D;YAC/D,+DAA+D;YAC/D,oEAAoE;YACpE,OAAO,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,KAAK,KAAK,GAAG;YAErD,0DAA0D;YAC1D,qDAAqD;YACrD,IACE,SAAS,aACT,KAAK,KAAK,CAAC,GAAG,GAAG,WAAW,OAAO,CAAC,EAAE,eAAe,WAAW,GAAG,EAAE,CAAC,EACtE;gBACA,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,WAAW;QAEX,MAAM,MAAM,KAAK,MAAM;QAEvB,qBAAqB;QACrB,IAAI,QAAQ,GAAG,QAAS;QAExB,IAAI,UAAU;QACd,IAAI,SAAS;QACb,IAAI,aAAa,KAAK;QACtB,MAAM,OAAO,KAAK,UAAU,CAAC;QAE7B,sBAAsB;QACtB,IAAI,MAAM,GAAG;YACX,IAAI,gBAAgB,OAAO;gBACzB,oBAAoB;gBAEpB,8DAA8D;gBAC9D,gDAAgD;gBAChD,aAAa,IAAI;gBAEjB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;oBACvC,6CAA6C;oBAC7C,IAAI,IAAI;oBACR,IAAI,OAAO;oBACX,sCAAsC;oBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;wBACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;oBACjD;oBACA,IAAI,IAAI,OAAO,MAAM,MAAM;wBACzB,MAAM,YAAY,KAAK,KAAK,CAAC,MAAM;wBACnC,WAAW;wBACX,OAAO;wBACP,kCAAkC;wBAClC,MAAO,IAAI,KAAK,EAAE,EAAG;4BACnB,IAAI,CAAC,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;wBAClD;wBACA,IAAI,IAAI,OAAO,MAAM,MAAM;4BACzB,WAAW;4BACX,OAAO;4BACP,sCAAsC;4BACtC,MAAO,IAAI,KAAK,EAAE,EAAG;gCACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;4BACjD;4BACA,IAAI,MAAM,KAAK;gCACb,6BAA6B;gCAC7B,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,KAAK,CAAC,MAAM,CAAC;gCAChD,UAAU;4BACZ,OAAO,IAAI,MAAM,MAAM;gCACrB,uCAAuC;gCAEvC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC;gCACnD,UAAU;4BACZ,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,OAAO;oBACL,UAAU;gBACZ,CAAC;YACH,OAAO,IAAI,oBAAoB,OAAO;gBACpC,uBAAuB;gBAEvB,IAAI,KAAK,UAAU,CAAC,OAAO,YAAY;oBACrC,SAAS,KAAK,KAAK,CAAC,GAAG;oBACvB,UAAU;oBACV,IAAI,MAAM,GAAG;wBACX,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;4BACvC,2DAA2D;4BAC3D,YAAY;4BACZ,aAAa,IAAI;4BACjB,UAAU;wBACZ,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,OAAO,IAAI,gBAAgB,OAAO;YAChC,wCAAwC;YACxC,UAAU;YACV,aAAa,IAAI;QACnB,CAAC;QAED,IACE,OAAO,MAAM,GAAG,KAChB,eAAe,MAAM,GAAG,KACxB,OAAO,WAAW,OAAO,eAAe,WAAW,IACnD;YAEA,QAAS;QACX,CAAC;QAED,IAAI,eAAe,MAAM,KAAK,KAAK,OAAO,MAAM,GAAG,GAAG;YACpD,iBAAiB;QACnB,CAAC;QACD,IAAI,CAAC,kBAAkB;YACrB,eAAe,CAAC,EAAE,KAAK,KAAK,CAAC,SAAS,EAAE,EAAE,aAAa,CAAC;YACxD,mBAAmB;QACrB,CAAC;QAED,IAAI,oBAAoB,eAAe,MAAM,GAAG,GAAG,KAAM;IAC3D;IAEA,qEAAqE;IACrE,wEAAwE;IACxE,SAAS;IAET,0BAA0B;IAC1B,eAAe,gBACb,cACA,CAAC,kBACD,MACA;IAGF,OAAO,iBAAiB,CAAC,mBAAmB,OAAO,EAAE,IAAI,gBAAgB;AAC3E,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,UAAU,IAAY,EAAU;IAC9C,WAAW;IACX,MAAM,MAAM,KAAK,MAAM;IACvB,IAAI,QAAQ,GAAG,OAAO;IACtB,IAAI,UAAU;IACd,IAAI;IACJ,IAAI,aAAa,KAAK;IACtB,MAAM,OAAO,KAAK,UAAU,CAAC;IAE7B,sBAAsB;IACtB,IAAI,MAAM,GAAG;QACX,IAAI,gBAAgB,OAAO;YACzB,oBAAoB;YAEpB,uEAAuE;YACvE,uCAAuC;YACvC,aAAa,IAAI;YAEjB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;gBACvC,6CAA6C;gBAC7C,IAAI,IAAI;gBACR,IAAI,OAAO;gBACX,sCAAsC;gBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;oBACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;gBACjD;gBACA,IAAI,IAAI,OAAO,MAAM,MAAM;oBACzB,MAAM,YAAY,KAAK,KAAK,CAAC,MAAM;oBACnC,WAAW;oBACX,OAAO;oBACP,kCAAkC;oBAClC,MAAO,IAAI,KAAK,EAAE,EAAG;wBACnB,IAAI,CAAC,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;oBAClD;oBACA,IAAI,IAAI,OAAO,MAAM,MAAM;wBACzB,WAAW;wBACX,OAAO;wBACP,sCAAsC;wBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;4BACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;wBACjD;wBACA,IAAI,MAAM,KAAK;4BACb,6BAA6B;4BAC7B,4DAA4D;4BAC5D,6BAA6B;4BAE7B,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;wBAClD,OAAO,IAAI,MAAM,MAAM;4BACrB,uCAAuC;4BAEvC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC;4BACnD,UAAU;wBACZ,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,OAAO;gBACL,UAAU;YACZ,CAAC;QACH,OAAO,IAAI,oBAAoB,OAAO;YACpC,uBAAuB;YAEvB,IAAI,KAAK,UAAU,CAAC,OAAO,YAAY;gBACrC,SAAS,KAAK,KAAK,CAAC,GAAG;gBACvB,UAAU;gBACV,IAAI,MAAM,GAAG;oBACX,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;wBACvC,2DAA2D;wBAC3D,YAAY;wBACZ,aAAa,IAAI;wBACjB,UAAU;oBACZ,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,OAAO,IAAI,gBAAgB,OAAO;QAChC,yEAAyE;QACzE,OAAO;QACP,OAAO;IACT,CAAC;IAED,IAAI;IACJ,IAAI,UAAU,KAAK;QACjB,OAAO,gBACL,KAAK,KAAK,CAAC,UACX,CAAC,YACD,MACA;IAEJ,OAAO;QACL,OAAO;IACT,CAAC;IACD,IAAI,KAAK,MAAM,KAAK,KAAK,CAAC,YAAY,OAAO;IAC7C,IAAI,KAAK,MAAM,GAAG,KAAK,gBAAgB,KAAK,UAAU,CAAC,MAAM,KAAK;QAChE,QAAQ;IACV,CAAC;IACD,IAAI,WAAW,WAAW;QACxB,IAAI,YAAY;YACd,IAAI,KAAK,MAAM,GAAG,GAAG,OAAO,CAAC,EAAE,EAAE,KAAK,CAAC;iBAClC,OAAO;QACd,OAAO,IAAI,KAAK,MAAM,GAAG,GAAG;YAC1B,OAAO;QACT,OAAO;YACL,OAAO;QACT,CAAC;IACH,OAAO,IAAI,YAAY;QACrB,IAAI,KAAK,MAAM,GAAG,GAAG,OAAO,CAAC,EAAE,OAAO,EAAE,EAAE,KAAK,CAAC;aAC3C,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;IAC3B,OAAO,IAAI,KAAK,MAAM,GAAG,GAAG;QAC1B,OAAO,SAAS;IAClB,OAAO;QACL,OAAO;IACT,CAAC;AACH,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,WAAW,IAAY,EAAW;IAChD,WAAW;IACX,MAAM,MAAM,KAAK,MAAM;IACvB,IAAI,QAAQ,GAAG,OAAO,KAAK;IAE3B,MAAM,OAAO,KAAK,UAAU,CAAC;IAC7B,IAAI,gBAAgB,OAAO;QACzB,OAAO,IAAI;IACb,OAAO,IAAI,oBAAoB,OAAO;QACpC,uBAAuB;QAEvB,IAAI,MAAM,KAAK,KAAK,UAAU,CAAC,OAAO,YAAY;YAChD,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,OAAO,IAAI;QACtD,CAAC;IACH,CAAC;IACD,OAAO,KAAK;AACd,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,KAAK,GAAG,KAAe,EAAU;IAC/C,MAAM,aAAa,MAAM,MAAM;IAC/B,IAAI,eAAe,GAAG,OAAO;IAE7B,IAAI;IACJ,IAAI,YAA2B,IAAI;IACnC,IAAK,IAAI,IAAI,GAAG,IAAI,YAAY,EAAE,EAAG;QACnC,MAAM,OAAO,KAAK,CAAC,EAAE;QACrB,WAAW;QACX,IAAI,KAAK,MAAM,GAAG,GAAG;YACnB,IAAI,WAAW,WAAW,SAAS,YAAY;iBAC1C,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC;QAC5B,CAAC;IACH;IAEA,IAAI,WAAW,WAAW,OAAO;IAEjC,yEAAyE;IACzE,oDAAoD;IACpD,EAAE;IACF,oEAAoE;IACpE,mEAAmE;IACnE,yEAAyE;IACzE,yCAAyC;IACzC,EAAE;IACF,uEAAuE;IACvE,gEAAgE;IAChE,oEAAoE;IACpE,+CAA+C;IAC/C,6DAA6D;IAC7D,IAAI,eAAe,IAAI;IACvB,IAAI,aAAa;IACjB,OAAO,aAAa,IAAI;IACxB,IAAI,gBAAgB,UAAU,UAAU,CAAC,KAAK;QAC5C,EAAE;QACF,MAAM,WAAW,UAAU,MAAM;QACjC,IAAI,WAAW,GAAG;YAChB,IAAI,gBAAgB,UAAU,UAAU,CAAC,KAAK;gBAC5C,EAAE;gBACF,IAAI,WAAW,GAAG;oBAChB,IAAI,gBAAgB,UAAU,UAAU,CAAC,KAAK,EAAE;yBAC3C;wBACH,0CAA0C;wBAC1C,eAAe,KAAK;oBACtB,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,IAAI,cAAc;QAChB,uDAAuD;QACvD,MAAO,aAAa,OAAO,MAAM,EAAE,EAAE,WAAY;YAC/C,IAAI,CAAC,gBAAgB,OAAO,UAAU,CAAC,cAAc,KAAM;QAC7D;QAEA,gCAAgC;QAChC,IAAI,cAAc,GAAG,SAAS,CAAC,EAAE,EAAE,OAAO,KAAK,CAAC,YAAY,CAAC;IAC/D,CAAC;IAED,OAAO,UAAU;AACnB,CAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAAS,SAAS,IAAY,EAAE,EAAU,EAAU;IACzD,WAAW;IACX,WAAW;IAEX,IAAI,SAAS,IAAI,OAAO;IAExB,MAAM,WAAW,QAAQ;IACzB,MAAM,SAAS,QAAQ;IAEvB,IAAI,aAAa,QAAQ,OAAO;IAEhC,OAAO,SAAS,WAAW;IAC3B,KAAK,OAAO,WAAW;IAEvB,IAAI,SAAS,IAAI,OAAO;IAExB,+BAA+B;IAC/B,IAAI,YAAY;IAChB,IAAI,UAAU,KAAK,MAAM;IACzB,MAAO,YAAY,SAAS,EAAE,UAAW;QACvC,IAAI,KAAK,UAAU,CAAC,eAAe,qBAAqB,KAAM;IAChE;IACA,2DAA2D;IAC3D,MAAO,UAAU,IAAI,WAAW,EAAE,QAAS;QACzC,IAAI,KAAK,UAAU,CAAC,UAAU,OAAO,qBAAqB,KAAM;IAClE;IACA,MAAM,UAAU,UAAU;IAE1B,+BAA+B;IAC/B,IAAI,UAAU;IACd,IAAI,QAAQ,GAAG,MAAM;IACrB,MAAO,UAAU,OAAO,EAAE,QAAS;QACjC,IAAI,GAAG,UAAU,CAAC,aAAa,qBAAqB,KAAM;IAC5D;IACA,2DAA2D;IAC3D,MAAO,QAAQ,IAAI,SAAS,EAAE,MAAO;QACnC,IAAI,GAAG,UAAU,CAAC,QAAQ,OAAO,qBAAqB,KAAM;IAC9D;IACA,MAAM,QAAQ,QAAQ;IAEtB,0DAA0D;IAC1D,MAAM,SAAS,UAAU,QAAQ,UAAU,KAAK;IAChD,IAAI,gBAAgB,CAAC;IACrB,IAAI,IAAI;IACR,MAAO,KAAK,QAAQ,EAAE,EAAG;QACvB,IAAI,MAAM,QAAQ;YAChB,IAAI,QAAQ,QAAQ;gBAClB,IAAI,GAAG,UAAU,CAAC,UAAU,OAAO,qBAAqB;oBACtD,yDAAyD;oBACzD,2DAA2D;oBAC3D,OAAO,OAAO,KAAK,CAAC,UAAU,IAAI;gBACpC,OAAO,IAAI,MAAM,GAAG;oBAClB,4CAA4C;oBAC5C,yCAAyC;oBACzC,OAAO,OAAO,KAAK,CAAC,UAAU;gBAChC,CAAC;YACH,CAAC;YACD,IAAI,UAAU,QAAQ;gBACpB,IAAI,KAAK,UAAU,CAAC,YAAY,OAAO,qBAAqB;oBAC1D,yDAAyD;oBACzD,iDAAiD;oBACjD,gBAAgB;gBAClB,OAAO,IAAI,MAAM,GAAG;oBAClB,0CAA0C;oBAC1C,8CAA8C;oBAC9C,gBAAgB;gBAClB,CAAC;YACH,CAAC;YACD,KAAM;QACR,CAAC;QACD,MAAM,WAAW,KAAK,UAAU,CAAC,YAAY;QAC7C,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU;QACvC,IAAI,aAAa,QAAQ,KAAM;aAC1B,IAAI,aAAa,qBAAqB,gBAAgB;IAC7D;IAEA,0EAA0E;IAC1E,4BAA4B;IAC5B,IAAI,MAAM,UAAU,kBAAkB,CAAC,GAAG;QACxC,OAAO;IACT,CAAC;IAED,IAAI,MAAM;IACV,IAAI,kBAAkB,CAAC,GAAG,gBAAgB;IAC1C,2EAA2E;IAC3E,SAAS;IACT,IAAK,IAAI,YAAY,gBAAgB,GAAG,KAAK,SAAS,EAAE,EAAG;QACzD,IAAI,MAAM,WAAW,KAAK,UAAU,CAAC,OAAO,qBAAqB;YAC/D,IAAI,IAAI,MAAM,KAAK,GAAG,OAAO;iBACxB,OAAO;QACd,CAAC;IACH;IAEA,0EAA0E;IAC1E,wBAAwB;IACxB,IAAI,IAAI,MAAM,GAAG,GAAG;QAClB,OAAO,MAAM,OAAO,KAAK,CAAC,UAAU,eAAe;IACrD,OAAO;QACL,WAAW;QACX,IAAI,OAAO,UAAU,CAAC,aAAa,qBAAqB,EAAE;QAC1D,OAAO,OAAO,KAAK,CAAC,SAAS;IAC/B,CAAC;AACH,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,iBAAiB,IAAY,EAAU;IACrD,8CAA8C;IAC9C,IAAI,OAAO,SAAS,UAAU,OAAO;IACrC,IAAI,KAAK,MAAM,KAAK,GAAG,OAAO;IAE9B,MAAM,eAAe,QAAQ;IAE7B,IAAI,aAAa,MAAM,IAAI,GAAG;QAC5B,IAAI,aAAa,UAAU,CAAC,OAAO,qBAAqB;YACtD,oBAAoB;YAEpB,IAAI,aAAa,UAAU,CAAC,OAAO,qBAAqB;gBACtD,MAAM,OAAO,aAAa,UAAU,CAAC;gBACrC,IAAI,SAAS,sBAAsB,SAAS,UAAU;oBACpD,iEAAiE;oBACjE,OAAO,CAAC,YAAY,EAAE,aAAa,KAAK,CAAC,GAAG,CAAC;gBAC/C,CAAC;YACH,CAAC;QACH,OAAO,IAAI,oBAAoB,aAAa,UAAU,CAAC,KAAK;YAC1D,uBAAuB;YAEvB,IACE,aAAa,UAAU,CAAC,OAAO,cAC/B,aAAa,UAAU,CAAC,OAAO,qBAC/B;gBACA,2DAA2D;gBAC3D,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC;YACjC,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO;AACT,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,QAAQ,IAAY,EAAU;IAC5C,WAAW;IACX,MAAM,MAAM,KAAK,MAAM;IACvB,IAAI,QAAQ,GAAG,OAAO;IACtB,IAAI,UAAU,CAAC;IACf,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAI,SAAS;IACb,MAAM,OAAO,KAAK,UAAU,CAAC;IAE7B,sBAAsB;IACtB,IAAI,MAAM,GAAG;QACX,IAAI,gBAAgB,OAAO;YACzB,oBAAoB;YAEpB,UAAU,SAAS;YAEnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;gBACvC,6CAA6C;gBAC7C,IAAI,IAAI;gBACR,IAAI,OAAO;gBACX,sCAAsC;gBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;oBACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;gBACjD;gBACA,IAAI,IAAI,OAAO,MAAM,MAAM;oBACzB,WAAW;oBACX,OAAO;oBACP,kCAAkC;oBAClC,MAAO,IAAI,KAAK,EAAE,EAAG;wBACnB,IAAI,CAAC,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;oBAClD;oBACA,IAAI,IAAI,OAAO,MAAM,MAAM;wBACzB,WAAW;wBACX,OAAO;wBACP,sCAAsC;wBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;4BACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;wBACjD;wBACA,IAAI,MAAM,KAAK;4BACb,6BAA6B;4BAC7B,OAAO;wBACT,CAAC;wBACD,IAAI,MAAM,MAAM;4BACd,uCAAuC;4BAEvC,6DAA6D;4BAC7D,qDAAqD;4BACrD,UAAU,SAAS,IAAI;wBACzB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,OAAO,IAAI,oBAAoB,OAAO;YACpC,uBAAuB;YAEvB,IAAI,KAAK,UAAU,CAAC,OAAO,YAAY;gBACrC,UAAU,SAAS;gBACnB,IAAI,MAAM,GAAG;oBACX,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,UAAU,SAAS;gBAC9D,CAAC;YACH,CAAC;QACH,CAAC;IACH,OAAO,IAAI,gBAAgB,OAAO;QAChC,6DAA6D;QAC7D,mBAAmB;QACnB,OAAO;IACT,CAAC;IAED,IAAK,IAAI,IAAI,MAAM,GAAG,KAAK,QAAQ,EAAE,EAAG;QACtC,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;YACvC,IAAI,CAAC,cAAc;gBACjB,MAAM;gBACN,KAAM;YACR,CAAC;QACH,OAAO;YACL,sCAAsC;YACtC,eAAe,KAAK;QACtB,CAAC;IACH;IAEA,IAAI,QAAQ,CAAC,GAAG;QACd,IAAI,YAAY,CAAC,GAAG,OAAO;aACtB,MAAM;IACb,CAAC;IACD,OAAO,KAAK,KAAK,CAAC,GAAG;AACvB,CAAC;AAED;;;;CAIC,GACD,OAAO,SAAS,SAAS,IAAY,EAAE,MAAM,EAAE,EAAU;IACvD,IAAI,QAAQ,aAAa,OAAO,QAAQ,UAAU;QAChD,MAAM,IAAI,UAAU,mCAAmC;IACzD,CAAC;IAED,WAAW;IAEX,IAAI,QAAQ;IACZ,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAI;IAEJ,qEAAqE;IACrE,0EAA0E;IAC1E,cAAc;IACd,IAAI,KAAK,MAAM,IAAI,GAAG;QACpB,MAAM,QAAQ,KAAK,UAAU,CAAC;QAC9B,IAAI,oBAAoB,QAAQ;YAC9B,IAAI,KAAK,UAAU,CAAC,OAAO,YAAY,QAAQ;QACjD,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,aAAa,IAAI,MAAM,GAAG,KAAK,IAAI,MAAM,IAAI,KAAK,MAAM,EAAE;QACpE,IAAI,IAAI,MAAM,KAAK,KAAK,MAAM,IAAI,QAAQ,MAAM,OAAO;QACvD,IAAI,SAAS,IAAI,MAAM,GAAG;QAC1B,IAAI,mBAAmB,CAAC;QACxB,IAAK,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,OAAO,EAAE,EAAG;YACzC,MAAM,OAAO,KAAK,UAAU,CAAC;YAC7B,IAAI,gBAAgB,OAAO;gBACzB,oEAAoE;gBACpE,gDAAgD;gBAChD,IAAI,CAAC,cAAc;oBACjB,QAAQ,IAAI;oBACZ,KAAM;gBACR,CAAC;YACH,OAAO;gBACL,IAAI,qBAAqB,CAAC,GAAG;oBAC3B,mEAAmE;oBACnE,mDAAmD;oBACnD,eAAe,KAAK;oBACpB,mBAAmB,IAAI;gBACzB,CAAC;gBACD,IAAI,UAAU,GAAG;oBACf,sCAAsC;oBACtC,IAAI,SAAS,IAAI,UAAU,CAAC,SAAS;wBACnC,IAAI,EAAE,WAAW,CAAC,GAAG;4BACnB,gEAAgE;4BAChE,YAAY;4BACZ,MAAM;wBACR,CAAC;oBACH,OAAO;wBACL,6DAA6D;wBAC7D,YAAY;wBACZ,SAAS,CAAC;wBACV,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC;QACH;QAEA,IAAI,UAAU,KAAK,MAAM;aACpB,IAAI,QAAQ,CAAC,GAAG,MAAM,KAAK,MAAM;QACtC,OAAO,KAAK,KAAK,CAAC,OAAO;IAC3B,OAAO;QACL,IAAK,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,OAAO,EAAE,EAAG;YACzC,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;gBACvC,oEAAoE;gBACpE,gDAAgD;gBAChD,IAAI,CAAC,cAAc;oBACjB,QAAQ,IAAI;oBACZ,KAAM;gBACR,CAAC;YACH,OAAO,IAAI,QAAQ,CAAC,GAAG;gBACrB,mEAAmE;gBACnE,iBAAiB;gBACjB,eAAe,KAAK;gBACpB,MAAM,IAAI;YACZ,CAAC;QACH;QAEA,IAAI,QAAQ,CAAC,GAAG,OAAO;QACvB,OAAO,KAAK,KAAK,CAAC,OAAO;IAC3B,CAAC;AACH,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,QAAQ,IAAY,EAAU;IAC5C,WAAW;IACX,IAAI,QAAQ;IACZ,IAAI,WAAW,CAAC;IAChB,IAAI,YAAY;IAChB,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,yEAAyE;IACzE,mCAAmC;IACnC,IAAI,cAAc;IAElB,qEAAqE;IACrE,0EAA0E;IAC1E,cAAc;IAEd,IACE,KAAK,MAAM,IAAI,KACf,KAAK,UAAU,CAAC,OAAO,cACvB,oBAAoB,KAAK,UAAU,CAAC,KACpC;QACA,QAAQ,YAAY;IACtB,CAAC;IAED,IAAK,IAAI,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,OAAO,EAAE,EAAG;QAC7C,MAAM,OAAO,KAAK,UAAU,CAAC;QAC7B,IAAI,gBAAgB,OAAO;YACzB,oEAAoE;YACpE,gDAAgD;YAChD,IAAI,CAAC,cAAc;gBACjB,YAAY,IAAI;gBAChB,KAAM;YACR,CAAC;YACD,QAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG;YACd,mEAAmE;YACnE,YAAY;YACZ,eAAe,KAAK;YACpB,MAAM,IAAI;QACZ,CAAC;QACD,IAAI,SAAS,UAAU;YACrB,kEAAkE;YAClE,IAAI,aAAa,CAAC,GAAG,WAAW;iBAC3B,IAAI,gBAAgB,GAAG,cAAc;QAC5C,OAAO,IAAI,aAAa,CAAC,GAAG;YAC1B,uEAAuE;YACvE,qDAAqD;YACrD,cAAc,CAAC;QACjB,CAAC;IACH;IAEA,IACE,aAAa,CAAC,KACd,QAAQ,CAAC,KACT,wDAAwD;IACxD,gBAAgB,KAChB,0DAA0D;IACzD,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GACvE;QACA,OAAO;IACT,CAAC;IACD,OAAO,KAAK,KAAK,CAAC,UAAU;AAC9B,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,OAAO,UAAiC,EAAU;IAChE,IAAI,eAAe,IAAI,IAAI,OAAO,eAAe,UAAU;QACzD,MAAM,IAAI,UACR,CAAC,gEAAgE,EAAE,OAAO,WAAW,CAAC,EACtF;IACJ,CAAC;IACD,OAAO,QAAQ,MAAM;AACvB,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,MAAM,IAAY,EAAc;IAC9C,WAAW;IAEX,MAAM,MAAkB;QAAE,MAAM;QAAI,KAAK;QAAI,MAAM;QAAI,KAAK;QAAI,MAAM;IAAG;IAEzE,MAAM,MAAM,KAAK,MAAM;IACvB,IAAI,QAAQ,GAAG,OAAO;IAEtB,IAAI,UAAU;IACd,IAAI,OAAO,KAAK,UAAU,CAAC;IAE3B,sBAAsB;IACtB,IAAI,MAAM,GAAG;QACX,IAAI,gBAAgB,OAAO;YACzB,oBAAoB;YAEpB,UAAU;YACV,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;gBACvC,6CAA6C;gBAC7C,IAAI,IAAI;gBACR,IAAI,OAAO;gBACX,sCAAsC;gBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;oBACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;gBACjD;gBACA,IAAI,IAAI,OAAO,MAAM,MAAM;oBACzB,WAAW;oBACX,OAAO;oBACP,kCAAkC;oBAClC,MAAO,IAAI,KAAK,EAAE,EAAG;wBACnB,IAAI,CAAC,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;oBAClD;oBACA,IAAI,IAAI,OAAO,MAAM,MAAM;wBACzB,WAAW;wBACX,OAAO;wBACP,sCAAsC;wBACtC,MAAO,IAAI,KAAK,EAAE,EAAG;4BACnB,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK,KAAM;wBACjD;wBACA,IAAI,MAAM,KAAK;4BACb,6BAA6B;4BAE7B,UAAU;wBACZ,OAAO,IAAI,MAAM,MAAM;4BACrB,uCAAuC;4BAEvC,UAAU,IAAI;wBAChB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,OAAO,IAAI,oBAAoB,OAAO;YACpC,uBAAuB;YAEvB,IAAI,KAAK,UAAU,CAAC,OAAO,YAAY;gBACrC,UAAU;gBACV,IAAI,MAAM,GAAG;oBACX,IAAI,gBAAgB,KAAK,UAAU,CAAC,KAAK;wBACvC,IAAI,QAAQ,GAAG;4BACb,yDAAyD;4BACzD,mBAAmB;4BACnB,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG;4BACrB,OAAO;wBACT,CAAC;wBACD,UAAU;oBACZ,CAAC;gBACH,OAAO;oBACL,yDAAyD;oBACzD,mBAAmB;oBACnB,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG;oBACrB,OAAO;gBACT,CAAC;YACH,CAAC;QACH,CAAC;IACH,OAAO,IAAI,gBAAgB,OAAO;QAChC,6DAA6D;QAC7D,mBAAmB;QACnB,IAAI,IAAI,GAAG,IAAI,GAAG,GAAG;QACrB,OAAO;IACT,CAAC;IAED,IAAI,UAAU,GAAG,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,GAAG;IAE1C,IAAI,WAAW,CAAC;IAChB,IAAI,YAAY;IAChB,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAI,IAAI,KAAK,MAAM,GAAG;IAEtB,yEAAyE;IACzE,mCAAmC;IACnC,IAAI,cAAc;IAElB,mBAAmB;IACnB,MAAO,KAAK,SAAS,EAAE,EAAG;QACxB,OAAO,KAAK,UAAU,CAAC;QACvB,IAAI,gBAAgB,OAAO;YACzB,oEAAoE;YACpE,gDAAgD;YAChD,IAAI,CAAC,cAAc;gBACjB,YAAY,IAAI;gBAChB,KAAM;YACR,CAAC;YACD,QAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG;YACd,mEAAmE;YACnE,YAAY;YACZ,eAAe,KAAK;YACpB,MAAM,IAAI;QACZ,CAAC;QACD,IAAI,SAAS,UAAU;YACrB,kEAAkE;YAClE,IAAI,aAAa,CAAC,GAAG,WAAW;iBAC3B,IAAI,gBAAgB,GAAG,cAAc;QAC5C,OAAO,IAAI,aAAa,CAAC,GAAG;YAC1B,uEAAuE;YACvE,qDAAqD;YACrD,cAAc,CAAC;QACjB,CAAC;IACH;IAEA,IACE,aAAa,CAAC,KACd,QAAQ,CAAC,KACT,wDAAwD;IACxD,gBAAgB,KAChB,0DAA0D;IACzD,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GACvE;QACA,IAAI,QAAQ,CAAC,GAAG;YACd,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;QAC9C,CAAC;IACH,OAAO;QACL,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;QACjC,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;QACjC,IAAI,GAAG,GAAG,KAAK,KAAK,CAAC,UAAU;IACjC,CAAC;IAED,2EAA2E;IAC3E,0EAA0E;IAC1E,6CAA6C;IAC7C,IAAI,YAAY,KAAK,cAAc,SAAS;QAC1C,IAAI,GAAG,GAAG,KAAK,KAAK,CAAC,GAAG,YAAY;IACtC,OAAO,IAAI,GAAG,GAAG,IAAI,IAAI;IAEzB,OAAO;AACT,CAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAAS,YAAY,GAAiB,EAAU;IACrD,MAAM,eAAe,MAAM,MAAM,IAAI,IAAI,IAAI;IAC7C,IAAI,IAAI,QAAQ,IAAI,SAAS;QAC3B,MAAM,IAAI,UAAU,uBAAuB;IAC7C,CAAC;IACD,IAAI,OAAO,mBACT,IAAI,QAAQ,CAAC,OAAO,CAAC,OAAO,MAAM,OAAO,CAAC,wBAAwB,QAClE,OAAO,CAAC,yBAAyB;IACnC,IAAI,IAAI,QAAQ,IAAI,IAAI;QACtB,sEAAsE;QACtE,0EAA0E;QAC1E,6CAA6C;QAC7C,OAAO,CAAC,IAAI,EAAE,IAAI,QAAQ,CAAC,EAAE,KAAK,CAAC;IACrC,CAAC;IACD,OAAO;AACT,CAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAAS,UAAU,IAAY,EAAO;IAC3C,IAAI,CAAC,WAAW,OAAO;QACrB,MAAM,IAAI,UAAU,6BAA6B;IACnD,CAAC;IACD,MAAM,GAAG,UAAU,SAAS,GAAG,KAAK,KAAK,CACvC;IAEF,MAAM,MAAM,IAAI,IAAI;IACpB,IAAI,QAAQ,GAAG,iBAAiB,SAAS,OAAO,CAAC,MAAM;IACvD,IAAI,YAAY,IAAI,IAAI,YAAY,aAAa;QAC/C,IAAI,QAAQ,GAAG;QACf,IAAI,CAAC,IAAI,QAAQ,EAAE;YACjB,MAAM,IAAI,UAAU,qBAAqB;QAC3C,CAAC;IACH,CAAC;IACD,OAAO;AACT,CAAC"}