\n if (!this.preserveMultipleSlashes) {\n for (let i = 1; i < parts.length - 1; i++) {\n const p = parts[i];\n // don't squeeze out UNC patterns\n if (i === 1 && p === '' && parts[0] === '')\n continue;\n if (p === '.' || p === '') {\n didSomething = true;\n parts.splice(i, 1);\n i--;\n }\n }\n if (parts[0] === '.' &&\n parts.length === 2 &&\n (parts[1] === '.' || parts[1] === '')) {\n didSomething = true;\n parts.pop();\n }\n }\n // //../ -> /\n let dd = 0;\n while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n const p = parts[dd - 1];\n if (p && p !== '.' && p !== '..' && p !== '**') {\n didSomething = true;\n parts.splice(dd - 1, 2);\n dd -= 2;\n }\n }\n } while (didSomething);\n return parts.length === 0 ? [''] : parts;\n }\n // First phase: single-pattern processing\n // is 1 or more portions\n // is 1 or more portions\n // is any portion other than ., .., '', or **\n // is . or ''\n //\n // **/.. is *brutal* for filesystem walking performance, because\n // it effectively resets the recursive walk each time it occurs,\n // and ** cannot be reduced out by a .. pattern part like a regexp\n // or most strings (other than .., ., and '') can be.\n //\n // /**/..//
/ -> {/..//
/,/**//
/}\n // // -> /\n // //../ -> /\n // **/**/ -> **/\n //\n // **/*/ -> */**/ <== not valid because ** doesn't follow\n // this WOULD be allowed if ** did follow symlinks, or * didn't\n firstPhasePreProcess(globParts) {\n let didSomething = false;\n do {\n didSomething = false;\n // /**/..//
/ -> {/..//
/,/**//
/}\n for (let parts of globParts) {\n let gs = -1;\n while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n let gss = gs;\n while (parts[gss + 1] === '**') {\n // /**/**/ -> /**/\n gss++;\n }\n // eg, if gs is 2 and gss is 4, that means we have 3 **\n // parts, and can remove 2 of them.\n if (gss > gs) {\n parts.splice(gs + 1, gss - gs);\n }\n let next = parts[gs + 1];\n const p = parts[gs + 2];\n const p2 = parts[gs + 3];\n if (next !== '..')\n continue;\n if (!p ||\n p === '.' ||\n p === '..' ||\n !p2 ||\n p2 === '.' ||\n p2 === '..') {\n continue;\n }\n didSomething = true;\n // edit parts in place, and push the new one\n parts.splice(gs, 1);\n const other = parts.slice(0);\n other[gs] = '**';\n globParts.push(other);\n gs--;\n }\n // // -> /\n if (!this.preserveMultipleSlashes) {\n for (let i = 1; i < parts.length - 1; i++) {\n const p = parts[i];\n // don't squeeze out UNC patterns\n if (i === 1 && p === '' && parts[0] === '')\n continue;\n if (p === '.' || p === '') {\n didSomething = true;\n parts.splice(i, 1);\n i--;\n }\n }\n if (parts[0] === '.' &&\n parts.length === 2 &&\n (parts[1] === '.' || parts[1] === '')) {\n didSomething = true;\n parts.pop();\n }\n }\n // //../ -> /\n let dd = 0;\n while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n const p = parts[dd - 1];\n if (p && p !== '.' && p !== '..' && p !== '**') {\n didSomething = true;\n const needDot = dd === 1 && parts[dd + 1] === '**';\n const splin = needDot ? ['.'] : [];\n parts.splice(dd - 1, 2, ...splin);\n if (parts.length === 0)\n parts.push('');\n dd -= 2;\n }\n }\n }\n } while (didSomething);\n return globParts;\n }\n // second phase: multi-pattern dedupes\n // {/*/,//} -> /*/\n // {/,/} -> /\n // {/**/,/} -> /**/\n //\n // {/**/,/**//} -> /**/\n // ^-- not valid because ** doens't follow symlinks\n secondPhasePreProcess(globParts) {\n for (let i = 0; i < globParts.length - 1; i++) {\n for (let j = i + 1; j < globParts.length; j++) {\n const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);\n if (!matched)\n continue;\n globParts[i] = matched;\n globParts[j] = [];\n }\n }\n return globParts.filter(gs => gs.length);\n }\n partsMatch(a, b, emptyGSMatch = false) {\n let ai = 0;\n let bi = 0;\n let result = [];\n let which = '';\n while (ai < a.length && bi < b.length) {\n if (a[ai] === b[bi]) {\n result.push(which === 'b' ? b[bi] : a[ai]);\n ai++;\n bi++;\n }\n else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {\n result.push(a[ai]);\n ai++;\n }\n else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {\n result.push(b[bi]);\n bi++;\n }\n else if (a[ai] === '*' &&\n b[bi] &&\n (this.options.dot || !b[bi].startsWith('.')) &&\n b[bi] !== '**') {\n if (which === 'b')\n return false;\n which = 'a';\n result.push(a[ai]);\n ai++;\n bi++;\n }\n else if (b[bi] === '*' &&\n a[ai] &&\n (this.options.dot || !a[ai].startsWith('.')) &&\n a[ai] !== '**') {\n if (which === 'a')\n return false;\n which = 'b';\n result.push(b[bi]);\n ai++;\n bi++;\n }\n else {\n return false;\n }\n }\n // if we fall out of the loop, it means they two are identical\n // as long as their lengths match\n return a.length === b.length && result;\n }\n parseNegate() {\n if (this.nonegate)\n return;\n const pattern = this.pattern;\n let negate = false;\n let negateOffset = 0;\n for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {\n negate = !negate;\n negateOffset++;\n }\n if (negateOffset)\n this.pattern = pattern.slice(negateOffset);\n this.negate = negate;\n }\n // set partial to true to test if, for example,\n // \"/a/b\" matches the start of \"/*/b/*/d\"\n // Partial means, if you run out of file before you run\n // out of pattern, then that's fine, as long as all\n // the parts match.\n matchOne(file, pattern, partial = false) {\n const options = this.options;\n // a UNC pattern like //?/c:/* can match a path like c:/x\n // and vice versa\n if (this.isWindows) {\n const fileUNC = file[0] === '' &&\n file[1] === '' &&\n file[2] === '?' &&\n typeof file[3] === 'string' &&\n /^[a-z]:$/i.test(file[3]);\n const patternUNC = pattern[0] === '' &&\n pattern[1] === '' &&\n pattern[2] === '?' &&\n typeof pattern[3] === 'string' &&\n /^[a-z]:$/i.test(pattern[3]);\n if (fileUNC && patternUNC) {\n const fd = file[3];\n const pd = pattern[3];\n if (fd.toLowerCase() === pd.toLowerCase()) {\n file[3] = pd;\n }\n }\n else if (patternUNC && typeof file[0] === 'string') {\n const pd = pattern[3];\n const fd = file[0];\n if (pd.toLowerCase() === fd.toLowerCase()) {\n pattern[3] = fd;\n pattern = pattern.slice(3);\n }\n }\n else if (fileUNC && typeof pattern[0] === 'string') {\n const fd = file[3];\n if (fd.toLowerCase() === pattern[0].toLowerCase()) {\n pattern[0] = fd;\n file = file.slice(3);\n }\n }\n }\n // resolve and reduce . and .. portions in the file as well.\n // dont' need to do the second phase, because it's only one string[]\n const { optimizationLevel = 1 } = this.options;\n if (optimizationLevel >= 2) {\n file = this.levelTwoFileOptimize(file);\n }\n this.debug('matchOne', this, { file, pattern });\n this.debug('matchOne', file.length, pattern.length);\n for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {\n this.debug('matchOne loop');\n var p = pattern[pi];\n var f = file[fi];\n this.debug(pattern, p, f);\n // should be impossible.\n // some invalid regexp stuff in the set.\n /* c8 ignore start */\n if (p === false) {\n return false;\n }\n /* c8 ignore stop */\n if (p === GLOBSTAR) {\n this.debug('GLOBSTAR', [pattern, p, f]);\n // \"**\"\n // a/**/b/**/c would match the following:\n // a/b/x/y/z/c\n // a/x/y/z/b/c\n // a/b/x/b/x/c\n // a/b/c\n // To do this, take the rest of the pattern after\n // the **, and see if it would match the file remainder.\n // If so, return success.\n // If not, the ** \"swallows\" a segment, and try again.\n // This is recursively awful.\n //\n // a/**/b/**/c matching a/b/x/y/z/c\n // - a matches a\n // - doublestar\n // - matchOne(b/x/y/z/c, b/**/c)\n // - b matches b\n // - doublestar\n // - matchOne(x/y/z/c, c) -> no\n // - matchOne(y/z/c, c) -> no\n // - matchOne(z/c, c) -> no\n // - matchOne(c, c) yes, hit\n var fr = fi;\n var pr = pi + 1;\n if (pr === pl) {\n this.debug('** at the end');\n // a ** at the end will just swallow the rest.\n // We have found a match.\n // however, it will not swallow /.x, unless\n // options.dot is set.\n // . and .. are *never* matched by **, for explosively\n // exponential reasons.\n for (; fi < fl; fi++) {\n if (file[fi] === '.' ||\n file[fi] === '..' ||\n (!options.dot && file[fi].charAt(0) === '.'))\n return false;\n }\n return true;\n }\n // ok, let's see if we can swallow whatever we can.\n while (fr < fl) {\n var swallowee = file[fr];\n this.debug('\\nglobstar while', file, fr, pattern, pr, swallowee);\n // XXX remove this slice. Just pass the start index.\n if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {\n this.debug('globstar found match!', fr, fl, swallowee);\n // found a match.\n return true;\n }\n else {\n // can't swallow \".\" or \"..\" ever.\n // can only swallow \".foo\" when explicitly asked.\n if (swallowee === '.' ||\n swallowee === '..' ||\n (!options.dot && swallowee.charAt(0) === '.')) {\n this.debug('dot detected!', file, fr, pattern, pr);\n break;\n }\n // ** swallows a segment, and continue.\n this.debug('globstar swallow a segment, and continue');\n fr++;\n }\n }\n // no match was found.\n // However, in partial mode, we can't say this is necessarily over.\n /* c8 ignore start */\n if (partial) {\n // ran out of file\n this.debug('\\n>>> no match, partial?', file, fr, pattern, pr);\n if (fr === fl) {\n return true;\n }\n }\n /* c8 ignore stop */\n return false;\n }\n // something other than **\n // non-magic patterns just have to match exactly\n // patterns with magic have been turned into regexps.\n let hit;\n if (typeof p === 'string') {\n hit = f === p;\n this.debug('string match', p, f, hit);\n }\n else {\n hit = p.test(f);\n this.debug('pattern match', p, f, hit);\n }\n if (!hit)\n return false;\n }\n // Note: ending in / means that we'll get a final \"\"\n // at the end of the pattern. This can only match a\n // corresponding \"\" at the end of the file.\n // If the file ends in /, then it can only match a\n // a pattern that ends in /, unless the pattern just\n // doesn't have any more for it. But, a/b/ should *not*\n // match \"a/b/*\", even though \"\" matches against the\n // [^/]*? pattern, except in partial mode, where it might\n // simply not be reached yet.\n // However, a/b/ should still satisfy a/*\n // now either we fell off the end of the pattern, or we're done.\n if (fi === fl && pi === pl) {\n // ran out of pattern and filename at the same time.\n // an exact hit!\n return true;\n }\n else if (fi === fl) {\n // ran out of file, but still had pattern left.\n // this is ok if we're doing the match as part of\n // a glob fs traversal.\n return partial;\n }\n else if (pi === pl) {\n // ran out of pattern, still have file left.\n // this is only acceptable if we're on the very last\n // empty segment of a file with a trailing slash.\n // a/* should match a/b/\n return fi === fl - 1 && file[fi] === '';\n /* c8 ignore start */\n }\n else {\n // should be unreachable.\n throw new Error('wtf?');\n }\n /* c8 ignore stop */\n }\n braceExpand() {\n return braceExpand(this.pattern, this.options);\n }\n parse(pattern) {\n assertValidPattern(pattern);\n const options = this.options;\n // shortcuts\n if (pattern === '**')\n return GLOBSTAR;\n if (pattern === '')\n return '';\n // far and away, the most common glob pattern parts are\n // *, *.*, and *. Add a fast check method for those.\n let m;\n let fastTest = null;\n if ((m = pattern.match(starRE))) {\n fastTest = options.dot ? starTestDot : starTest;\n }\n else if ((m = pattern.match(starDotExtRE))) {\n fastTest = (options.nocase\n ? options.dot\n ? starDotExtTestNocaseDot\n : starDotExtTestNocase\n : options.dot\n ? starDotExtTestDot\n : starDotExtTest)(m[1]);\n }\n else if ((m = pattern.match(qmarksRE))) {\n fastTest = (options.nocase\n ? options.dot\n ? qmarksTestNocaseDot\n : qmarksTestNocase\n : options.dot\n ? qmarksTestDot\n : qmarksTest)(m);\n }\n else if ((m = pattern.match(starDotStarRE))) {\n fastTest = options.dot ? starDotStarTestDot : starDotStarTest;\n }\n else if ((m = pattern.match(dotStarRE))) {\n fastTest = dotStarTest;\n }\n let re = '';\n let hasMagic = false;\n let escaping = false;\n // ? => one single character\n const patternListStack = [];\n const negativeLists = [];\n let stateChar = false;\n let uflag = false;\n let pl;\n // . and .. never match anything that doesn't start with .,\n // even when options.dot is set. However, if the pattern\n // starts with ., then traversal patterns can match.\n let dotTravAllowed = pattern.charAt(0) === '.';\n let dotFileAllowed = options.dot || dotTravAllowed;\n const patternStart = () => dotTravAllowed\n ? ''\n : dotFileAllowed\n ? '(?!(?:^|\\\\/)\\\\.{1,2}(?:$|\\\\/))'\n : '(?!\\\\.)';\n const subPatternStart = (p) => p.charAt(0) === '.'\n ? ''\n : options.dot\n ? '(?!(?:^|\\\\/)\\\\.{1,2}(?:$|\\\\/))'\n : '(?!\\\\.)';\n const clearStateChar = () => {\n if (stateChar) {\n // we had some state-tracking character\n // that wasn't consumed by this pass.\n switch (stateChar) {\n case '*':\n re += star;\n hasMagic = true;\n break;\n case '?':\n re += qmark;\n hasMagic = true;\n break;\n default:\n re += '\\\\' + stateChar;\n break;\n }\n this.debug('clearStateChar %j %j', stateChar, re);\n stateChar = false;\n }\n };\n for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {\n this.debug('%s\\t%s %s %j', pattern, i, re, c);\n // skip over any that are escaped.\n if (escaping) {\n // completely not allowed, even escaped.\n // should be impossible.\n /* c8 ignore start */\n if (c === '/') {\n return false;\n }\n /* c8 ignore stop */\n if (reSpecials[c]) {\n re += '\\\\';\n }\n re += c;\n escaping = false;\n continue;\n }\n switch (c) {\n // Should already be path-split by now.\n /* c8 ignore start */\n case '/': {\n return false;\n }\n /* c8 ignore stop */\n case '\\\\':\n clearStateChar();\n escaping = true;\n continue;\n // the various stateChar values\n // for the \"extglob\" stuff.\n case '?':\n case '*':\n case '+':\n case '@':\n case '!':\n this.debug('%s\\t%s %s %j <-- stateChar', pattern, i, re, c);\n // if we already have a stateChar, then it means\n // that there was something like ** or +? in there.\n // Handle the stateChar, then proceed with this one.\n this.debug('call clearStateChar %j', stateChar);\n clearStateChar();\n stateChar = c;\n // if extglob is disabled, then +(asdf|foo) isn't a thing.\n // just clear the statechar *now*, rather than even diving into\n // the patternList stuff.\n if (options.noext)\n clearStateChar();\n continue;\n case '(': {\n if (!stateChar) {\n re += '\\\\(';\n continue;\n }\n const plEntry = {\n type: stateChar,\n start: i - 1,\n reStart: re.length,\n open: plTypes[stateChar].open,\n close: plTypes[stateChar].close,\n };\n this.debug(this.pattern, '\\t', plEntry);\n patternListStack.push(plEntry);\n // negation is (?:(?!(?:js)(?:))[^/]*)\n re += plEntry.open;\n // next entry starts with a dot maybe?\n if (plEntry.start === 0 && plEntry.type !== '!') {\n dotTravAllowed = true;\n re += subPatternStart(pattern.slice(i + 1));\n }\n this.debug('plType %j %j', stateChar, re);\n stateChar = false;\n continue;\n }\n case ')': {\n const plEntry = patternListStack[patternListStack.length - 1];\n if (!plEntry) {\n re += '\\\\)';\n continue;\n }\n patternListStack.pop();\n // closing an extglob\n clearStateChar();\n hasMagic = true;\n pl = plEntry;\n // negation is (?:(?!js)[^/]*)\n // The others are (?:)\n re += pl.close;\n if (pl.type === '!') {\n negativeLists.push(Object.assign(pl, { reEnd: re.length }));\n }\n continue;\n }\n case '|': {\n const plEntry = patternListStack[patternListStack.length - 1];\n if (!plEntry) {\n re += '\\\\|';\n continue;\n }\n clearStateChar();\n re += '|';\n // next subpattern can start with a dot?\n if (plEntry.start === 0 && plEntry.type !== '!') {\n dotTravAllowed = true;\n re += subPatternStart(pattern.slice(i + 1));\n }\n continue;\n }\n // these are mostly the same in regexp and glob\n case '[':\n // swallow any state-tracking char before the [\n clearStateChar();\n const [src, needUflag, consumed, magic] = parseClass(pattern, i);\n if (consumed) {\n re += src;\n uflag = uflag || needUflag;\n i += consumed - 1;\n hasMagic = hasMagic || magic;\n }\n else {\n re += '\\\\[';\n }\n continue;\n case ']':\n re += '\\\\' + c;\n continue;\n default:\n // swallow any state char that wasn't consumed\n clearStateChar();\n re += regExpEscape(c);\n break;\n } // switch\n } // for\n // handle the case where we had a +( thing at the *end*\n // of the pattern.\n // each pattern list stack adds 3 chars, and we need to go through\n // and escape any | chars that were passed through as-is for the regexp.\n // Go through and escape them, taking care not to double-escape any\n // | chars that were already escaped.\n for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {\n let tail;\n tail = re.slice(pl.reStart + pl.open.length);\n this.debug(this.pattern, 'setting tail', re, pl);\n // maybe some even number of \\, then maybe 1 \\, followed by a |\n tail = tail.replace(/((?:\\\\{2}){0,64})(\\\\?)\\|/g, (_, $1, $2) => {\n if (!$2) {\n // the | isn't already escaped, so escape it.\n $2 = '\\\\';\n // should already be done\n /* c8 ignore start */\n }\n /* c8 ignore stop */\n // need to escape all those slashes *again*, without escaping the\n // one that we need for escaping the | character. As it works out,\n // escaping an even number of slashes can be done by simply repeating\n // it exactly after itself. That's why this trick works.\n //\n // I am sorry that you have to see this.\n return $1 + $1 + $2 + '|';\n });\n this.debug('tail=%j\\n %s', tail, tail, pl, re);\n const t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\\\' + pl.type;\n hasMagic = true;\n re = re.slice(0, pl.reStart) + t + '\\\\(' + tail;\n }\n // handle trailing things that only matter at the very end.\n clearStateChar();\n if (escaping) {\n // trailing \\\\\n re += '\\\\\\\\';\n }\n // only need to apply the nodot start if the re starts with\n // something that could conceivably capture a dot\n const addPatternStart = addPatternStartSet[re.charAt(0)];\n // Hack to work around lack of negative lookbehind in JS\n // A pattern like: *.!(x).!(y|z) needs to ensure that a name\n // like 'a.xyz.yz' doesn't match. So, the first negative\n // lookahead, has to look ALL the way ahead, to the end of\n // the pattern.\n for (let n = negativeLists.length - 1; n > -1; n--) {\n const nl = negativeLists[n];\n const nlBefore = re.slice(0, nl.reStart);\n const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);\n let nlAfter = re.slice(nl.reEnd);\n const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;\n // Handle nested stuff like *(*.js|!(*.json)), where open parens\n // mean that we should *not* include the ) in the bit that is considered\n // \"after\" the negated section.\n const closeParensBefore = nlBefore.split(')').length;\n const openParensBefore = nlBefore.split('(').length - closeParensBefore;\n let cleanAfter = nlAfter;\n for (let i = 0; i < openParensBefore; i++) {\n cleanAfter = cleanAfter.replace(/\\)[+*?]?/, '');\n }\n nlAfter = cleanAfter;\n const dollar = nlAfter === '' ? '(?:$|\\\\/)' : '';\n re = nlBefore + nlFirst + nlAfter + dollar + nlLast;\n }\n // if the re is not \"\" at this point, then we need to make sure\n // it doesn't match against an empty path part.\n // Otherwise a/* will match a/, which it should not.\n if (re !== '' && hasMagic) {\n re = '(?=.)' + re;\n }\n if (addPatternStart) {\n re = patternStart() + re;\n }\n // if it's nocase, and the lcase/uppercase don't match, it's magic\n if (options.nocase && !hasMagic && !options.nocaseMagicOnly) {\n hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();\n }\n // skip the regexp for non-magical patterns\n // unescape anything in it, though, so that it'll be\n // an exact match against a file etc.\n if (!hasMagic) {\n return globUnescape(re);\n }\n const flags = (options.nocase ? 'i' : '') + (uflag ? 'u' : '');\n try {\n const ext = fastTest\n ? {\n _glob: pattern,\n _src: re,\n test: fastTest,\n }\n : {\n _glob: pattern,\n _src: re,\n };\n return Object.assign(new RegExp('^' + re + '$', flags), ext);\n /* c8 ignore start */\n }\n catch (er) {\n // should be impossible\n // If it was an invalid regular expression, then it can't match\n // anything. This trick looks for a character after the end of\n // the string, which is of course impossible, except in multi-line\n // mode, but it's not a /m regex.\n this.debug('invalid regexp', er);\n return new RegExp('$.');\n }\n /* c8 ignore stop */\n }\n makeRe() {\n if (this.regexp || this.regexp === false)\n return this.regexp;\n // at this point, this.set is a 2d array of partial\n // pattern strings, or \"**\".\n //\n // It's better to use .match(). This function shouldn't\n // be used, really, but it's pretty convenient sometimes,\n // when you just want to work with a regex.\n const set = this.set;\n if (!set.length) {\n this.regexp = false;\n return this.regexp;\n }\n const options = this.options;\n const twoStar = options.noglobstar\n ? star\n : options.dot\n ? twoStarDot\n : twoStarNoDot;\n const flags = options.nocase ? 'i' : '';\n // regexpify non-globstar patterns\n // if ** is only item, then we just do one twoStar\n // if ** is first, and there are more, prepend (\\/|twoStar\\/)? to next\n // if ** is last, append (\\/twoStar|) to previous\n // if ** is in the middle, append (\\/|\\/twoStar\\/) to previous\n // then filter out GLOBSTAR symbols\n let re = set\n .map(pattern => {\n const pp = pattern.map(p => typeof p === 'string'\n ? regExpEscape(p)\n : p === GLOBSTAR\n ? GLOBSTAR\n : p._src);\n pp.forEach((p, i) => {\n const next = pp[i + 1];\n const prev = pp[i - 1];\n if (p !== GLOBSTAR || prev === GLOBSTAR) {\n return;\n }\n if (prev === undefined) {\n if (next !== undefined && next !== GLOBSTAR) {\n pp[i + 1] = '(?:\\\\/|' + twoStar + '\\\\/)?' + next;\n }\n else {\n pp[i] = twoStar;\n }\n }\n else if (next === undefined) {\n pp[i - 1] = prev + '(?:\\\\/|' + twoStar + ')?';\n }\n else if (next !== GLOBSTAR) {\n pp[i - 1] = prev + '(?:\\\\/|\\\\/' + twoStar + '\\\\/)' + next;\n pp[i + 1] = GLOBSTAR;\n }\n });\n return pp.filter(p => p !== GLOBSTAR).join('/');\n })\n .join('|');\n // must match entire pattern\n // ending in a * or ** will make it less strict.\n re = '^(?:' + re + ')$';\n // can match anything, as long as it's not this.\n if (this.negate)\n re = '^(?!' + re + ').*$';\n try {\n this.regexp = new RegExp(re, flags);\n /* c8 ignore start */\n }\n catch (ex) {\n // should be impossible\n this.regexp = false;\n }\n /* c8 ignore stop */\n return this.regexp;\n }\n slashSplit(p) {\n // if p starts with // on windows, we preserve that\n // so that UNC paths aren't broken. Otherwise, any number of\n // / characters are coalesced into one, unless\n // preserveMultipleSlashes is set to true.\n if (this.preserveMultipleSlashes) {\n return p.split('/');\n }\n else if (this.isWindows && /^\\/\\/[^\\/]+/.test(p)) {\n // add an extra '' for the one we lose\n return ['', ...p.split(/\\/+/)];\n }\n else {\n return p.split(/\\/+/);\n }\n }\n match(f, partial = this.partial) {\n this.debug('match', f, this.pattern);\n // short-circuit in the case of busted things.\n // comments, etc.\n if (this.comment) {\n return false;\n }\n if (this.empty) {\n return f === '';\n }\n if (f === '/' && partial) {\n return true;\n }\n const options = this.options;\n // windows: need to use /, not \\\n if (this.isWindows) {\n f = f.split('\\\\').join('/');\n }\n // treat the test path as a set of pathparts.\n const ff = this.slashSplit(f);\n this.debug(this.pattern, 'split', ff);\n // just ONE of the pattern sets in this.set needs to match\n // in order for it to be valid. If negating, then just one\n // match means that we have failed.\n // Either way, return on the first hit.\n const set = this.set;\n this.debug(this.pattern, 'set', set);\n // Find the basename of the path by looking for the last non-empty segment\n let filename = ff[ff.length - 1];\n if (!filename) {\n for (let i = ff.length - 2; !filename && i >= 0; i--) {\n filename = ff[i];\n }\n }\n for (let i = 0; i < set.length; i++) {\n const pattern = set[i];\n let file = ff;\n if (options.matchBase && pattern.length === 1) {\n file = [filename];\n }\n const hit = this.matchOne(file, pattern, partial);\n if (hit) {\n if (options.flipNegate) {\n return true;\n }\n return !this.negate;\n }\n }\n // didn't get any hits. this is success if it's a negative\n // pattern, failure otherwise.\n if (options.flipNegate) {\n return false;\n }\n return this.negate;\n }\n static defaults(def) {\n return minimatch.defaults(def).Minimatch;\n }\n}\n/* c8 ignore start */\nexport { escape } from './escape.js';\nexport { unescape } from './unescape.js';\n/* c8 ignore stop */\nminimatch.Minimatch = Minimatch;\nminimatch.escape = escape;\nminimatch.unescape = unescape;\n//# sourceMappingURL=index.js.map","/**\n * Escape all magic characters in a glob pattern.\n *\n * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}\n * option is used, then characters are escaped by wrapping in `[]`, because\n * a magic character wrapped in a character class can only be satisfied by\n * that exact character. In this mode, `\\` is _not_ escaped, because it is\n * not interpreted as a magic character, but instead as a path separator.\n */\nexport const escape = (s, { windowsPathsNoEscape = false, } = {}) => {\n // don't need to escape +@! because we escape the parens\n // that make those magic, and escaping ! as [!] isn't valid,\n // because [!]] is a valid glob class meaning not ']'.\n return windowsPathsNoEscape\n ? s.replace(/[?*()[\\]]/g, '[$&]')\n : s.replace(/[?*()[\\]\\\\]/g, '\\\\$&');\n};\n//# sourceMappingURL=escape.js.map","/**\n * Un-escape a string that has been escaped with {@link escape}.\n *\n * If the {@link windowsPathsNoEscape} option is used, then square-brace\n * escapes are removed, but not backslash escapes. For example, it will turn\n * the string `'[*]'` into `*`, but it will not turn `'\\\\*'` into `'*'`,\n * becuase `\\` is a path separator in `windowsPathsNoEscape` mode.\n *\n * When `windowsPathsNoEscape` is not set, then both brace escapes and\n * backslash escapes are removed.\n *\n * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped\n * or unescaped.\n */\nexport const unescape = (s, { windowsPathsNoEscape = false, } = {}) => {\n return windowsPathsNoEscape\n ? s.replace(/\\[([^\\/\\\\])\\]/g, '$1')\n : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, '$1$2').replace(/\\\\([^\\/])/g, '$1');\n};\n//# sourceMappingURL=unescape.js.map","import path from \"path-posix\";\nimport { XMLParser } from \"fast-xml-parser\";\nimport nestedProp from \"nested-property\";\nimport { encodePath, normalisePath } from \"./path.js\";\nvar PropertyType;\n(function (PropertyType) {\n PropertyType[\"Array\"] = \"array\";\n PropertyType[\"Object\"] = \"object\";\n PropertyType[\"Original\"] = \"original\";\n})(PropertyType || (PropertyType = {}));\nfunction getParser() {\n return new XMLParser({\n removeNSPrefix: true,\n numberParseOptions: {\n hex: true,\n leadingZeros: false\n }\n // // We don't use the processors here as decoding is done manually\n // // later on - decoding early would break some path checks.\n // attributeValueProcessor: val => decodeHTMLEntities(decodeURIComponent(val)),\n // tagValueProcessor: val => decodeHTMLEntities(decodeURIComponent(val))\n });\n}\nfunction getPropertyOfType(obj, prop, type = PropertyType.Original) {\n const val = nestedProp.get(obj, prop);\n if (type === \"array\" && Array.isArray(val) === false) {\n return [val];\n }\n else if (type === \"object\" && Array.isArray(val)) {\n return val[0];\n }\n return val;\n}\nfunction normaliseResponse(response) {\n const output = Object.assign({}, response);\n // Only either status OR propstat is allowed\n if (output.status) {\n nestedProp.set(output, \"status\", getPropertyOfType(output, \"status\", PropertyType.Object));\n }\n else {\n nestedProp.set(output, \"propstat\", getPropertyOfType(output, \"propstat\", PropertyType.Object));\n nestedProp.set(output, \"propstat.prop\", getPropertyOfType(output, \"propstat.prop\", PropertyType.Object));\n }\n return output;\n}\nfunction normaliseResult(result) {\n const { multistatus } = result;\n if (multistatus === \"\") {\n return {\n multistatus: {\n response: []\n }\n };\n }\n if (!multistatus) {\n throw new Error(\"Invalid response: No root multistatus found\");\n }\n const output = {\n multistatus: Array.isArray(multistatus) ? multistatus[0] : multistatus\n };\n nestedProp.set(output, \"multistatus.response\", getPropertyOfType(output, \"multistatus.response\", PropertyType.Array));\n nestedProp.set(output, \"multistatus.response\", nestedProp.get(output, \"multistatus.response\").map(response => normaliseResponse(response)));\n return output;\n}\n/**\n * Parse an XML response from a WebDAV service,\n * converting it to an internal DAV result\n * @param xml The raw XML string\n * @returns A parsed and processed DAV result\n */\nexport function parseXML(xml) {\n return new Promise(resolve => {\n const result = getParser().parse(xml);\n resolve(normaliseResult(result));\n });\n}\nexport function prepareFileFromProps(props, filename, isDetailed = false) {\n // Last modified time, raw size, item type and mime\n const { getlastmodified: lastMod = null, getcontentlength: rawSize = \"0\", resourcetype: resourceType = null, getcontenttype: mimeType = null, getetag: etag = null } = props;\n const type = resourceType &&\n typeof resourceType === \"object\" &&\n typeof resourceType.collection !== \"undefined\"\n ? \"directory\"\n : \"file\";\n const stat = {\n filename,\n basename: path.basename(filename),\n lastmod: lastMod,\n size: parseInt(rawSize, 10),\n type,\n etag: typeof etag === \"string\" ? etag.replace(/\"/g, \"\") : null\n };\n if (type === \"file\") {\n stat.mime = mimeType && typeof mimeType === \"string\" ? mimeType.split(\";\")[0] : \"\";\n }\n if (isDetailed) {\n stat.props = props;\n }\n return stat;\n}\n/**\n * Parse a DAV result for file stats\n * @param result The resulting DAV response\n * @param filename The filename that was stat'd\n * @param isDetailed Whether or not the raw props of\n * the resource should be returned\n * @returns A file stat result\n */\nexport function parseStat(result, filename, isDetailed = false) {\n let responseItem = null;\n try {\n // should be a propstat response, if not the if below will throw an error\n if (result.multistatus.response[0].propstat) {\n responseItem = result.multistatus.response[0];\n }\n }\n catch (e) {\n /* ignore */\n }\n if (!responseItem) {\n throw new Error(\"Failed getting item stat: bad response\");\n }\n const { propstat: { prop: props, status: statusLine } } = responseItem;\n // As defined in https://tools.ietf.org/html/rfc2068#section-6.1\n const [_, statusCodeStr, statusText] = statusLine.split(\" \", 3);\n const statusCode = parseInt(statusCodeStr, 10);\n if (statusCode >= 400) {\n const err = new Error(`Invalid response: ${statusCode} ${statusText}`);\n err.status = statusCode;\n throw err;\n }\n const filePath = normalisePath(filename);\n return prepareFileFromProps(props, filePath, isDetailed);\n}\n/**\n * Parse a DAV result for a search request\n *\n * @param result The resulting DAV response\n * @param searchArbiter The collection path that was searched\n * @param isDetailed Whether or not the raw props of the resource should be returned\n */\nexport function parseSearch(result, searchArbiter, isDetailed) {\n const response = {\n truncated: false,\n results: []\n };\n response.truncated = result.multistatus.response.some(v => {\n return ((v.status || v.propstat?.status).split(\" \", 3)?.[1] === \"507\" &&\n v.href.replace(/\\/$/, \"\").endsWith(encodePath(searchArbiter).replace(/\\/$/, \"\")));\n });\n result.multistatus.response.forEach(result => {\n if (result.propstat === undefined) {\n return;\n }\n const filename = result.href.split(\"/\").map(decodeURIComponent).join(\"/\");\n response.results.push(prepareFileFromProps(result.propstat.prop, filename, isDetailed));\n });\n return response;\n}\n/**\n * Translate a disk quota indicator to a recognised\n * value (includes \"unlimited\" and \"unknown\")\n * @param value The quota indicator, eg. \"-3\"\n * @returns The value in bytes, or another indicator\n */\nexport function translateDiskSpace(value) {\n switch (value.toString()) {\n case \"-3\":\n return \"unlimited\";\n case \"-2\":\n /* falls-through */\n case \"-1\":\n // -1 is non-computed\n return \"unknown\";\n default:\n return parseInt(value, 10);\n }\n}\n","/**\n * @copyright Copyright (c) 2020 John Molakvoæ \n *\n * @author John Molakvoæ \n *\n * @license AGPL-3.0-or-later\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the\n * License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with this program. If not, see .\n *\n */\nimport { parseXML } from 'webdav';\n// https://github.com/perry-mitchell/webdav-client/issues/339\nimport { processResponsePayload } from '../../../../node_modules/webdav/dist/node/response.js';\nimport { prepareFileFromProps } from '../../../../node_modules/webdav/dist/node/tools/dav.js';\nimport client from './DavClient.js';\nexport const DEFAULT_LIMIT = 20;\n/**\n * Retrieve the comments list\n *\n * @param {object} data destructuring object\n * @param {string} data.resourceType the resource type\n * @param {number} data.resourceId the resource ID\n * @param {object} [options] optional options for axios\n * @param {number} [options.offset] the pagination offset\n * @param {number} [options.limit] the pagination limit, defaults to 20\n * @param {Date} [options.datetime] optional date to query\n * @return {{data: object[]}} the comments list\n */\nexport const getComments = async function ({ resourceType, resourceId }, options) {\n const resourcePath = ['', resourceType, resourceId].join('/');\n const datetime = options.datetime ? `${options.datetime.toISOString()}` : '';\n const response = await client.customRequest(resourcePath, Object.assign({\n method: 'REPORT',\n data: `\n\t\t\t\n\t\t\t\t${options.limit ?? DEFAULT_LIMIT}\n\t\t\t\t${options.offset || 0}\n\t\t\t\t${datetime}\n\t\t\t`,\n }, options));\n const responseData = await response.text();\n const result = await parseXML(responseData);\n const stat = getDirectoryFiles(result, true);\n return processResponsePayload(response, stat, true);\n};\n// https://github.com/perry-mitchell/webdav-client/blob/8d9694613c978ce7404e26a401c39a41f125f87f/source/operations/directoryContents.ts\nconst getDirectoryFiles = function (result, isDetailed = false) {\n // Extract the response items (directory contents)\n const { multistatus: { response: responseItems }, } = result;\n // Map all items to a consistent output structure (results)\n return responseItems.map(item => {\n // Each item should contain a stat object\n const { propstat: { prop: props }, } = item;\n return prepareFileFromProps(props, props.id.toString(), isDetailed);\n });\n};\n","import minimatch from \"minimatch\";\nimport { convertResponseHeaders } from \"./tools/headers.js\";\nexport function createErrorFromResponse(response, prefix = \"\") {\n const err = new Error(`${prefix}Invalid response: ${response.status} ${response.statusText}`);\n err.status = response.status;\n err.response = response;\n return err;\n}\nexport function handleResponseCode(context, response) {\n const { status } = response;\n if (status === 401 && context.digest)\n return response;\n if (status >= 400) {\n const err = createErrorFromResponse(response);\n throw err;\n }\n return response;\n}\nexport function processGlobFilter(files, glob) {\n return files.filter(file => minimatch(file.filename, glob, { matchBase: true }));\n}\n/**\n * Process a response payload (eg. from `customRequest`) and\n * prepare it for further processing. Exposed for custom\n * request handling.\n * @param response The response for a request\n * @param data The data returned\n * @param isDetailed Whether or not a detailed result is\n * requested\n * @returns The response data, or a detailed response object\n * if required\n */\nexport function processResponsePayload(response, data, isDetailed = false) {\n return isDetailed\n ? {\n data,\n headers: response.headers ? convertResponseHeaders(response.headers) : {},\n status: response.status,\n statusText: response.statusText\n }\n : data;\n}\n","import axios from '@nextcloud/axios';\nimport { getCurrentUser } from '@nextcloud/auth';\nimport { loadState } from '@nextcloud/initial-state';\nimport { generateOcsUrl } from '@nextcloud/router';\nimport { defineComponent } from 'vue';\nexport default defineComponent({\n props: {\n resourceId: {\n type: Number,\n required: true,\n },\n resourceType: {\n type: String,\n default: 'files',\n },\n },\n data() {\n return {\n editorData: {\n actorDisplayName: getCurrentUser().displayName,\n actorId: getCurrentUser().uid,\n key: 'editor',\n },\n userData: {},\n };\n },\n methods: {\n /**\n * Autocomplete @mentions\n *\n * @param {string} search the query\n * @param {Function} callback the callback to process the results with\n */\n async autoComplete(search, callback) {\n const { data } = await axios.get(generateOcsUrl('core/autocomplete/get'), {\n params: {\n search,\n itemType: 'files',\n itemId: this.resourceId,\n sorter: 'commenters|share-recipients',\n limit: loadState('comments', 'maxAutoCompleteResults'),\n },\n });\n // Save user data so it can be used by the editor to replace mentions\n data.ocs.data.forEach(user => { this.userData[user.id] = user; });\n return callback(Object.values(this.userData));\n },\n /**\n * Make sure we have all mentions as Array of objects\n *\n * @param mentions the mentions list\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n genMentionsData(mentions) {\n Object.values(mentions)\n .flat()\n .forEach(mention => {\n this.userData[mention.mentionId] = {\n // TODO: support groups\n icon: 'icon-user',\n id: mention.mentionId,\n label: mention.mentionDisplayName,\n source: 'users',\n primary: getCurrentUser()?.uid === mention.mentionId,\n };\n });\n return this.userData;\n },\n },\n});\n","\n\n\n\t\n\t\t\n\t\t
\n\n\t\t
\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t
\n\n\t\t\t\n\t\t\t\n\n\t\t\t\n\n\t\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t\n\t