{"version":3,"file":"GetComments-C8c91xtE.chunk.mjs","sources":["../build/frontend/apps/comments/src/utils/davUtils.ts","../build/frontend/apps/comments/src/services/DavClient.ts","../node_modules/balanced-match/index.js","../node_modules/webdav/node_modules/brace-expansion/index.js","../node_modules/webdav/node_modules/minimatch/dist/esm/assert-valid-pattern.js","../node_modules/webdav/node_modules/minimatch/dist/esm/brace-expressions.js","../node_modules/webdav/node_modules/minimatch/dist/esm/unescape.js","../node_modules/webdav/node_modules/minimatch/dist/esm/ast.js","../node_modules/webdav/node_modules/minimatch/dist/esm/escape.js","../node_modules/webdav/node_modules/minimatch/dist/esm/index.js","../node_modules/webdav/dist/node/tools/headers.js","../node_modules/webdav/dist/node/response.js","../node_modules/path-posix/index.js","../node_modules/nested-property/dist/nested-property.js","../node_modules/webdav/dist/node/tools/dav.js","../build/frontend/apps/comments/src/services/GetComments.ts"],"sourcesContent":["/**\n * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\n\nimport { generateRemoteUrl } from '@nextcloud/router'\n\n/**\n *\n */\nfunction getRootPath() {\n\treturn generateRemoteUrl('dav/comments')\n}\n\nexport { getRootPath }\n","/**\n * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\n\nimport { getRequestToken, onRequestTokenUpdate } from '@nextcloud/auth'\nimport { createClient } from 'webdav'\nimport { getRootPath } from '../utils/davUtils.ts'\n\n// init webdav client\nconst client = createClient(getRootPath())\n\n// set CSRF token header\n/**\n * @param token\n */\nfunction setHeaders(token) {\n\tclient.setHeaders({\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: token ?? '',\n\t})\n}\n\n// refresh headers when request token changes\nonRequestTokenUpdate(setHeaders)\nsetHeaders(getRequestToken())\n\nexport default client\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","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\nvar EXPANSION_MAX = 100000\n\n// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An\n// input like `'{a,b}'.repeat(1500)` stays under that count - its output is\n// truncated to 100k results - while making every result ~1500 characters\n// long. The result set, and the intermediate arrays built while combining\n// brace sets, then grow large enough to exhaust memory and crash the process\n// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of\n// characters the accumulator may hold at any point, so memory stays flat no\n// matter how many brace groups are chained. The limit sits well above any\n// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M\n// characters) so legitimate input is unaffected.\nvar EXPANSION_MAX_LENGTH = 4000000\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, options) {\n  if (!str)\n    return [];\n\n  options = options || {};\n  var max = options.max == null ? EXPANSION_MAX : options.max;\n  var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;\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), max, maxLength, 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\n// Build `{ acc[a] + pre + values[v] }` for every combination, capping the\n// number of results at `max` and the total number of characters at `maxLength`.\n// This is the one place output grows, so bounding it here keeps the single\n// accumulator - and therefore memory - flat regardless of how many brace groups\n// are combined (CVE-2026-14257).\nfunction combine(\n  acc,\n  pre,\n  values,\n  max,\n  maxLength,\n  dropEmpties\n) {\n  var out = []\n  var length = 0\n  for (var a = 0; a < acc.length; a++) {\n    for (var v = 0; v < values.length; v++) {\n      if (out.length >= max) return out\n      var expansion = acc[a] + pre + values[v]\n      // Bash drops empty results at the top level. Skip them before they count\n      // against `max`, so `max` bounds the number of *kept* results.\n      if (dropEmpties && !expansion) continue\n      if (length + expansion.length > maxLength) return out\n      out.push(expansion)\n      length += expansion.length\n    }\n  }\n  return out\n}\n\n// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)\n// sequence body.\nfunction expandSequence(\n  body,\n  isAlphaSequence,\n  max,\n  maxLength\n) {\n  var n = body.split(/\\.\\./)\n  var N = []\n  // A sequence body always splits into two or three parts, but the compiler\n  // can't know that.\n  /* c8 ignore start */\n  if (n[0] === undefined || n[1] === undefined) {\n    return N\n  }\n  /* c8 ignore stop */\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    n.length === 3 && n[2] !== undefined ?\n      Math.max(Math.abs(numeric(n[2])), 1)\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  var length = 0\n  for (var i = x; test(i, y) && N.length < max; i += incr) {\n    var c\n    if (isAlphaSequence) {\n      c = String.fromCharCode(i)\n      if (c === '\\\\') {\n        c = ''\n      }\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    if (length + c.length > maxLength) break\n    N.push(c)\n    length += c.length\n  }\n  return N\n}\n\nfunction expand(\n  str,\n  max,\n  maxLength,\n  isTop\n) {\n  // Consume the string's top-level brace groups left to right, threading a\n  // running set of combined prefixes (`acc`). Expanding the tail iteratively -\n  // rather than recursing on `m.post` once per group - keeps the native stack\n  // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no\n  // longer overflow the stack, and leaves a single accumulator whose size\n  // `maxLength` bounds directly (CVE-2026-14257).\n  var acc = ['']\n\n  // Bash drops empty results, but only when the *first* top-level group is a\n  // comma set - a sequence like `{a..\\}` may legitimately yield ''. The drop\n  // is on the final strings, so it is applied to whichever `combine` produces\n  // them (the one with no brace set left in the tail).\n  var dropEmpties = false\n  var firstGroup = true\n\n  for (;;) {\n    const m = balanced('{', '}', str)\n\n    // No brace set left: the rest of the string is literal.\n    if (!m) {\n      return combine(acc, str, [''], max, maxLength, dropEmpties)\n    }\n\n    // no need to expand pre, since it is guaranteed to be free of brace-sets\n    const pre = m.pre\n\n    if (/\\$$/.test(pre)) {\n      acc = combine(\n        acc,\n        pre + '{' + m.body + '}',\n        [''],\n        max,\n        maxLength,\n        dropEmpties && !m.post.length\n      )\n      firstGroup = false\n      if (!m.post.length) break\n      str = m.post\n      continue\n    }\n\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        isTop = true;\n        continue;\n      }\n      // Nothing here expands, so the whole remaining string is literal.\n      return combine(\n        acc,\n        pre + '{' + m.body + '}' + m.post,\n        [''],\n        max,\n        maxLength,\n        dropEmpties\n      )\n    }\n\n    if (firstGroup) {\n      dropEmpties = isTop && !isSequence\n      firstGroup = false\n    }\n\n    var values;\n    if (isSequence) {\n      values = expandSequence(m.body, isAlphaSequence, max, maxLength);\n    } else {\n      var n = parseCommaParts(m.body);\n      if (n.length === 1 && n[0] !== undefined) {\n        // x{{a,b}}y ==> x{a}y x{b}y\n        n = expand(n[0], max, maxLength, false).map(embrace);\n        //XXX is this necessary? Can't seem to hit it in tests.\n        /* c8 ignore start */\n        if (n.length === 1) {\n          acc = combine(\n            acc,\n            pre + n[0],\n            [''],\n            max,\n            maxLength,\n            dropEmpties && !m.post.length\n          )\n          if (!m.post.length) break\n          str = m.post\n          continue\n        }\n        /* c8 ignore stop */\n      }\n\n      // Values that `combine` is going to drop as empty produce no result, so\n      // they must not count against `max` - otherwise `{a,,b}` with `max: 2`\n      // would stop at `['a', '']` and yield one result instead of two. Skipping\n      // them outright keeps `values` bounded while leaving `max` a bound on\n      // *kept* results.\n      var dropsEmpties = dropEmpties && !m.post.length && !pre\n      for (var d = 0; dropsEmpties && d < acc.length; d++) {\n        if (acc[d]) {\n          dropsEmpties = false\n        }\n      }\n\n      values = []\n      var valuesLength = 0\n      outer: for (var j = 0; j < n.length; j++) {\n        var expanded = expand(n[j], max, maxLength, false)\n        for (var k = 0; k < expanded.length; k++) {\n          var v = expanded[k]\n          if (dropsEmpties && !v) continue\n          if (values.length >= max || valuesLength + v.length > maxLength) {\n            break outer\n          }\n          values.push(v)\n          valuesLength += v.length\n        }\n      }\n    }\n\n    acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length)\n    if (!m.post.length) break\n    str = m.post\n  }\n\n  return acc\n}\n","const MAX_PATTERN_LENGTH = 1024 * 64;\nexport const 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//# sourceMappingURL=assert-valid-pattern.js.map","// 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","/**\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","// parse a single path portion\nvar _a;\nimport { parseClass } from './brace-expressions.js';\nimport { unescape } from './unescape.js';\nconst types = new Set(['!', '?', '+', '*', '@']);\nconst isExtglobType = (c) => types.has(c);\nconst isExtglobAST = (c) => isExtglobType(c.type);\nconst adoptionMap = new Map([\n    ['!', ['@']],\n    ['?', ['?', '@']],\n    ['@', ['@']],\n    ['*', ['*', '+', '?', '@']],\n    ['+', ['+', '@']],\n]);\nconst adoptionWithSpaceMap = new Map([\n    ['!', ['?']],\n    ['@', ['?']],\n    ['+', ['?', '*']],\n]);\nconst adoptionAnyMap = new Map([\n    ['!', ['?', '@']],\n    ['?', ['?', '@']],\n    ['@', ['?', '@']],\n    ['*', ['*', '+', '?', '@']],\n    ['+', ['+', '@', '?', '*']],\n]);\nconst usurpMap = new Map([\n    ['!', new Map([['!', '@']])],\n    ['?', new Map([['*', '*'], ['+', '*']])],\n    ['@', new Map([['!', '!'], ['?', '?'], ['@', '@'], ['*', '*'], ['+', '+']])],\n    ['+', new Map([['?', '*'], ['*', '*']])],\n]);\n// Patterns that get prepended to bind to the start of either the\n// entire string, or just a single path portion, to prevent dots\n// and/or traversal patterns, when needed.\n// Exts don't need the ^ or / bit, because the root binds that already.\nconst startNoTraversal = '(?!(?:^|/)\\\\.\\\\.?(?:$|/))';\nconst startNoDot = '(?!\\\\.)';\n// characters that indicate a start of pattern needs the \"no dots\" bit,\n// because a dot *might* be matched. ( is not in the list, because in\n// the case of a child extglob, it will handle the prevention itself.\nconst addPatternStart = new Set(['[', '.']);\n// cases where traversal is A-OK, no dot prevention needed\nconst justDots = new Set(['..', '.']);\nconst reSpecials = new Set('().*{}+?[]^$\\\\!');\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// any single thing other than /\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// use + when we need to ensure that *something* matches, because the * is\n// the only thing in the path portion.\nconst starNoEmpty = qmark + '+?';\n// remove the \\ chars that we added if we end up doing a nonmagic compare\n// const deslash = (s: string) => s.replace(/\\\\(.)/g, '$1')\nexport class AST {\n    type;\n    #root;\n    #hasMagic;\n    #uflag = false;\n    #parts = [];\n    #parent;\n    #parentIndex;\n    #negs;\n    #filledNegs = false;\n    #options;\n    #toString;\n    // set to true if it's an extglob with no children\n    // (which really means one child of '')\n    #emptyExt = false;\n    constructor(type, parent, options = {}) {\n        this.type = type;\n        // extglobs are inherently magical\n        if (type)\n            this.#hasMagic = true;\n        this.#parent = parent;\n        this.#root = this.#parent ? this.#parent.#root : this;\n        this.#options = this.#root === this ? options : this.#root.#options;\n        this.#negs = this.#root === this ? [] : this.#root.#negs;\n        if (type === '!' && !this.#root.#filledNegs)\n            this.#negs.push(this);\n        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;\n    }\n    get hasMagic() {\n        /* c8 ignore start */\n        if (this.#hasMagic !== undefined)\n            return this.#hasMagic;\n        /* c8 ignore stop */\n        for (const p of this.#parts) {\n            if (typeof p === 'string')\n                continue;\n            if (p.type || p.hasMagic)\n                return (this.#hasMagic = true);\n        }\n        // note: will be undefined until we generate the regexp src and find out\n        return this.#hasMagic;\n    }\n    // reconstructs the pattern\n    toString() {\n        if (this.#toString !== undefined)\n            return this.#toString;\n        if (!this.type) {\n            return (this.#toString = this.#parts.map(p => String(p)).join(''));\n        }\n        else {\n            return (this.#toString =\n                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');\n        }\n    }\n    #fillNegs() {\n        /* c8 ignore start */\n        if (this !== this.#root)\n            throw new Error('should only call on root');\n        if (this.#filledNegs)\n            return this;\n        /* c8 ignore stop */\n        // call toString() once to fill this out\n        this.toString();\n        this.#filledNegs = true;\n        let n;\n        while ((n = this.#negs.pop())) {\n            if (n.type !== '!')\n                continue;\n            // walk up the tree, appending everthing that comes AFTER parentIndex\n            let p = n;\n            let pp = p.#parent;\n            while (pp) {\n                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {\n                    for (const part of n.#parts) {\n                        /* c8 ignore start */\n                        if (typeof part === 'string') {\n                            throw new Error('string part in extglob AST??');\n                        }\n                        /* c8 ignore stop */\n                        part.copyIn(pp.#parts[i]);\n                    }\n                }\n                p = pp;\n                pp = p.#parent;\n            }\n        }\n        return this;\n    }\n    push(...parts) {\n        for (const p of parts) {\n            if (p === '')\n                continue;\n            /* c8 ignore start */\n            if (typeof p !== 'string' && !(p instanceof _a && p.#parent === this)) {\n                throw new Error('invalid part: ' + p);\n            }\n            /* c8 ignore stop */\n            this.#parts.push(p);\n        }\n    }\n    toJSON() {\n        const ret = this.type === null\n            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))\n            : [this.type, ...this.#parts.map(p => p.toJSON())];\n        if (this.isStart() && !this.type)\n            ret.unshift([]);\n        if (this.isEnd() &&\n            (this === this.#root ||\n                (this.#root.#filledNegs && this.#parent?.type === '!'))) {\n            ret.push({});\n        }\n        return ret;\n    }\n    isStart() {\n        if (this.#root === this)\n            return true;\n        // if (this.type) return !!this.#parent?.isStart()\n        if (!this.#parent?.isStart())\n            return false;\n        if (this.#parentIndex === 0)\n            return true;\n        // if everything AHEAD of this is a negation, then it's still the \"start\"\n        const p = this.#parent;\n        for (let i = 0; i < this.#parentIndex; i++) {\n            const pp = p.#parts[i];\n            if (!(pp instanceof _a && pp.type === '!')) {\n                return false;\n            }\n        }\n        return true;\n    }\n    isEnd() {\n        if (this.#root === this)\n            return true;\n        if (this.#parent?.type === '!')\n            return true;\n        if (!this.#parent?.isEnd())\n            return false;\n        if (!this.type)\n            return this.#parent?.isEnd();\n        // if not root, it'll always have a parent\n        /* c8 ignore start */\n        const pl = this.#parent ? this.#parent.#parts.length : 0;\n        /* c8 ignore stop */\n        return this.#parentIndex === pl - 1;\n    }\n    copyIn(part) {\n        if (typeof part === 'string')\n            this.push(part);\n        else\n            this.push(part.clone(this));\n    }\n    clone(parent) {\n        const c = new _a(this.type, parent);\n        for (const p of this.#parts) {\n            c.copyIn(p);\n        }\n        return c;\n    }\n    static #parseAST(str, ast, pos, opt, extDepth) {\n        const maxDepth = opt.maxExtglobRecursion ?? 2;\n        let escaping = false;\n        let inBrace = false;\n        let braceStart = -1;\n        let braceNeg = false;\n        if (ast.type === null) {\n            // outside of a extglob, append until we find a start\n            let i = pos;\n            let acc = '';\n            while (i < str.length) {\n                const c = str.charAt(i++);\n                // still accumulate escapes at this point, but we do ignore\n                // starts that are escaped\n                if (escaping || c === '\\\\') {\n                    escaping = !escaping;\n                    acc += c;\n                    continue;\n                }\n                if (inBrace) {\n                    if (i === braceStart + 1) {\n                        if (c === '^' || c === '!') {\n                            braceNeg = true;\n                        }\n                    }\n                    else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                        inBrace = false;\n                    }\n                    acc += c;\n                    continue;\n                }\n                else if (c === '[') {\n                    inBrace = true;\n                    braceStart = i;\n                    braceNeg = false;\n                    acc += c;\n                    continue;\n                }\n                const doRecurse = !opt.noext &&\n                    isExtglobType(c) &&\n                    str.charAt(i) === '(' &&\n                    extDepth <= maxDepth;\n                if (doRecurse) {\n                    ast.push(acc);\n                    acc = '';\n                    const ext = new _a(c, ast);\n                    i = _a.#parseAST(str, ext, i, opt, extDepth + 1);\n                    ast.push(ext);\n                    continue;\n                }\n                acc += c;\n            }\n            ast.push(acc);\n            return i;\n        }\n        // some kind of extglob, pos is at the (\n        // find the next | or )\n        let i = pos + 1;\n        let part = new _a(null, ast);\n        const parts = [];\n        let acc = '';\n        while (i < str.length) {\n            const c = str.charAt(i++);\n            // still accumulate escapes at this point, but we do ignore\n            // starts that are escaped\n            if (escaping || c === '\\\\') {\n                escaping = !escaping;\n                acc += c;\n                continue;\n            }\n            if (inBrace) {\n                if (i === braceStart + 1) {\n                    if (c === '^' || c === '!') {\n                        braceNeg = true;\n                    }\n                }\n                else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                    inBrace = false;\n                }\n                acc += c;\n                continue;\n            }\n            else if (c === '[') {\n                inBrace = true;\n                braceStart = i;\n                braceNeg = false;\n                acc += c;\n                continue;\n            }\n            const doRecurse = isExtglobType(c) &&\n                str.charAt(i) === '(' &&\n                /* c8 ignore start - the maxDepth is sufficient here */\n                (extDepth <= maxDepth || (ast && ast.#canAdoptType(c)));\n            /* c8 ignore stop */\n            if (doRecurse) {\n                const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;\n                part.push(acc);\n                acc = '';\n                const ext = new _a(c, part);\n                part.push(ext);\n                i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);\n                continue;\n            }\n            if (c === '|') {\n                part.push(acc);\n                acc = '';\n                parts.push(part);\n                part = new _a(null, ast);\n                continue;\n            }\n            if (c === ')') {\n                if (acc === '' && ast.#parts.length === 0) {\n                    ast.#emptyExt = true;\n                }\n                part.push(acc);\n                acc = '';\n                ast.push(...parts, part);\n                return i;\n            }\n            acc += c;\n        }\n        // unfinished extglob\n        // if we got here, it was a malformed extglob! not an extglob, but\n        // maybe something else in there.\n        ast.type = null;\n        ast.#hasMagic = undefined;\n        ast.#parts = [str.substring(pos - 1)];\n        return i;\n    }\n    #canAdoptWithSpace(child) {\n        return this.#canAdopt(child, adoptionWithSpaceMap);\n    }\n    #canAdopt(child, map = adoptionMap) {\n        if (!child ||\n            typeof child !== 'object' ||\n            child.type !== null ||\n            child.#parts.length !== 1 ||\n            this.type === null) {\n            return false;\n        }\n        const gc = child.#parts[0];\n        if (!gc || typeof gc !== 'object' || gc.type === null) {\n            return false;\n        }\n        return this.#canAdoptType(gc.type, map);\n    }\n    #canAdoptType(c, map = adoptionAnyMap) {\n        return !!map.get(this.type)?.includes(c);\n    }\n    #adoptWithSpace(child, index) {\n        const gc = child.#parts[0];\n        const blank = new _a(null, gc, this.options);\n        blank.#parts.push('');\n        gc.push(blank);\n        this.#adopt(child, index);\n    }\n    #adopt(child, index) {\n        const gc = child.#parts[0];\n        this.#parts.splice(index, 1, ...gc.#parts);\n        for (const p of gc.#parts) {\n            if (typeof p === 'object')\n                p.#parent = this;\n        }\n        this.#toString = undefined;\n    }\n    #canUsurpType(c) {\n        const m = usurpMap.get(this.type);\n        return !!(m?.has(c));\n    }\n    #canUsurp(child) {\n        if (!child ||\n            typeof child !== 'object' ||\n            child.type !== null ||\n            child.#parts.length !== 1 ||\n            this.type === null ||\n            this.#parts.length !== 1) {\n            return false;\n        }\n        const gc = child.#parts[0];\n        if (!gc || typeof gc !== 'object' || gc.type === null) {\n            return false;\n        }\n        return this.#canUsurpType(gc.type);\n    }\n    #usurp(child) {\n        const m = usurpMap.get(this.type);\n        const gc = child.#parts[0];\n        const nt = m?.get(gc.type);\n        /* c8 ignore start - impossible */\n        if (!nt)\n            return false;\n        /* c8 ignore stop */\n        this.#parts = gc.#parts;\n        for (const p of this.#parts) {\n            if (typeof p === 'object')\n                p.#parent = this;\n        }\n        this.type = nt;\n        this.#toString = undefined;\n        this.#emptyExt = false;\n    }\n    #flatten() {\n        if (!isExtglobAST(this)) {\n            for (const p of this.#parts) {\n                if (typeof p === 'object')\n                    p.#flatten();\n            }\n        }\n        else {\n            let iterations = 0;\n            let done = false;\n            do {\n                done = true;\n                for (let i = 0; i < this.#parts.length; i++) {\n                    const c = this.#parts[i];\n                    if (typeof c === 'object') {\n                        c.#flatten();\n                        if (this.#canAdopt(c)) {\n                            done = false;\n                            this.#adopt(c, i);\n                        }\n                        else if (this.#canAdoptWithSpace(c)) {\n                            done = false;\n                            this.#adoptWithSpace(c, i);\n                        }\n                        else if (this.#canUsurp(c)) {\n                            done = false;\n                            this.#usurp(c);\n                        }\n                    }\n                }\n            } while (!done && ++iterations < 10);\n        }\n        this.#toString = undefined;\n    }\n    static fromGlob(pattern, options = {}) {\n        const ast = new _a(null, undefined, options);\n        _a.#parseAST(pattern, ast, 0, options, 0);\n        return ast;\n    }\n    // returns the regular expression if there's magic, or the unescaped\n    // string if not.\n    toMMPattern() {\n        // should only be called on root\n        /* c8 ignore start */\n        if (this !== this.#root)\n            return this.#root.toMMPattern();\n        /* c8 ignore stop */\n        const glob = this.toString();\n        const [re, body, hasMagic, uflag] = this.toRegExpSource();\n        // if we're in nocase mode, and not nocaseMagicOnly, then we do\n        // still need a regular expression if we have to case-insensitively\n        // match capital/lowercase characters.\n        const anyMagic = hasMagic ||\n            this.#hasMagic ||\n            (this.#options.nocase &&\n                !this.#options.nocaseMagicOnly &&\n                glob.toUpperCase() !== glob.toLowerCase());\n        if (!anyMagic) {\n            return body;\n        }\n        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');\n        return Object.assign(new RegExp(`^${re}$`, flags), {\n            _src: re,\n            _glob: glob,\n        });\n    }\n    get options() {\n        return this.#options;\n    }\n    // returns the string match, the regexp source, whether there's magic\n    // in the regexp (so a regular expression is required) and whether or\n    // not the uflag is needed for the regular expression (for posix classes)\n    // TODO: instead of injecting the start/end at this point, just return\n    // the BODY of the regexp, along with the start/end portions suitable\n    // for binding the start/end in either a joined full-path makeRe context\n    // (where we bind to (^|/), or a standalone matchPart context (where\n    // we bind to ^, and not /).  Otherwise slashes get duped!\n    //\n    // In part-matching mode, the start is:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: ^(?!\\.\\.?$)\n    // - if dots allowed or not possible: ^\n    // - if dots possible and not allowed: ^(?!\\.)\n    // end is:\n    // - if not isEnd(): nothing\n    // - else: $\n    //\n    // In full-path matching mode, we put the slash at the START of the\n    // pattern, so start is:\n    // - if first pattern: same as part-matching mode\n    // - if not isStart(): nothing\n    // - if traversal possible, but not allowed: /(?!\\.\\.?(?:$|/))\n    // - if dots allowed or not possible: /\n    // - if dots possible and not allowed: /(?!\\.)\n    // end is:\n    // - if last pattern, same as part-matching mode\n    // - else nothing\n    //\n    // Always put the (?:$|/) on negated tails, though, because that has to be\n    // there to bind the end of the negated pattern portion, and it's easier to\n    // just stick it in now rather than try to inject it later in the middle of\n    // the pattern.\n    //\n    // We can just always return the same end, and leave it up to the caller\n    // to know whether it's going to be used joined or in parts.\n    // And, if the start is adjusted slightly, can do the same there:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: (?:/|^)(?!\\.\\.?$)\n    // - if dots allowed or not possible: (?:/|^)\n    // - if dots possible and not allowed: (?:/|^)(?!\\.)\n    //\n    // But it's better to have a simpler binding without a conditional, for\n    // performance, so probably better to return both start options.\n    //\n    // Then the caller just ignores the end if it's not the first pattern,\n    // and the start always gets applied.\n    //\n    // But that's always going to be $ if it's the ending pattern, or nothing,\n    // so the caller can just attach $ at the end of the pattern when building.\n    //\n    // So the todo is:\n    // - better detect what kind of start is needed\n    // - return both flavors of starting pattern\n    // - attach $ at the end of the pattern when creating the actual RegExp\n    //\n    // Ah, but wait, no, that all only applies to the root when the first pattern\n    // is not an extglob. If the first pattern IS an extglob, then we need all\n    // that dot prevention biz to live in the extglob portions, because eg\n    // +(*|.x*) can match .xy but not .yx.\n    //\n    // So, return the two flavors if it's #root and the first child is not an\n    // AST, otherwise leave it to the child AST to handle it, and there,\n    // use the (?:^|/) style of start binding.\n    //\n    // Even simplified further:\n    // - Since the start for a join is eg /(?!\\.) and the start for a part\n    // is ^(?!\\.), we can just prepend (?!\\.) to the pattern (either root\n    // or start or whatever) and prepend ^ or / at the Regexp construction.\n    toRegExpSource(allowDot) {\n        const dot = allowDot ?? !!this.#options.dot;\n        if (this.#root === this) {\n            this.#flatten();\n            this.#fillNegs();\n        }\n        if (!isExtglobAST(this)) {\n            const noEmpty = this.isStart() && this.isEnd();\n            const src = this.#parts\n                .map(p => {\n                const [re, _, hasMagic, uflag] = typeof p === 'string'\n                    ? _a.#parseGlob(p, this.#hasMagic, noEmpty)\n                    : p.toRegExpSource(allowDot);\n                this.#hasMagic = this.#hasMagic || hasMagic;\n                this.#uflag = this.#uflag || uflag;\n                return re;\n            })\n                .join('');\n            let start = '';\n            if (this.isStart()) {\n                if (typeof this.#parts[0] === 'string') {\n                    // this is the string that will match the start of the pattern,\n                    // so we need to protect against dots and such.\n                    // '.' and '..' cannot match unless the pattern is that exactly,\n                    // even if it starts with . or dot:true is set.\n                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);\n                    if (!dotTravAllowed) {\n                        const aps = addPatternStart;\n                        // check if we have a possibility of matching . or ..,\n                        // and prevent that.\n                        const needNoTrav = \n                        // dots are allowed, and the pattern starts with [ or .\n                        (dot && aps.has(src.charAt(0))) ||\n                            // the pattern starts with \\., and then [ or .\n                            (src.startsWith('\\\\.') && aps.has(src.charAt(2))) ||\n                            // the pattern starts with \\.\\., and then [ or .\n                            (src.startsWith('\\\\.\\\\.') && aps.has(src.charAt(4)));\n                        // no need to prevent dots if it can't match a dot, or if a\n                        // sub-pattern will be preventing it anyway.\n                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));\n                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';\n                    }\n                }\n            }\n            // append the \"end of path portion\" pattern to negation tails\n            let end = '';\n            if (this.isEnd() &&\n                this.#root.#filledNegs &&\n                this.#parent?.type === '!') {\n                end = '(?:$|\\\\/)';\n            }\n            const final = start + src + end;\n            return [\n                final,\n                unescape(src),\n                (this.#hasMagic = !!this.#hasMagic),\n                this.#uflag,\n            ];\n        }\n        // We need to calculate the body *twice* if it's a repeat pattern\n        // at the start, once in nodot mode, then again in dot mode, so a\n        // pattern like *(?) can match 'x.y'\n        const repeated = this.type === '*' || this.type === '+';\n        // some kind of extglob\n        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';\n        let body = this.#partsToRegExp(dot);\n        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {\n            // invalid extglob, has to at least be *something* present, if it's\n            // the entire path portion.\n            const s = this.toString();\n            const me = this;\n            me.#parts = [s];\n            me.type = null;\n            me.#hasMagic = undefined;\n            return [s, unescape(this.toString()), false, false];\n        }\n        // XXX abstract out this map method\n        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot\n            ? ''\n            : this.#partsToRegExp(true);\n        if (bodyDotAllowed === body) {\n            bodyDotAllowed = '';\n        }\n        if (bodyDotAllowed) {\n            body = `(?:${body})(?:${bodyDotAllowed})*?`;\n        }\n        // an empty !() is exactly equivalent to a starNoEmpty\n        let final = '';\n        if (this.type === '!' && this.#emptyExt) {\n            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;\n        }\n        else {\n            const close = this.type === '!'\n                ? // !() must match something,but !(x) can match ''\n                    '))' +\n                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +\n                        star +\n                        ')'\n                : this.type === '@'\n                    ? ')'\n                    : this.type === '?'\n                        ? ')?'\n                        : this.type === '+' && bodyDotAllowed\n                            ? ')'\n                            : this.type === '*' && bodyDotAllowed\n                                ? `)?`\n                                : `)${this.type}`;\n            final = start + body + close;\n        }\n        return [\n            final,\n            unescape(body),\n            (this.#hasMagic = !!this.#hasMagic),\n            this.#uflag,\n        ];\n    }\n    #partsToRegExp(dot) {\n        return this.#parts\n            .map(p => {\n            // extglob ASTs should only contain parent ASTs\n            /* c8 ignore start */\n            if (typeof p === 'string') {\n                throw new Error('string type in extglob ast??');\n            }\n            /* c8 ignore stop */\n            // can ignore hasMagic, because extglobs are already always magic\n            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);\n            this.#uflag = this.#uflag || uflag;\n            return re;\n        })\n            .filter(p => !(this.isStart() && this.isEnd()) || !!p)\n            .join('|');\n    }\n    static #parseGlob(glob, hasMagic, noEmpty = false) {\n        let escaping = false;\n        let re = '';\n        let uflag = false;\n        // multiple stars that aren't globstars coalesce into one *\n        let inStar = false;\n        for (let i = 0; i < glob.length; i++) {\n            const c = glob.charAt(i);\n            if (escaping) {\n                escaping = false;\n                re += (reSpecials.has(c) ? '\\\\' : '') + c;\n                inStar = false;\n                continue;\n            }\n            if (c === '\\\\') {\n                if (i === glob.length - 1) {\n                    re += '\\\\\\\\';\n                }\n                else {\n                    escaping = true;\n                }\n                continue;\n            }\n            if (c === '[') {\n                const [src, needUflag, consumed, magic] = parseClass(glob, i);\n                if (consumed) {\n                    re += src;\n                    uflag = uflag || needUflag;\n                    i += consumed - 1;\n                    hasMagic = hasMagic || magic;\n                    inStar = false;\n                    continue;\n                }\n            }\n            if (c === '*') {\n                if (inStar)\n                    continue;\n                inStar = true;\n                re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;\n                hasMagic = true;\n                continue;\n            }\n            else {\n                inStar = false;\n            }\n            if (c === '?') {\n                re += qmark;\n                hasMagic = true;\n                continue;\n            }\n            re += regExpEscape(c);\n        }\n        return [re, unescape(glob), !!hasMagic, uflag];\n    }\n}\n_a = AST;\n//# sourceMappingURL=ast.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","import expand from 'brace-expansion';\nimport { assertValidPattern } from './assert-valid-pattern.js';\nimport { AST } from './ast.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};\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;\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 = '(?:(?!(?:\\\\/|^)\\\\.).)*?';\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        AST: class AST extends orig.AST {\n            /* c8 ignore start */\n            constructor(type, parent, options = {}) {\n                super(type, parent, ext(def, options));\n            }\n            /* c8 ignore stop */\n            static fromGlob(pattern, options = {}) {\n                return orig.AST.fromGlob(pattern, ext(def, options));\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;\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 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    maxGlobstarRecursion;\n    regexp;\n    constructor(pattern, options = {}) {\n        assertValidPattern(pattern);\n        options = options || {};\n        this.options = options;\n        this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;\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            // just collapse multiple ** portions into one\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                    globParts[i] = [];\n                    globParts[j] = matched;\n                    break;\n                }\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        let fileStartIndex = 0;\n        let patternStartIndex = 0;\n        // UNC paths like //?/X:/... can match X:/... and vice versa\n        // Drive letters in absolute drive or unc paths are always compared\n        // case-insensitively.\n        if (this.isWindows) {\n            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);\n            const fileUNC = !fileDrive &&\n                file[0] === '' &&\n                file[1] === '' &&\n                file[2] === '?' &&\n                /^[a-z]:$/i.test(file[3]);\n            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);\n            const patternUNC = !patternDrive &&\n                pattern[0] === '' &&\n                pattern[1] === '' &&\n                pattern[2] === '?' &&\n                typeof pattern[3] === 'string' &&\n                /^[a-z]:$/i.test(pattern[3]);\n            const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;\n            const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;\n            if (typeof fdi === 'number' && typeof pdi === 'number') {\n                const [fd, pd] = [\n                    file[fdi],\n                    pattern[pdi],\n                ];\n                if (fd.toLowerCase() === pd.toLowerCase()) {\n                    pattern[pdi] = fd;\n                    patternStartIndex = pdi;\n                    fileStartIndex = fdi;\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        if (pattern.includes(GLOBSTAR)) {\n            return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);\n        }\n        return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);\n    }\n    #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {\n        const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);\n        const lastgs = pattern.lastIndexOf(GLOBSTAR);\n        const [head, body, tail] = partial ? [\n            pattern.slice(patternIndex, firstgs),\n            pattern.slice(firstgs + 1),\n            [],\n        ] : [\n            pattern.slice(patternIndex, firstgs),\n            pattern.slice(firstgs + 1, lastgs),\n            pattern.slice(lastgs + 1),\n        ];\n        if (head.length) {\n            const fileHead = file.slice(fileIndex, fileIndex + head.length);\n            if (!this.#matchOne(fileHead, head, partial, 0, 0))\n                return false;\n            fileIndex += head.length;\n        }\n        let fileTailMatch = 0;\n        if (tail.length) {\n            if (tail.length + fileIndex > file.length)\n                return false;\n            let tailStart = file.length - tail.length;\n            if (this.#matchOne(file, tail, partial, tailStart, 0)) {\n                fileTailMatch = tail.length;\n            }\n            else {\n                if (file[file.length - 1] !== '' ||\n                    fileIndex + tail.length === file.length) {\n                    return false;\n                }\n                tailStart--;\n                if (!this.#matchOne(file, tail, partial, tailStart, 0))\n                    return false;\n                fileTailMatch = tail.length + 1;\n            }\n        }\n        if (!body.length) {\n            let sawSome = !!fileTailMatch;\n            for (let i = fileIndex; i < file.length - fileTailMatch; i++) {\n                const f = String(file[i]);\n                sawSome = true;\n                if (f === '.' || f === '..' ||\n                    (!this.options.dot && f.startsWith('.'))) {\n                    return false;\n                }\n            }\n            return partial || sawSome;\n        }\n        const bodySegments = [[[], 0]];\n        let currentBody = bodySegments[0];\n        let nonGsParts = 0;\n        const nonGsPartsSums = [0];\n        for (const b of body) {\n            if (b === GLOBSTAR) {\n                nonGsPartsSums.push(nonGsParts);\n                currentBody = [[], 0];\n                bodySegments.push(currentBody);\n            }\n            else {\n                currentBody[0].push(b);\n                nonGsParts++;\n            }\n        }\n        let i = bodySegments.length - 1;\n        const fileLength = file.length - fileTailMatch;\n        for (const b of bodySegments) {\n            b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);\n        }\n        return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);\n    }\n    #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {\n        const bs = bodySegments[bodyIndex];\n        if (!bs) {\n            for (let i = fileIndex; i < file.length; i++) {\n                sawTail = true;\n                const f = file[i];\n                if (f === '.' || f === '..' ||\n                    (!this.options.dot && f.startsWith('.'))) {\n                    return false;\n                }\n            }\n            return sawTail;\n        }\n        const [body, after] = bs;\n        while (fileIndex <= after) {\n            const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);\n            if (m && globStarDepth < this.maxGlobstarRecursion) {\n                const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);\n                if (sub !== false)\n                    return sub;\n            }\n            const f = file[fileIndex];\n            if (f === '.' || f === '..' ||\n                (!this.options.dot && f.startsWith('.'))) {\n                return false;\n            }\n            fileIndex++;\n        }\n        return partial || null;\n    }\n    #matchOne(file, pattern, partial, fileIndex, patternIndex) {\n        let fi;\n        let pi;\n        let pl;\n        let fl;\n        for (fi = fileIndex, pi = patternIndex,\n            fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {\n            this.debug('matchOne loop');\n            let p = pattern[pi];\n            let f = file[fi];\n            this.debug(pattern, p, f);\n            /* c8 ignore start */\n            if (p === false || p === GLOBSTAR)\n                return false;\n            /* c8 ignore stop */\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        if (fi === fl && pi === pl) {\n            return true;\n        }\n        else if (fi === fl) {\n            return partial;\n        }\n        else if (pi === pl) {\n            return fi === fl - 1 && file[fi] === '';\n            /* c8 ignore start */\n        }\n        else {\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        const re = AST.fromGlob(pattern, this.options).toMMPattern();\n        if (fastTest && typeof re === 'object') {\n            // Avoids overriding in frozen environments\n            Reflect.defineProperty(re, 'test', { value: fastTest });\n        }\n        return re;\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 = new Set(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 => {\n                if (p instanceof RegExp) {\n                    for (const f of p.flags.split(''))\n                        flags.add(f);\n                }\n                return typeof p === 'string'\n                    ? regExpEscape(p)\n                    : p === GLOBSTAR\n                        ? GLOBSTAR\n                        : p._src;\n            });\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        // need to wrap in parens if we had more than one thing with |,\n        // otherwise only the first will be anchored to ^ and the last to $\n        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];\n        // must match entire pattern\n        // ending in a * or ** will make it less strict.\n        re = '^' + open + re + close + '$';\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].join(''));\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 { AST } from './ast.js';\nexport { escape } from './escape.js';\nexport { unescape } from './unescape.js';\n/* c8 ignore stop */\nminimatch.AST = AST;\nminimatch.Minimatch = Minimatch;\nminimatch.escape = escape;\nminimatch.unescape = unescape;\n//# sourceMappingURL=index.js.map","export function convertResponseHeaders(headers) {\n    const output = {};\n    for (const key of headers.keys()) {\n        output[key] = headers.get(key);\n    }\n    return output;\n}\nexport function mergeHeaders(...headerPayloads) {\n    if (headerPayloads.length === 0)\n        return {};\n    const headerKeys = {};\n    return headerPayloads.reduce((output, headers) => {\n        Object.keys(headers).forEach(header => {\n            const lowerHeader = header.toLowerCase();\n            if (headerKeys.hasOwnProperty(lowerHeader)) {\n                output[headerKeys[lowerHeader]] = headers[header];\n            }\n            else {\n                headerKeys[lowerHeader] = header;\n                output[header] = headers[header];\n            }\n        });\n        return output;\n    }, {});\n}\n","import { minimatch } from \"minimatch\";\nimport { convertResponseHeaders } from \"./tools/headers.js\";\nexport function createErrorFromResponse(response, prefix = \"\") {\n    const err = new Error(`${prefix}Invalid response: ${response.status} ${response.statusText}`);\n    err.status = response.status;\n    err.response = response;\n    return err;\n}\nexport function handleResponseCode(context, response) {\n    const { status } = response;\n    if (status === 401 && context.digest)\n        return response;\n    if (status >= 400) {\n        const err = createErrorFromResponse(response);\n        throw err;\n    }\n    return response;\n}\nexport function processGlobFilter(files, glob) {\n    return files.filter(file => minimatch(file.filename, glob, { matchBase: true }));\n}\n/**\n * Process a response payload (eg. from `customRequest`) and\n *  prepare it for further processing. Exposed for custom\n *  request handling.\n * @param response The response for a request\n * @param data The data returned\n * @param isDetailed Whether or not a detailed result is\n *  requested\n * @returns The response data, or a detailed response object\n *  if required\n */\nexport function processResponsePayload(response, data, isDetailed = false) {\n    return isDetailed\n        ? {\n            data,\n            headers: response.headers ? convertResponseHeaders(response.headers) : {},\n            status: response.status,\n            statusText: response.statusText\n        }\n        : data;\n}\n","// 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","/**\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","import path from \"path-posix\";\nimport { XMLParser } from \"fast-xml-parser\";\n// @ts-expect-error Types declare default export but runtime provides named export\nimport { EntityDecoder } from \"@nodable/entities\";\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 toJPathString(jPath) {\n    if (typeof jPath === \"string\") {\n        return jPath;\n    }\n    return jPath.toString(\".\", false);\n}\nfunction getParser({ attributeNamePrefix, attributeParsers, entityDecoder: entityDecoderOptions, tagParsers }) {\n    const parserOptions = {\n        allowBooleanAttributes: true,\n        attributeNamePrefix,\n        textNodeName: \"text\",\n        ignoreAttributes: false,\n        removeNSPrefix: true,\n        jPath: false,\n        numberParseOptions: {\n            hex: true,\n            leadingZeros: false\n        },\n        attributeValueProcessor(_, attrValue, jPath) {\n            const pathStr = toJPathString(jPath);\n            for (const processor of attributeParsers) {\n                try {\n                    const value = processor(pathStr, attrValue);\n                    if (value !== attrValue) {\n                        return value;\n                    }\n                }\n                catch (error) {\n                    // skipping this invalid processor\n                }\n            }\n            return attrValue;\n        },\n        tagValueProcessor(tagName, tagValue, jPath) {\n            const pathStr = toJPathString(jPath);\n            for (const processor of tagParsers) {\n                try {\n                    const value = processor(pathStr, tagValue);\n                    if (value !== tagValue) {\n                        return value;\n                    }\n                }\n                catch (error) {\n                    // skipping this invalid processor\n                }\n            }\n            return tagValue;\n        }\n    };\n    if (entityDecoderOptions) {\n        parserOptions.entityDecoder = new EntityDecoder({\n            limit: {\n                maxTotalExpansions: entityDecoderOptions.limit?.maxTotalExpansions ?? 0,\n                maxExpandedLength: entityDecoderOptions.limit?.maxExpandedLength ?? 0\n            }\n        });\n    }\n    return new XMLParser(parserOptions);\n}\n/**\n * Tag parser for the displayname prop.\n * Ensure that the displayname is not parsed and always handled as is.\n * @param path The jPath of the tag\n * @param value The text value of the tag\n */\nexport function displaynameTagParser(path, value) {\n    if (path.endsWith(\"propstat.prop.displayname\")) {\n        // Do not parse the displayname, because this causes e.g. '2024.10' to result in number 2024.1\n        return;\n    }\n    return value;\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 * @param context The current client context\n * @returns A parsed and processed DAV result\n */\nexport function parseXML(xml, context) {\n    // backwards compatibility as this method is exported from the package\n    context = context ?? {\n        attributeNamePrefix: \"@\",\n        attributeParsers: [],\n        tagParsers: [displaynameTagParser]\n    };\n    return new Promise(resolve => {\n        const result = getParser(context).parse(xml);\n        resolve(normaliseResult(result));\n    });\n}\n/**\n * Get a file stat result from given DAV properties\n * @param props DAV properties\n * @param filename The filename for the file stat\n * @param isDetailed Whether or not the raw props of the resource should be returned\n * @returns A file stat result\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        // The XML parser tries to interpret values, but the display name is required to be a string\n        if (typeof props.displayname !== \"undefined\") {\n            props.displayname = String(props.displayname);\n        }\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 (String(value)) {\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(String(value), 10);\n    }\n}\n","/**\n * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\n\nimport type { DAVResult, FileStat, ResponseDataDetailed } from 'webdav'\n\nimport { parseXML } from 'webdav'\nimport { processResponsePayload } from 'webdav/dist/node/response.js'\nimport { prepareFileFromProps } from 'webdav/dist/node/tools/dav.js'\nimport client from './DavClient.ts'\n\nexport const DEFAULT_LIMIT = 20\n\n/**\n * Retrieve the comments list\n *\n * @param data destructuring object\n * @param data.resourceType the resource type\n * @param data.resourceId the resource ID\n * @param [options] optional options for axios\n * @param [options.offset] the pagination offset\n * @param [options.limit] the pagination limit, defaults to 20\n * @param [options.datetime] optional date to query\n * @return the comments list\n */\nexport async function getComments({ resourceType, resourceId }, options: { offset: number, limit?: number, datetime?: Date }) {\n\tconst resourcePath = ['', resourceType, resourceId].join('/')\n\tconst datetime = options.datetime ? `<oc:datetime>${options.datetime.toISOString()}</oc:datetime>` : ''\n\tconst response = await client.customRequest(resourcePath, {\n\t\tmethod: 'REPORT',\n\t\tdata: `<?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\t\t...options,\n\t})\n\n\tconst responseData = await response.text()\n\tconst result = await parseXML(responseData)\n\tconst stat = getDirectoryFiles(result, true)\n\t// https://github.com/perry-mitchell/webdav-client/issues/339\n\treturn processResponsePayload(response, stat, true) as ResponseDataDetailed<FileStat[]>\n}\n\n/**\n * https://github.com/perry-mitchell/webdav-client/blob/8d9694613c978ce7404e26a401c39a41f125f87f/source/operations/directoryContents.ts\n *\n * @param result\n * @param isDetailed\n */\nfunction getDirectoryFiles(\n\tresult: DAVResult,\n\tisDetailed = false,\n): Array<FileStat> {\n\t// Extract the response items (directory contents)\n\tconst {\n\t\tmultistatus: { response: responseItems },\n\t} = result\n\n\t// Map all items to a consistent output structure (results)\n\treturn responseItems.map((item) => {\n\t\t// Each item should contain a stat object\n\t\tconst props = item.propstat!.prop!\n\n\t\treturn prepareFileFromProps(props, props.id!.toString(), isDetailed)\n\t})\n}\n"],"names":["getRootPath","generateRemoteUrl","client","createClient","setHeaders","token","onRequestTokenUpdate","getRequestToken","balancedMatch","balanced","a","b","str","maybeMatch","r","range","reg","m","begs","beg","left","right","result","ai","bi","i","require$$0","braceExpansion","expandTop","escSlash","escOpen","escClose","escComma","escPeriod","EXPANSION_MAX","EXPANSION_MAX_LENGTH","numeric","escapeBraces","unescapeBraces","parseCommaParts","parts","pre","body","post","p","postParts","options","max","maxLength","expand","embrace","isPadded","el","lte","y","gte","combine","acc","values","dropEmpties","out","length","v","expansion","expandSequence","isAlphaSequence","n","N","x","width","incr","test","reverse","pad","c","need","z","isTop","firstGroup","isNumericSequence","isSequence","isOptions","dropsEmpties","d","valuesLength","outer","j","expanded","k","MAX_PATTERN_LENGTH","assertValidPattern","pattern","posixClasses","braceEscape","s","regexpEscape","rangesToString","ranges","parseClass","glob","position","pos","negs","sawStart","uflag","escaping","negate","endPos","rangeStart","WHILE","cls","unip","u","neg","sranges","snegs","unescape","windowsPathsNoEscape","_a","types","isExtglobType","isExtglobAST","adoptionMap","adoptionWithSpaceMap","adoptionAnyMap","usurpMap","startNoTraversal","startNoDot","addPatternStart","justDots","reSpecials","regExpEscape","qmark","star","starNoEmpty","AST","#root","#hasMagic","#uflag","#parts","#parent","#parentIndex","#negs","#filledNegs","#options","#toString","#emptyExt","type","parent","#fillNegs","pp","part","ret","pl","#parseAST","ast","opt","extDepth","maxDepth","inBrace","braceStart","braceNeg","ext","#canAdoptType","depthAdd","#canAdoptWithSpace","child","#canAdopt","map","gc","#adoptWithSpace","index","blank","#adopt","#canUsurpType","#canUsurp","#usurp","nt","#flatten","iterations","done","re","hasMagic","flags","allowDot","dot","noEmpty","src","_","#parseGlob","start","aps","needNoTrav","needNoDot","end","repeated","#partsToRegExp","me","bodyDotAllowed","final","close","_hasMagic","inStar","needUflag","consumed","magic","escape","minimatch","Minimatch","starDotExtRE","starDotExtTest","f","starDotExtTestDot","starDotExtTestNocase","starDotExtTestNocaseDot","starDotStarRE","starDotStarTest","starDotStarTestDot","dotStarRE","dotStarTest","starRE","starTest","starTestDot","qmarksRE","qmarksTestNocase","$0","noext","qmarksTestNoExt","qmarksTestNocaseDot","qmarksTestNoExtDot","qmarksTestDot","qmarksTest","len","defaultPlatform","process","define_process_env_default","path","sep","GLOBSTAR","twoStarDot","twoStarNoDot","filter","defaults","def","orig","list","braceExpand","makeRe","match","mm","globMagic","args","rawGlobParts","set","__","isUNC","isDrive","ss","globParts","optimizationLevel","gs","prev","didSomething","dd","gss","next","p2","other","splin","matched","emptyGSMatch","which","negateOffset","file","partial","fileStartIndex","patternStartIndex","fileDrive","fileUNC","patternDrive","patternUNC","fdi","pdi","fd","pd","#matchGlobstar","#matchOne","fileIndex","patternIndex","firstgs","lastgs","head","tail","fileHead","fileTailMatch","tailStart","sawSome","bodySegments","currentBody","nonGsParts","nonGsPartsSums","fileLength","#matchGlobStarBodySections","bodyIndex","globStarDepth","sawTail","bs","after","sub","fi","pi","fl","hit","fastTest","twoStar","open","ff","filename","convertResponseHeaders","headers","output","key","processResponsePayload","response","data","isDetailed","util","isString","normalizeArray","allowAboveRoot","res","splitPathRe","posix","posixSplitPath","resolvedPath","resolvedAbsolute","isAbsolute","trailingSlash","segment","from","to","trim","arr","fromParts","toParts","samePartsLength","outputParts","root","dir","pathObject","base","pathString","allParts","pathPosix","_typeof","obj","_classCallCheck","instance","Constructor","_possibleConstructorReturn","self","call","_assertThisInitialized","_inherits","subClass","superClass","_setPrototypeOf","_wrapNativeSuper","Class","_cache","_isNativeFunction","Wrapper","_construct","_getPrototypeOf","Parent","_isNativeReflectConstruct","fn","o","ARRAY_WILDCARD","PATH_DELIMITER","ObjectPrototypeMutationError","_Error","params","_this","nestedProperty","setNestedProperty","getNestedProperty","hasNestedProperty","object","property","isInNestedProperty","traverse","currentObject","currentProperty","has","segments","isLastSegment","value","nextPropIsNumber","nextPropIsArrayWildcard","err","objectInPath","isIn","pathExists","callback","_loop","idx","currentSegment","remainingSegments","pathToHere","_ret","PropertyType","prepareFileFromProps","props","lastMod","rawSize","resourceType","mimeType","etag","stat","DEFAULT_LIMIT","getComments","resourceId","resourcePath","datetime","responseData","parseXML","getDirectoryFiles","responseItems","item"],"mappings":"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","x_google_ignoreList":[2,3,4,5,6,7,8,9,10,11,12,13,14]}