nextcloud-server/dist/comments-comments-tab.js.map

{"version":3,"file":"comments-comments-tab.js?v=e141523520183bf2ad2e","mappings":"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","sources":["webpack:///nextcloud/webpack/runtime/chunk loaded","webpack:///nextcloud/webpack/runtime/load script","webpack:///nextcloud/node_modules/webdav/node_modules/minimatch/dist/mjs/brace-expressions.js","webpack:///nextcloud/node_modules/webdav/node_modules/minimatch/dist/mjs/index.js","webpack:///nextcloud/node_modules/webdav/node_modules/minimatch/dist/mjs/escape.js","webpack:///nextcloud/node_modules/webdav/node_modules/minimatch/dist/mjs/unescape.js","webpack:///nextcloud/node_modules/webdav/dist/node/tools/dav.js","webpack:///nextcloud/apps/comments/src/services/GetComments.ts","webpack:///nextcloud/apps/comments/src/comments-activity-tab.ts","webpack:///nextcloud/apps/comments/src/comments-tab.js","webpack:///nextcloud/node_modules/webdav/dist/node/response.js","webpack:///nextcloud/apps/comments/src/logger.js","webpack:///nextcloud/apps/comments/src/services/DavClient.js","webpack:///nextcloud/apps/comments/src/utils/davUtils.js","webpack:///nextcloud/node_modules/balanced-match/index.js","webpack:///nextcloud/node_modules/fast-xml-parser/src/fxp.js","webpack:///nextcloud/node_modules/moment/locale|sync|/^\\.\\/.*$","webpack:///nextcloud/node_modules/nested-property/dist/nested-property.js","webpack:///nextcloud/node_modules/path-posix/index.js","webpack:///nextcloud/node_modules/webdav/node_modules/brace-expansion/index.js","webpack:///nextcloud/webpack/bootstrap","webpack:///nextcloud/webpack/runtime/compat get default export","webpack:///nextcloud/webpack/runtime/define property getters","webpack:///nextcloud/webpack/runtime/ensure chunk","webpack:///nextcloud/webpack/runtime/get javascript chunk filename","webpack:///nextcloud/webpack/runtime/global","webpack:///nextcloud/webpack/runtime/hasOwnProperty shorthand","webpack:///nextcloud/webpack/runtime/make namespace object","webpack:///nextcloud/webpack/runtime/node module decorator","webpack:///nextcloud/webpack/runtime/runtimeId","webpack:///nextcloud/webpack/runtime/publicPath","webpack:///nextcloud/webpack/runtime/jsonp chunk loading","webpack:///nextcloud/webpack/runtime/nonce","webpack:///nextcloud/webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"nextcloud:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","// translate the various posix character classes into unicode properties\n// this works across all unicode locales\n// { <posix class>: [<translation>, /u flag required, negated]\nconst posixClasses = {\n    '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}', true],\n    '[:alpha:]': ['\\\\p{L}\\\\p{Nl}', true],\n    '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f', false],\n    '[:blank:]': ['\\\\p{Zs}\\\\t', true],\n    '[:cntrl:]': ['\\\\p{Cc}', true],\n    '[:digit:]': ['\\\\p{Nd}', true],\n    '[:graph:]': ['\\\\p{Z}\\\\p{C}', true, true],\n    '[:lower:]': ['\\\\p{Ll}', true],\n    '[:print:]': ['\\\\p{C}', true],\n    '[:punct:]': ['\\\\p{P}', true],\n    '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f', true],\n    '[:upper:]': ['\\\\p{Lu}', true],\n    '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}', true],\n    '[:xdigit:]': ['A-Fa-f0-9', false],\n};\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s) => s.replace(/[[\\]\\\\-]/g, '\\\\$&');\n// escape all regexp magic characters\nconst regexpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// everything has already been escaped, we just have to join\nconst rangesToString = (ranges) => ranges.join('');\n// takes a glob string at a posix brace expression, and returns\n// an equivalent regular expression source, and boolean indicating\n// whether the /u flag needs to be applied, and the number of chars\n// consumed to parse the character class.\n// This also removes out of order ranges, and returns ($.) if the\n// entire class just no good.\nexport const parseClass = (glob, position) => {\n    const pos = position;\n    /* c8 ignore start */\n    if (glob.charAt(pos) !== '[') {\n        throw new Error('not in a brace expression');\n    }\n    /* c8 ignore stop */\n    const ranges = [];\n    const negs = [];\n    let i = pos + 1;\n    let sawStart = false;\n    let uflag = false;\n    let escaping = false;\n    let negate = false;\n    let endPos = pos;\n    let rangeStart = '';\n    WHILE: while (i < glob.length) {\n        const c = glob.charAt(i);\n        if ((c === '!' || c === '^') && i === pos + 1) {\n            negate = true;\n            i++;\n            continue;\n        }\n        if (c === ']' && sawStart && !escaping) {\n            endPos = i + 1;\n            break;\n        }\n        sawStart = true;\n        if (c === '\\\\') {\n            if (!escaping) {\n                escaping = true;\n                i++;\n                continue;\n            }\n            // escaped \\ char, fall through and treat like normal char\n        }\n        if (c === '[' && !escaping) {\n            // either a posix class, a collation equivalent, or just a [\n            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {\n                if (glob.startsWith(cls, i)) {\n                    // invalid, [a-[] is fine, but not [a-[:alpha]]\n                    if (rangeStart) {\n                        return ['$.', false, glob.length - pos, true];\n                    }\n                    i += cls.length;\n                    if (neg)\n                        negs.push(unip);\n                    else\n                        ranges.push(unip);\n                    uflag = uflag || u;\n                    continue WHILE;\n                }\n            }\n        }\n        // now it's just a normal character, effectively\n        escaping = false;\n        if (rangeStart) {\n            // throw this range away if it's not valid, but others\n            // can still match.\n            if (c > rangeStart) {\n                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));\n            }\n            else if (c === rangeStart) {\n                ranges.push(braceEscape(c));\n            }\n            rangeStart = '';\n            i++;\n            continue;\n        }\n        // now might be the start of a range.\n        // can be either c-d or c-] or c<more...>] or c] at this point\n        if (glob.startsWith('-]', i + 1)) {\n            ranges.push(braceEscape(c + '-'));\n            i += 2;\n            continue;\n        }\n        if (glob.startsWith('-', i + 1)) {\n            rangeStart = c;\n            i += 2;\n            continue;\n        }\n        // not the start of a range, just a single character\n        ranges.push(braceEscape(c));\n        i++;\n    }\n    if (endPos < i) {\n        // didn't see the end of the class, not a valid class,\n        // but might still be valid as a literal match.\n        return ['', false, 0, false];\n    }\n    // if we got no ranges and no negates, then we have a range that\n    // cannot possibly match anything, and that poisons the whole glob\n    if (!ranges.length && !negs.length) {\n        return ['$.', false, glob.length - pos, true];\n    }\n    // if we got one positive range, and it's a single character, then that's\n    // not actually a magic pattern, it's just that one literal character.\n    // we should not treat that as \"magic\", we should just return the literal\n    // character. [_] is a perfectly valid way to escape glob magic chars.\n    if (negs.length === 0 &&\n        ranges.length === 1 &&\n        /^\\\\?.$/.test(ranges[0]) &&\n        !negate) {\n        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];\n        return [regexpEscape(r), false, endPos - pos, false];\n    }\n    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';\n    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';\n    const comb = ranges.length && negs.length\n        ? '(' + sranges + '|' + snegs + ')'\n        : ranges.length\n            ? sranges\n            : snegs;\n    return [comb, uflag, endPos - pos, true];\n};\n//# sourceMappingURL=brace-expressions.js.map","import expand from 'brace-expansion';\nimport { parseClass } from './brace-expressions.js';\nimport { escape } from './escape.js';\nimport { unescape } from './unescape.js';\nexport const minimatch = (p, pattern, options = {}) => {\n    assertValidPattern(pattern);\n    // shortcut: comments match nothing.\n    if (!options.nocomment && pattern.charAt(0) === '#') {\n        return false;\n    }\n    return new Minimatch(pattern, options).match(p);\n};\nexport default minimatch;\n// Optimized checking for the most common glob patterns.\nconst starDotExtRE = /^\\*+([^+@!?\\*\\[\\(]*)$/;\nconst starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);\nconst starDotExtTestDot = (ext) => (f) => f.endsWith(ext);\nconst starDotExtTestNocase = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);\n};\nconst starDotExtTestNocaseDot = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => f.toLowerCase().endsWith(ext);\n};\nconst starDotStarRE = /^\\*+\\.\\*+$/;\nconst starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');\nconst starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');\nconst dotStarRE = /^\\.\\*+$/;\nconst dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');\nconst starRE = /^\\*+$/;\nconst starTest = (f) => f.length !== 0 && !f.startsWith('.');\nconst starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';\nconst qmarksRE = /^\\?+([^+@!?\\*\\[\\(]*)?$/;\nconst qmarksTestNocase = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestNocaseDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTest = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTestNoExt = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && !f.startsWith('.');\n};\nconst qmarksTestNoExtDot = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && f !== '.' && f !== '..';\n};\n/* c8 ignore start */\nconst defaultPlatform = (typeof process === 'object' && process\n    ? (typeof process.env === 'object' &&\n        process.env &&\n        process.env.__MINIMATCH_TESTING_PLATFORM__) ||\n        process.platform\n    : 'posix');\nconst path = {\n    win32: { sep: '\\\\' },\n    posix: { sep: '/' },\n};\n/* c8 ignore stop */\nexport const sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;\nminimatch.sep = sep;\nexport const GLOBSTAR = Symbol('globstar **');\nminimatch.GLOBSTAR = GLOBSTAR;\nconst plTypes = {\n    '!': { open: '(?:(?!(?:', close: '))[^/]*?)' },\n    '?': { open: '(?:', close: ')?' },\n    '+': { open: '(?:', close: ')+' },\n    '*': { open: '(?:', close: ')*' },\n    '@': { open: '(?:', close: ')' },\n};\n// any single thing other than /\n// don't need to escape / when using new RegExp()\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// ** when dots are allowed.  Anything goes, except .. and .\n// not (^ or / followed by one or two dots followed by $ or /),\n// followed by anything, any number of times.\nconst twoStarDot = '(?:(?!(?:\\\\/|^)(?:\\\\.{1,2})($|\\\\/)).)*?';\n// not a ^ or / followed by a dot,\n// followed by anything, any number of times.\nconst twoStarNoDot = '(?:(?!(?:\\\\/|^)\\\\.).)*?';\n// \"abc\" -> { a:true, b:true, c:true }\nconst charSet = (s) => s.split('').reduce((set, c) => {\n    set[c] = true;\n    return set;\n}, {});\n// characters that need to be escaped in RegExp.\nconst reSpecials = charSet('().*{}+?[]^$\\\\!');\n// characters that indicate we have to add the pattern start\nconst addPatternStartSet = charSet('[.(');\nexport const filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);\nminimatch.filter = filter;\nconst ext = (a, b = {}) => Object.assign({}, a, b);\nexport const defaults = (def) => {\n    if (!def || typeof def !== 'object' || !Object.keys(def).length) {\n        return minimatch;\n    }\n    const orig = minimatch;\n    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));\n    return Object.assign(m, {\n        Minimatch: class Minimatch extends orig.Minimatch {\n            constructor(pattern, options = {}) {\n                super(pattern, ext(def, options));\n            }\n            static defaults(options) {\n                return orig.defaults(ext(def, options)).Minimatch;\n            }\n        },\n        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),\n        escape: (s, options = {}) => orig.escape(s, ext(def, options)),\n        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),\n        defaults: (options) => orig.defaults(ext(def, options)),\n        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),\n        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),\n        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),\n        sep: orig.sep,\n        GLOBSTAR: GLOBSTAR,\n    });\n};\nminimatch.defaults = defaults;\n// Brace expansion:\n// a{b,c}d -> abd acd\n// a{b,}c -> abc ac\n// a{0..3}d -> a0d a1d a2d a3d\n// a{b,c{d,e}f}g -> abg acdfg acefg\n// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg\n//\n// Invalid sets are not expanded.\n// a{2..}b -> a{2..}b\n// a{b}c -> a{b}c\nexport const braceExpand = (pattern, options = {}) => {\n    assertValidPattern(pattern);\n    // Thanks to Yeting Li <https://github.com/yetingli> for\n    // improving this regexp to avoid a ReDOS vulnerability.\n    if (options.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(pattern)) {\n        // shortcut. no need to expand.\n        return [pattern];\n    }\n    return expand(pattern);\n};\nminimatch.braceExpand = braceExpand;\nconst MAX_PATTERN_LENGTH = 1024 * 64;\nconst assertValidPattern = (pattern) => {\n    if (typeof pattern !== 'string') {\n        throw new TypeError('invalid pattern');\n    }\n    if (pattern.length > MAX_PATTERN_LENGTH) {\n        throw new TypeError('pattern is too long');\n    }\n};\n// parse a component of the expanded set.\n// At this point, no pattern may contain \"/\" in it\n// so we're going to return a 2d array, where each entry is the full\n// pattern, split on '/', and then turned into a regular expression.\n// A regexp is made at the end which joins each array with an\n// escaped /, and another full one which joins each regexp with |.\n//\n// Following the lead of Bash 4.1, note that \"**\" only has special meaning\n// when it is the *only* thing in a path portion.  Otherwise, any series\n// of * is equivalent to a single *.  Globstar behavior is enabled by\n// default, and can be disabled by setting options.noglobstar.\nexport const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();\nminimatch.makeRe = makeRe;\nexport const match = (list, pattern, options = {}) => {\n    const mm = new Minimatch(pattern, options);\n    list = list.filter(f => mm.match(f));\n    if (mm.options.nonull && !list.length) {\n        list.push(pattern);\n    }\n    return list;\n};\nminimatch.match = match;\n// replace stuff like \\* with *\nconst globUnescape = (s) => s.replace(/\\\\(.)/g, '$1');\nconst globMagic = /[?*]|[+@!]\\(.*?\\)|\\[|\\]/;\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\nexport class Minimatch {\n    options;\n    set;\n    pattern;\n    windowsPathsNoEscape;\n    nonegate;\n    negate;\n    comment;\n    empty;\n    preserveMultipleSlashes;\n    partial;\n    globSet;\n    globParts;\n    nocase;\n    isWindows;\n    platform;\n    windowsNoMagicRoot;\n    regexp;\n    constructor(pattern, options = {}) {\n        assertValidPattern(pattern);\n        options = options || {};\n        this.options = options;\n        this.pattern = pattern;\n        this.platform = options.platform || defaultPlatform;\n        this.isWindows = this.platform === 'win32';\n        this.windowsPathsNoEscape =\n            !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;\n        if (this.windowsPathsNoEscape) {\n            this.pattern = this.pattern.replace(/\\\\/g, '/');\n        }\n        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;\n        this.regexp = null;\n        this.negate = false;\n        this.nonegate = !!options.nonegate;\n        this.comment = false;\n        this.empty = false;\n        this.partial = !!options.partial;\n        this.nocase = !!this.options.nocase;\n        this.windowsNoMagicRoot =\n            options.windowsNoMagicRoot !== undefined\n                ? options.windowsNoMagicRoot\n                : !!(this.isWindows && this.nocase);\n        this.globSet = [];\n        this.globParts = [];\n        this.set = [];\n        // make the set of regexps etc.\n        this.make();\n    }\n    hasMagic() {\n        if (this.options.magicalBraces && this.set.length > 1) {\n            return true;\n        }\n        for (const pattern of this.set) {\n            for (const part of pattern) {\n                if (typeof part !== 'string')\n                    return true;\n            }\n        }\n        return false;\n    }\n    debug(..._) { }\n    make() {\n        const pattern = this.pattern;\n        const options = this.options;\n        // empty patterns and comments match nothing.\n        if (!options.nocomment && pattern.charAt(0) === '#') {\n            this.comment = true;\n            return;\n        }\n        if (!pattern) {\n            this.empty = true;\n            return;\n        }\n        // step 1: figure out negation, etc.\n        this.parseNegate();\n        // step 2: expand braces\n        this.globSet = [...new Set(this.braceExpand())];\n        if (options.debug) {\n            this.debug = (...args) => console.error(...args);\n        }\n        this.debug(this.pattern, this.globSet);\n        // step 3: now we have a set, so turn each one into a series of\n        // path-portion matching patterns.\n        // These will be regexps, except in the case of \"**\", which is\n        // set to the GLOBSTAR object for globstar behavior,\n        // and will not contain any / characters\n        //\n        // First, we preprocess to make the glob pattern sets a bit simpler\n        // and deduped.  There are some perf-killing patterns that can cause\n        // problems with a glob walk, but we can simplify them down a bit.\n        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));\n        this.globParts = this.preprocess(rawGlobParts);\n        this.debug(this.pattern, this.globParts);\n        // glob --> regexps\n        let set = this.globParts.map((s, _, __) => {\n            if (this.isWindows && this.windowsNoMagicRoot) {\n                // check if it's a drive or unc path.\n                const isUNC = s[0] === '' &&\n                    s[1] === '' &&\n                    (s[2] === '?' || !globMagic.test(s[2])) &&\n                    !globMagic.test(s[3]);\n                const isDrive = /^[a-z]:/i.test(s[0]);\n                if (isUNC) {\n                    return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];\n                }\n                else if (isDrive) {\n                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];\n                }\n            }\n            return s.map(ss => this.parse(ss));\n        });\n        this.debug(this.pattern, set);\n        // filter out everything that didn't compile properly.\n        this.set = set.filter(s => s.indexOf(false) === -1);\n        // do not treat the ? in UNC paths as magic\n        if (this.isWindows) {\n            for (let i = 0; i < this.set.length; i++) {\n                const p = this.set[i];\n                if (p[0] === '' &&\n                    p[1] === '' &&\n                    this.globParts[i][2] === '?' &&\n                    typeof p[3] === 'string' &&\n                    /^[a-z]:$/i.test(p[3])) {\n                    p[2] = '?';\n                }\n            }\n        }\n        this.debug(this.pattern, this.set);\n    }\n    // various transforms to equivalent pattern sets that are\n    // faster to process in a filesystem walk.  The goal is to\n    // eliminate what we can, and push all ** patterns as far\n    // to the right as possible, even if it increases the number\n    // of patterns that we have to process.\n    preprocess(globParts) {\n        // if we're not in globstar mode, then turn all ** into *\n        if (this.options.noglobstar) {\n            for (let i = 0; i < globParts.length; i++) {\n                for (let j = 0; j < globParts[i].length; j++) {\n                    if (globParts[i][j] === '**') {\n                        globParts[i][j] = '*';\n                    }\n                }\n            }\n        }\n        const { optimizationLevel = 1 } = this.options;\n        if (optimizationLevel >= 2) {\n            // aggressive optimization for the purpose of fs walking\n            globParts = this.firstPhasePreProcess(globParts);\n            globParts = this.secondPhasePreProcess(globParts);\n        }\n        else if (optimizationLevel >= 1) {\n            // just basic optimizations to remove some .. parts\n            globParts = this.levelOneOptimize(globParts);\n        }\n        else {\n            globParts = this.adjascentGlobstarOptimize(globParts);\n        }\n        return globParts;\n    }\n    // just get rid of adjascent ** portions\n    adjascentGlobstarOptimize(globParts) {\n        return globParts.map(parts => {\n            let gs = -1;\n            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                let i = gs;\n                while (parts[i + 1] === '**') {\n                    i++;\n                }\n                if (i !== gs) {\n                    parts.splice(gs, i - gs);\n                }\n            }\n            return parts;\n        });\n    }\n    // get rid of adjascent ** and resolve .. portions\n    levelOneOptimize(globParts) {\n        return globParts.map(parts => {\n            parts = parts.reduce((set, part) => {\n                const prev = set[set.length - 1];\n                if (part === '**' && prev === '**') {\n                    return set;\n                }\n                if (part === '..') {\n                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {\n                        set.pop();\n                        return set;\n                    }\n                }\n                set.push(part);\n                return set;\n            }, []);\n            return parts.length === 0 ? [''] : parts;\n        });\n    }\n    levelTwoFileOptimize(parts) {\n        if (!Array.isArray(parts)) {\n            parts = this.slashSplit(parts);\n        }\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // <pre>/<e>/<rest> -> <pre>/<rest>\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            // <pre>/<p>/../<rest> -> <pre>/<rest>\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    // <pre> is 1 or more portions\n    // <rest> is 1 or more portions\n    // <p> is any portion other than ., .., '', or **\n    // <e> 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    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n    // <pre>/<e>/<rest> -> <pre>/<rest>\n    // <pre>/<p>/../<rest> -> <pre>/<rest>\n    // **/**/<rest> -> **/<rest>\n    //\n    // **/*/<rest> -> */**/<rest> <== 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            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\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                        // <pre>/**/**/<rest> -> <pre>/**/<rest>\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                // <pre>/<e>/<rest> -> <pre>/<rest>\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                // <pre>/<p>/../<rest> -> <pre>/<rest>\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    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>\n    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>\n    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>\n    //\n    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>\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 *.<ext>  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)(?:<rest>))[^/]*)\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 (?:<pattern>)<type>\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æ <skjnldsv@protonmail.com>\n *\n * @author John Molakvoæ <skjnldsv@protonmail.com>\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 <http://www.gnu.org/licenses/>.\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 ? `<oc:datetime>${options.datetime.toISOString()}</oc:datetime>` : '';\n    const response = await client.customRequest(resourcePath, Object.assign({\n        method: 'REPORT',\n        data: `<?xml version=\"1.0\"?>\n\t\t\t<oc:filter-comments\n\t\t\t\txmlns:d=\"DAV:\"\n\t\t\t\txmlns:oc=\"http://owncloud.org/ns\"\n\t\t\t\txmlns:nc=\"http://nextcloud.org/ns\"\n\t\t\t\txmlns:ocs=\"http://open-collaboration-services.org/ns\">\n\t\t\t\t<oc:limit>${options.limit ?? DEFAULT_LIMIT}</oc:limit>\n\t\t\t\t<oc:offset>${options.offset || 0}</oc:offset>\n\t\t\t\t${datetime}\n\t\t\t</oc:filter-comments>`,\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","/**\n * @copyright Copyright (c) 2023 Ferdinand Thiessen <opensource@fthiessen.de>\n *\n * @author Ferdinand Thiessen <opensource@fthiessen.de>\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 <http://www.gnu.org/licenses/>.\n *\n */\nimport moment from '@nextcloud/moment';\nimport Vue from 'vue';\nimport logger from './logger.js';\nimport { getComments } from './services/GetComments.js';\nlet ActivityTabPluginView;\nlet ActivityTabPluginInstance;\n/**\n * Register the comments plugins for the Activity sidebar\n */\nexport function registerCommentsPlugins() {\n    window.OCA.Activity.registerSidebarAction({\n        mount: async (el, { context, fileInfo, reload }) => {\n            if (!ActivityTabPluginView) {\n                const { default: ActivityCommmentAction } = await import('./views/ActivityCommentAction.vue');\n                ActivityTabPluginView = Vue.extend(ActivityCommmentAction);\n            }\n            ActivityTabPluginInstance = new ActivityTabPluginView({\n                parent: context,\n                propsData: {\n                    reloadCallback: reload,\n                    resourceId: fileInfo.id,\n                },\n            });\n            ActivityTabPluginInstance.$mount(el);\n            logger.info('Comments plugin mounted in Activity sidebar action', { fileInfo });\n        },\n        unmount: () => {\n            // destroy previous instance if available\n            if (ActivityTabPluginInstance) {\n                ActivityTabPluginInstance.$destroy();\n            }\n        },\n    });\n    window.OCA.Activity.registerSidebarEntries(async ({ fileInfo, limit, offset }) => {\n        const { data: comments } = await getComments({ resourceType: 'files', resourceId: fileInfo.id }, { limit, offset });\n        logger.debug('Loaded comments', { fileInfo, comments });\n        const { default: CommentView } = await import('./views/ActivityCommentEntry.vue');\n        const CommentsViewObject = Vue.extend(CommentView);\n        return comments.map((comment) => ({\n            timestamp: moment(comment.props.creationDateTime).toDate().getTime(),\n            mount(element, { context, reload }) {\n                this._CommentsViewInstance = new CommentsViewObject({\n                    parent: context,\n                    propsData: {\n                        comment,\n                        resourceId: fileInfo.id,\n                        reloadCallback: reload,\n                    },\n                });\n                this._CommentsViewInstance.$mount(element);\n            },\n            unmount() {\n                this._CommentsViewInstance.$destroy();\n            },\n        }));\n    });\n    window.OCA.Activity.registerSidebarFilter((activity) => activity.type !== 'comments');\n    logger.info('Comments plugin registered for Activity sidebar action');\n}\n","/**\n * @copyright Copyright (c) 2020 John Molakvoæ <skjnldsv@protonmail.com>\n *\n * @author John Molakvoæ <skjnldsv@protonmail.com>\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 <http://www.gnu.org/licenses/>.\n *\n */\n\n// eslint-disable-next-line n/no-missing-import, import/no-unresolved\nimport MessageReplyText from '@mdi/svg/svg/message-reply-text.svg?raw'\nimport { getRequestToken } from '@nextcloud/auth'\nimport { loadState } from '@nextcloud/initial-state'\nimport { registerCommentsPlugins } from './comments-activity-tab.ts'\n\n// @ts-expect-error __webpack_nonce__ is injected by webpack\n__webpack_nonce__ = btoa(getRequestToken())\n\nif (loadState('comments', 'activityEnabled', false) && OCA?.Activity?.registerSidebarAction !== undefined) {\n\t// Do not mount own tab but mount into activity\n\twindow.addEventListener('DOMContentLoaded', function() {\n\t\tregisterCommentsPlugins()\n\t})\n} else {\n\t// Init Comments tab component\n\tlet TabInstance = null\n\tconst commentTab = new OCA.Files.Sidebar.Tab({\n\t\tid: 'comments',\n\t\tname: t('comments', 'Comments'),\n\t\ticonSvg: MessageReplyText,\n\n\t\tasync mount(el, fileInfo, context) {\n\t\t\tif (TabInstance) {\n\t\t\t\tTabInstance.$destroy()\n\t\t\t}\n\t\t\tTabInstance = new OCA.Comments.View('files', {\n\t\t\t\t// Better integration with vue parent component\n\t\t\t\tparent: context,\n\t\t\t})\n\t\t\t// Only mount after we have all the info we need\n\t\t\tawait TabInstance.update(fileInfo.id)\n\t\t\tTabInstance.$mount(el)\n\t\t},\n\t\tupdate(fileInfo) {\n\t\t\tTabInstance.update(fileInfo.id)\n\t\t},\n\t\tdestroy() {\n\t\t\tTabInstance.$destroy()\n\t\t\tTabInstance = null\n\t\t},\n\t\tscrollBottomReached() {\n\t\t\tTabInstance.onScrollBottomReached()\n\t\t},\n\t})\n\n\twindow.addEventListener('DOMContentLoaded', function() {\n\t\tif (OCA.Files && OCA.Files.Sidebar) {\n\t\t\tOCA.Files.Sidebar.registerTab(commentTab)\n\t\t}\n\t})\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","/**\n * @copyright Copyright (c) 2023 Lucas Azevedo <lhs_azevedo@hotmail.com>\n *\n * @author Lucas Azevedo <lhs_azevedo@hotmail.com>\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 <http://www.gnu.org/licenses/>.\n *\n */\n\nimport { getLoggerBuilder } from '@nextcloud/logger'\n\nexport default getLoggerBuilder()\n\t.setApp('comments')\n\t.detectUser()\n\t.build()\n","/**\n * @copyright Copyright (c) 2021 John Molakvoæ <skjnldsv@protonmail.com>\n *\n * @author John Molakvoæ <skjnldsv@protonmail.com>\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 <http://www.gnu.org/licenses/>.\n *\n */\n\nimport { createClient } from 'webdav'\nimport { getRootPath } from '../utils/davUtils.js'\nimport { getRequestToken } from '@nextcloud/auth'\n\n// init webdav client\nconst client = createClient(getRootPath(), {\n\theaders: {\n\t\t// Add this so the server knows it is an request from the browser\n\t\t'X-Requested-With': 'XMLHttpRequest',\n\t\t// Inject user auth\n\t\trequesttoken: getRequestToken() ?? '',\n\t},\n})\n\nexport default client\n","/**\n * @copyright Copyright (c) 2020 John Molakvoæ <skjnldsv@protonmail.com>\n *\n * @author John Molakvoæ <skjnldsv@protonmail.com>\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 <http://www.gnu.org/licenses/>.\n *\n */\n\nimport { generateRemoteUrl } from '@nextcloud/router'\n\nconst getRootPath = function() {\n\treturn generateRemoteUrl('dav/comments')\n}\n\nexport { getRootPath }\n","'use strict';\nmodule.exports = balanced;\nfunction balanced(a, b, str) {\n  if (a instanceof RegExp) a = maybeMatch(a, str);\n  if (b instanceof RegExp) b = maybeMatch(b, str);\n\n  var r = range(a, b, str);\n\n  return r && {\n    start: r[0],\n    end: r[1],\n    pre: str.slice(0, r[0]),\n    body: str.slice(r[0] + a.length, r[1]),\n    post: str.slice(r[1] + b.length)\n  };\n}\n\nfunction maybeMatch(reg, str) {\n  var m = str.match(reg);\n  return m ? m[0] : null;\n}\n\nbalanced.range = range;\nfunction range(a, b, str) {\n  var begs, beg, left, right, result;\n  var ai = str.indexOf(a);\n  var bi = str.indexOf(b, ai + 1);\n  var i = ai;\n\n  if (ai >= 0 && bi > 0) {\n    if(a===b) {\n      return [ai, bi];\n    }\n    begs = [];\n    left = str.length;\n\n    while (i >= 0 && !result) {\n      if (i == ai) {\n        begs.push(i);\n        ai = str.indexOf(a, i + 1);\n      } else if (begs.length == 1) {\n        result = [ begs.pop(), bi ];\n      } else {\n        beg = begs.pop();\n        if (beg < left) {\n          left = beg;\n          right = bi;\n        }\n\n        bi = str.indexOf(b, i + 1);\n      }\n\n      i = ai < bi && ai >= 0 ? ai : bi;\n    }\n\n    if (begs.length) {\n      result = [ left, right ];\n    }\n  }\n\n  return result;\n}\n","'use strict';\n\nconst validator = require('./validator');\nconst XMLParser = require('./xmlparser/XMLParser');\nconst XMLBuilder = require('./xmlbuilder/json2xml');\n\nmodule.exports = {\n  XMLParser: XMLParser,\n  XMLValidator: validator,\n  XMLBuilder: XMLBuilder\n}","var map = {\n\t\"./af\": 42786,\n\t\"./af.js\": 42786,\n\t\"./ar\": 30867,\n\t\"./ar-dz\": 14130,\n\t\"./ar-dz.js\": 14130,\n\t\"./ar-kw\": 96135,\n\t\"./ar-kw.js\": 96135,\n\t\"./ar-ly\": 56440,\n\t\"./ar-ly.js\": 56440,\n\t\"./ar-ma\": 47702,\n\t\"./ar-ma.js\": 47702,\n\t\"./ar-sa\": 16040,\n\t\"./ar-sa.js\": 16040,\n\t\"./ar-tn\": 37100,\n\t\"./ar-tn.js\": 37100,\n\t\"./ar.js\": 30867,\n\t\"./az\": 31083,\n\t\"./az.js\": 31083,\n\t\"./be\": 9808,\n\t\"./be.js\": 9808,\n\t\"./bg\": 68338,\n\t\"./bg.js\": 68338,\n\t\"./bm\": 67438,\n\t\"./bm.js\": 67438,\n\t\"./bn\": 8905,\n\t\"./bn-bd\": 76225,\n\t\"./bn-bd.js\": 76225,\n\t\"./bn.js\": 8905,\n\t\"./bo\": 11560,\n\t\"./bo.js\": 11560,\n\t\"./br\": 1278,\n\t\"./br.js\": 1278,\n\t\"./bs\": 80622,\n\t\"./bs.js\": 80622,\n\t\"./ca\": 2468,\n\t\"./ca.js\": 2468,\n\t\"./cs\": 5822,\n\t\"./cs.js\": 5822,\n\t\"./cv\": 50877,\n\t\"./cv.js\": 50877,\n\t\"./cy\": 47373,\n\t\"./cy.js\": 47373,\n\t\"./da\": 24780,\n\t\"./da.js\": 24780,\n\t\"./de\": 59740,\n\t\"./de-at\": 60217,\n\t\"./de-at.js\": 60217,\n\t\"./de-ch\": 60894,\n\t\"./de-ch.js\": 60894,\n\t\"./de.js\": 59740,\n\t\"./dv\": 5300,\n\t\"./dv.js\": 5300,\n\t\"./el\": 50837,\n\t\"./el.js\": 50837,\n\t\"./en-au\": 78348,\n\t\"./en-au.js\": 78348,\n\t\"./en-ca\": 77925,\n\t\"./en-ca.js\": 77925,\n\t\"./en-gb\": 22243,\n\t\"./en-gb.js\": 22243,\n\t\"./en-ie\": 46436,\n\t\"./en-ie.js\": 46436,\n\t\"./en-il\": 47207,\n\t\"./en-il.js\": 47207,\n\t\"./en-in\": 44175,\n\t\"./en-in.js\": 44175,\n\t\"./en-nz\": 76319,\n\t\"./en-nz.js\": 76319,\n\t\"./en-sg\": 31662,\n\t\"./en-sg.js\": 31662,\n\t\"./eo\": 92915,\n\t\"./eo.js\": 92915,\n\t\"./es\": 55655,\n\t\"./es-do\": 55251,\n\t\"./es-do.js\": 55251,\n\t\"./es-mx\": 96112,\n\t\"./es-mx.js\": 96112,\n\t\"./es-us\": 71146,\n\t\"./es-us.js\": 71146,\n\t\"./es.js\": 55655,\n\t\"./et\": 5603,\n\t\"./et.js\": 5603,\n\t\"./eu\": 77763,\n\t\"./eu.js\": 77763,\n\t\"./fa\": 76959,\n\t\"./fa.js\": 76959,\n\t\"./fi\": 11897,\n\t\"./fi.js\": 11897,\n\t\"./fil\": 42549,\n\t\"./fil.js\": 42549,\n\t\"./fo\": 94694,\n\t\"./fo.js\": 94694,\n\t\"./fr\": 94470,\n\t\"./fr-ca\": 63049,\n\t\"./fr-ca.js\": 63049,\n\t\"./fr-ch\": 52330,\n\t\"./fr-ch.js\": 52330,\n\t\"./fr.js\": 94470,\n\t\"./fy\": 5044,\n\t\"./fy.js\": 5044,\n\t\"./ga\": 29295,\n\t\"./ga.js\": 29295,\n\t\"./gd\": 2101,\n\t\"./gd.js\": 2101,\n\t\"./gl\": 38794,\n\t\"./gl.js\": 38794,\n\t\"./gom-deva\": 27884,\n\t\"./gom-deva.js\": 27884,\n\t\"./gom-latn\": 23168,\n\t\"./gom-latn.js\": 23168,\n\t\"./gu\": 95349,\n\t\"./gu.js\": 95349,\n\t\"./he\": 24206,\n\t\"./he.js\": 24206,\n\t\"./hi\": 30094,\n\t\"./hi.js\": 30094,\n\t\"./hr\": 30316,\n\t\"./hr.js\": 30316,\n\t\"./hu\": 22138,\n\t\"./hu.js\": 22138,\n\t\"./hy-am\": 11423,\n\t\"./hy-am.js\": 11423,\n\t\"./id\": 29218,\n\t\"./id.js\": 29218,\n\t\"./is\": 90135,\n\t\"./is.js\": 90135,\n\t\"./it\": 90626,\n\t\"./it-ch\": 10150,\n\t\"./it-ch.js\": 10150,\n\t\"./it.js\": 90626,\n\t\"./ja\": 39183,\n\t\"./ja.js\": 39183,\n\t\"./jv\": 24286,\n\t\"./jv.js\": 24286,\n\t\"./ka\": 12105,\n\t\"./ka.js\": 12105,\n\t\"./kk\": 47772,\n\t\"./kk.js\": 47772,\n\t\"./km\": 18758,\n\t\"./km.js\": 18758,\n\t\"./kn\": 79282,\n\t\"./kn.js\": 79282,\n\t\"./ko\": 33730,\n\t\"./ko.js\": 33730,\n\t\"./ku\": 1408,\n\t\"./ku.js\": 1408,\n\t\"./ky\": 33291,\n\t\"./ky.js\": 33291,\n\t\"./lb\": 36841,\n\t\"./lb.js\": 36841,\n\t\"./lo\": 55466,\n\t\"./lo.js\": 55466,\n\t\"./lt\": 57010,\n\t\"./lt.js\": 57010,\n\t\"./lv\": 37595,\n\t\"./lv.js\": 37595,\n\t\"./me\": 39861,\n\t\"./me.js\": 39861,\n\t\"./mi\": 35493,\n\t\"./mi.js\": 35493,\n\t\"./mk\": 95966,\n\t\"./mk.js\": 95966,\n\t\"./ml\": 87341,\n\t\"./ml.js\": 87341,\n\t\"./mn\": 5115,\n\t\"./mn.js\": 5115,\n\t\"./mr\": 10370,\n\t\"./mr.js\": 10370,\n\t\"./ms\": 9847,\n\t\"./ms-my\": 41237,\n\t\"./ms-my.js\": 41237,\n\t\"./ms.js\": 9847,\n\t\"./mt\": 72126,\n\t\"./mt.js\": 72126,\n\t\"./my\": 56165,\n\t\"./my.js\": 56165,\n\t\"./nb\": 64924,\n\t\"./nb.js\": 64924,\n\t\"./ne\": 16744,\n\t\"./ne.js\": 16744,\n\t\"./nl\": 93901,\n\t\"./nl-be\": 59814,\n\t\"./nl-be.js\": 59814,\n\t\"./nl.js\": 93901,\n\t\"./nn\": 83877,\n\t\"./nn.js\": 83877,\n\t\"./oc-lnc\": 92135,\n\t\"./oc-lnc.js\": 92135,\n\t\"./pa-in\": 15858,\n\t\"./pa-in.js\": 15858,\n\t\"./pl\": 64495,\n\t\"./pl.js\": 64495,\n\t\"./pt\": 89520,\n\t\"./pt-br\": 57971,\n\t\"./pt-br.js\": 57971,\n\t\"./pt.js\": 89520,\n\t\"./ro\": 96459,\n\t\"./ro.js\": 96459,\n\t\"./ru\": 21793,\n\t\"./ru.js\": 21793,\n\t\"./sd\": 40950,\n\t\"./sd.js\": 40950,\n\t\"./se\": 10490,\n\t\"./se.js\": 10490,\n\t\"./si\": 90124,\n\t\"./si.js\": 90124,\n\t\"./sk\": 64249,\n\t\"./sk.js\": 64249,\n\t\"./sl\": 14985,\n\t\"./sl.js\": 14985,\n\t\"./sq\": 51104,\n\t\"./sq.js\": 51104,\n\t\"./sr\": 49131,\n\t\"./sr-cyrl\": 79915,\n\t\"./sr-cyrl.js\": 79915,\n\t\"./sr.js\": 49131,\n\t\"./ss\": 85893,\n\t\"./ss.js\": 85893,\n\t\"./sv\": 98760,\n\t\"./sv.js\": 98760,\n\t\"./sw\": 91172,\n\t\"./sw.js\": 91172,\n\t\"./ta\": 27333,\n\t\"./ta.js\": 27333,\n\t\"./te\": 23110,\n\t\"./te.js\": 23110,\n\t\"./tet\": 52095,\n\t\"./tet.js\": 52095,\n\t\"./tg\": 27321,\n\t\"./tg.js\": 27321,\n\t\"./th\": 9041,\n\t\"./th.js\": 9041,\n\t\"./tk\": 19005,\n\t\"./tk.js\": 19005,\n\t\"./tl-ph\": 75768,\n\t\"./tl-ph.js\": 75768,\n\t\"./tlh\": 89444,\n\t\"./tlh.js\": 89444,\n\t\"./tr\": 72397,\n\t\"./tr.js\": 72397,\n\t\"./tzl\": 28254,\n\t\"./tzl.js\": 28254,\n\t\"./tzm\": 51106,\n\t\"./tzm-latn\": 30699,\n\t\"./tzm-latn.js\": 30699,\n\t\"./tzm.js\": 51106,\n\t\"./ug-cn\": 9288,\n\t\"./ug-cn.js\": 9288,\n\t\"./uk\": 67691,\n\t\"./uk.js\": 67691,\n\t\"./ur\": 13795,\n\t\"./ur.js\": 13795,\n\t\"./uz\": 6791,\n\t\"./uz-latn\": 60588,\n\t\"./uz-latn.js\": 60588,\n\t\"./uz.js\": 6791,\n\t\"./vi\": 65666,\n\t\"./vi.js\": 65666,\n\t\"./x-pseudo\": 14378,\n\t\"./x-pseudo.js\": 14378,\n\t\"./yo\": 75805,\n\t\"./yo.js\": 75805,\n\t\"./zh-cn\": 83839,\n\t\"./zh-cn.js\": 83839,\n\t\"./zh-hk\": 55726,\n\t\"./zh-hk.js\": 55726,\n\t\"./zh-mo\": 99807,\n\t\"./zh-mo.js\": 99807,\n\t\"./zh-tw\": 74152,\n\t\"./zh-tw.js\": 74152\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 46700;","/**\n* @license nested-property https://github.com/cosmosio/nested-property\n*\n* The MIT License (MIT)\n*\n* Copyright (c) 2014-2020 Olivier Scherrer <pode.fr@gmail.com>\n*/\n\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nvar ARRAY_WILDCARD = \"+\";\nvar PATH_DELIMITER = \".\";\n\nvar ObjectPrototypeMutationError = /*#__PURE__*/function (_Error) {\n  _inherits(ObjectPrototypeMutationError, _Error);\n\n  function ObjectPrototypeMutationError(params) {\n    var _this;\n\n    _classCallCheck(this, ObjectPrototypeMutationError);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ObjectPrototypeMutationError).call(this, params));\n    _this.name = \"ObjectPrototypeMutationError\";\n    return _this;\n  }\n\n  return ObjectPrototypeMutationError;\n}(_wrapNativeSuper(Error));\n\nmodule.exports = {\n  set: setNestedProperty,\n  get: getNestedProperty,\n  has: hasNestedProperty,\n  hasOwn: function hasOwn(object, property, options) {\n    return this.has(object, property, options || {\n      own: true\n    });\n  },\n  isIn: isInNestedProperty,\n  ObjectPrototypeMutationError: ObjectPrototypeMutationError\n};\n/**\n * Get the property of an object nested in one or more objects or array\n * Given an object such as a.b.c.d = 5, getNestedProperty(a, \"b.c.d\") will return 5.\n * It also works through arrays. Given a nested array such as a[0].b = 5, getNestedProperty(a, \"0.b\") will return 5.\n * For accessing nested properties through all items in an array, you may use the array wildcard \"+\".\n * For instance, getNestedProperty([{a:1}, {a:2}, {a:3}], \"+.a\") will return [1, 2, 3]\n * @param {Object} object the object to get the property from\n * @param {String} property the path to the property as a string\n * @returns the object or the the property value if found\n */\n\nfunction getNestedProperty(object, property) {\n  if (_typeof(object) != \"object\" || object === null) {\n    return object;\n  }\n\n  if (typeof property == \"undefined\") {\n    return object;\n  }\n\n  if (typeof property == \"number\") {\n    return object[property];\n  }\n\n  try {\n    return traverse(object, property, function _getNestedProperty(currentObject, currentProperty) {\n      return currentObject[currentProperty];\n    });\n  } catch (err) {\n    return object;\n  }\n}\n/**\n * Tell if a nested object has a given property (or array a given index)\n * given an object such as a.b.c.d = 5, hasNestedProperty(a, \"b.c.d\") will return true.\n * It also returns true if the property is in the prototype chain.\n * @param {Object} object the object to get the property from\n * @param {String} property the path to the property as a string\n * @param {Object} options:\n *  - own: set to reject properties from the prototype\n * @returns true if has (property in object), false otherwise\n */\n\n\nfunction hasNestedProperty(object, property) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  if (_typeof(object) != \"object\" || object === null) {\n    return false;\n  }\n\n  if (typeof property == \"undefined\") {\n    return false;\n  }\n\n  if (typeof property == \"number\") {\n    return property in object;\n  }\n\n  try {\n    var has = false;\n    traverse(object, property, function _hasNestedProperty(currentObject, currentProperty, segments, index) {\n      if (isLastSegment(segments, index)) {\n        if (options.own) {\n          has = currentObject.hasOwnProperty(currentProperty);\n        } else {\n          has = currentProperty in currentObject;\n        }\n      } else {\n        return currentObject && currentObject[currentProperty];\n      }\n    });\n    return has;\n  } catch (err) {\n    return false;\n  }\n}\n/**\n * Set the property of an object nested in one or more objects\n * If the property doesn't exist, it gets created.\n * @param {Object} object\n * @param {String} property\n * @param value the value to set\n * @returns object if no assignment was made or the value if the assignment was made\n */\n\n\nfunction setNestedProperty(object, property, value) {\n  if (_typeof(object) != \"object\" || object === null) {\n    return object;\n  }\n\n  if (typeof property == \"undefined\") {\n    return object;\n  }\n\n  if (typeof property == \"number\") {\n    object[property] = value;\n    return object[property];\n  }\n\n  try {\n    return traverse(object, property, function _setNestedProperty(currentObject, currentProperty, segments, index) {\n      if (currentObject === Reflect.getPrototypeOf({})) {\n        throw new ObjectPrototypeMutationError(\"Attempting to mutate Object.prototype\");\n      }\n\n      if (!currentObject[currentProperty]) {\n        var nextPropIsNumber = Number.isInteger(Number(segments[index + 1]));\n        var nextPropIsArrayWildcard = segments[index + 1] === ARRAY_WILDCARD;\n\n        if (nextPropIsNumber || nextPropIsArrayWildcard) {\n          currentObject[currentProperty] = [];\n        } else {\n          currentObject[currentProperty] = {};\n        }\n      }\n\n      if (isLastSegment(segments, index)) {\n        currentObject[currentProperty] = value;\n      }\n\n      return currentObject[currentProperty];\n    });\n  } catch (err) {\n    if (err instanceof ObjectPrototypeMutationError) {\n      // rethrow\n      throw err;\n    } else {\n      return object;\n    }\n  }\n}\n/**\n * Tell if an object is on the path to a nested property\n * If the object is on the path, and the path exists, it returns true, and false otherwise.\n * @param {Object} object to get the nested property from\n * @param {String} property name of the nested property\n * @param {Object} objectInPath the object to check\n * @param {Object} options:\n *  - validPath: return false if the path is invalid, even if the object is in the path\n * @returns {boolean} true if the object is on the path\n */\n\n\nfunction isInNestedProperty(object, property, objectInPath) {\n  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n\n  if (_typeof(object) != \"object\" || object === null) {\n    return false;\n  }\n\n  if (typeof property == \"undefined\") {\n    return false;\n  }\n\n  try {\n    var isIn = false,\n        pathExists = false;\n    traverse(object, property, function _isInNestedProperty(currentObject, currentProperty, segments, index) {\n      isIn = isIn || currentObject === objectInPath || !!currentObject && currentObject[currentProperty] === objectInPath;\n      pathExists = isLastSegment(segments, index) && _typeof(currentObject) === \"object\" && currentProperty in currentObject;\n      return currentObject && currentObject[currentProperty];\n    });\n\n    if (options.validPath) {\n      return isIn && pathExists;\n    } else {\n      return isIn;\n    }\n  } catch (err) {\n    return false;\n  }\n}\n\nfunction traverse(object, path) {\n  var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};\n  var segments = path.split(PATH_DELIMITER);\n  var length = segments.length;\n\n  var _loop = function _loop(idx) {\n    var currentSegment = segments[idx];\n\n    if (!object) {\n      return {\n        v: void 0\n      };\n    }\n\n    if (currentSegment === ARRAY_WILDCARD) {\n      if (Array.isArray(object)) {\n        return {\n          v: object.map(function (value, index) {\n            var remainingSegments = segments.slice(idx + 1);\n\n            if (remainingSegments.length > 0) {\n              return traverse(value, remainingSegments.join(PATH_DELIMITER), callback);\n            } else {\n              return callback(object, index, segments, idx);\n            }\n          })\n        };\n      } else {\n        var pathToHere = segments.slice(0, idx).join(PATH_DELIMITER);\n        throw new Error(\"Object at wildcard (\".concat(pathToHere, \") is not an array\"));\n      }\n    } else {\n      object = callback(object, currentSegment, segments, idx);\n    }\n  };\n\n  for (var idx = 0; idx < length; idx++) {\n    var _ret = _loop(idx);\n\n    if (_typeof(_ret) === \"object\") return _ret.v;\n  }\n\n  return object;\n}\n\nfunction isLastSegment(segments, index) {\n  return segments.length === index + 1;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\nvar util = require('util');\nvar isString = function (x) {\n  return typeof x === 'string';\n};\n\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  var res = [];\n  for (var i = 0; i < parts.length; i++) {\n    var p = parts[i];\n\n    // ignore empty parts\n    if (!p || p === '.')\n      continue;\n\n    if (p === '..') {\n      if (res.length && res[res.length - 1] !== '..') {\n        res.pop();\n      } else if (allowAboveRoot) {\n        res.push('..');\n      }\n    } else {\n      res.push(p);\n    }\n  }\n\n  return res;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar posix = {};\n\n\nfunction posixSplitPath(filename) {\n  return splitPathRe.exec(filename).slice(1);\n}\n\n\n// path.resolve([from ...], to)\n// posix version\nposix.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (!isString(path)) {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\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 = normalizeArray(resolvedPath.split('/'),\n                                !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nposix.normalize = function(path) {\n  var isAbsolute = posix.isAbsolute(path),\n      trailingSlash = path.substr(-1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(path.split('/'), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nposix.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nposix.join = function() {\n  var path = '';\n  for (var i = 0; i < arguments.length; i++) {\n    var segment = arguments[i];\n    if (!isString(segment)) {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    if (segment) {\n      if (!path) {\n        path += segment;\n      } else {\n        path += '/' + segment;\n      }\n    }\n  }\n  return posix.normalize(path);\n};\n\n\n// path.relative(from, to)\n// posix version\nposix.relative = function(from, to) {\n  from = posix.resolve(from).substr(1);\n  to = posix.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\n\nposix._makeLong = function(path) {\n  return path;\n};\n\n\nposix.dirname = function(path) {\n  var result = posixSplitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nposix.basename = function(path, ext) {\n  var f = posixSplitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nposix.extname = function(path) {\n  return posixSplitPath(path)[3];\n};\n\n\nposix.format = function(pathObject) {\n  if (!util.isObject(pathObject)) {\n    throw new TypeError(\n        \"Parameter 'pathObject' must be an object, not \" + typeof pathObject\n    );\n  }\n\n  var root = pathObject.root || '';\n\n  if (!isString(root)) {\n    throw new TypeError(\n        \"'pathObject.root' must be a string or undefined, not \" +\n        typeof pathObject.root\n    );\n  }\n\n  var dir = pathObject.dir ? pathObject.dir + posix.sep : '';\n  var base = pathObject.base || '';\n  return dir + base;\n};\n\n\nposix.parse = function(pathString) {\n  if (!isString(pathString)) {\n    throw new TypeError(\n        \"Parameter 'pathString' must be a string, not \" + typeof pathString\n    );\n  }\n  var allParts = posixSplitPath(pathString);\n  if (!allParts || allParts.length !== 4) {\n    throw new TypeError(\"Invalid path '\" + pathString + \"'\");\n  }\n  allParts[1] = allParts[1] || '';\n  allParts[2] = allParts[2] || '';\n  allParts[3] = allParts[3] || '';\n\n  return {\n    root: allParts[0],\n    dir: allParts[0] + allParts[1].slice(0, allParts[1].length - 1),\n    base: allParts[2],\n    ext: allParts[3],\n    name: allParts[2].slice(0, allParts[2].length - allParts[3].length)\n  };\n};\n\n\nposix.sep = '/';\nposix.delimiter = ':';\n\n  module.exports = posix;\n","var balanced = require('balanced-match');\n\nmodule.exports = expandTop;\n\nvar escSlash = '\\0SLASH'+Math.random()+'\\0';\nvar escOpen = '\\0OPEN'+Math.random()+'\\0';\nvar escClose = '\\0CLOSE'+Math.random()+'\\0';\nvar escComma = '\\0COMMA'+Math.random()+'\\0';\nvar escPeriod = '\\0PERIOD'+Math.random()+'\\0';\n\nfunction numeric(str) {\n  return parseInt(str, 10) == str\n    ? parseInt(str, 10)\n    : str.charCodeAt(0);\n}\n\nfunction escapeBraces(str) {\n  return str.split('\\\\\\\\').join(escSlash)\n            .split('\\\\{').join(escOpen)\n            .split('\\\\}').join(escClose)\n            .split('\\\\,').join(escComma)\n            .split('\\\\.').join(escPeriod);\n}\n\nfunction unescapeBraces(str) {\n  return str.split(escSlash).join('\\\\')\n            .split(escOpen).join('{')\n            .split(escClose).join('}')\n            .split(escComma).join(',')\n            .split(escPeriod).join('.');\n}\n\n\n// Basically just str.split(\",\"), but handling cases\n// where we have nested braced sections, which should be\n// treated as individual members, like {a,{b,c},d}\nfunction parseCommaParts(str) {\n  if (!str)\n    return [''];\n\n  var parts = [];\n  var m = balanced('{', '}', str);\n\n  if (!m)\n    return str.split(',');\n\n  var pre = m.pre;\n  var body = m.body;\n  var post = m.post;\n  var p = pre.split(',');\n\n  p[p.length-1] += '{' + body + '}';\n  var postParts = parseCommaParts(post);\n  if (post.length) {\n    p[p.length-1] += postParts.shift();\n    p.push.apply(p, postParts);\n  }\n\n  parts.push.apply(parts, p);\n\n  return parts;\n}\n\nfunction expandTop(str) {\n  if (!str)\n    return [];\n\n  // I don't know why Bash 4.3 does this, but it does.\n  // Anything starting with {} will have the first two bytes preserved\n  // but *only* at the top level, so {},a}b will not expand to anything,\n  // but a{},b}c will be expanded to [a}c,abc].\n  // One could argue that this is a bug in Bash, but since the goal of\n  // this module is to match Bash's rules, we escape a leading {}\n  if (str.substr(0, 2) === '{}') {\n    str = '\\\\{\\\\}' + str.substr(2);\n  }\n\n  return expand(escapeBraces(str), true).map(unescapeBraces);\n}\n\nfunction embrace(str) {\n  return '{' + str + '}';\n}\nfunction isPadded(el) {\n  return /^-?0\\d/.test(el);\n}\n\nfunction lte(i, y) {\n  return i <= y;\n}\nfunction gte(i, y) {\n  return i >= y;\n}\n\nfunction expand(str, isTop) {\n  var expansions = [];\n\n  var m = balanced('{', '}', str);\n  if (!m) return [str];\n\n  // no need to expand pre, since it is guaranteed to be free of brace-sets\n  var pre = m.pre;\n  var post = m.post.length\n    ? expand(m.post, false)\n    : [''];\n\n  if (/\\$$/.test(m.pre)) {    \n    for (var k = 0; k < post.length; k++) {\n      var expansion = pre+ '{' + m.body + '}' + post[k];\n      expansions.push(expansion);\n    }\n  } else {\n    var isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n    var isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n    var isSequence = isNumericSequence || isAlphaSequence;\n    var isOptions = m.body.indexOf(',') >= 0;\n    if (!isSequence && !isOptions) {\n      // {a},b}\n      if (m.post.match(/,.*\\}/)) {\n        str = m.pre + '{' + m.body + escClose + m.post;\n        return expand(str);\n      }\n      return [str];\n    }\n\n    var n;\n    if (isSequence) {\n      n = m.body.split(/\\.\\./);\n    } else {\n      n = parseCommaParts(m.body);\n      if (n.length === 1) {\n        // x{{a,b}}y ==> x{a}y x{b}y\n        n = expand(n[0], false).map(embrace);\n        if (n.length === 1) {\n          return post.map(function(p) {\n            return m.pre + n[0] + p;\n          });\n        }\n      }\n    }\n\n    // at this point, n is the parts, and we know it's not a comma set\n    // with a single entry.\n    var N;\n\n    if (isSequence) {\n      var x = numeric(n[0]);\n      var y = numeric(n[1]);\n      var width = Math.max(n[0].length, n[1].length)\n      var incr = n.length == 3\n        ? Math.abs(numeric(n[2]))\n        : 1;\n      var test = lte;\n      var reverse = y < x;\n      if (reverse) {\n        incr *= -1;\n        test = gte;\n      }\n      var pad = n.some(isPadded);\n\n      N = [];\n\n      for (var i = x; test(i, y); i += incr) {\n        var c;\n        if (isAlphaSequence) {\n          c = String.fromCharCode(i);\n          if (c === '\\\\')\n            c = '';\n        } else {\n          c = String(i);\n          if (pad) {\n            var need = width - c.length;\n            if (need > 0) {\n              var z = new Array(need + 1).join('0');\n              if (i < 0)\n                c = '-' + z + c.slice(1);\n              else\n                c = z + c;\n            }\n          }\n        }\n        N.push(c);\n      }\n    } else {\n      N = [];\n\n      for (var j = 0; j < n.length; j++) {\n        N.push.apply(N, expand(n[j], false));\n      }\n    }\n\n    for (var j = 0; j < N.length; j++) {\n      for (var k = 0; k < post.length; k++) {\n        var expansion = pre + N[j] + post[k];\n        if (!isTop || isSequence || expansion)\n          expansions.push(expansion);\n      }\n    }\n  }\n\n  return expansions;\n}\n\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \"-\" + chunkId + \".js?v=\" + {\"430\":\"77fc3fbf1e72551ad8b1\",\"1462\":\"03cc0c51ba09241e2635\",\"4322\":\"412f17bea41d1e48d8f3\",\"5951\":\"b0f4b015795aef0916bd\",\"6318\":\"f0bd431d3ace71e619f3\",\"6826\":\"504846207e59b4d660c6\"}[chunkId] + \"\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.j = 576;","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t576: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunknextcloud\"] = self[\"webpackChunknextcloud\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","__webpack_require__.nc = undefined;","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [7874], () => (__webpack_require__(78498)))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["deferred","inProgress","dataWebpackPrefix","posixClasses","braceEscape","s","replace","rangesToString","ranges","join","parseClass","glob","position","pos","charAt","Error","negs","i","sawStart","uflag","escaping","negate","endPos","rangeStart","WHILE","length","c","cls","unip","u","neg","Object","entries","startsWith","push","test","slice","sranges","snegs","p","pattern","options","assertValidPattern","nocomment","Minimatch","match","starDotExtRE","starDotExtTest","ext","f","endsWith","starDotExtTestDot","starDotExtTestNocase","toLowerCase","starDotExtTestNocaseDot","starDotStarRE","starDotStarTest","includes","starDotStarTestDot","dotStarRE","dotStarTest","starRE","starTest","starTestDot","qmarksRE","qmarksTestNocase","$0","noext","qmarksTestNoExt","qmarksTestNocaseDot","qmarksTestNoExtDot","qmarksTestDot","qmarksTest","len","defaultPlatform","process","env","__MINIMATCH_TESTING_PLATFORM__","platform","sep","GLOBSTAR","Symbol","plTypes","open","close","qmark","star","charSet","split","reduce","set","reSpecials","addPatternStartSet","filter","a","b","assign","defaults","def","keys","orig","constructor","super","unescape","escape","makeRe","braceExpand","list","nobrace","TypeError","mm","nonull","globMagic","regExpEscape","windowsPathsNoEscape","nonegate","comment","empty","preserveMultipleSlashes","partial","globSet","globParts","nocase","isWindows","windowsNoMagicRoot","regexp","this","allowWindowsEscape","undefined","make","hasMagic","magicalBraces","part","debug","_","parseNegate","Set","args","console","error","rawGlobParts","map","slashSplit","preprocess","__","isUNC","isDrive","ss","parse","indexOf","noglobstar","j","optimizationLevel","firstPhasePreProcess","secondPhasePreProcess","levelOneOptimize","adjascentGlobstarOptimize","parts","gs","splice","prev","pop","levelTwoFileOptimize","Array","isArray","didSomething","dd","gss","next","p2","other","splin","matched","partsMatch","emptyGSMatch","ai","bi","result","which","dot","negateOffset","matchOne","file","fileUNC","patternUNC","fd","pd","fi","pi","fl","pl","fr","pr","swallowee","hit","m","fastTest","re","patternListStack","negativeLists","stateChar","dotTravAllowed","dotFileAllowed","subPatternStart","clearStateChar","plEntry","type","start","reStart","reEnd","src","needUflag","consumed","magic","tail","$1","$2","t","addPatternStart","n","nl","nlBefore","nlFirst","nlAfter","nlLast","closeParensBefore","openParensBefore","cleanAfter","nocaseMagicOnly","toUpperCase","flags","_glob","_src","RegExp","er","twoStar","pp","forEach","ex","ff","filename","matchBase","flipNegate","PropertyType","getDirectoryFiles","isDetailed","arguments","multistatus","response","responseItems","item","propstat","prop","props","getlastmodified","lastMod","getcontentlength","rawSize","resourcetype","resourceType","getcontenttype","mimeType","getetag","etag","collection","stat","basename","lastmod","size","parseInt","mime","prepareFileFromProps","id","toString","ActivityTabPluginView","ActivityTabPluginInstance","__webpack_nonce__","btoa","getRequestToken","loadState","OCA","Activity","registerSidebarAction","window","addEventListener","mount","async","el","_ref","context","fileInfo","reload","default","ActivityCommmentAction","Vue","extend","parent","propsData","reloadCallback","resourceId","$mount","logger","info","unmount","$destroy","registerSidebarEntries","limit","offset","_ref2","data","comments","resourcePath","datetime","toISOString","client","customRequest","method","responseData","text","parseXML","headers","status","statusText","processResponsePayload","getComments","CommentView","CommentsViewObject","timestamp","moment","creationDateTime","toDate","getTime","element","_ref3","_CommentsViewInstance","registerSidebarFilter","activity","TabInstance","commentTab","Files","Sidebar","Tab","name","iconSvg","Comments","View","update","destroy","scrollBottomReached","onScrollBottomReached","registerTab","getLoggerBuilder","setApp","detectUser","build","createClient","getRootPath","requesttoken","generateRemoteUrl","balanced","str","maybeMatch","r","range","end","pre","body","post","reg","begs","beg","left","right","module","exports","validator","XMLParser","XMLBuilder","XMLValidator","webpackContext","req","webpackContextResolve","__webpack_require__","o","e","code","resolve","_typeof","obj","iterator","prototype","_wrapNativeSuper","Class","_cache","Map","fn","Function","call","has","get","Wrapper","_construct","_getPrototypeOf","create","value","enumerable","writable","configurable","_setPrototypeOf","Parent","Reflect","construct","sham","Proxy","Date","_isNativeReflectConstruct","apply","instance","bind","setPrototypeOf","__proto__","getPrototypeOf","ObjectPrototypeMutationError","_Error","params","_this","Constructor","_classCallCheck","self","ReferenceError","_assertThisInitialized","_possibleConstructorReturn","subClass","superClass","_inherits","traverse","object","path","callback","segments","_loop","idx","currentSegment","v","index","remainingSegments","pathToHere","concat","_ret","isLastSegment","property","currentObject","currentProperty","nextPropIsNumber","Number","isInteger","nextPropIsArrayWildcard","err","own","hasOwnProperty","hasOwn","isIn","objectInPath","pathExists","validPath","util","isString","x","normalizeArray","allowAboveRoot","res","splitPathRe","posix","posixSplitPath","exec","resolvedPath","resolvedAbsolute","cwd","normalize","isAbsolute","trailingSlash","substr","segment","relative","from","to","trim","arr","fromParts","toParts","Math","min","samePartsLength","outputParts","_makeLong","dirname","root","dir","extname","format","pathObject","isObject","base","pathString","allParts","delimiter","expand","escSlash","escOpen","escClose","escComma","escPeriod","escapeBraces","unescapeBraces","random","numeric","charCodeAt","parseCommaParts","postParts","shift","embrace","isPadded","lte","y","gte","isTop","expansions","k","expansion","N","isNumericSequence","isAlphaSequence","isSequence","isOptions","width","max","incr","abs","pad","some","String","fromCharCode","need","z","__webpack_module_cache__","moduleId","cachedModule","loaded","__webpack_modules__","O","chunkIds","priority","notFulfilled","Infinity","fulfilled","every","key","getter","__esModule","d","definition","defineProperty","chunkId","Promise","all","promises","g","globalThis","l","url","done","script","needAttach","scripts","document","getElementsByTagName","getAttribute","createElement","charset","timeout","nc","setAttribute","onScriptComplete","event","onerror","onload","clearTimeout","doneFns","parentNode","removeChild","setTimeout","target","head","appendChild","toStringTag","nmd","paths","children","scriptUrl","importScripts","location","currentScript","baseURI","href","installedChunks","installedChunkData","promise","reject","errorType","realSrc","message","request","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","chunkLoadingGlobal","__webpack_exports__"],"sourceRoot":""}