{
  "version": 3,
  "sources": ["../src/index.ts"],
  "sourcesContent": ["// 'path' module extracted from Node.js v8.11.1 (only the posix part)\nimport type Path from 'node:path'\n\nexport const path:typeof Path = {\n    _makeLong: function _makeLong (path) {\n        return path\n    },\n\n    dirname,\n    basename,\n    extname,\n    parse,\n    resolve,\n    normalize,\n    join,\n    relative,\n    isAbsolute,\n\n    format: function format (pathObject) {\n        if (pathObject === null || typeof pathObject !== 'object') {\n            throw new TypeError('The \"pathObject\" argument must be of type' +\n                ' Object. Received type ' + typeof pathObject)\n        }\n        return _format('/', pathObject)\n    },\n\n    sep: '/',\n    delimiter: ':',\n    // @ts-expect-error skip this\n    win32: null,\n    // @ts-expect-error assigned below\n    posix: null\n}\n\n// @ts-expect-error read only error b/c node types\npath.posix = path\n\nfunction assertPath (path) {\n    if (typeof path !== 'string') {\n        throw new TypeError(\n            'Path must be a string. Received ' + JSON.stringify(path)\n        )\n    }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix (path, allowAboveRoot) {\n    let res = ''\n    let lastSegmentLength = 0\n    let lastSlash = -1\n    let dots = 0\n    let code\n    for (let i = 0; i <= path.length; ++i) {\n        if (i < path.length) { code = path.charCodeAt(i) } else if (code === 47 /* / */) { break } else { code = 47 } /* / */\n        if (code === 47 /* / */) {\n            if (lastSlash === i - 1 || dots === 1) {\n                // NOOP\n            } else if (lastSlash !== i - 1 && dots === 2) {\n                if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /* . */ || res.charCodeAt(res.length - 2) !== 46 /* . */) {\n                    if (res.length > 2) {\n                        const lastSlashIndex = res.lastIndexOf('/')\n                        if (lastSlashIndex !== res.length - 1) {\n                            if (lastSlashIndex === -1) {\n                                res = ''\n                                lastSegmentLength = 0\n                            } else {\n                                res = res.slice(0, lastSlashIndex)\n                                lastSegmentLength = res.length - 1 - res.lastIndexOf('/')\n                            }\n                            lastSlash = i\n                            dots = 0\n                            continue\n                        }\n                    } else if (res.length === 2 || res.length === 1) {\n                        res = ''\n                        lastSegmentLength = 0\n                        lastSlash = i\n                        dots = 0\n                        continue\n                    }\n                }\n                if (allowAboveRoot) {\n                    if (res.length > 0) { res += '/..' } else { res = '..' }\n                    lastSegmentLength = 2\n                }\n            } else {\n                if (res.length > 0) { res += '/' + path.slice(lastSlash + 1, i) } else { res = path.slice(lastSlash + 1, i) }\n                lastSegmentLength = i - lastSlash - 1\n            }\n            lastSlash = i\n            dots = 0\n        } else if (code === 46 /* . */ && dots !== -1) {\n            ++dots\n        } else {\n            dots = -1\n        }\n    }\n    return res\n}\n\nfunction _format (sep, pathObject) {\n    const dir = pathObject.dir || pathObject.root\n    const base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '')\n    if (!dir) {\n        return base\n    }\n    if (dir === pathObject.root) {\n        return dir + base\n    }\n    return dir + sep + base\n}\n\nexport default path\n\nexport function basename (path, ext?) {\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\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 === 47 /* / */) {\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; 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) === 47 /* / */) {\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\nexport function extname (path) {\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 === 47 /* / */) {\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 === 46 /* . */) {\n            // If this is our first dot, mark it as the start of our extension\n            if (startDot === -1) { startDot = i } 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 || 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        (\n            preDotState === 1 &&\n            startDot === end - 1 &&\n            startDot === startPart + 1\n        )\n    ) {\n        return ''\n    }\n\n    return path.slice(startDot, end)\n}\n\nexport function parse (path) {\n    assertPath(path)\n\n    const ret = { root: '', dir: '', base: '', ext: '', name: '' }\n    if (path.length === 0) return ret\n    let code = path.charCodeAt(0)\n    const isAbsolute = code === 47 /* / */\n    let start\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        code = path.charCodeAt(i)\n        if (code === 47 /* / */) {\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 === 46 /* . */) {\n            // If this is our first dot, mark it as the start of our extension\n            if (startDot === -1) startDot = i; 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 || 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        (\n            preDotState === 1 &&\n            startDot === end - 1 &&\n            startDot === startPart + 1\n        )\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); else if (isAbsolute) ret.dir = '/'\n\n    return ret\n}\n\nexport function dirname (path:string):string {\n    assertPath(path)\n    if (path.length === 0) return '.'\n    let code = path.charCodeAt(0)\n    const hasRoot = code === 47 /* / */\n    let end = -1\n    let matchedSlash = true\n    for (let i = path.length - 1; i >= 1; --i) {\n        code = path.charCodeAt(i)\n        if (code === 47 /* / */) {\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// path.resolve([from ...], to)\nexport function resolve (...args) {\n    let resolvedPath = ''\n    let resolvedAbsolute = false\n    let cwd\n\n    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        let path\n        if (i >= 0) {\n            path = args[i]\n        } else {\n            if (cwd === undefined) {\n                cwd = (process?.cwd() || '/')\n            }\n            path = 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) === 47 /* / */\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 = normalizeStringPosix(resolvedPath, !resolvedAbsolute)\n\n    if (resolvedAbsolute) {\n        if (resolvedPath.length > 0) { return '/' + resolvedPath } else { return '/' }\n    } else if (resolvedPath.length > 0) {\n        return resolvedPath\n    } else {\n        return '.'\n    }\n}\n\nexport function normalize (path:string):string {\n    assertPath(path)\n\n    if (path.length === 0) return '.'\n\n    const isAbsolute = path.charCodeAt(0) === 47 /* / */\n    const trailingSeparator = path.charCodeAt(path.length - 1) === 47 /* / */\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute)\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\nexport function isAbsolute (path:string):boolean {\n    assertPath(path)\n    return path.length > 0 && path.charCodeAt(0) === 47\n}\n\nexport function join (...args:string[]):string {\n    if (arguments.length === 0) { return '.' }\n    let joined\n    for (let i = 0; i < arguments.length; ++i) {\n        const arg = args[i]\n        assertPath(arg)\n        if (arg.length > 0) {\n            if (joined === undefined) {\n                joined = arg\n            } else {\n                joined += '/' + arg\n            }\n        }\n    }\n    if (joined === undefined) { return '.' }\n\n    return path.normalize(joined)\n}\n\nexport function relative (from:string, to:string):string {\n    assertPath(from)\n    assertPath(to)\n\n    if (from === to) return ''\n\n    from = path.resolve(from)\n    to = path.resolve(to)\n\n    if (from === to) return ''\n\n    // Trim any leading backslashes\n    let fromStart = 1\n    for (; fromStart < from.length; ++fromStart) {\n        if (from.charCodeAt(fromStart) !== 47 /* / */) { break }\n    }\n    const fromEnd = from.length\n    const fromLen = fromEnd - fromStart\n\n    // Trim any leading backslashes\n    let toStart = 1\n    for (; toStart < to.length; ++toStart) {\n        if (to.charCodeAt(toStart) !== 47 /* / */) { break }\n    }\n    const toEnd = to.length\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) === 47 /* / */) {\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) === 47 /* / */) {\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 } else if (fromCode === 47 /* / */) { 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) === 47 /* / */) {\n            if (out.length === 0) { out += '..' } 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) } else {\n        toStart += lastCommonSep\n        if (to.charCodeAt(toStart) === 47 /* / */) { ++toStart }\n        return to.slice(toStart)\n    }\n}\n"],
  "mappings": "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",
  "names": ["src_exports", "__export", "basename", "src_default", "dirname", "extname", "isAbsolute", "join", "normalize", "parse", "path", "relative", "resolve", "__toCommonJS", "path", "__name", "dirname", "basename", "extname", "parse", "resolve", "normalize", "join", "relative", "isAbsolute", "pathObject", "_format", "assertPath", "normalizeStringPosix", "allowAboveRoot", "res", "lastSegmentLength", "lastSlash", "dots", "code", "i", "lastSlashIndex", "sep", "dir", "base", "src_default", "ext", "start", "end", "matchedSlash", "extIdx", "firstNonSlashEnd", "startDot", "startPart", "preDotState", "ret", "hasRoot", "args", "resolvedPath", "resolvedAbsolute", "cwd", "trailingSeparator", "joined", "arg", "from", "to", "fromStart", "fromEnd", "fromLen", "toStart", "toLen", "length", "lastCommonSep", "fromCode", "toCode", "out"]
}