{"version":3,"file":"static/js/6850_27ea246fc5192bc7c603.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/glob.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/hash.js"],"sourcesContent":["import { isThenable } from './async.js';\nimport { isEqualOrParent } from './extpath.js';\nimport { LRUCache } from './map.js';\nimport { basename, extname, posix, sep } from './path.js';\nimport { isLinux } from './platform.js';\nimport { escapeRegExpCharacters, ltrim } from './strings.js';\nexport const GLOBSTAR = '**';\nexport const GLOB_SPLIT = '/';\nconst PATH_REGEX = '[/\\\\\\\\]'; // any slash or backslash\nconst NO_PATH_REGEX = '[^/\\\\\\\\]'; // any non-slash and non-backslash\nconst ALL_FORWARD_SLASHES = /\\//g;\nfunction starsToRegExp(starCount, isLastPattern) {\n    switch (starCount) {\n        case 0:\n            return '';\n        case 1:\n            return `${NO_PATH_REGEX}*?`; // 1 star matches any number of characters except path separator (/ and \\) - non greedy (?)\n        default:\n            // Matches:  (Path Sep OR Path Val followed by Path Sep) 0-many times except when it's the last pattern\n            //           in which case also matches (Path Sep followed by Path Val)\n            // Group is non capturing because we don't need to capture at all (?:...)\n            // Overall we use non-greedy matching because it could be that we match too much\n            return `(?:${PATH_REGEX}|${NO_PATH_REGEX}+${PATH_REGEX}${isLastPattern ? `|${PATH_REGEX}${NO_PATH_REGEX}+` : ''})*?`;\n    }\n}\nexport function splitGlobAware(pattern, splitChar) {\n    if (!pattern) {\n        return [];\n    }\n    const segments = [];\n    let inBraces = false;\n    let inBrackets = false;\n    let curVal = '';\n    for (const char of pattern) {\n        switch (char) {\n            case splitChar:\n                if (!inBraces && !inBrackets) {\n                    segments.push(curVal);\n                    curVal = '';\n                    continue;\n                }\n                break;\n            case '{':\n                inBraces = true;\n                break;\n            case '}':\n                inBraces = false;\n                break;\n            case '[':\n                inBrackets = true;\n                break;\n            case ']':\n                inBrackets = false;\n                break;\n        }\n        curVal += char;\n    }\n    // Tail\n    if (curVal) {\n        segments.push(curVal);\n    }\n    return segments;\n}\nfunction parseRegExp(pattern) {\n    if (!pattern) {\n        return '';\n    }\n    let regEx = '';\n    // Split up into segments for each slash found\n    const segments = splitGlobAware(pattern, GLOB_SPLIT);\n    // Special case where we only have globstars\n    if (segments.every(segment => segment === GLOBSTAR)) {\n        regEx = '.*';\n    }\n    // Build regex over segments\n    else {\n        let previousSegmentWasGlobStar = false;\n        segments.forEach((segment, index) => {\n            // Treat globstar specially\n            if (segment === GLOBSTAR) {\n                // if we have more than one globstar after another, just ignore it\n                if (previousSegmentWasGlobStar) {\n                    return;\n                }\n                regEx += starsToRegExp(2, index === segments.length - 1);\n            }\n            // Anything else, not globstar\n            else {\n                // States\n                let inBraces = false;\n                let braceVal = '';\n                let inBrackets = false;\n                let bracketVal = '';\n                for (const char of segment) {\n                    // Support brace expansion\n                    if (char !== '}' && inBraces) {\n                        braceVal += char;\n                        continue;\n                    }\n                    // Support brackets\n                    if (inBrackets && (char !== ']' || !bracketVal) /* ] is literally only allowed as first character in brackets to match it */) {\n                        let res;\n                        // range operator\n                        if (char === '-') {\n                            res = char;\n                        }\n                        // negation operator (only valid on first index in bracket)\n                        else if ((char === '^' || char === '!') && !bracketVal) {\n                            res = '^';\n                        }\n                        // glob split matching is not allowed within character ranges\n                        // see http://man7.org/linux/man-pages/man7/glob.7.html\n                        else if (char === GLOB_SPLIT) {\n                            res = '';\n                        }\n                        // anything else gets escaped\n                        else {\n                            res = escapeRegExpCharacters(char);\n                        }\n                        bracketVal += res;\n                        continue;\n                    }\n                    switch (char) {\n                        case '{':\n                            inBraces = true;\n                            continue;\n                        case '[':\n                            inBrackets = true;\n                            continue;\n                        case '}': {\n                            const choices = splitGlobAware(braceVal, ',');\n                            // Converts {foo,bar} => [foo|bar]\n                            const braceRegExp = `(?:${choices.map(choice => parseRegExp(choice)).join('|')})`;\n                            regEx += braceRegExp;\n                            inBraces = false;\n                            braceVal = '';\n                            break;\n                        }\n                        case ']': {\n                            regEx += ('[' + bracketVal + ']');\n                            inBrackets = false;\n                            bracketVal = '';\n                            break;\n                        }\n                        case '?':\n                            regEx += NO_PATH_REGEX; // 1 ? matches any single character except path separator (/ and \\)\n                            continue;\n                        case '*':\n                            regEx += starsToRegExp(1);\n                            continue;\n                        default:\n                            regEx += escapeRegExpCharacters(char);\n                    }\n                }\n                // Tail: Add the slash we had split on if there is more to\n                // come and the remaining pattern is not a globstar\n                // For example if pattern: some/**/*.js we want the \"/\" after\n                // some to be included in the RegEx to prevent a folder called\n                // \"something\" to match as well.\n                if (index < segments.length - 1 && // more segments to come after this\n                    (segments[index + 1] !== GLOBSTAR || // next segment is not **, or...\n                        index + 2 < segments.length // ...next segment is ** but there is more segments after that\n                    )) {\n                    regEx += PATH_REGEX;\n                }\n            }\n            // update globstar state\n            previousSegmentWasGlobStar = (segment === GLOBSTAR);\n        });\n    }\n    return regEx;\n}\n// regexes to check for trivial glob patterns that just check for String#endsWith\nconst T1 = /^\\*\\*\\/\\*\\.[\\w\\.-]+$/; // **/*.something\nconst T2 = /^\\*\\*\\/([\\w\\.-]+)\\/?$/; // **/something\nconst T3 = /^{\\*\\*\\/\\*?[\\w\\.-]+\\/?(,\\*\\*\\/\\*?[\\w\\.-]+\\/?)*}$/; // {**/*.something,**/*.else} or {**/package.json,**/project.json}\nconst T3_2 = /^{\\*\\*\\/\\*?[\\w\\.-]+(\\/(\\*\\*)?)?(,\\*\\*\\/\\*?[\\w\\.-]+(\\/(\\*\\*)?)?)*}$/; // Like T3, with optional trailing /**\nconst T4 = /^\\*\\*((\\/[\\w\\.-]+)+)\\/?$/; // **/something/else\nconst T5 = /^([\\w\\.-]+(\\/[\\w\\.-]+)*)\\/?$/; // something/else\nconst CACHE = new LRUCache(10000); // bounded to 10000 elements\nconst FALSE = function () {\n    return false;\n};\nconst NULL = function () {\n    return null;\n};\nfunction parsePattern(arg1, options) {\n    if (!arg1) {\n        return NULL;\n    }\n    // Handle relative patterns\n    let pattern;\n    if (typeof arg1 !== 'string') {\n        pattern = arg1.pattern;\n    }\n    else {\n        pattern = arg1;\n    }\n    // Whitespace trimming\n    pattern = pattern.trim();\n    // Check cache\n    const patternKey = `${pattern}_${!!options.trimForExclusions}`;\n    let parsedPattern = CACHE.get(patternKey);\n    if (parsedPattern) {\n        return wrapRelativePattern(parsedPattern, arg1);\n    }\n    // Check for Trivials\n    let match;\n    if (T1.test(pattern)) {\n        parsedPattern = trivia1(pattern.substr(4), pattern); // common pattern: **/*.txt just need endsWith check\n    }\n    else if (match = T2.exec(trimForExclusions(pattern, options))) { // common pattern: **/some.txt just need basename check\n        parsedPattern = trivia2(match[1], pattern);\n    }\n    else if ((options.trimForExclusions ? T3_2 : T3).test(pattern)) { // repetition of common patterns (see above) {**/*.txt,**/*.png}\n        parsedPattern = trivia3(pattern, options);\n    }\n    else if (match = T4.exec(trimForExclusions(pattern, options))) { // common pattern: **/something/else just need endsWith check\n        parsedPattern = trivia4and5(match[1].substr(1), pattern, true);\n    }\n    else if (match = T5.exec(trimForExclusions(pattern, options))) { // common pattern: something/else just need equals check\n        parsedPattern = trivia4and5(match[1], pattern, false);\n    }\n    // Otherwise convert to pattern\n    else {\n        parsedPattern = toRegExp(pattern);\n    }\n    // Cache\n    CACHE.set(patternKey, parsedPattern);\n    return wrapRelativePattern(parsedPattern, arg1);\n}\nfunction wrapRelativePattern(parsedPattern, arg2) {\n    if (typeof arg2 === 'string') {\n        return parsedPattern;\n    }\n    const wrappedPattern = function (path, basename) {\n        if (!isEqualOrParent(path, arg2.base, !isLinux)) {\n            // skip glob matching if `base` is not a parent of `path`\n            return null;\n        }\n        // Given we have checked `base` being a parent of `path`,\n        // we can now remove the `base` portion of the `path`\n        // and only match on the remaining path components\n        // For that we try to extract the portion of the `path`\n        // that comes after the `base` portion. We have to account\n        // for the fact that `base` might end in a path separator\n        // (https://github.com/microsoft/vscode/issues/162498)\n        return parsedPattern(ltrim(path.substr(arg2.base.length), sep), basename);\n    };\n    // Make sure to preserve associated metadata\n    wrappedPattern.allBasenames = parsedPattern.allBasenames;\n    wrappedPattern.allPaths = parsedPattern.allPaths;\n    wrappedPattern.basenames = parsedPattern.basenames;\n    wrappedPattern.patterns = parsedPattern.patterns;\n    return wrappedPattern;\n}\nfunction trimForExclusions(pattern, options) {\n    return options.trimForExclusions && pattern.endsWith('/**') ? pattern.substr(0, pattern.length - 2) : pattern; // dropping **, tailing / is dropped later\n}\n// common pattern: **/*.txt just need endsWith check\nfunction trivia1(base, pattern) {\n    return function (path, basename) {\n        return typeof path === 'string' && path.endsWith(base) ? pattern : null;\n    };\n}\n// common pattern: **/some.txt just need basename check\nfunction trivia2(base, pattern) {\n    const slashBase = `/${base}`;\n    const backslashBase = `\\\\${base}`;\n    const parsedPattern = function (path, basename) {\n        if (typeof path !== 'string') {\n            return null;\n        }\n        if (basename) {\n            return basename === base ? pattern : null;\n        }\n        return path === base || path.endsWith(slashBase) || path.endsWith(backslashBase) ? pattern : null;\n    };\n    const basenames = [base];\n    parsedPattern.basenames = basenames;\n    parsedPattern.patterns = [pattern];\n    parsedPattern.allBasenames = basenames;\n    return parsedPattern;\n}\n// repetition of common patterns (see above) {**/*.txt,**/*.png}\nfunction trivia3(pattern, options) {\n    const parsedPatterns = aggregateBasenameMatches(pattern.slice(1, -1)\n        .split(',')\n        .map(pattern => parsePattern(pattern, options))\n        .filter(pattern => pattern !== NULL), pattern);\n    const patternsLength = parsedPatterns.length;\n    if (!patternsLength) {\n        return NULL;\n    }\n    if (patternsLength === 1) {\n        return parsedPatterns[0];\n    }\n    const parsedPattern = function (path, basename) {\n        for (let i = 0, n = parsedPatterns.length; i < n; i++) {\n            if (parsedPatterns[i](path, basename)) {\n                return pattern;\n            }\n        }\n        return null;\n    };\n    const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);\n    if (withBasenames) {\n        parsedPattern.allBasenames = withBasenames.allBasenames;\n    }\n    const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);\n    if (allPaths.length) {\n        parsedPattern.allPaths = allPaths;\n    }\n    return parsedPattern;\n}\n// common patterns: **/something/else just need endsWith check, something/else just needs and equals check\nfunction trivia4and5(targetPath, pattern, matchPathEnds) {\n    const usingPosixSep = sep === posix.sep;\n    const nativePath = usingPosixSep ? targetPath : targetPath.replace(ALL_FORWARD_SLASHES, sep);\n    const nativePathEnd = sep + nativePath;\n    const targetPathEnd = posix.sep + targetPath;\n    let parsedPattern;\n    if (matchPathEnds) {\n        parsedPattern = function (path, basename) {\n            return typeof path === 'string' && ((path === nativePath || path.endsWith(nativePathEnd)) || !usingPosixSep && (path === targetPath || path.endsWith(targetPathEnd))) ? pattern : null;\n        };\n    }\n    else {\n        parsedPattern = function (path, basename) {\n            return typeof path === 'string' && (path === nativePath || (!usingPosixSep && path === targetPath)) ? pattern : null;\n        };\n    }\n    parsedPattern.allPaths = [(matchPathEnds ? '*/' : './') + targetPath];\n    return parsedPattern;\n}\nfunction toRegExp(pattern) {\n    try {\n        const regExp = new RegExp(`^${parseRegExp(pattern)}$`);\n        return function (path) {\n            regExp.lastIndex = 0; // reset RegExp to its initial state to reuse it!\n            return typeof path === 'string' && regExp.test(path) ? pattern : null;\n        };\n    }\n    catch (error) {\n        return NULL;\n    }\n}\nexport function match(arg1, path, hasSibling) {\n    if (!arg1 || typeof path !== 'string') {\n        return false;\n    }\n    return parse(arg1)(path, undefined, hasSibling);\n}\nexport function parse(arg1, options = {}) {\n    if (!arg1) {\n        return FALSE;\n    }\n    // Glob with String\n    if (typeof arg1 === 'string' || isRelativePattern(arg1)) {\n        const parsedPattern = parsePattern(arg1, options);\n        if (parsedPattern === NULL) {\n            return FALSE;\n        }\n        const resultPattern = function (path, basename) {\n            return !!parsedPattern(path, basename);\n        };\n        if (parsedPattern.allBasenames) {\n            resultPattern.allBasenames = parsedPattern.allBasenames;\n        }\n        if (parsedPattern.allPaths) {\n            resultPattern.allPaths = parsedPattern.allPaths;\n        }\n        return resultPattern;\n    }\n    // Glob with Expression\n    return parsedExpression(arg1, options);\n}\nexport function isRelativePattern(obj) {\n    const rp = obj;\n    if (!rp) {\n        return false;\n    }\n    return typeof rp.base === 'string' && typeof rp.pattern === 'string';\n}\nfunction parsedExpression(expression, options) {\n    const parsedPatterns = aggregateBasenameMatches(Object.getOwnPropertyNames(expression)\n        .map(pattern => parseExpressionPattern(pattern, expression[pattern], options))\n        .filter(pattern => pattern !== NULL));\n    const patternsLength = parsedPatterns.length;\n    if (!patternsLength) {\n        return NULL;\n    }\n    if (!parsedPatterns.some(parsedPattern => !!parsedPattern.requiresSiblings)) {\n        if (patternsLength === 1) {\n            return parsedPatterns[0];\n        }\n        const resultExpression = function (path, basename) {\n            let resultPromises = undefined;\n            for (let i = 0, n = parsedPatterns.length; i < n; i++) {\n                const result = parsedPatterns[i](path, basename);\n                if (typeof result === 'string') {\n                    return result; // immediately return as soon as the first expression matches\n                }\n                // If the result is a promise, we have to keep it for\n                // later processing and await the result properly.\n                if (isThenable(result)) {\n                    if (!resultPromises) {\n                        resultPromises = [];\n                    }\n                    resultPromises.push(result);\n                }\n            }\n            // With result promises, we have to loop over each and\n            // await the result before we can return any result.\n            if (resultPromises) {\n                return (async () => {\n                    for (const resultPromise of resultPromises) {\n                        const result = await resultPromise;\n                        if (typeof result === 'string') {\n                            return result;\n                        }\n                    }\n                    return null;\n                })();\n            }\n            return null;\n        };\n        const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);\n        if (withBasenames) {\n            resultExpression.allBasenames = withBasenames.allBasenames;\n        }\n        const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);\n        if (allPaths.length) {\n            resultExpression.allPaths = allPaths;\n        }\n        return resultExpression;\n    }\n    const resultExpression = function (path, base, hasSibling) {\n        let name = undefined;\n        let resultPromises = undefined;\n        for (let i = 0, n = parsedPatterns.length; i < n; i++) {\n            // Pattern matches path\n            const parsedPattern = parsedPatterns[i];\n            if (parsedPattern.requiresSiblings && hasSibling) {\n                if (!base) {\n                    base = basename(path);\n                }\n                if (!name) {\n                    name = base.substr(0, base.length - extname(path).length);\n                }\n            }\n            const result = parsedPattern(path, base, name, hasSibling);\n            if (typeof result === 'string') {\n                return result; // immediately return as soon as the first expression matches\n            }\n            // If the result is a promise, we have to keep it for\n            // later processing and await the result properly.\n            if (isThenable(result)) {\n                if (!resultPromises) {\n                    resultPromises = [];\n                }\n                resultPromises.push(result);\n            }\n        }\n        // With result promises, we have to loop over each and\n        // await the result before we can return any result.\n        if (resultPromises) {\n            return (async () => {\n                for (const resultPromise of resultPromises) {\n                    const result = await resultPromise;\n                    if (typeof result === 'string') {\n                        return result;\n                    }\n                }\n                return null;\n            })();\n        }\n        return null;\n    };\n    const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);\n    if (withBasenames) {\n        resultExpression.allBasenames = withBasenames.allBasenames;\n    }\n    const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);\n    if (allPaths.length) {\n        resultExpression.allPaths = allPaths;\n    }\n    return resultExpression;\n}\nfunction parseExpressionPattern(pattern, value, options) {\n    if (value === false) {\n        return NULL; // pattern is disabled\n    }\n    const parsedPattern = parsePattern(pattern, options);\n    if (parsedPattern === NULL) {\n        return NULL;\n    }\n    // Expression Pattern is <boolean>\n    if (typeof value === 'boolean') {\n        return parsedPattern;\n    }\n    // Expression Pattern is <SiblingClause>\n    if (value) {\n        const when = value.when;\n        if (typeof when === 'string') {\n            const result = (path, basename, name, hasSibling) => {\n                if (!hasSibling || !parsedPattern(path, basename)) {\n                    return null;\n                }\n                const clausePattern = when.replace('$(basename)', () => name);\n                const matched = hasSibling(clausePattern);\n                return isThenable(matched) ?\n                    matched.then(match => match ? pattern : null) :\n                    matched ? pattern : null;\n            };\n            result.requiresSiblings = true;\n            return result;\n        }\n    }\n    // Expression is anything\n    return parsedPattern;\n}\nfunction aggregateBasenameMatches(parsedPatterns, result) {\n    const basenamePatterns = parsedPatterns.filter(parsedPattern => !!parsedPattern.basenames);\n    if (basenamePatterns.length < 2) {\n        return parsedPatterns;\n    }\n    const basenames = basenamePatterns.reduce((all, current) => {\n        const basenames = current.basenames;\n        return basenames ? all.concat(basenames) : all;\n    }, []);\n    let patterns;\n    if (result) {\n        patterns = [];\n        for (let i = 0, n = basenames.length; i < n; i++) {\n            patterns.push(result);\n        }\n    }\n    else {\n        patterns = basenamePatterns.reduce((all, current) => {\n            const patterns = current.patterns;\n            return patterns ? all.concat(patterns) : all;\n        }, []);\n    }\n    const aggregate = function (path, basename) {\n        if (typeof path !== 'string') {\n            return null;\n        }\n        if (!basename) {\n            let i;\n            for (i = path.length; i > 0; i--) {\n                const ch = path.charCodeAt(i - 1);\n                if (ch === 47 /* CharCode.Slash */ || ch === 92 /* CharCode.Backslash */) {\n                    break;\n                }\n            }\n            basename = path.substr(i);\n        }\n        const index = basenames.indexOf(basename);\n        return index !== -1 ? patterns[index] : null;\n    };\n    aggregate.basenames = basenames;\n    aggregate.patterns = patterns;\n    aggregate.allBasenames = basenames;\n    const aggregatedPatterns = parsedPatterns.filter(parsedPattern => !parsedPattern.basenames);\n    aggregatedPatterns.push(aggregate);\n    return aggregatedPatterns;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from './strings.js';\n/**\n * Return a hash value for an object.\n */\nexport function hash(obj) {\n    return doHash(obj, 0);\n}\nexport function doHash(obj, hashVal) {\n    switch (typeof obj) {\n        case 'object':\n            if (obj === null) {\n                return numberHash(349, hashVal);\n            }\n            else if (Array.isArray(obj)) {\n                return arrayHash(obj, hashVal);\n            }\n            return objectHash(obj, hashVal);\n        case 'string':\n            return stringHash(obj, hashVal);\n        case 'boolean':\n            return booleanHash(obj, hashVal);\n        case 'number':\n            return numberHash(obj, hashVal);\n        case 'undefined':\n            return numberHash(937, hashVal);\n        default:\n            return numberHash(617, hashVal);\n    }\n}\nexport function numberHash(val, initialHashVal) {\n    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32\n}\nfunction booleanHash(b, initialHashVal) {\n    return numberHash(b ? 433 : 863, initialHashVal);\n}\nexport function stringHash(s, hashVal) {\n    hashVal = numberHash(149417, hashVal);\n    for (let i = 0, length = s.length; i < length; i++) {\n        hashVal = numberHash(s.charCodeAt(i), hashVal);\n    }\n    return hashVal;\n}\nfunction arrayHash(arr, initialHashVal) {\n    initialHashVal = numberHash(104579, initialHashVal);\n    return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);\n}\nfunction objectHash(obj, initialHashVal) {\n    initialHashVal = numberHash(181387, initialHashVal);\n    return Object.keys(obj).sort().reduce((hashVal, key) => {\n        hashVal = stringHash(key, hashVal);\n        return doHash(obj[key], hashVal);\n    }, initialHashVal);\n}\nfunction leftRotate(value, bits, totalBits = 32) {\n    // delta + bits = totalBits\n    const delta = totalBits - bits;\n    // All ones, expect `delta` zeros aligned to the right\n    const mask = ~((1 << delta) - 1);\n    // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)\n    return ((value << bits) | ((mask & value) >>> delta)) >>> 0;\n}\nfunction fill(dest, index = 0, count = dest.byteLength, value = 0) {\n    for (let i = 0; i < count; i++) {\n        dest[index + i] = value;\n    }\n}\nfunction leftPad(value, length, char = '0') {\n    while (value.length < length) {\n        value = char + value;\n    }\n    return value;\n}\nexport function toHexString(bufferOrValue, bitsize = 32) {\n    if (bufferOrValue instanceof ArrayBuffer) {\n        return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');\n    }\n    return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);\n}\n/**\n * A SHA1 implementation that works with strings and does not allocate.\n */\nexport class StringSHA1 {\n    constructor() {\n        this._h0 = 0x67452301;\n        this._h1 = 0xEFCDAB89;\n        this._h2 = 0x98BADCFE;\n        this._h3 = 0x10325476;\n        this._h4 = 0xC3D2E1F0;\n        this._buff = new Uint8Array(64 /* SHA1Constant.BLOCK_SIZE */ + 3 /* to fit any utf-8 */);\n        this._buffDV = new DataView(this._buff.buffer);\n        this._buffLen = 0;\n        this._totalLen = 0;\n        this._leftoverHighSurrogate = 0;\n        this._finished = false;\n    }\n    update(str) {\n        const strLen = str.length;\n        if (strLen === 0) {\n            return;\n        }\n        const buff = this._buff;\n        let buffLen = this._buffLen;\n        let leftoverHighSurrogate = this._leftoverHighSurrogate;\n        let charCode;\n        let offset;\n        if (leftoverHighSurrogate !== 0) {\n            charCode = leftoverHighSurrogate;\n            offset = -1;\n            leftoverHighSurrogate = 0;\n        }\n        else {\n            charCode = str.charCodeAt(0);\n            offset = 0;\n        }\n        while (true) {\n            let codePoint = charCode;\n            if (strings.isHighSurrogate(charCode)) {\n                if (offset + 1 < strLen) {\n                    const nextCharCode = str.charCodeAt(offset + 1);\n                    if (strings.isLowSurrogate(nextCharCode)) {\n                        offset++;\n                        codePoint = strings.computeCodePoint(charCode, nextCharCode);\n                    }\n                    else {\n                        // illegal => unicode replacement character\n                        codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;\n                    }\n                }\n                else {\n                    // last character is a surrogate pair\n                    leftoverHighSurrogate = charCode;\n                    break;\n                }\n            }\n            else if (strings.isLowSurrogate(charCode)) {\n                // illegal => unicode replacement character\n                codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;\n            }\n            buffLen = this._push(buff, buffLen, codePoint);\n            offset++;\n            if (offset < strLen) {\n                charCode = str.charCodeAt(offset);\n            }\n            else {\n                break;\n            }\n        }\n        this._buffLen = buffLen;\n        this._leftoverHighSurrogate = leftoverHighSurrogate;\n    }\n    _push(buff, buffLen, codePoint) {\n        if (codePoint < 0x0080) {\n            buff[buffLen++] = codePoint;\n        }\n        else if (codePoint < 0x0800) {\n            buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else if (codePoint < 0x10000) {\n            buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else {\n            buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        if (buffLen >= 64 /* SHA1Constant.BLOCK_SIZE */) {\n            this._step();\n            buffLen -= 64 /* SHA1Constant.BLOCK_SIZE */;\n            this._totalLen += 64 /* SHA1Constant.BLOCK_SIZE */;\n            // take last 3 in case of UTF8 overflow\n            buff[0] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 0];\n            buff[1] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 1];\n            buff[2] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 2];\n        }\n        return buffLen;\n    }\n    digest() {\n        if (!this._finished) {\n            this._finished = true;\n            if (this._leftoverHighSurrogate) {\n                // illegal => unicode replacement character\n                this._leftoverHighSurrogate = 0;\n                this._buffLen = this._push(this._buff, this._buffLen, 65533 /* SHA1Constant.UNICODE_REPLACEMENT */);\n            }\n            this._totalLen += this._buffLen;\n            this._wrapUp();\n        }\n        return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);\n    }\n    _wrapUp() {\n        this._buff[this._buffLen++] = 0x80;\n        fill(this._buff, this._buffLen);\n        if (this._buffLen > 56) {\n            this._step();\n            fill(this._buff);\n        }\n        // this will fit because the mantissa can cover up to 52 bits\n        const ml = 8 * this._totalLen;\n        this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);\n        this._buffDV.setUint32(60, ml % 4294967296, false);\n        this._step();\n    }\n    _step() {\n        const bigBlock32 = StringSHA1._bigBlock32;\n        const data = this._buffDV;\n        for (let j = 0; j < 64 /* 16*4 */; j += 4) {\n            bigBlock32.setUint32(j, data.getUint32(j, false), false);\n        }\n        for (let j = 64; j < 320 /* 80*4 */; j += 4) {\n            bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);\n        }\n        let a = this._h0;\n        let b = this._h1;\n        let c = this._h2;\n        let d = this._h3;\n        let e = this._h4;\n        let f, k;\n        let temp;\n        for (let j = 0; j < 80; j++) {\n            if (j < 20) {\n                f = (b & c) | ((~b) & d);\n                k = 0x5A827999;\n            }\n            else if (j < 40) {\n                f = b ^ c ^ d;\n                k = 0x6ED9EBA1;\n            }\n            else if (j < 60) {\n                f = (b & c) | (b & d) | (c & d);\n                k = 0x8F1BBCDC;\n            }\n            else {\n                f = b ^ c ^ d;\n                k = 0xCA62C1D6;\n            }\n            temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;\n            e = d;\n            d = c;\n            c = leftRotate(b, 30);\n            b = a;\n            a = temp;\n        }\n        this._h0 = (this._h0 + a) & 0xffffffff;\n        this._h1 = (this._h1 + b) & 0xffffffff;\n        this._h2 = (this._h2 + c) & 0xffffffff;\n        this._h3 = (this._h3 + d) & 0xffffffff;\n        this._h4 = (this._h4 + e) & 0xffffffff;\n    }\n}\nStringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320\n"],"names":["GLOBSTAR","GLOB_SPLIT","PATH_REGEX","NO_PATH_REGEX","ALL_FORWARD_SLASHES","starsToRegExp","starCount","isLastPattern","splitGlobAware","pattern","splitChar","segments","inBraces","inBrackets","curVal","char","push","parseRegExp","regEx","every","segment","previousSegmentWasGlobStar","forEach","index","length","braceVal","bracketVal","braceRegExp","map","choice","join","res","T1","T2","T3","T3_2","T4","T5","CACHE","FALSE","NULL","parsePattern","arg1","options","trim","patternKey","trimForExclusions","match","parsedPattern","get","test","base","path","basename","endsWith","trivia1","substr","exec","slashBase","backslashBase","basenames","patterns","allBasenames","trivia2","parsedPatterns","aggregateBasenameMatches","slice","split","filter","patternsLength","i","n","withBasenames","find","allPaths","reduce","all","current","concat","trivia3","trivia4and5","regExp","RegExp","lastIndex","error","toRegExp","set","wrapRelativePattern","arg2","wrappedPattern","targetPath","matchPathEnds","usingPosixSep","nativePath","replace","nativePathEnd","targetPathEnd","hasSibling","parse","undefined","obj","rp","isRelativePattern","resultPattern","expression","Object","getOwnPropertyNames","value","when","result","name","matched","then","requiresSiblings","parseExpressionPattern","some","resultExpression","resultPromises","resultPromise","parsedExpression","basenamePatterns","aggregate","ch","charCodeAt","indexOf","aggregatedPatterns","hash","doHash","hashVal","numberHash","Array","isArray","arr","initialHashVal","item","keys","sort","key","stringHash","objectHash","b","booleanHash","val","s","leftRotate","bits","totalBits","delta","fill","dest","count","byteLength","toHexString","bufferOrValue","bitsize","ArrayBuffer","from","Uint8Array","toString","padStart","leftPad","StringSHA1","constructor","this","_h0","_h1","_h2","_h3","_h4","_buff","_buffDV","DataView","buffer","_buffLen","_totalLen","_leftoverHighSurrogate","_finished","update","str","strLen","buff","charCode","offset","buffLen","leftoverHighSurrogate","codePoint","nextCharCode","_push","_step","digest","_wrapUp","ml","setUint32","Math","floor","bigBlock32","_bigBlock32","data","j","getUint32","f","k","temp","a","c","d","e"],"sourceRoot":""}