{"version":3,"file":"GetComments-DSuBVNUT.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\nfunction numeric(str) {\n return parseInt(str, 10) == str\n ? parseInt(str, 10)\n : str.charCodeAt(0);\n}\n\nfunction escapeBraces(str) {\n return str.split('\\\\\\\\').join(escSlash)\n .split('\\\\{').join(escOpen)\n .split('\\\\}').join(escClose)\n .split('\\\\,').join(escComma)\n .split('\\\\.').join(escPeriod);\n}\n\nfunction unescapeBraces(str) {\n return str.split(escSlash).join('\\\\')\n .split(escOpen).join('{')\n .split(escClose).join('}')\n .split(escComma).join(',')\n .split(escPeriod).join('.');\n}\n\n\n// Basically just str.split(\",\"), but handling cases\n// where we have nested braced sections, which should be\n// treated as individual members, like {a,{b,c},d}\nfunction parseCommaParts(str) {\n if (!str)\n return [''];\n\n var parts = [];\n var m = balanced('{', '}', str);\n\n if (!m)\n return str.split(',');\n\n var pre = m.pre;\n var body = m.body;\n var post = m.post;\n var p = pre.split(',');\n\n p[p.length-1] += '{' + body + '}';\n var postParts = parseCommaParts(post);\n if (post.length) {\n p[p.length-1] += postParts.shift();\n p.push.apply(p, postParts);\n }\n\n parts.push.apply(parts, p);\n\n return parts;\n}\n\nfunction expandTop(str) {\n if (!str)\n return [];\n\n // I don't know why Bash 4.3 does this, but it does.\n // Anything starting with {} will have the first two bytes preserved\n // but *only* at the top level, so {},a}b will not expand to anything,\n // but a{},b}c will be expanded to [a}c,abc].\n // One could argue that this is a bug in Bash, but since the goal of\n // this module is to match Bash's rules, we escape a leading {}\n if (str.substr(0, 2) === '{}') {\n str = '\\\\{\\\\}' + str.substr(2);\n }\n\n return expand(escapeBraces(str), true).map(unescapeBraces);\n}\n\nfunction embrace(str) {\n return '{' + str + '}';\n}\nfunction isPadded(el) {\n return /^-?0\\d/.test(el);\n}\n\nfunction lte(i, y) {\n return i <= y;\n}\nfunction gte(i, y) {\n return i >= y;\n}\n\nfunction expand(str, isTop) {\n var expansions = [];\n\n var m = balanced('{', '}', str);\n if (!m) return [str];\n\n // no need to expand pre, since it is guaranteed to be free of brace-sets\n var pre = m.pre;\n var post = m.post.length\n ? expand(m.post, false)\n : [''];\n\n if (/\\$$/.test(m.pre)) { \n for (var k = 0; k < post.length; k++) {\n var expansion = pre+ '{' + m.body + '}' + post[k];\n expansions.push(expansion);\n }\n } else {\n var isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n var isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n var isSequence = isNumericSequence || isAlphaSequence;\n var isOptions = m.body.indexOf(',') >= 0;\n if (!isSequence && !isOptions) {\n // {a},b}\n if (m.post.match(/,(?!,).*\\}/)) {\n str = m.pre + '{' + m.body + escClose + m.post;\n return expand(str);\n }\n return [str];\n }\n\n var n;\n if (isSequence) {\n n = m.body.split(/\\.\\./);\n } else {\n n = parseCommaParts(m.body);\n if (n.length === 1) {\n // x{{a,b}}y ==> x{a}y x{b}y\n n = expand(n[0], false).map(embrace);\n if (n.length === 1) {\n return post.map(function(p) {\n return m.pre + n[0] + p;\n });\n }\n }\n }\n\n // at this point, n is the parts, and we know it's not a comma set\n // with a single entry.\n var N;\n\n if (isSequence) {\n var x = numeric(n[0]);\n var y = numeric(n[1]);\n var width = Math.max(n[0].length, n[1].length)\n var incr = n.length == 3\n ? Math.abs(numeric(n[2]))\n : 1;\n var test = lte;\n var reverse = y < x;\n if (reverse) {\n incr *= -1;\n test = gte;\n }\n var pad = n.some(isPadded);\n\n N = [];\n\n for (var i = x; test(i, y); i += incr) {\n var c;\n if (isAlphaSequence) {\n c = String.fromCharCode(i);\n if (c === '\\\\')\n c = '';\n } else {\n c = String(i);\n if (pad) {\n var need = width - c.length;\n if (need > 0) {\n var z = new Array(need + 1).join('0');\n if (i < 0)\n c = '-' + z + c.slice(1);\n else\n c = z + c;\n }\n }\n }\n N.push(c);\n }\n } else {\n N = [];\n\n for (var j = 0; j < n.length; j++) {\n N.push.apply(N, expand(n[j], false));\n }\n }\n\n for (var j = 0; j < N.length; j++) {\n for (var k = 0; k < post.length; k++) {\n var expansion = pre + N[j] + post[k];\n if (!isTop || isSequence || expansion)\n expansions.push(expansion);\n }\n }\n }\n\n return expansions;\n}\n\n","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// { : [, /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] 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 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 // 
// -> 
/\n            if (!this.preserveMultipleSlashes) {\n                for (let i = 1; i < parts.length - 1; i++) {\n                    const p = parts[i];\n                    // don't squeeze out UNC patterns\n                    if (i === 1 && p === '' && parts[0] === '')\n                        continue;\n                    if (p === '.' || p === '') {\n                        didSomething = true;\n                        parts.splice(i, 1);\n                        i--;\n                    }\n                }\n                if (parts[0] === '.' &&\n                    parts.length === 2 &&\n                    (parts[1] === '.' || parts[1] === '')) {\n                    didSomething = true;\n                    parts.pop();\n                }\n            }\n            // 
/
/../ -> 
/\n            let dd = 0;\n            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                const p = parts[dd - 1];\n                if (p && p !== '.' && p !== '..' && p !== '**') {\n                    didSomething = true;\n                    parts.splice(dd - 1, 2);\n                    dd -= 2;\n                }\n            }\n        } while (didSomething);\n        return parts.length === 0 ? [''] : parts;\n    }\n    // First phase: single-pattern processing\n    // 
 is 1 or more portions\n    //  is 1 or more portions\n    // 
 is any portion other than ., .., '', or **\n    //  is . or ''\n    //\n    // **/.. is *brutal* for filesystem walking performance, because\n    // it effectively resets the recursive walk each time it occurs,\n    // and ** cannot be reduced out by a .. pattern part like a regexp\n    // or most strings (other than .., ., and '') can be.\n    //\n    // 
/**/../
/
/ -> {
/../
/
/,
/**/
/
/}\n    // 
// -> 
/\n    // 
/
/../ -> 
/\n    // **/**/ -> **/\n    //\n    // **/*/ -> */**/ <== not valid because ** doesn't follow\n    // this WOULD be allowed if ** did follow symlinks, or * didn't\n    firstPhasePreProcess(globParts) {\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // 
/**/../
/
/ -> {
/../
/
/,
/**/
/
/}\n            for (let parts of globParts) {\n                let gs = -1;\n                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                    let gss = gs;\n                    while (parts[gss + 1] === '**') {\n                        // 
/**/**/ -> 
/**/\n                        gss++;\n                    }\n                    // eg, if gs is 2 and gss is 4, that means we have 3 **\n                    // parts, and can remove 2 of them.\n                    if (gss > gs) {\n                        parts.splice(gs + 1, gss - gs);\n                    }\n                    let next = parts[gs + 1];\n                    const p = parts[gs + 2];\n                    const p2 = parts[gs + 3];\n                    if (next !== '..')\n                        continue;\n                    if (!p ||\n                        p === '.' ||\n                        p === '..' ||\n                        !p2 ||\n                        p2 === '.' ||\n                        p2 === '..') {\n                        continue;\n                    }\n                    didSomething = true;\n                    // edit parts in place, and push the new one\n                    parts.splice(gs, 1);\n                    const other = parts.slice(0);\n                    other[gs] = '**';\n                    globParts.push(other);\n                    gs--;\n                }\n                // 
// -> 
/\n                if (!this.preserveMultipleSlashes) {\n                    for (let i = 1; i < parts.length - 1; i++) {\n                        const p = parts[i];\n                        // don't squeeze out UNC patterns\n                        if (i === 1 && p === '' && parts[0] === '')\n                            continue;\n                        if (p === '.' || p === '') {\n                            didSomething = true;\n                            parts.splice(i, 1);\n                            i--;\n                        }\n                    }\n                    if (parts[0] === '.' &&\n                        parts.length === 2 &&\n                        (parts[1] === '.' || parts[1] === '')) {\n                        didSomething = true;\n                        parts.pop();\n                    }\n                }\n                // 
/
/../ -> 
/\n                let dd = 0;\n                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                    const p = parts[dd - 1];\n                    if (p && p !== '.' && p !== '..' && p !== '**') {\n                        didSomething = true;\n                        const needDot = dd === 1 && parts[dd + 1] === '**';\n                        const splin = needDot ? ['.'] : [];\n                        parts.splice(dd - 1, 2, ...splin);\n                        if (parts.length === 0)\n                            parts.push('');\n                        dd -= 2;\n                    }\n                }\n            }\n        } while (didSomething);\n        return globParts;\n    }\n    // second phase: multi-pattern dedupes\n    // {
/*/,
/
/} -> 
/*/\n    // {
/,
/} -> 
/\n    // {
/**/,
/} -> 
/**/\n    //\n    // {
/**/,
/**/
/} -> 
/**/\n    // ^-- not valid because ** doens't follow symlinks\n    secondPhasePreProcess(globParts) {\n        for (let i = 0; i < globParts.length - 1; i++) {\n            for (let j = i + 1; j < globParts.length; j++) {\n                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);\n                if (matched) {\n                    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 *.  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 \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 ? `${options.datetime.toISOString()}` : ''\n\tconst response = await client.customRequest(resourcePath, {\n\t\tmethod: 'REPORT',\n\t\tdata: `\n\t\t\t\n\t\t\t\t${options.limit ?? DEFAULT_LIMIT}\n\t\t\t\t${options.offset || 0}\n\t\t\t\t${datetime}\n\t\t\t`,\n\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\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 {\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","numeric","escapeBraces","unescapeBraces","parseCommaParts","parts","pre","body","post","p","postParts","expand","embrace","isPadded","el","lte","y","gte","isTop","expansions","k","expansion","isNumericSequence","isAlphaSequence","isSequence","isOptions","n","N","x","width","incr","test","reverse","pad","c","need","z","j","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","options","#fillNegs","pp","part","ret","pl","#parseAST","ast","opt","extDepth","maxDepth","inBrace","braceStart","braceNeg","acc","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","length","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":"sLAUA,SAASA,IAAc,CACtB,OAAOC,GAAkB,cAAc,CACxC,CCFA,MAAMC,GAASC,GAAaH,GAAA,CAAa,EAMzC,SAASI,GAAWC,EAAO,CAC1BH,GAAO,WAAW,CAEjB,mBAAoB,iBAEpB,aAAcG,GAAS,EAAA,CACvB,CACF,CAGAC,GAAqBF,EAAU,EAC/BA,GAAWG,IAAiB,6CC1B5BC,EAAiBC,EACjB,SAASA,EAASC,EAAGC,EAAGC,EAAK,CACvBF,aAAa,SAAQA,EAAIG,EAAWH,EAAGE,CAAG,GAC1CD,aAAa,SAAQA,EAAIE,EAAWF,EAAGC,CAAG,GAE9C,IAAIE,EAAIC,EAAML,EAAGC,EAAGC,CAAG,EAEvB,OAAOE,GAAK,CACV,MAAOA,EAAE,CAAC,EACV,IAAKA,EAAE,CAAC,EACR,IAAKF,EAAI,MAAM,EAAGE,EAAE,CAAC,CAAC,EACtB,KAAMF,EAAI,MAAME,EAAE,CAAC,EAAIJ,EAAE,OAAQI,EAAE,CAAC,CAAC,EACrC,KAAMF,EAAI,MAAME,EAAE,CAAC,EAAIH,EAAE,MAAM,EAEnC,CAEA,SAASE,EAAWG,EAAKJ,EAAK,CAC5B,IAAIK,EAAIL,EAAI,MAAMI,CAAG,EACrB,OAAOC,EAAIA,EAAE,CAAC,EAAI,IACpB,CAEAR,EAAS,MAAQM,EACjB,SAASA,EAAML,EAAGC,EAAGC,EAAK,CACxB,IAAIM,EAAMC,EAAKC,EAAMC,EAAOC,EACxBC,EAAKX,EAAI,QAAQF,CAAC,EAClBc,EAAKZ,EAAI,QAAQD,EAAGY,EAAK,CAAC,EAC1BE,EAAIF,EAER,GAAIA,GAAM,GAAKC,EAAK,EAAG,CACrB,GAAGd,IAAIC,EACL,MAAO,CAACY,EAAIC,CAAE,EAKhB,IAHAN,EAAO,CAAA,EACPE,EAAOR,EAAI,OAEJa,GAAK,GAAK,CAACH,GACZG,GAAKF,GACPL,EAAK,KAAKO,CAAC,EACXF,EAAKX,EAAI,QAAQF,EAAGe,EAAI,CAAC,GAChBP,EAAK,QAAU,EACxBI,EAAS,CAAEJ,EAAK,IAAG,EAAIM,CAAE,GAEzBL,EAAMD,EAAK,IAAG,EACVC,EAAMC,IACRA,EAAOD,EACPE,EAAQG,GAGVA,EAAKZ,EAAI,QAAQD,EAAGc,EAAI,CAAC,GAG3BA,EAAIF,EAAKC,GAAMD,GAAM,EAAIA,EAAKC,EAG5BN,EAAK,SACPI,EAAS,CAAEF,EAAMC,CAAK,EAE5B,CAEE,OAAOC,CACT,qDC7DA,IAAIb,EAAWiB,GAAA,EAEfC,EAAiBC,EAEjB,IAAIC,EAAW,UAAU,KAAK,OAAM,EAAG,KACnCC,EAAU,SAAS,KAAK,OAAM,EAAG,KACjCC,EAAW,UAAU,KAAK,OAAM,EAAG,KACnCC,EAAW,UAAU,KAAK,OAAM,EAAG,KACnCC,EAAY,WAAW,KAAK,OAAM,EAAG,KAEzC,SAASC,EAAQtB,EAAK,CACpB,OAAO,SAASA,EAAK,EAAE,GAAKA,EACxB,SAASA,EAAK,EAAE,EAChBA,EAAI,WAAW,CAAC,CACtB,CAEA,SAASuB,EAAavB,EAAK,CACzB,OAAOA,EAAI,MAAM,MAAM,EAAE,KAAKiB,CAAQ,EAC3B,MAAM,KAAK,EAAE,KAAKC,CAAO,EACzB,MAAM,KAAK,EAAE,KAAKC,CAAQ,EAC1B,MAAM,KAAK,EAAE,KAAKC,CAAQ,EAC1B,MAAM,KAAK,EAAE,KAAKC,CAAS,CACxC,CAEA,SAASG,EAAexB,EAAK,CAC3B,OAAOA,EAAI,MAAMiB,CAAQ,EAAE,KAAK,IAAI,EACzB,MAAMC,CAAO,EAAE,KAAK,GAAG,EACvB,MAAMC,CAAQ,EAAE,KAAK,GAAG,EACxB,MAAMC,CAAQ,EAAE,KAAK,GAAG,EACxB,MAAMC,CAAS,EAAE,KAAK,GAAG,CACtC,CAMA,SAASI,EAAgBzB,EAAK,CAC5B,GAAI,CAACA,EACH,MAAO,CAAC,EAAE,EAEZ,IAAI0B,EAAQ,CAAA,EACRrB,EAAIR,EAAS,IAAK,IAAKG,CAAG,EAE9B,GAAI,CAACK,EACH,OAAOL,EAAI,MAAM,GAAG,EAEtB,IAAI2B,EAAMtB,EAAE,IACRuB,EAAOvB,EAAE,KACTwB,EAAOxB,EAAE,KACTyB,EAAIH,EAAI,MAAM,GAAG,EAErBG,EAAEA,EAAE,OAAO,CAAC,GAAK,IAAMF,EAAO,IAC9B,IAAIG,EAAYN,EAAgBI,CAAI,EACpC,OAAIA,EAAK,SACPC,EAAEA,EAAE,OAAO,CAAC,GAAKC,EAAU,MAAK,EAChCD,EAAE,KAAK,MAAMA,EAAGC,CAAS,GAG3BL,EAAM,KAAK,MAAMA,EAAOI,CAAC,EAElBJ,CACT,CAEA,SAASV,EAAUhB,EAAK,CACtB,OAAKA,GASDA,EAAI,OAAO,EAAG,CAAC,IAAM,OACvBA,EAAM,SAAWA,EAAI,OAAO,CAAC,GAGxBgC,EAAOT,EAAavB,CAAG,EAAG,EAAI,EAAE,IAAIwB,CAAc,GAZhD,CAAA,CAaX,CAEA,SAASS,EAAQjC,EAAK,CACpB,MAAO,IAAMA,EAAM,GACrB,CACA,SAASkC,EAASC,EAAI,CACpB,MAAO,SAAS,KAAKA,CAAE,CACzB,CAEA,SAASC,EAAIvB,EAAGwB,EAAG,CACjB,OAAOxB,GAAKwB,CACd,CACA,SAASC,EAAIzB,EAAGwB,EAAG,CACjB,OAAOxB,GAAKwB,CACd,CAEA,SAASL,EAAOhC,EAAKuC,EAAO,CAC1B,IAAIC,EAAa,CAAA,EAEbnC,EAAIR,EAAS,IAAK,IAAKG,CAAG,EAC9B,GAAI,CAACK,EAAG,MAAO,CAACL,CAAG,EAGnB,IAAI2B,EAAMtB,EAAE,IACRwB,EAAOxB,EAAE,KAAK,OACd2B,EAAO3B,EAAE,KAAM,EAAK,EACpB,CAAC,EAAE,EAEP,GAAI,MAAM,KAAKA,EAAE,GAAG,EAClB,QAASoC,EAAI,EAAGA,EAAIZ,EAAK,OAAQY,IAAK,CACpC,IAAIC,EAAYf,EAAK,IAAMtB,EAAE,KAAO,IAAMwB,EAAKY,CAAC,EAChDD,EAAW,KAAKE,CAAS,CAC/B,KACS,CACL,IAAIC,EAAoB,iCAAiC,KAAKtC,EAAE,IAAI,EAChEuC,EAAkB,uCAAuC,KAAKvC,EAAE,IAAI,EACpEwC,EAAaF,GAAqBC,EAClCE,EAAYzC,EAAE,KAAK,QAAQ,GAAG,GAAK,EACvC,GAAI,CAACwC,GAAc,CAACC,EAElB,OAAIzC,EAAE,KAAK,MAAM,YAAY,GAC3BL,EAAMK,EAAE,IAAM,IAAMA,EAAE,KAAOc,EAAWd,EAAE,KACnC2B,EAAOhC,CAAG,GAEZ,CAACA,CAAG,EAGb,IAAI+C,EACJ,GAAIF,EACFE,EAAI1C,EAAE,KAAK,MAAM,MAAM,UAEvB0C,EAAItB,EAAgBpB,EAAE,IAAI,EACtB0C,EAAE,SAAW,IAEfA,EAAIf,EAAOe,EAAE,CAAC,EAAG,EAAK,EAAE,IAAId,CAAO,EAC/Bc,EAAE,SAAW,GACf,OAAOlB,EAAK,IAAI,SAASC,GAAG,CAC1B,OAAOzB,EAAE,IAAM0C,EAAE,CAAC,EAAIjB,EAClC,CAAW,EAOP,IAAIkB,EAEJ,GAAIH,EAAY,CACd,IAAII,EAAI3B,EAAQyB,EAAE,CAAC,CAAC,EAChBV,EAAIf,EAAQyB,EAAE,CAAC,CAAC,EAChBG,EAAQ,KAAK,IAAIH,EAAE,CAAC,EAAE,OAAQA,EAAE,CAAC,EAAE,MAAM,EACzCI,EAAOJ,EAAE,QAAU,EACnB,KAAK,IAAIzB,EAAQyB,EAAE,CAAC,CAAC,CAAC,EACtB,EACAK,GAAOhB,EACPiB,GAAUhB,EAAIY,EACdI,KACFF,GAAQ,GACRC,GAAOd,GAET,IAAIgB,GAAMP,EAAE,KAAKb,CAAQ,EAEzBc,EAAI,CAAA,EAEJ,QAASnC,EAAIoC,EAAGG,GAAKvC,EAAGwB,CAAC,EAAGxB,GAAKsC,EAAM,CACrC,IAAII,EACJ,GAAIX,EACFW,EAAI,OAAO,aAAa1C,CAAC,EACrB0C,IAAM,OACRA,EAAI,YAENA,EAAI,OAAO1C,CAAC,EACRyC,GAAK,CACP,IAAIE,GAAON,EAAQK,EAAE,OACrB,GAAIC,GAAO,EAAG,CACZ,IAAIC,GAAI,IAAI,MAAMD,GAAO,CAAC,EAAE,KAAK,GAAG,EAChC3C,EAAI,EACN0C,EAAI,IAAME,GAAIF,EAAE,MAAM,CAAC,EAEvBA,EAAIE,GAAIF,CACxB,CACA,CAEQP,EAAE,KAAKO,CAAC,CAChB,CACA,KAAW,CACLP,EAAI,CAAA,EAEJ,QAASU,EAAI,EAAGA,EAAIX,EAAE,OAAQW,IAC5BV,EAAE,KAAK,MAAMA,EAAGhB,EAAOe,EAAEW,CAAC,EAAG,EAAK,CAAC,CAE3C,CAEI,QAASA,EAAI,EAAGA,EAAIV,EAAE,OAAQU,IAC5B,QAASjB,EAAI,EAAGA,EAAIZ,EAAK,OAAQY,IAAK,CACpC,IAAIC,EAAYf,EAAMqB,EAAEU,CAAC,EAAI7B,EAAKY,CAAC,GAC/B,CAACF,GAASM,GAAcH,IAC1BF,EAAW,KAAKE,CAAS,CACnC,CAEA,CAEE,OAAOF,CACT,sCCzMMmB,GAAqB,KAAO,GACrBC,EAAsBC,GAAY,CAC3C,GAAI,OAAOA,GAAY,SACnB,MAAM,IAAI,UAAU,iBAAiB,EAEzC,GAAIA,EAAQ,OAASF,GACjB,MAAM,IAAI,UAAU,qBAAqB,CAEjD,ECLMG,GAAe,CACjB,YAAa,CAAC,uBAAwB,EAAI,EAC1C,YAAa,CAAC,gBAAiB,EAAI,EACnC,YAAa,CAAC,cAAyB,EAAK,EAC5C,YAAa,CAAC,aAAc,EAAI,EAChC,YAAa,CAAC,UAAW,EAAI,EAC7B,YAAa,CAAC,UAAW,EAAI,EAC7B,YAAa,CAAC,eAAgB,GAAM,EAAI,EACxC,YAAa,CAAC,UAAW,EAAI,EAC7B,YAAa,CAAC,SAAU,EAAI,EAC5B,YAAa,CAAC,SAAU,EAAI,EAC5B,YAAa,CAAC,wBAAyB,EAAI,EAC3C,YAAa,CAAC,UAAW,EAAI,EAC7B,WAAY,CAAC,8BAA+B,EAAI,EAChD,aAAc,CAAC,YAAa,EAAK,CACrC,EAGMC,EAAeC,GAAMA,EAAE,QAAQ,YAAa,MAAM,EAElDC,GAAgBD,GAAMA,EAAE,QAAQ,2BAA4B,MAAM,EAElEE,GAAkBC,GAAWA,EAAO,KAAK,EAAE,EAOpCC,GAAa,CAACC,EAAMC,IAAa,CAC1C,MAAMC,EAAMD,EAEZ,GAAID,EAAK,OAAOE,CAAG,IAAM,IACrB,MAAM,IAAI,MAAM,2BAA2B,EAG/C,MAAMJ,EAAS,CAAA,EACTK,EAAO,CAAA,EACb,IAAI3D,EAAI0D,EAAM,EACVE,EAAW,GACXC,EAAQ,GACRC,EAAW,GACXC,EAAS,GACTC,EAASN,EACTO,EAAa,GACjBC,EAAO,KAAOlE,EAAIwD,EAAK,QAAQ,CAC3B,MAAMd,EAAIc,EAAK,OAAOxD,CAAC,EACvB,IAAK0C,IAAM,KAAOA,IAAM,MAAQ1C,IAAM0D,EAAM,EAAG,CAC3CK,EAAS,GACT/D,IACA,QACJ,CACA,GAAI0C,IAAM,KAAOkB,GAAY,CAACE,EAAU,CACpCE,EAAShE,EAAI,EACb,KACJ,CAEA,GADA4D,EAAW,GACPlB,IAAM,MACF,CAACoB,EAAU,CACXA,EAAW,GACX9D,IACA,QACJ,CAGJ,GAAI0C,IAAM,KAAO,CAACoB,GAEd,SAAW,CAACK,EAAK,CAACC,EAAMC,EAAGC,CAAG,CAAC,IAAK,OAAO,QAAQrB,EAAY,EAC3D,GAAIO,EAAK,WAAWW,EAAKnE,CAAC,EAAG,CAEzB,GAAIiE,EACA,MAAO,CAAC,KAAM,GAAOT,EAAK,OAASE,EAAK,EAAI,EAEhD1D,GAAKmE,EAAI,OACLG,EACAX,EAAK,KAAKS,CAAI,EAEdd,EAAO,KAAKc,CAAI,EACpBP,EAAQA,GAASQ,EACjB,SAASH,CACb,EAKR,GADAJ,EAAW,GACPG,EAAY,CAGRvB,EAAIuB,EACJX,EAAO,KAAKJ,EAAYe,CAAU,EAAI,IAAMf,EAAYR,CAAC,CAAC,EAErDA,IAAMuB,GACXX,EAAO,KAAKJ,EAAYR,CAAC,CAAC,EAE9BuB,EAAa,GACbjE,IACA,QACJ,CAGA,GAAIwD,EAAK,WAAW,KAAMxD,EAAI,CAAC,EAAG,CAC9BsD,EAAO,KAAKJ,EAAYR,EAAI,GAAG,CAAC,EAChC1C,GAAK,EACL,QACJ,CACA,GAAIwD,EAAK,WAAW,IAAKxD,EAAI,CAAC,EAAG,CAC7BiE,EAAavB,EACb1C,GAAK,EACL,QACJ,CAEAsD,EAAO,KAAKJ,EAAYR,CAAC,CAAC,EAC1B1C,GACJ,CACA,GAAIgE,EAAShE,EAGT,MAAO,CAAC,GAAI,GAAO,EAAG,EAAK,EAI/B,GAAI,CAACsD,EAAO,QAAU,CAACK,EAAK,OACxB,MAAO,CAAC,KAAM,GAAOH,EAAK,OAASE,EAAK,EAAI,EAMhD,GAAIC,EAAK,SAAW,GAChBL,EAAO,SAAW,GAClB,SAAS,KAAKA,EAAO,CAAC,CAAC,GACvB,CAACS,EAAQ,CACT,MAAM1E,EAAIiE,EAAO,CAAC,EAAE,SAAW,EAAIA,EAAO,CAAC,EAAE,MAAM,EAAE,EAAIA,EAAO,CAAC,EACjE,MAAO,CAACF,GAAa/D,CAAC,EAAG,GAAO2E,EAASN,EAAK,EAAK,CACvD,CACA,MAAMa,EAAU,KAAOR,EAAS,IAAM,IAAMV,GAAeC,CAAM,EAAI,IAC/DkB,EAAQ,KAAOT,EAAS,GAAK,KAAOV,GAAeM,CAAI,EAAI,IAMjE,MAAO,CALML,EAAO,QAAUK,EAAK,OAC7B,IAAMY,EAAU,IAAMC,EAAQ,IAC9BlB,EAAO,OACHiB,EACAC,EACIX,EAAOG,EAASN,EAAK,EAAI,CAC3C,ECpIae,EAAW,CAACtB,EAAG,CAAE,qBAAAuB,EAAuB,EAAK,EAAM,CAAA,IACrDA,EACDvB,EAAE,QAAQ,iBAAkB,IAAI,EAChCA,EAAE,QAAQ,4BAA6B,MAAM,EAAE,QAAQ,aAAc,IAAI,EChBnF,IAAIwB,EAGJ,MAAMC,GAAQ,IAAI,IAAI,CAAC,IAAK,IAAK,IAAK,IAAK,GAAG,CAAC,EACzCC,EAAiBnC,GAAMkC,GAAM,IAAIlC,CAAC,EAClCoC,GAAgBpC,GAAMmC,EAAcnC,EAAE,IAAI,EAC1CqC,GAAc,IAAI,IAAI,CACxB,CAAC,IAAK,CAAC,GAAG,CAAC,EACX,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,EAChB,CAAC,IAAK,CAAC,GAAG,CAAC,EACX,CAAC,IAAK,CAAC,IAAK,IAAK,IAAK,GAAG,CAAC,EAC1B,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,CACpB,CAAC,EACKC,GAAuB,IAAI,IAAI,CACjC,CAAC,IAAK,CAAC,GAAG,CAAC,EACX,CAAC,IAAK,CAAC,GAAG,CAAC,EACX,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,CACpB,CAAC,EACKC,GAAiB,IAAI,IAAI,CAC3B,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,EAChB,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,EAChB,CAAC,IAAK,CAAC,IAAK,GAAG,CAAC,EAChB,CAAC,IAAK,CAAC,IAAK,IAAK,IAAK,GAAG,CAAC,EAC1B,CAAC,IAAK,CAAC,IAAK,IAAK,IAAK,GAAG,CAAC,CAC9B,CAAC,EACKC,GAAW,IAAI,IAAI,CACrB,CAAC,IAAK,IAAI,IAAI,CAAC,CAAC,IAAK,GAAG,CAAC,CAAC,CAAC,EAC3B,CAAC,IAAK,IAAI,IAAI,CAAC,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,CAAC,CAAC,CAAC,EACvC,CAAC,IAAK,IAAI,IAAI,CAAC,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,CAAC,CAAC,CAAC,EAC3E,CAAC,IAAK,IAAI,IAAI,CAAC,CAAC,IAAK,GAAG,EAAG,CAAC,IAAK,GAAG,CAAC,CAAC,CAAC,CAC3C,CAAC,EAKKC,GAAmB,4BACnBC,EAAa,UAIbC,GAAkB,IAAI,IAAI,CAAC,IAAK,GAAG,CAAC,EAEpCC,GAAW,IAAI,IAAI,CAAC,KAAM,GAAG,CAAC,EAC9BC,GAAa,IAAI,IAAI,iBAAiB,EACtCC,GAAgBrC,GAAMA,EAAE,QAAQ,2BAA4B,MAAM,EAElEsC,EAAQ,OAERC,GAAOD,EAAQ,KAGfE,GAAcF,EAAQ,KAGrB,MAAMG,EAAI,CACb,KACAC,GACAC,GACAC,GAAS,GACTC,GAAS,CAAA,EACTC,GACAC,GACAC,GACAC,GAAc,GACdC,GACAC,GAGAC,GAAY,GACZ,YAAYC,EAAMC,EAAQC,EAAU,CAAA,EAAI,CACpC,KAAK,KAAOF,EAERA,IACA,KAAKV,GAAY,IACrB,KAAKG,GAAUQ,EACf,KAAKZ,GAAQ,KAAKI,GAAU,KAAKA,GAAQJ,GAAQ,KACjD,KAAKQ,GAAW,KAAKR,KAAU,KAAOa,EAAU,KAAKb,GAAMQ,GAC3D,KAAKF,GAAQ,KAAKN,KAAU,KAAO,GAAK,KAAKA,GAAMM,GAC/CK,IAAS,KAAO,CAAC,KAAKX,GAAMO,IAC5B,KAAKD,GAAM,KAAK,IAAI,EACxB,KAAKD,GAAe,KAAKD,GAAU,KAAKA,GAAQD,GAAO,OAAS,CACpE,CACA,IAAI,UAAW,CAEX,GAAI,KAAKF,KAAc,OACnB,OAAO,KAAKA,GAEhB,UAAW7E,KAAK,KAAK+E,GACjB,GAAI,OAAO/E,GAAM,WAEbA,EAAE,MAAQA,EAAE,UACZ,OAAQ,KAAK6E,GAAY,GAGjC,OAAO,KAAKA,EAChB,CAEA,UAAW,CACP,OAAI,KAAKQ,KAAc,OACZ,KAAKA,GACX,KAAK,KAIE,KAAKA,GACT,KAAK,KAAO,IAAM,KAAKN,GAAO,IAAI/E,GAAK,OAAOA,CAAC,CAAC,EAAE,KAAK,GAAG,EAAI,IAJ1D,KAAKqF,GAAY,KAAKN,GAAO,IAAI/E,GAAK,OAAOA,CAAC,CAAC,EAAE,KAAK,EAAE,CAMxE,CACA0F,IAAY,CAER,GAAI,OAAS,KAAKd,GACd,MAAM,IAAI,MAAM,0BAA0B,EAC9C,GAAI,KAAKO,GACL,OAAO,KAGX,KAAK,SAAQ,EACb,KAAKA,GAAc,GACnB,IAAIlE,EACJ,KAAQA,EAAI,KAAKiE,GAAM,IAAG,GAAK,CAC3B,GAAIjE,EAAE,OAAS,IACX,SAEJ,IAAIjB,EAAIiB,EACJ0E,EAAK3F,EAAEgF,GACX,KAAOW,GAAI,CACP,QAAS5G,EAAIiB,EAAEiF,GAAe,EAAG,CAACU,EAAG,MAAQ5G,EAAI4G,EAAGZ,GAAO,OAAQhG,IAC/D,UAAW6G,KAAQ3E,EAAE8D,GAAQ,CAEzB,GAAI,OAAOa,GAAS,SAChB,MAAM,IAAI,MAAM,8BAA8B,EAGlDA,EAAK,OAAOD,EAAGZ,GAAOhG,CAAC,CAAC,CAC5B,CAEJiB,EAAI2F,EACJA,EAAK3F,EAAEgF,EACX,CACJ,CACA,OAAO,IACX,CACA,QAAQpF,EAAO,CACX,UAAWI,KAAKJ,EACZ,GAAII,IAAM,GAGV,CAAA,GAAI,OAAOA,GAAM,UAAY,EAAEA,aAAa0D,GAAM1D,EAAEgF,KAAY,MAC5D,MAAM,IAAI,MAAM,iBAAmBhF,CAAC,EAGxC,KAAK+E,GAAO,KAAK/E,CAAC,CAAA,CAE1B,CACA,QAAS,CACL,MAAM6F,EAAM,KAAK,OAAS,KACpB,KAAKd,GAAO,MAAK,EAAG,IAAI/E,GAAM,OAAOA,GAAM,SAAWA,EAAIA,EAAE,OAAM,CAAG,EACrE,CAAC,KAAK,KAAM,GAAG,KAAK+E,GAAO,IAAI/E,GAAKA,EAAE,OAAM,CAAE,CAAC,EACrD,OAAI,KAAK,WAAa,CAAC,KAAK,MACxB6F,EAAI,QAAQ,EAAE,EACd,KAAK,MAAK,IACT,OAAS,KAAKjB,IACV,KAAKA,GAAMO,IAAe,KAAKH,IAAS,OAAS,MACtDa,EAAI,KAAK,EAAE,EAERA,CACX,CACA,SAAU,CACN,GAAI,KAAKjB,KAAU,KACf,MAAO,GAEX,GAAI,CAAC,KAAKI,IAAS,QAAO,EACtB,MAAO,GACX,GAAI,KAAKC,KAAiB,EACtB,MAAO,GAEX,MAAMjF,EAAI,KAAKgF,GACf,QAASjG,EAAI,EAAGA,EAAI,KAAKkG,GAAclG,IAAK,CACxC,MAAM4G,EAAK3F,EAAE+E,GAAOhG,CAAC,EACrB,GAAI,EAAE4G,aAAcjC,GAAMiC,EAAG,OAAS,KAClC,MAAO,EAEf,CACA,MAAO,EACX,CACA,OAAQ,CAGJ,GAFI,KAAKf,KAAU,MAEf,KAAKI,IAAS,OAAS,IACvB,MAAO,GACX,GAAI,CAAC,KAAKA,IAAS,MAAK,EACpB,MAAO,GACX,GAAI,CAAC,KAAK,KACN,OAAO,KAAKA,IAAS,MAAK,EAG9B,MAAMc,EAAK,KAAKd,GAAU,KAAKA,GAAQD,GAAO,OAAS,EAEvD,OAAO,KAAKE,KAAiBa,EAAK,CACtC,CACA,OAAOF,EAAM,CACL,OAAOA,GAAS,SAChB,KAAK,KAAKA,CAAI,EAEd,KAAK,KAAKA,EAAK,MAAM,IAAI,CAAC,CAClC,CACA,MAAMJ,EAAQ,CACV,MAAM/D,EAAI,IAAIiC,EAAG,KAAK,KAAM8B,CAAM,EAClC,UAAWxF,KAAK,KAAK+E,GACjBtD,EAAE,OAAOzB,CAAC,EAEd,OAAOyB,CACX,CACA,MAAOsE,GAAU7H,EAAK8H,EAAKvD,EAAKwD,EAAKC,EAAU,CAC3C,MAAMC,EAAWF,EAAI,qBAAuB,EAC5C,IAAIpD,EAAW,GACXuD,EAAU,GACVC,EAAa,GACbC,EAAW,GACf,GAAIN,EAAI,OAAS,KAAM,CAEnB,IAAIjH,EAAI0D,EACJ8D,EAAM,GACV,KAAOxH,EAAIb,EAAI,QAAQ,CACnB,MAAMuD,EAAIvD,EAAI,OAAOa,GAAG,EAGxB,GAAI8D,GAAYpB,IAAM,KAAM,CACxBoB,EAAW,CAACA,EACZ0D,GAAO9E,EACP,QACJ,CACA,GAAI2E,EAAS,CACLrH,IAAMsH,EAAa,GACf5E,IAAM,KAAOA,IAAM,OACnB6E,EAAW,IAGV7E,IAAM,KAAO,EAAE1C,IAAMsH,EAAa,GAAKC,KAC5CF,EAAU,IAEdG,GAAO9E,EACP,QACJ,SACSA,IAAM,IAAK,CAChB2E,EAAU,GACVC,EAAatH,EACbuH,EAAW,GACXC,GAAO9E,EACP,QACJ,CAKA,GAJkB,CAACwE,EAAI,OACnBrC,EAAcnC,CAAC,GACfvD,EAAI,OAAOa,CAAC,IAAM,KAClBmH,GAAYC,EACD,CACXH,EAAI,KAAKO,CAAG,EACZA,EAAM,GACN,MAAMC,EAAM,IAAI9C,EAAGjC,EAAGuE,CAAG,EACzBjH,EAAI2E,EAAGqC,GAAU7H,EAAKsI,EAAKzH,EAAGkH,EAAKC,EAAW,CAAC,EAC/CF,EAAI,KAAKQ,CAAG,EACZ,QACJ,CACAD,GAAO9E,CACX,CACA,OAAAuE,EAAI,KAAKO,CAAG,EACLxH,CACX,CAGA,IAAIA,EAAI0D,EAAM,EACVmD,EAAO,IAAIlC,EAAG,KAAMsC,CAAG,EAC3B,MAAMpG,EAAQ,CAAA,EACd,IAAI2G,EAAM,GACV,KAAOxH,EAAIb,EAAI,QAAQ,CACnB,MAAMuD,EAAIvD,EAAI,OAAOa,GAAG,EAGxB,GAAI8D,GAAYpB,IAAM,KAAM,CACxBoB,EAAW,CAACA,EACZ0D,GAAO9E,EACP,QACJ,CACA,GAAI2E,EAAS,CACLrH,IAAMsH,EAAa,GACf5E,IAAM,KAAOA,IAAM,OACnB6E,EAAW,IAGV7E,IAAM,KAAO,EAAE1C,IAAMsH,EAAa,GAAKC,KAC5CF,EAAU,IAEdG,GAAO9E,EACP,QACJ,SACSA,IAAM,IAAK,CAChB2E,EAAU,GACVC,EAAatH,EACbuH,EAAW,GACXC,GAAO9E,EACP,QACJ,CAMA,GALkBmC,EAAcnC,CAAC,GAC7BvD,EAAI,OAAOa,CAAC,IAAM,MAEjBmH,GAAYC,GAAaH,GAAOA,EAAIS,GAAchF,CAAC,GAEzC,CACX,MAAMiF,EAAWV,GAAOA,EAAIS,GAAchF,CAAC,EAAI,EAAI,EACnDmE,EAAK,KAAKW,CAAG,EACbA,EAAM,GACN,MAAMC,EAAM,IAAI9C,EAAGjC,EAAGmE,CAAI,EAC1BA,EAAK,KAAKY,CAAG,EACbzH,EAAI2E,EAAGqC,GAAU7H,EAAKsI,EAAKzH,EAAGkH,EAAKC,EAAWQ,CAAQ,EACtD,QACJ,CACA,GAAIjF,IAAM,IAAK,CACXmE,EAAK,KAAKW,CAAG,EACbA,EAAM,GACN3G,EAAM,KAAKgG,CAAI,EACfA,EAAO,IAAIlC,EAAG,KAAMsC,CAAG,EACvB,QACJ,CACA,GAAIvE,IAAM,IACN,OAAI8E,IAAQ,IAAMP,EAAIjB,GAAO,SAAW,IACpCiB,EAAIV,GAAY,IAEpBM,EAAK,KAAKW,CAAG,EACbA,EAAM,GACNP,EAAI,KAAK,GAAGpG,EAAOgG,CAAI,EAChB7G,EAEXwH,GAAO9E,CACX,CAIA,OAAAuE,EAAI,KAAO,KACXA,EAAInB,GAAY,OAChBmB,EAAIjB,GAAS,CAAC7G,EAAI,UAAUuE,EAAM,CAAC,CAAC,EAC7B1D,CACX,CACA4H,GAAmBC,EAAO,CACtB,OAAO,KAAKC,GAAUD,EAAO7C,EAAoB,CACrD,CACA8C,GAAUD,EAAOE,EAAMhD,GAAa,CAChC,GAAI,CAAC8C,GACD,OAAOA,GAAU,UACjBA,EAAM,OAAS,MACfA,EAAM7B,GAAO,SAAW,GACxB,KAAK,OAAS,KACd,MAAO,GAEX,MAAMgC,EAAKH,EAAM7B,GAAO,CAAC,EACzB,MAAI,CAACgC,GAAM,OAAOA,GAAO,UAAYA,EAAG,OAAS,KACtC,GAEJ,KAAKN,GAAcM,EAAG,KAAMD,CAAG,CAC1C,CACAL,GAAchF,EAAGqF,EAAM9C,GAAgB,CACnC,MAAO,CAAC,CAAC8C,EAAI,IAAI,KAAK,IAAI,GAAG,SAASrF,CAAC,CAC3C,CACAuF,GAAgBJ,EAAOK,EAAO,CAC1B,MAAMF,EAAKH,EAAM7B,GAAO,CAAC,EACnBmC,EAAQ,IAAIxD,EAAG,KAAMqD,EAAI,KAAK,OAAO,EAC3CG,EAAMnC,GAAO,KAAK,EAAE,EACpBgC,EAAG,KAAKG,CAAK,EACb,KAAKC,GAAOP,EAAOK,CAAK,CAC5B,CACAE,GAAOP,EAAOK,EAAO,CACjB,MAAMF,EAAKH,EAAM7B,GAAO,CAAC,EACzB,KAAKA,GAAO,OAAOkC,EAAO,EAAG,GAAGF,EAAGhC,EAAM,EACzC,UAAW/E,KAAK+G,EAAGhC,GACX,OAAO/E,GAAM,WACbA,EAAEgF,GAAU,MAEpB,KAAKK,GAAY,MACrB,CACA+B,GAAc3F,EAAG,CAEb,MAAO,CAAC,CADEwC,GAAS,IAAI,KAAK,IAAI,GACnB,IAAIxC,CAAC,CACtB,CACA4F,GAAUT,EAAO,CACb,GAAI,CAACA,GACD,OAAOA,GAAU,UACjBA,EAAM,OAAS,MACfA,EAAM7B,GAAO,SAAW,GACxB,KAAK,OAAS,MACd,KAAKA,GAAO,SAAW,EACvB,MAAO,GAEX,MAAMgC,EAAKH,EAAM7B,GAAO,CAAC,EACzB,MAAI,CAACgC,GAAM,OAAOA,GAAO,UAAYA,EAAG,OAAS,KACtC,GAEJ,KAAKK,GAAcL,EAAG,IAAI,CACrC,CACAO,GAAOV,EAAO,CACV,MAAMrI,EAAI0F,GAAS,IAAI,KAAK,IAAI,EAC1B8C,EAAKH,EAAM7B,GAAO,CAAC,EACnBwC,EAAKhJ,GAAG,IAAIwI,EAAG,IAAI,EAEzB,GAAI,CAACQ,EACD,MAAO,GAEX,KAAKxC,GAASgC,EAAGhC,GACjB,UAAW/E,KAAK,KAAK+E,GACb,OAAO/E,GAAM,WACbA,EAAEgF,GAAU,MAEpB,KAAK,KAAOuC,EACZ,KAAKlC,GAAY,OACjB,KAAKC,GAAY,EACrB,CACAkC,IAAW,CACP,GAAK3D,GAAa,IAAI,EAMjB,CACD,IAAI4D,EAAa,EACbC,EAAO,GACX,EAAG,CACCA,EAAO,GACP,QAAS3I,EAAI,EAAGA,EAAI,KAAKgG,GAAO,OAAQhG,IAAK,CACzC,MAAM0C,EAAI,KAAKsD,GAAOhG,CAAC,EACnB,OAAO0C,GAAM,WACbA,EAAE+F,GAAQ,EACN,KAAKX,GAAUpF,CAAC,GAChBiG,EAAO,GACP,KAAKP,GAAO1F,EAAG1C,CAAC,GAEX,KAAK4H,GAAmBlF,CAAC,GAC9BiG,EAAO,GACP,KAAKV,GAAgBvF,EAAG1C,CAAC,GAEpB,KAAKsI,GAAU5F,CAAC,IACrBiG,EAAO,GACP,KAAKJ,GAAO7F,CAAC,GAGzB,CACJ,OAAS,CAACiG,GAAQ,EAAED,EAAa,GACrC,KA7BI,WAAWzH,KAAK,KAAK+E,GACb,OAAO/E,GAAM,UACbA,EAAEwH,GAAQ,EA4BtB,KAAKnC,GAAY,MACrB,CACA,OAAO,SAAStD,EAAS0D,EAAU,GAAI,CACnC,MAAMO,EAAM,IAAItC,EAAG,KAAM,OAAW+B,CAAO,EAC3C,OAAA/B,EAAGqC,GAAUhE,EAASiE,EAAK,EAAGP,EAAS,CAAC,EACjCO,CACX,CAGA,aAAc,CAGV,GAAI,OAAS,KAAKpB,GACd,OAAO,KAAKA,GAAM,YAAW,EAEjC,MAAMrC,EAAO,KAAK,SAAQ,EACpB,CAACoF,EAAI7H,EAAM8H,EAAUhF,CAAK,EAAI,KAAK,eAAc,EASvD,GAAI,EALagF,GACb,KAAK/C,IACJ,KAAKO,GAAS,QACX,CAAC,KAAKA,GAAS,iBACf7C,EAAK,YAAW,IAAOA,EAAK,YAAW,GAE3C,OAAOzC,EAEX,MAAM+H,GAAS,KAAKzC,GAAS,OAAS,IAAM,KAAOxC,EAAQ,IAAM,IACjE,OAAO,OAAO,OAAO,IAAI,OAAO,IAAI+E,CAAE,IAAKE,CAAK,EAAG,CAC/C,KAAMF,EACN,MAAOpF,CACnB,CAAS,CACL,CACA,IAAI,SAAU,CACV,OAAO,KAAK6C,EAChB,CAsEA,eAAe0C,EAAU,CACrB,MAAMC,EAAMD,GAAY,CAAC,CAAC,KAAK1C,GAAS,IAKxC,GAJI,KAAKR,KAAU,OACf,KAAK4C,GAAQ,EACb,KAAK9B,GAAS,GAEd,CAAC7B,GAAa,IAAI,EAAG,CACrB,MAAMmE,EAAU,KAAK,QAAO,GAAM,KAAK,MAAK,EACtCC,EAAM,KAAKlD,GACZ,IAAI/E,GAAK,CACV,KAAM,CAAC2H,EAAIO,EAAGN,EAAUhF,CAAK,EAAI,OAAO5C,GAAM,SACxC0D,EAAGyE,GAAWnI,EAAG,KAAK6E,GAAWmD,CAAO,EACxChI,EAAE,eAAe8H,CAAQ,EAC/B,OAAA,KAAKjD,GAAY,KAAKA,IAAa+C,EACnC,KAAK9C,GAAS,KAAKA,IAAUlC,EACtB+E,CACX,CAAC,EACI,KAAK,EAAE,EACZ,IAAIS,EAAQ,GACZ,GAAI,KAAK,WACD,OAAO,KAAKrD,GAAO,CAAC,GAAM,UAMtB,EADmB,KAAKA,GAAO,SAAW,GAAKV,GAAS,IAAI,KAAKU,GAAO,CAAC,CAAC,GACzD,CACjB,MAAMsD,EAAMjE,GAGNkE,EAELP,GAAOM,EAAI,IAAIJ,EAAI,OAAO,CAAC,CAAC,GAExBA,EAAI,WAAW,KAAK,GAAKI,EAAI,IAAIJ,EAAI,OAAO,CAAC,CAAC,GAE9CA,EAAI,WAAW,QAAQ,GAAKI,EAAI,IAAIJ,EAAI,OAAO,CAAC,CAAC,EAGhDM,EAAY,CAACR,GAAO,CAACD,GAAYO,EAAI,IAAIJ,EAAI,OAAO,CAAC,CAAC,EAC5DG,EAAQE,EAAapE,GAAmBqE,EAAYpE,EAAa,EACrE,CAIR,IAAIqE,EAAM,GACV,OAAI,KAAK,MAAK,GACV,KAAK5D,GAAMO,IACX,KAAKH,IAAS,OAAS,MACvBwD,EAAM,aAGH,CADOJ,EAAQH,EAAMO,EAGxBhF,EAASyE,CAAG,EACX,KAAKpD,GAAY,CAAC,CAAC,KAAKA,GACzB,KAAKC,EACrB,CACQ,CAIA,MAAM2D,EAAW,KAAK,OAAS,KAAO,KAAK,OAAS,IAE9CL,EAAQ,KAAK,OAAS,IAAM,YAAc,MAChD,IAAItI,EAAO,KAAK4I,GAAeX,CAAG,EAClC,GAAI,KAAK,QAAO,GAAM,KAAK,SAAW,CAACjI,GAAQ,KAAK,OAAS,IAAK,CAG9D,MAAMoC,EAAI,KAAK,SAAQ,EACjByG,EAAK,KACX,OAAAA,EAAG5D,GAAS,CAAC7C,CAAC,EACdyG,EAAG,KAAO,KACVA,EAAG9D,GAAY,OACR,CAAC3C,EAAGsB,EAAS,KAAK,UAAU,EAAG,GAAO,EAAK,CACtD,CAEA,IAAIoF,EAAiB,CAACH,GAAYX,GAAYC,GAAO,CAAC5D,EAChD,GACA,KAAKuE,GAAe,EAAI,EAC1BE,IAAmB9I,IACnB8I,EAAiB,IAEjBA,IACA9I,EAAO,MAAMA,CAAI,OAAO8I,CAAc,OAG1C,IAAIC,EAAQ,GACZ,GAAI,KAAK,OAAS,KAAO,KAAKvD,GAC1BuD,GAAS,KAAK,QAAO,GAAM,CAACd,EAAM5D,EAAa,IAAMO,OAEpD,CACD,MAAMoE,EAAQ,KAAK,OAAS,IAEpB,MACK,KAAK,QAAO,GAAM,CAACf,GAAO,CAACD,EAAW3D,EAAa,IACpDM,GACA,IACN,KAAK,OAAS,IACV,IACA,KAAK,OAAS,IACV,KACA,KAAK,OAAS,KAAOmE,EACjB,IACA,KAAK,OAAS,KAAOA,EACjB,KACA,IAAI,KAAK,IAAI,GACnCC,EAAQT,EAAQtI,EAAOgJ,CAC3B,CACA,MAAO,CACHD,EACArF,EAAS1D,CAAI,EACZ,KAAK+E,GAAY,CAAC,CAAC,KAAKA,GACzB,KAAKC,EACjB,CACI,CACA4D,GAAeX,EAAK,CAChB,OAAO,KAAKhD,GACP,IAAI/E,GAAK,CAGV,GAAI,OAAOA,GAAM,SACb,MAAM,IAAI,MAAM,8BAA8B,EAIlD,KAAM,CAAC2H,EAAIO,EAAGa,EAAWnG,CAAK,EAAI5C,EAAE,eAAe+H,CAAG,EACtD,OAAA,KAAKjD,GAAS,KAAKA,IAAUlC,EACtB+E,CACX,CAAC,EACI,OAAO3H,GAAK,EAAE,KAAK,QAAO,GAAM,KAAK,MAAK,IAAO,CAAC,CAACA,CAAC,EACpD,KAAK,GAAG,CACjB,CACA,MAAOmI,GAAW5F,EAAMqF,EAAUI,EAAU,GAAO,CAC/C,IAAInF,EAAW,GACX8E,EAAK,GACL/E,EAAQ,GAERoG,EAAS,GACb,QAASjK,EAAI,EAAGA,EAAIwD,EAAK,OAAQxD,IAAK,CAClC,MAAM0C,EAAIc,EAAK,OAAOxD,CAAC,EACvB,GAAI8D,EAAU,CACVA,EAAW,GACX8E,IAAOrD,GAAW,IAAI7C,CAAC,EAAI,KAAO,IAAMA,EACxCuH,EAAS,GACT,QACJ,CACA,GAAIvH,IAAM,KAAM,CACR1C,IAAMwD,EAAK,OAAS,EACpBoF,GAAM,OAGN9E,EAAW,GAEf,QACJ,CACA,GAAIpB,IAAM,IAAK,CACX,KAAM,CAACwG,EAAKgB,EAAWC,EAAUC,CAAK,EAAI7G,GAAWC,EAAMxD,CAAC,EAC5D,GAAImK,EAAU,CACVvB,GAAMM,EACNrF,EAAQA,GAASqG,EACjBlK,GAAKmK,EAAW,EAChBtB,EAAWA,GAAYuB,EACvBH,EAAS,GACT,QACJ,CACJ,CACA,GAAIvH,IAAM,IAAK,CACX,GAAIuH,EACA,SACJA,EAAS,GACTrB,GAAMK,GAAW,SAAS,KAAKzF,CAAI,EAAImC,GAAcD,GACrDmD,EAAW,GACX,QACJ,MAEIoB,EAAS,GAEb,GAAIvH,IAAM,IAAK,CACXkG,GAAMnD,EACNoD,EAAW,GACX,QACJ,CACAD,GAAMpD,GAAa9C,CAAC,CACxB,CACA,MAAO,CAACkG,EAAInE,EAASjB,CAAI,EAAG,CAAC,CAACqF,EAAUhF,CAAK,CACjD,CACJ,CACAc,EAAKiB,GC5tBE,MAAMyE,GAAS,CAAClH,EAAG,CAAE,qBAAAuB,EAAuB,EAAK,EAAM,CAAA,IAInDA,EACDvB,EAAE,QAAQ,aAAc,MAAM,EAC9BA,EAAE,QAAQ,eAAgB,MAAM,WCVnC,MAAMmH,EAAY,CAACrJ,EAAG+B,EAAS0D,EAAU,CAAA,KAC5C3D,EAAmBC,CAAO,EAEtB,CAAC0D,EAAQ,WAAa1D,EAAQ,OAAO,CAAC,IAAM,IACrC,GAEJ,IAAIuH,EAAUvH,EAAS0D,CAAO,EAAE,MAAMzF,CAAC,GAG5CuJ,GAAe,wBACfC,GAAkBhD,GAASiD,GAAM,CAACA,EAAE,WAAW,GAAG,GAAKA,EAAE,SAASjD,CAAG,EACrEkD,GAAqBlD,GAASiD,GAAMA,EAAE,SAASjD,CAAG,EAClDmD,GAAwBnD,IAC1BA,EAAMA,EAAI,YAAA,EACFiD,GAAM,CAACA,EAAE,WAAW,GAAG,GAAKA,EAAE,YAAA,EAAc,SAASjD,CAAG,GAE9DoD,GAA2BpD,IAC7BA,EAAMA,EAAI,YAAA,EACFiD,GAAMA,EAAE,YAAA,EAAc,SAASjD,CAAG,GAExCqD,GAAgB,aAChBC,GAAmBL,GAAM,CAACA,EAAE,WAAW,GAAG,GAAKA,EAAE,SAAS,GAAG,EAC7DM,GAAsBN,GAAMA,IAAM,KAAOA,IAAM,MAAQA,EAAE,SAAS,GAAG,EACrEO,GAAY,UACZC,GAAeR,GAAMA,IAAM,KAAOA,IAAM,MAAQA,EAAE,WAAW,GAAG,EAChES,GAAS,QACTC,GAAYV,GAAMA,EAAE,SAAW,GAAK,CAACA,EAAE,WAAW,GAAG,EACrDW,GAAeX,GAAMA,EAAE,SAAW,GAAKA,IAAM,KAAOA,IAAM,KAC1DY,GAAW,yBACXC,GAAmB,CAAC,CAACC,EAAI/D,EAAM,EAAE,IAAM,CACzC,MAAMgE,EAAQC,GAAgB,CAACF,CAAE,CAAC,EAClC,OAAK/D,GAELA,EAAMA,EAAI,YAAA,EACFiD,GAAMe,EAAMf,CAAC,GAAKA,EAAE,YAAA,EAAc,SAASjD,CAAG,GAF3CgE,CAGf,EACME,GAAsB,CAAC,CAACH,EAAI/D,EAAM,EAAE,IAAM,CAC5C,MAAMgE,EAAQG,GAAmB,CAACJ,CAAE,CAAC,EACrC,OAAK/D,GAELA,EAAMA,EAAI,YAAA,EACFiD,GAAMe,EAAMf,CAAC,GAAKA,EAAE,YAAA,EAAc,SAASjD,CAAG,GAF3CgE,CAGf,EACMI,GAAgB,CAAC,CAACL,EAAI/D,EAAM,EAAE,IAAM,CACtC,MAAMgE,EAAQG,GAAmB,CAACJ,CAAE,CAAC,EACrC,OAAQ/D,EAAeiD,GAAMe,EAAMf,CAAC,GAAKA,EAAE,SAASjD,CAAG,EAAzCgE,CAClB,EACMK,GAAa,CAAC,CAACN,EAAI/D,EAAM,EAAE,IAAM,CACnC,MAAMgE,EAAQC,GAAgB,CAACF,CAAE,CAAC,EAClC,OAAQ/D,EAAeiD,GAAMe,EAAMf,CAAC,GAAKA,EAAE,SAASjD,CAAG,EAAzCgE,CAClB,EACMC,GAAkB,CAAC,CAACF,CAAE,IAAM,CAC9B,MAAMO,EAAMP,EAAG,OACf,OAAQd,GAAMA,EAAE,SAAWqB,GAAO,CAACrB,EAAE,WAAW,GAAG,CACvD,EACMkB,GAAqB,CAAC,CAACJ,CAAE,IAAM,CACjC,MAAMO,EAAMP,EAAG,OACf,OAAQd,GAAMA,EAAE,SAAWqB,GAAOrB,IAAM,KAAOA,IAAM,IACzD,EAEMsB,GAAmB,OAAOC,GAAY,UAAYA,EACjD,OAAOC,GAAgB,UACtBA,GACAA,EAAY,gCACZD,EAAQ,SACV,QACAE,GAAO,CACT,MAAO,CAAE,IAAK,IAAA,EACd,MAAO,CAAE,IAAK,GAAA,CAClB,EAEaC,GAAMJ,KAAoB,QAAUG,GAAK,MAAM,IAAMA,GAAK,MAAM,IAC7E7B,EAAU,IAAM8B,GACT,MAAMC,SAAkB,aAAa,EAC5C/B,EAAU,SAAW+B,EAGrB,MAAM5G,GAAQ,OAERC,GAAOD,GAAQ,KAIf6G,GAAa,0CAGbC,GAAe,0BACRC,GAAS,CAACxJ,EAAS0D,EAAU,CAAA,IAAQzF,GAAMqJ,EAAUrJ,EAAG+B,EAAS0D,CAAO,EACrF4D,EAAU,OAASkC,GACnB,MAAM/E,EAAM,CAACxI,EAAGC,EAAI,CAAA,IAAO,OAAO,OAAO,CAAA,EAAID,EAAGC,CAAC,EACpCuN,GAAYC,GAAQ,CAC7B,GAAI,CAACA,GAAO,OAAOA,GAAQ,UAAY,CAAC,OAAO,KAAKA,CAAG,EAAE,OACrD,OAAOpC,EAEX,MAAMqC,EAAOrC,EAEb,OAAO,OAAO,OADJ,CAACrJ,EAAG+B,EAAS0D,EAAU,CAAA,IAAOiG,EAAK1L,EAAG+B,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,EAClD,CACpB,UAAW,cAAwBiG,EAAK,SAAU,CAC9C,YAAY3J,EAAS0D,EAAU,GAAI,CAC/B,MAAM1D,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,CACpC,CACA,OAAO,SAASA,EAAS,CACrB,OAAOiG,EAAK,SAASlF,EAAIiF,EAAKhG,CAAO,CAAC,EAAE,SAC5C,CAAA,EAEJ,IAAK,cAAkBiG,EAAK,GAAI,CAE5B,YAAYnG,EAAMC,EAAQC,EAAU,CAAA,EAAI,CACpC,MAAMF,EAAMC,EAAQgB,EAAIiF,EAAKhG,CAAO,CAAC,CACzC,CAEA,OAAO,SAAS1D,EAAS0D,EAAU,GAAI,CACnC,OAAOiG,EAAK,IAAI,SAAS3J,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,CACvD,CAAA,EAEJ,SAAU,CAACvD,EAAGuD,EAAU,KAAOiG,EAAK,SAASxJ,EAAGsE,EAAIiF,EAAKhG,CAAO,CAAC,EACjE,OAAQ,CAACvD,EAAGuD,EAAU,KAAOiG,EAAK,OAAOxJ,EAAGsE,EAAIiF,EAAKhG,CAAO,CAAC,EAC7D,OAAQ,CAAC1D,EAAS0D,EAAU,KAAOiG,EAAK,OAAO3J,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,EACzE,SAAWA,GAAYiG,EAAK,SAASlF,EAAIiF,EAAKhG,CAAO,CAAC,EACtD,OAAQ,CAAC1D,EAAS0D,EAAU,KAAOiG,EAAK,OAAO3J,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,EACzE,YAAa,CAAC1D,EAAS0D,EAAU,KAAOiG,EAAK,YAAY3J,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,EACnF,MAAO,CAACkG,EAAM5J,EAAS0D,EAAU,CAAA,IAAOiG,EAAK,MAAMC,EAAM5J,EAASyE,EAAIiF,EAAKhG,CAAO,CAAC,EACnF,IAAKiG,EAAK,IACV,SAAAN,CAAA,CACH,CACL,EACA/B,EAAU,SAAWmC,GAWd,MAAMI,GAAc,CAAC7J,EAAS0D,EAAU,MAC3C3D,EAAmBC,CAAO,EAGtB0D,EAAQ,SAAW,CAAC,mBAAmB,KAAK1D,CAAO,EAE5C,CAACA,CAAO,EAEZ7B,GAAO6B,CAAO,GAEzBsH,EAAU,YAAcuC,GAYjB,MAAMC,GAAS,CAAC9J,EAAS0D,EAAU,CAAA,IAAO,IAAI6D,EAAUvH,EAAS0D,CAAO,EAAE,OAAA,EACjF4D,EAAU,OAASwC,GACZ,MAAMC,GAAQ,CAACH,EAAM5J,EAAS0D,EAAU,CAAA,IAAO,CAClD,MAAMsG,EAAK,IAAIzC,EAAUvH,EAAS0D,CAAO,EACzC,OAAAkG,EAAOA,EAAK,OAAOlC,GAAKsC,EAAG,MAAMtC,CAAC,CAAC,EAC/BsC,EAAG,QAAQ,QAAU,CAACJ,EAAK,QAC3BA,EAAK,KAAK5J,CAAO,EAEd4J,CACX,EACAtC,EAAU,MAAQyC,GAElB,MAAME,GAAY,0BACZzH,GAAgBrC,GAAMA,EAAE,QAAQ,2BAA4B,MAAM,EACjE,MAAMoH,CAAU,CACnB,QACA,IACA,QACA,qBACA,SACA,OACA,QACA,MACA,wBACA,QACA,QACA,UACA,OACA,UACA,SACA,mBACA,qBACA,OACA,YAAYvH,EAAS0D,EAAU,GAAI,CAC/B3D,EAAmBC,CAAO,EAC1B0D,EAAUA,GAAW,CAAA,EACrB,KAAK,QAAUA,EACf,KAAK,qBAAuBA,EAAQ,sBAAwB,IAC5D,KAAK,QAAU1D,EACf,KAAK,SAAW0D,EAAQ,UAAYsF,GACpC,KAAK,UAAY,KAAK,WAAa,QACnC,KAAK,qBACD,CAAC,CAACtF,EAAQ,sBAAwBA,EAAQ,qBAAuB,GACjE,KAAK,uBACL,KAAK,QAAU,KAAK,QAAQ,QAAQ,MAAO,GAAG,GAElD,KAAK,wBAA0B,CAAC,CAACA,EAAQ,wBACzC,KAAK,OAAS,KACd,KAAK,OAAS,GACd,KAAK,SAAW,CAAC,CAACA,EAAQ,SAC1B,KAAK,QAAU,GACf,KAAK,MAAQ,GACb,KAAK,QAAU,CAAC,CAACA,EAAQ,QACzB,KAAK,OAAS,CAAC,CAAC,KAAK,QAAQ,OAC7B,KAAK,mBACDA,EAAQ,qBAAuB,OACzBA,EAAQ,mBACR,CAAC,EAAE,KAAK,WAAa,KAAK,QACpC,KAAK,QAAU,CAAA,EACf,KAAK,UAAY,CAAA,EACjB,KAAK,IAAM,CAAA,EAEX,KAAK,KAAA,CACT,CACA,UAAW,CACP,GAAI,KAAK,QAAQ,eAAiB,KAAK,IAAI,OAAS,EAChD,MAAO,GAEX,UAAW1D,KAAW,KAAK,IACvB,UAAW6D,KAAQ7D,EACf,GAAI,OAAO6D,GAAS,SAChB,MAAO,GAGnB,MAAO,EACX,CACA,SAASsC,EAAG,CAAE,CACd,MAAO,CACH,MAAMnG,EAAU,KAAK,QACf0D,EAAU,KAAK,QAErB,GAAI,CAACA,EAAQ,WAAa1D,EAAQ,OAAO,CAAC,IAAM,IAAK,CACjD,KAAK,QAAU,GACf,MACJ,CACA,GAAI,CAACA,EAAS,CACV,KAAK,MAAQ,GACb,MACJ,CAEA,KAAK,YAAA,EAEL,KAAK,QAAU,CAAC,GAAG,IAAI,IAAI,KAAK,YAAA,CAAa,CAAC,EAC1C0D,EAAQ,QACR,KAAK,MAAQ,IAAIwG,IAAS,QAAQ,MAAM,GAAGA,CAAI,GAEnD,KAAK,MAAM,KAAK,QAAS,KAAK,OAAO,EAUrC,MAAMC,EAAe,KAAK,QAAQ,OAAS,KAAK,WAAWhK,CAAC,CAAC,EAC7D,KAAK,UAAY,KAAK,WAAWgK,CAAY,EAC7C,KAAK,MAAM,KAAK,QAAS,KAAK,SAAS,EAEvC,IAAIC,EAAM,KAAK,UAAU,IAAI,CAACjK,EAAGgG,EAAGkE,IAAO,CACvC,GAAI,KAAK,WAAa,KAAK,mBAAoB,CAE3C,MAAMC,EAAQnK,EAAE,CAAC,IAAM,IACnBA,EAAE,CAAC,IAAM,KACRA,EAAE,CAAC,IAAM,KAAO,CAAC8J,GAAU,KAAK9J,EAAE,CAAC,CAAC,IACrC,CAAC8J,GAAU,KAAK9J,EAAE,CAAC,CAAC,EAClBoK,EAAU,WAAW,KAAKpK,EAAE,CAAC,CAAC,EACpC,GAAImK,EACA,MAAO,CAAC,GAAGnK,EAAE,MAAM,EAAG,CAAC,EAAG,GAAGA,EAAE,MAAM,CAAC,EAAE,IAAIqK,GAAM,KAAK,MAAMA,CAAE,CAAC,CAAC,KAE5DD,EACL,MAAO,CAACpK,EAAE,CAAC,EAAG,GAAGA,EAAE,MAAM,CAAC,EAAE,IAAIqK,GAAM,KAAK,MAAMA,CAAE,CAAC,CAAC,CAE7D,CACA,OAAOrK,EAAE,IAAIqK,GAAM,KAAK,MAAMA,CAAE,CAAC,CACrC,CAAC,EAKD,GAJA,KAAK,MAAM,KAAK,QAASJ,CAAG,EAE5B,KAAK,IAAMA,EAAI,OAAOjK,GAAKA,EAAE,QAAQ,EAAK,IAAM,EAAE,EAE9C,KAAK,UACL,QAASnD,EAAI,EAAGA,EAAI,KAAK,IAAI,OAAQA,IAAK,CACtC,MAAMiB,EAAI,KAAK,IAAIjB,CAAC,EAChBiB,EAAE,CAAC,IAAM,IACTA,EAAE,CAAC,IAAM,IACT,KAAK,UAAUjB,CAAC,EAAE,CAAC,IAAM,KACzB,OAAOiB,EAAE,CAAC,GAAM,UAChB,YAAY,KAAKA,EAAE,CAAC,CAAC,IACrBA,EAAE,CAAC,EAAI,IAEf,CAEJ,KAAK,MAAM,KAAK,QAAS,KAAK,GAAG,CACrC,CAMA,WAAWwM,EAAW,CAElB,GAAI,KAAK,QAAQ,WACb,QAASzN,EAAI,EAAGA,EAAIyN,EAAU,OAAQzN,IAClC,QAAS6C,EAAI,EAAGA,EAAI4K,EAAUzN,CAAC,EAAE,OAAQ6C,IACjC4K,EAAUzN,CAAC,EAAE6C,CAAC,IAAM,OACpB4K,EAAUzN,CAAC,EAAE6C,CAAC,EAAI,KAKlC,KAAM,CAAE,kBAAA6K,EAAoB,CAAA,EAAM,KAAK,QACvC,OAAIA,GAAqB,GAErBD,EAAY,KAAK,qBAAqBA,CAAS,EAC/CA,EAAY,KAAK,sBAAsBA,CAAS,GAE3CC,GAAqB,EAE1BD,EAAY,KAAK,iBAAiBA,CAAS,EAI3CA,EAAY,KAAK,0BAA0BA,CAAS,EAEjDA,CACX,CAEA,0BAA0BA,EAAW,CACjC,OAAOA,EAAU,IAAI5M,GAAS,CAC1B,IAAI8M,EAAK,GACT,MAAeA,EAAK9M,EAAM,QAAQ,KAAM8M,EAAK,CAAC,KAAvC,IAA2C,CAC9C,IAAI3N,EAAI2N,EACR,KAAO9M,EAAMb,EAAI,CAAC,IAAM,MACpBA,IAEAA,IAAM2N,GACN9M,EAAM,OAAO8M,EAAI3N,EAAI2N,CAAE,CAE/B,CACA,OAAO9M,CACX,CAAC,CACL,CAEA,iBAAiB4M,EAAW,CACxB,OAAOA,EAAU,IAAI5M,IACjBA,EAAQA,EAAM,OAAO,CAACuM,EAAKvG,IAAS,CAChC,MAAM+G,EAAOR,EAAIA,EAAI,OAAS,CAAC,EAC/B,OAAIvG,IAAS,MAAQ+G,IAAS,KACnBR,EAEPvG,IAAS,MACL+G,GAAQA,IAAS,MAAQA,IAAS,KAAOA,IAAS,MAClDR,EAAI,IAAA,EACGA,IAGfA,EAAI,KAAKvG,CAAI,EACNuG,EACX,EAAG,CAAA,CAAE,EACEvM,EAAM,SAAW,EAAI,CAAC,EAAE,EAAIA,EACtC,CACL,CACA,qBAAqBA,EAAO,CACnB,MAAM,QAAQA,CAAK,IACpBA,EAAQ,KAAK,WAAWA,CAAK,GAEjC,IAAIgN,EAAe,GACnB,EAAG,CAGC,GAFAA,EAAe,GAEX,CAAC,KAAK,wBAAyB,CAC/B,QAAS7N,EAAI,EAAGA,EAAIa,EAAM,OAAS,EAAGb,IAAK,CACvC,MAAMiB,EAAIJ,EAAMb,CAAC,EAEbA,IAAM,GAAKiB,IAAM,IAAMJ,EAAM,CAAC,IAAM,KAEpCI,IAAM,KAAOA,IAAM,MACnB4M,EAAe,GACfhN,EAAM,OAAOb,EAAG,CAAC,EACjBA,IAER,CACIa,EAAM,CAAC,IAAM,KACbA,EAAM,SAAW,IAChBA,EAAM,CAAC,IAAM,KAAOA,EAAM,CAAC,IAAM,MAClCgN,EAAe,GACfhN,EAAM,IAAA,EAEd,CAEA,IAAIiN,EAAK,EACT,MAAeA,EAAKjN,EAAM,QAAQ,KAAMiN,EAAK,CAAC,KAAvC,IAA2C,CAC9C,MAAM7M,EAAIJ,EAAMiN,EAAK,CAAC,EAClB7M,GAAKA,IAAM,KAAOA,IAAM,MAAQA,IAAM,OACtC4M,EAAe,GACfhN,EAAM,OAAOiN,EAAK,EAAG,CAAC,EACtBA,GAAM,EAEd,CACJ,OAASD,GACT,OAAOhN,EAAM,SAAW,EAAI,CAAC,EAAE,EAAIA,CACvC,CAmBA,qBAAqB4M,EAAW,CAC5B,IAAII,EAAe,GACnB,EAAG,CACCA,EAAe,GAEf,QAAShN,KAAS4M,EAAW,CACzB,IAAIE,EAAK,GACT,MAAeA,EAAK9M,EAAM,QAAQ,KAAM8M,EAAK,CAAC,KAAvC,IAA2C,CAC9C,IAAII,EAAMJ,EACV,KAAO9M,EAAMkN,EAAM,CAAC,IAAM,MAEtBA,IAIAA,EAAMJ,GACN9M,EAAM,OAAO8M,EAAK,EAAGI,EAAMJ,CAAE,EAEjC,IAAIK,EAAOnN,EAAM8M,EAAK,CAAC,EACvB,MAAM1M,EAAIJ,EAAM8M,EAAK,CAAC,EAChBM,EAAKpN,EAAM8M,EAAK,CAAC,EAGvB,GAFIK,IAAS,MAET,CAAC/M,GACDA,IAAM,KACNA,IAAM,MACN,CAACgN,GACDA,IAAO,KACPA,IAAO,KACP,SAEJJ,EAAe,GAEfhN,EAAM,OAAO8M,EAAI,CAAC,EAClB,MAAMO,EAAQrN,EAAM,MAAM,CAAC,EAC3BqN,EAAMP,CAAE,EAAI,KACZF,EAAU,KAAKS,CAAK,EACpBP,GACJ,CAEA,GAAI,CAAC,KAAK,wBAAyB,CAC/B,QAAS,EAAI,EAAG,EAAI9M,EAAM,OAAS,EAAG,IAAK,CACvC,MAAMI,EAAIJ,EAAM,CAAC,EAEb,IAAM,GAAKI,IAAM,IAAMJ,EAAM,CAAC,IAAM,KAEpCI,IAAM,KAAOA,IAAM,MACnB4M,EAAe,GACfhN,EAAM,OAAO,EAAG,CAAC,EACjB,IAER,CACIA,EAAM,CAAC,IAAM,KACbA,EAAM,SAAW,IAChBA,EAAM,CAAC,IAAM,KAAOA,EAAM,CAAC,IAAM,MAClCgN,EAAe,GACfhN,EAAM,IAAA,EAEd,CAEA,IAAIiN,EAAK,EACT,MAAeA,EAAKjN,EAAM,QAAQ,KAAMiN,EAAK,CAAC,KAAvC,IAA2C,CAC9C,MAAM7M,EAAIJ,EAAMiN,EAAK,CAAC,EACtB,GAAI7M,GAAKA,IAAM,KAAOA,IAAM,MAAQA,IAAM,KAAM,CAC5C4M,EAAe,GAEf,MAAMM,EADUL,IAAO,GAAKjN,EAAMiN,EAAK,CAAC,IAAM,KACtB,CAAC,GAAG,EAAI,CAAA,EAChCjN,EAAM,OAAOiN,EAAK,EAAG,EAAG,GAAGK,CAAK,EAC5BtN,EAAM,SAAW,GACjBA,EAAM,KAAK,EAAE,EACjBiN,GAAM,CACV,CACJ,CACJ,CACJ,OAASD,GACT,OAAOJ,CACX,CAQA,sBAAsBA,EAAW,CAC7B,QAASzN,EAAI,EAAGA,EAAIyN,EAAU,OAAS,EAAGzN,IACtC,QAAS6C,EAAI7C,EAAI,EAAG6C,EAAI4K,EAAU,OAAQ5K,IAAK,CAC3C,MAAMuL,EAAU,KAAK,WAAWX,EAAUzN,CAAC,EAAGyN,EAAU5K,CAAC,EAAG,CAAC,KAAK,uBAAuB,EACzF,GAAIuL,EAAS,CACTX,EAAUzN,CAAC,EAAI,CAAA,EACfyN,EAAU5K,CAAC,EAAIuL,EACf,KACJ,CACJ,CAEJ,OAAOX,EAAU,OAAOE,GAAMA,EAAG,MAAM,CAC3C,CACA,WAAW1O,EAAGC,EAAGmP,EAAe,GAAO,CACnC,IAAIvO,EAAK,EACLC,EAAK,EACLF,EAAS,CAAA,EACTyO,EAAQ,GACZ,KAAOxO,EAAKb,EAAE,QAAUc,EAAKb,EAAE,QAC3B,GAAID,EAAEa,CAAE,IAAMZ,EAAEa,CAAE,EACdF,EAAO,KAAKyO,IAAU,IAAMpP,EAAEa,CAAE,EAAId,EAAEa,CAAE,CAAC,EACzCA,IACAC,YAEKsO,GAAgBpP,EAAEa,CAAE,IAAM,MAAQZ,EAAEa,CAAE,IAAMd,EAAEa,EAAK,CAAC,EACzDD,EAAO,KAAKZ,EAAEa,CAAE,CAAC,EACjBA,YAEKuO,GAAgBnP,EAAEa,CAAE,IAAM,MAAQd,EAAEa,CAAE,IAAMZ,EAAEa,EAAK,CAAC,EACzDF,EAAO,KAAKX,EAAEa,CAAE,CAAC,EACjBA,YAEKd,EAAEa,CAAE,IAAM,KACfZ,EAAEa,CAAE,IACH,KAAK,QAAQ,KAAO,CAACb,EAAEa,CAAE,EAAE,WAAW,GAAG,IAC1Cb,EAAEa,CAAE,IAAM,KAAM,CAChB,GAAIuO,IAAU,IACV,MAAO,GACXA,EAAQ,IACRzO,EAAO,KAAKZ,EAAEa,CAAE,CAAC,EACjBA,IACAC,GACJ,SACSb,EAAEa,CAAE,IAAM,KACfd,EAAEa,CAAE,IACH,KAAK,QAAQ,KAAO,CAACb,EAAEa,CAAE,EAAE,WAAW,GAAG,IAC1Cb,EAAEa,CAAE,IAAM,KAAM,CAChB,GAAIwO,IAAU,IACV,MAAO,GACXA,EAAQ,IACRzO,EAAO,KAAKX,EAAEa,CAAE,CAAC,EACjBD,IACAC,GACJ,KAEI,OAAO,GAKf,OAAOd,EAAE,SAAWC,EAAE,QAAUW,CACpC,CACA,aAAc,CACV,GAAI,KAAK,SACL,OACJ,MAAMmD,EAAU,KAAK,QACrB,IAAIe,EAAS,GACTwK,EAAe,EACnB,QAASvO,EAAI,EAAGA,EAAIgD,EAAQ,QAAUA,EAAQ,OAAOhD,CAAC,IAAM,IAAKA,IAC7D+D,EAAS,CAACA,EACVwK,IAEAA,IACA,KAAK,QAAUvL,EAAQ,MAAMuL,CAAY,GAC7C,KAAK,OAASxK,CAClB,CAMA,SAASyK,EAAMxL,EAASyL,EAAU,GAAO,CACrC,IAAIC,EAAiB,EACjBC,EAAoB,EAIxB,GAAI,KAAK,UAAW,CAChB,MAAMC,EAAY,OAAOJ,EAAK,CAAC,GAAM,UAAY,YAAY,KAAKA,EAAK,CAAC,CAAC,EACnEK,EAAU,CAACD,GACbJ,EAAK,CAAC,IAAM,IACZA,EAAK,CAAC,IAAM,IACZA,EAAK,CAAC,IAAM,KACZ,YAAY,KAAKA,EAAK,CAAC,CAAC,EACtBM,EAAe,OAAO9L,EAAQ,CAAC,GAAM,UAAY,YAAY,KAAKA,EAAQ,CAAC,CAAC,EAC5E+L,EAAa,CAACD,GAChB9L,EAAQ,CAAC,IAAM,IACfA,EAAQ,CAAC,IAAM,IACfA,EAAQ,CAAC,IAAM,KACf,OAAOA,EAAQ,CAAC,GAAM,UACtB,YAAY,KAAKA,EAAQ,CAAC,CAAC,EACzBgM,EAAMH,EAAU,EAAID,EAAY,EAAI,OACpCK,EAAMF,EAAa,EAAID,EAAe,EAAI,OAChD,GAAI,OAAOE,GAAQ,UAAY,OAAOC,GAAQ,SAAU,CACpD,KAAM,CAACC,EAAIC,CAAE,EAAI,CACbX,EAAKQ,CAAG,EACRhM,EAAQiM,CAAG,CAAA,EAEXC,EAAG,YAAA,IAAkBC,EAAG,gBACxBnM,EAAQiM,CAAG,EAAIC,EACfP,EAAoBM,EACpBP,EAAiBM,EAEzB,CACJ,CAGA,KAAM,CAAE,kBAAAtB,EAAoB,CAAA,EAAM,KAAK,QAIvC,OAHIA,GAAqB,IACrBc,EAAO,KAAK,qBAAqBA,CAAI,GAErCxL,EAAQ,SAASqJ,CAAQ,EAClB,KAAK+C,GAAeZ,EAAMxL,EAASyL,EAASC,EAAgBC,CAAiB,EAEjF,KAAKU,GAAUb,EAAMxL,EAASyL,EAASC,EAAgBC,CAAiB,CACnF,CACAS,GAAeZ,EAAMxL,EAASyL,EAASa,EAAWC,EAAc,CAC5D,MAAMC,EAAUxM,EAAQ,QAAQqJ,EAAUkD,CAAY,EAChDE,EAASzM,EAAQ,YAAYqJ,CAAQ,EACrC,CAACqD,EAAM3O,EAAM4O,CAAI,EAAIlB,EAAU,CACjCzL,EAAQ,MAAMuM,EAAcC,CAAO,EACnCxM,EAAQ,MAAMwM,EAAU,CAAC,EACzB,CAAA,CAAC,EACD,CACAxM,EAAQ,MAAMuM,EAAcC,CAAO,EACnCxM,EAAQ,MAAMwM,EAAU,EAAGC,CAAM,EACjCzM,EAAQ,MAAMyM,EAAS,CAAC,CAAA,EAE5B,GAAIC,EAAK,OAAQ,CACb,MAAME,EAAWpB,EAAK,MAAMc,EAAWA,EAAYI,EAAK,MAAM,EAC9D,GAAI,CAAC,KAAKL,GAAUO,EAAUF,EAAMjB,EAAS,EAAG,CAAC,EAC7C,MAAO,GACXa,GAAaI,EAAK,MACtB,CACA,IAAIG,EAAgB,EACpB,GAAIF,EAAK,OAAQ,CACb,GAAIA,EAAK,OAASL,EAAYd,EAAK,OAC/B,MAAO,GACX,IAAIsB,EAAYtB,EAAK,OAASmB,EAAK,OACnC,GAAI,KAAKN,GAAUb,EAAMmB,EAAMlB,EAASqB,EAAW,CAAC,EAChDD,EAAgBF,EAAK,WAEpB,CAMD,GALInB,EAAKA,EAAK,OAAS,CAAC,IAAM,IAC1Bc,EAAYK,EAAK,SAAWnB,EAAK,SAGrCsB,IACI,CAAC,KAAKT,GAAUb,EAAMmB,EAAMlB,EAASqB,EAAW,CAAC,GACjD,MAAO,GACXD,EAAgBF,EAAK,OAAS,CAClC,CACJ,CACA,GAAI,CAAC5O,EAAK,OAAQ,CACd,IAAIgP,EAAU,CAAC,CAACF,EAChB,QAAS7P,EAAIsP,EAAWtP,EAAIwO,EAAK,OAASqB,EAAe7P,IAAK,CAC1D,MAAM0K,EAAI,OAAO8D,EAAKxO,CAAC,CAAC,EAExB,GADA+P,EAAU,GACNrF,IAAM,KAAOA,IAAM,MAClB,CAAC,KAAK,QAAQ,KAAOA,EAAE,WAAW,GAAG,EACtC,MAAO,EAEf,CACA,OAAO+D,GAAWsB,CACtB,CACA,MAAMC,EAAe,CAAC,CAAC,CAAA,EAAI,CAAC,CAAC,EAC7B,IAAIC,EAAcD,EAAa,CAAC,EAC5BE,EAAa,EACjB,MAAMC,EAAiB,CAAC,CAAC,EACzB,UAAWjR,KAAK6B,EACR7B,IAAMmN,GACN8D,EAAe,KAAKD,CAAU,EAC9BD,EAAc,CAAC,CAAA,EAAI,CAAC,EACpBD,EAAa,KAAKC,CAAW,IAG7BA,EAAY,CAAC,EAAE,KAAK/Q,CAAC,EACrBgR,KAGR,IAAIlQ,EAAIgQ,EAAa,OAAS,EAC9B,MAAMI,EAAa5B,EAAK,OAASqB,EACjC,UAAW3Q,KAAK8Q,EACZ9Q,EAAE,CAAC,EAAIkR,GAAcD,EAAenQ,GAAG,EAAId,EAAE,CAAC,EAAE,QAEpD,MAAO,CAAC,CAAC,KAAKmR,GAA2B7B,EAAMwB,EAAcV,EAAW,EAAGb,EAAS,EAAG,CAAC,CAACoB,CAAa,CAC1G,CACAQ,GAA2B7B,EAAMwB,EAAcV,EAAWgB,EAAW7B,EAAS8B,EAAeC,EAAS,CAClG,MAAMC,EAAKT,EAAaM,CAAS,EACjC,GAAI,CAACG,EAAI,CACL,QAASzQ,EAAIsP,EAAWtP,EAAIwO,EAAK,OAAQxO,IAAK,CAC1CwQ,EAAU,GACV,MAAM9F,EAAI8D,EAAKxO,CAAC,EAChB,GAAI0K,IAAM,KAAOA,IAAM,MAClB,CAAC,KAAK,QAAQ,KAAOA,EAAE,WAAW,GAAG,EACtC,MAAO,EAEf,CACA,OAAO8F,CACX,CACA,KAAM,CAACzP,EAAM2P,CAAK,EAAID,EACtB,KAAOnB,GAAaoB,GAAO,CAEvB,GADU,KAAKrB,GAAUb,EAAK,MAAM,EAAGc,EAAYvO,EAAK,MAAM,EAAGA,EAAM0N,EAASa,EAAW,CAAC,GACnFiB,EAAgB,KAAK,qBAAsB,CAChD,MAAMI,EAAM,KAAKN,GAA2B7B,EAAMwB,EAAcV,EAAYvO,EAAK,OAAQuP,EAAY,EAAG7B,EAAS8B,EAAgB,EAAGC,CAAO,EAC3I,GAAIG,IAAQ,GACR,OAAOA,CACf,CACA,MAAMjG,EAAI8D,EAAKc,CAAS,EACxB,GAAI5E,IAAM,KAAOA,IAAM,MAClB,CAAC,KAAK,QAAQ,KAAOA,EAAE,WAAW,GAAG,EACtC,MAAO,GAEX4E,GACJ,CACA,OAAOb,GAAW,IACtB,CACAY,GAAUb,EAAMxL,EAASyL,EAASa,EAAWC,EAAc,CACvD,IAAIqB,EACAC,EACA9J,EACA+J,EACJ,IAAKF,EAAKtB,EAAWuB,EAAKtB,EACtBuB,EAAKtC,EAAK,OAAQzH,EAAK/D,EAAQ,OAAQ4N,EAAKE,GAAMD,EAAK9J,EAAI6J,IAAMC,IAAM,CACvE,KAAK,MAAM,eAAe,EAC1B,IAAI5P,EAAI+B,EAAQ6N,CAAE,EACdnG,EAAI8D,EAAKoC,CAAE,EAGf,GAFA,KAAK,MAAM5N,EAAS/B,EAAGyJ,CAAC,EAEpBzJ,IAAM,IAASA,IAAMoL,EACrB,MAAO,GAEX,IAAI0E,EASJ,GARI,OAAO9P,GAAM,UACb8P,EAAMrG,IAAMzJ,EACZ,KAAK,MAAM,eAAgBA,EAAGyJ,EAAGqG,CAAG,IAGpCA,EAAM9P,EAAE,KAAKyJ,CAAC,EACd,KAAK,MAAM,gBAAiBzJ,EAAGyJ,EAAGqG,CAAG,GAErC,CAACA,EACD,MAAO,EACf,CACA,GAAIH,IAAOE,GAAMD,IAAO9J,EACpB,MAAO,GACX,GACS6J,IAAOE,EACZ,OAAOrC,EACX,GACSoC,IAAO9J,EACZ,OAAO6J,IAAOE,EAAK,GAAKtC,EAAKoC,CAAE,IAAM,GAIrC,MAAM,IAAI,MAAM,MAAM,CAG9B,CACA,aAAc,CACV,OAAO/D,GAAY,KAAK,QAAS,KAAK,OAAO,CACjD,CACA,MAAM7J,EAAS,CACXD,EAAmBC,CAAO,EAC1B,MAAM0D,EAAU,KAAK,QAErB,GAAI1D,IAAY,KACZ,OAAOqJ,EACX,GAAIrJ,IAAY,GACZ,MAAO,GAGX,IAAIxD,EACAwR,EAAW,MACVxR,EAAIwD,EAAQ,MAAMmI,EAAM,GACzB6F,EAAWtK,EAAQ,IAAM2E,GAAcD,IAEjC5L,EAAIwD,EAAQ,MAAMwH,EAAY,GACpCwG,GAAYtK,EAAQ,OACdA,EAAQ,IACJmE,GACAD,GACJlE,EAAQ,IACJiE,GACAF,IAAgBjL,EAAE,CAAC,CAAC,GAExBA,EAAIwD,EAAQ,MAAMsI,EAAQ,GAChC0F,GAAYtK,EAAQ,OACdA,EAAQ,IACJiF,GACAJ,GACJ7E,EAAQ,IACJmF,GACAC,IAAYtM,CAAC,GAEjBA,EAAIwD,EAAQ,MAAM8H,EAAa,GACrCkG,EAAWtK,EAAQ,IAAMsE,GAAqBD,IAExCvL,EAAIwD,EAAQ,MAAMiI,EAAS,KACjC+F,EAAW9F,IAEf,MAAMtC,EAAKhD,GAAI,SAAS5C,EAAS,KAAK,OAAO,EAAE,YAAA,EAC/C,OAAIgO,GAAY,OAAOpI,GAAO,UAE1B,QAAQ,eAAeA,EAAI,OAAQ,CAAE,MAAOoI,EAAU,EAEnDpI,CACX,CACA,QAAS,CACL,GAAI,KAAK,QAAU,KAAK,SAAW,GAC/B,OAAO,KAAK,OAOhB,MAAMwE,EAAM,KAAK,IACjB,GAAI,CAACA,EAAI,OACL,OAAA,KAAK,OAAS,GACP,KAAK,OAEhB,MAAM1G,EAAU,KAAK,QACfuK,EAAUvK,EAAQ,WAClBhB,GACAgB,EAAQ,IACJ4F,GACAC,GACJzD,EAAQ,IAAI,IAAIpC,EAAQ,OAAS,CAAC,GAAG,EAAI,EAAE,EAOjD,IAAIkC,EAAKwE,EACJ,IAAIpK,GAAW,CAChB,MAAM4D,EAAK5D,EAAQ,IAAI/B,GAAK,CACxB,GAAIA,aAAa,OACb,UAAWyJ,KAAKzJ,EAAE,MAAM,MAAM,EAAE,EAC5B6H,EAAM,IAAI4B,CAAC,EAEnB,OAAO,OAAOzJ,GAAM,SACduE,GAAavE,CAAC,EACdA,IAAMoL,EACFA,EACApL,EAAE,IAChB,CAAC,EACD,OAAA2F,EAAG,QAAQ,CAAC3F,EAAGjB,IAAM,CACjB,MAAMgO,EAAOpH,EAAG5G,EAAI,CAAC,EACf4N,EAAOhH,EAAG5G,EAAI,CAAC,EACjBiB,IAAMoL,GAAYuB,IAASvB,IAG3BuB,IAAS,OACLI,IAAS,QAAaA,IAAS3B,EAC/BzF,EAAG5G,EAAI,CAAC,EAAI,UAAYiR,EAAU,QAAUjD,EAG5CpH,EAAG5G,CAAC,EAAIiR,EAGPjD,IAAS,OACdpH,EAAG5G,EAAI,CAAC,EAAI4N,EAAO,UAAYqD,EAAU,KAEpCjD,IAAS3B,IACdzF,EAAG5G,EAAI,CAAC,EAAI4N,EAAO,aAAeqD,EAAU,OAASjD,EACrDpH,EAAG5G,EAAI,CAAC,EAAIqM,GAEpB,CAAC,EACMzF,EAAG,OAAO3F,GAAKA,IAAMoL,CAAQ,EAAE,KAAK,GAAG,CAClD,CAAC,EACI,KAAK,GAAG,EAGb,KAAM,CAAC6E,EAAMnH,CAAK,EAAIqD,EAAI,OAAS,EAAI,CAAC,MAAO,GAAG,EAAI,CAAC,GAAI,EAAE,EAG7DxE,EAAK,IAAMsI,EAAOtI,EAAKmB,EAAQ,IAE3B,KAAK,SACLnB,EAAK,OAASA,EAAK,QACvB,GAAI,CACA,KAAK,OAAS,IAAI,OAAOA,EAAI,CAAC,GAAGE,CAAK,EAAE,KAAK,EAAE,CAAC,CAEpD,MACW,CAEP,KAAK,OAAS,EAClB,CAEA,OAAO,KAAK,MAChB,CACA,WAAW7H,EAAG,CAKV,OAAI,KAAK,wBACEA,EAAE,MAAM,GAAG,EAEb,KAAK,WAAa,cAAc,KAAKA,CAAC,EAEpC,CAAC,GAAI,GAAGA,EAAE,MAAM,KAAK,CAAC,EAGtBA,EAAE,MAAM,KAAK,CAE5B,CACA,MAAMyJ,EAAG+D,EAAU,KAAK,QAAS,CAI7B,GAHA,KAAK,MAAM,QAAS/D,EAAG,KAAK,OAAO,EAG/B,KAAK,QACL,MAAO,GAEX,GAAI,KAAK,MACL,OAAOA,IAAM,GAEjB,GAAIA,IAAM,KAAO+D,EACb,MAAO,GAEX,MAAM/H,EAAU,KAAK,QAEjB,KAAK,YACLgE,EAAIA,EAAE,MAAM,IAAI,EAAE,KAAK,GAAG,GAG9B,MAAMyG,EAAK,KAAK,WAAWzG,CAAC,EAC5B,KAAK,MAAM,KAAK,QAAS,QAASyG,CAAE,EAKpC,MAAM/D,EAAM,KAAK,IACjB,KAAK,MAAM,KAAK,QAAS,MAAOA,CAAG,EAEnC,IAAIgE,EAAWD,EAAGA,EAAG,OAAS,CAAC,EAC/B,GAAI,CAACC,EACD,QAASpR,EAAImR,EAAG,OAAS,EAAG,CAACC,GAAYpR,GAAK,EAAGA,IAC7CoR,EAAWD,EAAGnR,CAAC,EAGvB,QAASA,EAAI,EAAGA,EAAIoN,EAAI,OAAQpN,IAAK,CACjC,MAAMgD,EAAUoK,EAAIpN,CAAC,EACrB,IAAIwO,EAAO2C,EAKX,GAJIzK,EAAQ,WAAa1D,EAAQ,SAAW,IACxCwL,EAAO,CAAC4C,CAAQ,GAER,KAAK,SAAS5C,EAAMxL,EAASyL,CAAO,EAE5C,OAAI/H,EAAQ,WACD,GAEJ,CAAC,KAAK,MAErB,CAGA,OAAIA,EAAQ,WACD,GAEJ,KAAK,MAChB,CACA,OAAO,SAASgG,EAAK,CACjB,OAAOpC,EAAU,SAASoC,CAAG,EAAE,SACnC,CACJ,CAMApC,EAAU,IAAM1E,GAChB0E,EAAU,UAAYC,EACtBD,EAAU,OAASD,GACnBC,EAAU,SAAW7F,EC7+Bd,SAAS4M,GAAuBC,EAAS,CAC5C,MAAMC,EAAS,CAAA,EACf,UAAWC,KAAOF,EAAQ,OACtBC,EAAOC,CAAG,EAAIF,EAAQ,IAAIE,CAAG,EAEjC,OAAOD,CACX,CC0BO,SAASE,GAAuBC,EAAUC,EAAMC,EAAa,GAAO,CACvE,OAAOA,EACD,CACE,KAAAD,EACA,QAASD,EAAS,QAAUL,GAAuBK,EAAS,OAAO,EAAI,CAAA,EACvE,OAAQA,EAAS,OACjB,WAAYA,EAAS,UACjC,EACUC,CACV,4CCnBA,IAAIE,EAAO5R,GAAA,EACP6R,EAAW,SAAU1P,EAAG,CAC1B,OAAO,OAAOA,GAAM,QACtB,EAOA,SAAS2P,EAAelR,EAAOmR,EAAgB,CAE7C,QADIC,EAAM,CAAA,EACDjS,EAAI,EAAGA,EAAIa,EAAM,OAAQb,IAAK,CACrC,IAAIiB,EAAIJ,EAAMb,CAAC,EAGX,CAACiB,GAAKA,IAAM,MAGZA,IAAM,KACJgR,EAAI,QAAUA,EAAIA,EAAI,OAAS,CAAC,IAAM,KACxCA,EAAI,IAAG,EACED,GACTC,EAAI,KAAK,IAAI,EAGfA,EAAI,KAAKhR,CAAC,EAEhB,CAEE,OAAOgR,CACT,CAIA,IAAIC,EACA,gEACAC,EAAQ,CAAA,EAGZ,SAASC,EAAehB,EAAU,CAChC,OAAOc,EAAY,KAAKd,CAAQ,EAAE,MAAM,CAAC,CAC3C,CAKA,OAAAe,EAAM,QAAU,UAAW,CAIzB,QAHIE,EAAe,GACfC,EAAmB,GAEdtS,EAAI,UAAU,OAAS,EAAGA,GAAK,IAAM,CAACsS,EAAkBtS,IAAK,CACpE,IAAImM,EAAQnM,GAAK,EAAK,UAAUA,CAAC,EAAIiM,EAAQ,IAAG,EAGhD,GAAK6F,EAAS3F,CAAI,GAEX,GAAI,CAACA,EACV,aAFA,OAAM,IAAI,UAAU,2CAA2C,EAKjEkG,EAAelG,EAAO,IAAMkG,EAC5BC,EAAmBnG,EAAK,OAAO,CAAC,IAAM,GAC1C,CAME,OAAAkG,EAAeN,EAAeM,EAAa,MAAM,GAAG,EACtB,CAACC,CAAgB,EAAE,KAAK,GAAG,GAEhDA,EAAmB,IAAM,IAAMD,GAAiB,GAC3D,EAIAF,EAAM,UAAY,SAAShG,EAAM,CAC/B,IAAIoG,EAAaJ,EAAM,WAAWhG,CAAI,EAClCqG,EAAgBrG,EAAK,OAAO,EAAE,IAAM,IAGxC,OAAAA,EAAO4F,EAAe5F,EAAK,MAAM,GAAG,EAAG,CAACoG,CAAU,EAAE,KAAK,GAAG,EAExD,CAACpG,GAAQ,CAACoG,IACZpG,EAAO,KAELA,GAAQqG,IACVrG,GAAQ,MAGFoG,EAAa,IAAM,IAAMpG,CACnC,EAGAgG,EAAM,WAAa,SAAShG,EAAM,CAChC,OAAOA,EAAK,OAAO,CAAC,IAAM,GAC5B,EAGAgG,EAAM,KAAO,UAAW,CAEtB,QADIhG,EAAO,GACFnM,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAAK,CACzC,IAAIyS,EAAU,UAAUzS,CAAC,EACzB,GAAI,CAAC8R,EAASW,CAAO,EACnB,MAAM,IAAI,UAAU,wCAAwC,EAE1DA,IACGtG,EAGHA,GAAQ,IAAMsG,EAFdtG,GAAQsG,EAKhB,CACE,OAAON,EAAM,UAAUhG,CAAI,CAC7B,EAKAgG,EAAM,SAAW,SAASO,EAAMC,EAAI,CAClCD,EAAOP,EAAM,QAAQO,CAAI,EAAE,OAAO,CAAC,EACnCC,EAAKR,EAAM,QAAQQ,CAAE,EAAE,OAAO,CAAC,EAE/B,SAASC,EAAKC,EAAK,CAEjB,QADIxJ,EAAQ,EACLA,EAAQwJ,EAAI,QACbA,EAAIxJ,CAAK,IAAM,GADMA,IACzB,CAIF,QADII,EAAMoJ,EAAI,OAAS,EAChBpJ,GAAO,GACRoJ,EAAIpJ,CAAG,IAAM,GADFA,IACf,CAGF,OAAIJ,EAAQI,EAAY,CAAA,EACjBoJ,EAAI,MAAMxJ,EAAOI,EAAM,CAAC,CACnC,CAOE,QALIqJ,EAAYF,EAAKF,EAAK,MAAM,GAAG,CAAC,EAChCK,EAAUH,EAAKD,EAAG,MAAM,GAAG,CAAC,EAE5BK,EAAS,KAAK,IAAIF,EAAU,OAAQC,EAAQ,MAAM,EAClDE,EAAkBD,EACbhT,EAAI,EAAGA,EAAIgT,EAAQhT,IAC1B,GAAI8S,EAAU9S,CAAC,IAAM+S,EAAQ/S,CAAC,EAAG,CAC/BiT,EAAkBjT,EAClB,KACN,CAIE,QADIkT,EAAc,CAAA,EACTlT,EAAIiT,EAAiBjT,EAAI8S,EAAU,OAAQ9S,IAClDkT,EAAY,KAAK,IAAI,EAGvB,OAAAA,EAAcA,EAAY,OAAOH,EAAQ,MAAME,CAAe,CAAC,EAExDC,EAAY,KAAK,GAAG,CAC7B,EAGAf,EAAM,UAAY,SAAShG,EAAM,CAC/B,OAAOA,CACT,EAGAgG,EAAM,QAAU,SAAShG,EAAM,CAC7B,IAAItM,EAASuS,EAAejG,CAAI,EAC5BgH,EAAOtT,EAAO,CAAC,EACfuT,EAAMvT,EAAO,CAAC,EAElB,MAAI,CAACsT,GAAQ,CAACC,EAEL,KAGLA,IAEFA,EAAMA,EAAI,OAAO,EAAGA,EAAI,OAAS,CAAC,GAG7BD,EAAOC,EAChB,EAGAjB,EAAM,SAAW,SAAShG,EAAM1E,EAAK,CACnC,IAAIiD,EAAI0H,EAAejG,CAAI,EAAE,CAAC,EAE9B,OAAI1E,GAAOiD,EAAE,OAAO,GAAKjD,EAAI,MAAM,IAAMA,IACvCiD,EAAIA,EAAE,OAAO,EAAGA,EAAE,OAASjD,EAAI,MAAM,GAEhCiD,CACT,EAGAyH,EAAM,QAAU,SAAShG,EAAM,CAC7B,OAAOiG,EAAejG,CAAI,EAAE,CAAC,CAC/B,EAGAgG,EAAM,OAAS,SAASkB,EAAY,CAClC,GAAI,CAACxB,EAAK,SAASwB,CAAU,EAC3B,MAAM,IAAI,UACN,iDAAmD,OAAOA,GAIhE,IAAIF,EAAOE,EAAW,MAAQ,GAE9B,GAAI,CAACvB,EAASqB,CAAI,EAChB,MAAM,IAAI,UACN,wDACA,OAAOE,EAAW,MAIxB,IAAID,EAAMC,EAAW,IAAMA,EAAW,IAAMlB,EAAM,IAAM,GACpDmB,EAAOD,EAAW,MAAQ,GAC9B,OAAOD,EAAME,CACf,EAGAnB,EAAM,MAAQ,SAASoB,EAAY,CACjC,GAAI,CAACzB,EAASyB,CAAU,EACtB,MAAM,IAAI,UACN,gDAAkD,OAAOA,GAG/D,IAAIC,EAAWpB,EAAemB,CAAU,EACxC,GAAI,CAACC,GAAYA,EAAS,SAAW,EACnC,MAAM,IAAI,UAAU,iBAAmBD,EAAa,GAAG,EAEzD,OAAAC,EAAS,CAAC,EAAIA,EAAS,CAAC,GAAK,GAC7BA,EAAS,CAAC,EAAIA,EAAS,CAAC,GAAK,GAC7BA,EAAS,CAAC,EAAIA,EAAS,CAAC,GAAK,GAEtB,CACL,KAAMA,EAAS,CAAC,EAChB,IAAKA,EAAS,CAAC,EAAIA,EAAS,CAAC,EAAE,MAAM,EAAGA,EAAS,CAAC,EAAE,OAAS,CAAC,EAC9D,KAAMA,EAAS,CAAC,EAChB,IAAKA,EAAS,CAAC,EACf,KAAMA,EAAS,CAAC,EAAE,MAAM,EAAGA,EAAS,CAAC,EAAE,OAASA,EAAS,CAAC,EAAE,MAAM,EAEtE,EAGArB,EAAM,IAAM,IACZA,EAAM,UAAY,IAEhBsB,EAAiBtB,2ECxQnB,SAASuB,EAAQC,EAAK,CAAE,0BAA2B,OAAI,OAAO,QAAW,YAAc,OAAO,OAAO,UAAa,SAAYD,EAAU,SAAiBC,EAAK,CAAE,OAAO,OAAOA,GAAiBD,EAAU,SAAiBC,EAAK,CAAE,OAAOA,GAAO,OAAO,QAAW,YAAcA,EAAI,cAAgB,QAAUA,IAAQ,OAAO,UAAY,SAAW,OAAOA,CAAI,EAAaD,EAAQC,CAAG,CAAE,CAExX,SAASC,EAAgBC,EAAUC,EAAa,CAAE,GAAI,EAAED,aAAoBC,GAAgB,MAAM,IAAI,UAAU,mCAAmC,CAAI,CAEvJ,SAASC,EAA2BC,EAAMC,EAAM,CAAE,OAAIA,IAASP,EAAQO,CAAI,IAAM,UAAY,OAAOA,GAAS,YAAsBA,EAAeC,EAAuBF,CAAI,CAAE,CAE/K,SAASE,EAAuBF,EAAM,CAAE,GAAIA,IAAS,OAAU,MAAM,IAAI,eAAe,2DAA2D,EAAK,OAAOA,CAAK,CAEpK,SAASG,EAAUC,EAAUC,EAAY,CAAE,GAAI,OAAOA,GAAe,YAAcA,IAAe,KAAQ,MAAM,IAAI,UAAU,oDAAoD,EAAKD,EAAS,UAAY,OAAO,OAAOC,GAAcA,EAAW,UAAW,CAAE,YAAa,CAAE,MAAOD,EAAU,SAAU,GAAM,aAAc,EAAI,CAAE,CAAE,EAAOC,GAAYC,EAAgBF,EAAUC,CAAU,CAAE,CAE/X,SAASE,EAAiBC,EAAO,CAAE,IAAIC,EAAS,OAAO,KAAQ,WAAa,IAAI,IAAQ,OAAW,OAAAF,EAAmB,SAA0BC,EAAO,CAAE,GAAIA,IAAU,MAAQ,CAACE,EAAkBF,CAAK,EAAG,OAAOA,EAAO,GAAI,OAAOA,GAAU,WAAc,MAAM,IAAI,UAAU,oDAAoD,EAAK,GAAI,OAAOC,EAAW,IAAa,CAAE,GAAIA,EAAO,IAAID,CAAK,EAAG,OAAOC,EAAO,IAAID,CAAK,EAAGC,EAAO,IAAID,EAAOG,CAAO,CAAE,CAAG,SAASA,GAAU,CAAE,OAAOC,EAAWJ,EAAO,UAAWK,EAAgB,IAAI,EAAE,WAAW,CAAE,CAAG,OAAAF,EAAQ,UAAY,OAAO,OAAOH,EAAM,UAAW,CAAE,YAAa,CAAE,MAAOG,EAAS,WAAY,GAAO,SAAU,GAAM,aAAc,EAAI,CAAE,CAAE,EAAUL,EAAgBK,EAASH,CAAK,CAAE,EAAWD,EAAiBC,CAAK,CAAE,CAErvB,SAASI,EAAWE,EAAQ5H,EAAMsH,EAAO,CAAE,OAAIO,IAA+BH,EAAa,QAAQ,UAAoBA,EAAa,SAAoBE,EAAQ5H,EAAMsH,EAAO,CAAE,IAAIvV,EAAI,CAAC,IAAI,EAAGA,EAAE,KAAK,MAAMA,EAAGiO,CAAI,EAAG,IAAI4G,EAAc,SAAS,KAAK,MAAMgB,EAAQ7V,CAAC,EAAO4U,EAAW,IAAIC,EAAe,OAAIU,GAAOF,EAAgBT,EAAUW,EAAM,SAAS,EAAUX,CAAS,EAAae,EAAW,MAAM,KAAM,SAAS,CAAE,CAEha,SAASG,GAA4B,CAA0E,GAApE,OAAO,QAAY,KAAe,CAAC,QAAQ,WAA6B,QAAQ,UAAU,KAAM,MAAO,GAAO,GAAI,OAAO,OAAU,WAAY,MAAO,GAAM,GAAI,CAAE,OAAA,KAAK,UAAU,SAAS,KAAK,QAAQ,UAAU,KAAM,CAAA,EAAI,UAAY,CAAA,CAAE,CAAC,EAAU,EAAK,MAAa,CAAE,MAAO,EAAM,CAAE,CAElU,SAASL,EAAkBM,EAAI,CAAE,OAAO,SAAS,SAAS,KAAKA,CAAE,EAAE,QAAQ,eAAe,IAAM,EAAG,CAEnG,SAASV,EAAgBW,EAAGhU,EAAG,CAAE,OAAAqT,EAAkB,OAAO,gBAAkB,SAAyBW,EAAGhU,EAAG,CAAE,OAAAgU,EAAE,UAAYhU,EAAUgU,GAAaX,EAAgBW,EAAGhU,CAAC,CAAE,CAExK,SAAS4T,EAAgBI,EAAG,CAAE,OAAAJ,EAAkB,OAAO,eAAiB,OAAO,eAAiB,SAAyBI,EAAG,CAAE,OAAOA,EAAE,WAAa,OAAO,eAAeA,CAAC,CAAE,EAAWJ,EAAgBI,CAAC,CAAE,CAE3M,IAAIC,EAAiB,IACjBC,EAAiB,IAEjBC,GAA4C,SAAUC,EAAQ,CAChElB,EAAUiB,EAA8BC,CAAM,EAE9C,SAASD,EAA6BE,EAAQ,CAC5C,IAAIC,EAEJ,OAAA3B,EAAgB,KAAMwB,CAA4B,EAElDG,EAAQxB,EAA2B,KAAMc,EAAgBO,CAA4B,EAAE,KAAK,KAAME,CAAM,CAAC,EACzGC,EAAM,KAAO,+BACNA,CACX,CAEE,OAAOH,CACT,GAAEb,EAAiB,KAAK,CAAC,EAEzBiB,EAAiB,CACf,IAAKC,EACL,IAAKC,EACL,IAAKC,EACL,OAAQ,SAAgBC,EAAQC,EAAUnP,EAAS,CACjD,OAAO,KAAK,IAAIkP,EAAQC,EAAUnP,GAAW,CAC3C,IAAK,EACX,CAAK,CACL,EACE,KAAMoP,EACN,6BAA8BV,GAahC,SAASM,EAAkBE,EAAQC,EAAU,CAK3C,GAJInC,EAAQkC,CAAM,GAAK,UAAYA,IAAW,MAI1C,OAAOC,EAAY,IACrB,OAAOD,EAGT,GAAI,OAAOC,GAAY,SACrB,OAAOD,EAAOC,CAAQ,EAGxB,GAAI,CACF,OAAOE,EAASH,EAAQC,EAAU,SAA4BG,EAAeC,EAAiB,CAC5F,OAAOD,EAAcC,CAAe,CAC1C,CAAK,CACL,MAAgB,CACZ,OAAOL,CACX,CACA,CAaA,SAASD,EAAkBC,EAAQC,EAAU,CAC3C,IAAInP,EAAU,UAAU,OAAS,GAAK,UAAU,CAAC,IAAM,OAAY,UAAU,CAAC,EAAI,CAAA,EAMlF,GAJIgN,EAAQkC,CAAM,GAAK,UAAYA,IAAW,MAI1C,OAAOC,EAAY,IACrB,MAAO,GAGT,GAAI,OAAOA,GAAY,SACrB,OAAOA,KAAYD,EAGrB,GAAI,CACF,IAAIM,EAAM,GACV,OAAAH,EAASH,EAAQC,EAAU,SAA4BG,EAAeC,EAAiBE,EAAUjO,EAAO,CACtG,GAAIkO,EAAcD,EAAUjO,CAAK,EAC3BxB,EAAQ,IACVwP,EAAMF,EAAc,eAAeC,CAAe,EAElDC,EAAMD,KAAmBD,cAGpBA,GAAiBA,EAAcC,CAAe,CAE7D,CAAK,EACMC,CACX,MAAgB,CACZ,MAAO,EACX,CACA,CAWA,SAAST,EAAkBG,EAAQC,EAAUQ,EAAO,CAKlD,GAJI3C,EAAQkC,CAAM,GAAK,UAAYA,IAAW,MAI1C,OAAOC,EAAY,IACrB,OAAOD,EAGT,GAAI,OAAOC,GAAY,SACrB,OAAAD,EAAOC,CAAQ,EAAIQ,EACZT,EAAOC,CAAQ,EAGxB,GAAI,CACF,OAAOE,EAASH,EAAQC,EAAU,SAA4BG,EAAeC,EAAiBE,EAAUjO,EAAO,CAC7G,GAAI8N,IAAkB,QAAQ,eAAe,CAAA,CAAE,EAC7C,MAAM,IAAIZ,EAA6B,uCAAuC,EAGhF,GAAI,CAACY,EAAcC,CAAe,EAAG,CACnC,IAAIK,EAAmB,OAAO,UAAU,OAAOH,EAASjO,EAAQ,CAAC,CAAC,CAAC,EAC/DqO,EAA0BJ,EAASjO,EAAQ,CAAC,IAAMgN,EAElDoB,GAAoBC,EACtBP,EAAcC,CAAe,EAAI,CAAA,EAEjCD,EAAcC,CAAe,EAAI,CAAA,CAE3C,CAEM,OAAIG,EAAcD,EAAUjO,CAAK,IAC/B8N,EAAcC,CAAe,EAAII,GAG5BL,EAAcC,CAAe,CAC1C,CAAK,CACL,OAAWO,EAAK,CACZ,GAAIA,aAAepB,EAEjB,MAAMoB,EAEN,OAAOZ,CAEb,CACA,CAaA,SAASE,EAAmBF,EAAQC,EAAUY,EAAc,CAC1D,IAAI/P,EAAU,UAAU,OAAS,GAAK,UAAU,CAAC,IAAM,OAAY,UAAU,CAAC,EAAI,CAAA,EAMlF,GAJIgN,EAAQkC,CAAM,GAAK,UAAYA,IAAW,MAI1C,OAAOC,EAAY,IACrB,MAAO,GAGT,GAAI,CACF,IAAIa,EAAO,GACPC,EAAa,GAOjB,OANAZ,EAASH,EAAQC,EAAU,SAA6BG,EAAeC,EAAiBE,EAAUjO,EAAO,CACvG,OAAAwO,EAAOA,GAAQV,IAAkBS,GAAgB,CAAC,CAACT,GAAiBA,EAAcC,CAAe,IAAMQ,EACvGE,EAAaP,EAAcD,EAAUjO,CAAK,GAAKwL,EAAQsC,CAAa,IAAM,UAAYC,KAAmBD,EAClGA,GAAiBA,EAAcC,CAAe,CAC3D,CAAK,EAEGvP,EAAQ,UACHgQ,GAAQC,EAERD,CAEb,MAAgB,CACZ,MAAO,EACX,CACA,CAEA,SAASX,EAASH,EAAQzJ,EAAM,CAoC9B,QAnCIyK,EAAW,UAAU,OAAS,GAAK,UAAU,CAAC,IAAM,OAAY,UAAU,CAAC,EAAI,UAAY,CAAA,EAC3FT,EAAWhK,EAAK,MAAMgJ,CAAc,EACpCnC,EAASmD,EAAS,OAElBU,EAAQ,SAAeC,EAAK,CAC9B,IAAIC,EAAiBZ,EAASW,CAAG,EAEjC,GAAI,CAAClB,EACH,MAAO,CACL,EAAG,QAIP,GAAImB,IAAmB7B,EAAgB,CACrC,GAAI,MAAM,QAAQU,CAAM,EACtB,MAAO,CACL,EAAGA,EAAO,IAAI,SAAUS,EAAOnO,EAAO,CACpC,IAAI8O,EAAoBb,EAAS,MAAMW,EAAM,CAAC,EAE9C,OAAIE,EAAkB,OAAS,EACtBjB,EAASM,EAAOW,EAAkB,KAAK7B,CAAc,EAAGyB,CAAQ,EAEhEA,EAAShB,EAAQ1N,EAAOiO,EAAUW,CAAG,CAE1D,CAAW,GAGH,IAAIG,EAAad,EAAS,MAAM,EAAGW,CAAG,EAAE,KAAK3B,CAAc,EAC3D,MAAM,IAAI,MAAM,uBAAuB,OAAO8B,EAAY,mBAAmB,CAAC,CAEtF,MACMrB,EAASgB,EAAShB,EAAQmB,EAAgBZ,EAAUW,CAAG,CAE7D,EAEWA,EAAM,EAAGA,EAAM9D,EAAQ8D,IAAO,CACrC,IAAII,EAAOL,EAAMC,CAAG,EAEpB,GAAIpD,EAAQwD,CAAI,IAAM,SAAU,OAAOA,EAAK,CAChD,CAEE,OAAOtB,CACT,CAEA,SAASQ,EAAcD,EAAUjO,EAAO,CACtC,OAAOiO,EAAS,SAAWjO,EAAQ,CACrC,eCtRA,IAAIiP,IACH,SAAUA,EAAc,CACrBA,EAAa,MAAW,QACxBA,EAAa,OAAY,SACzBA,EAAa,SAAc,UAC/B,GAAGA,KAAiBA,GAAe,CAAA,EAAG,EA4I/B,SAASC,GAAqBC,EAAOjG,EAAUQ,EAAa,GAAO,CAEtE,KAAM,CAAE,gBAAiB0F,EAAU,KAAM,iBAAkBC,EAAU,IAAK,aAAcC,EAAe,KAAM,eAAgBC,EAAW,KAAM,QAASC,EAAO,IAAI,EAAKL,EACjK7Q,EAAOgR,GACT,OAAOA,GAAiB,UACxB,OAAOA,EAAa,WAAe,IACjC,YACA,OACAG,EAAO,CACT,SAAAvG,EACA,SAAUjF,GAAK,SAASiF,CAAQ,EAChC,QAASkG,EACT,KAAM,SAASC,EAAS,EAAE,EAC1B,KAAA/Q,EACA,KAAM,OAAOkR,GAAS,SAAWA,EAAK,QAAQ,KAAM,EAAE,EAAI,IAClE,EACI,OAAIlR,IAAS,SACTmR,EAAK,KAAOF,GAAY,OAAOA,GAAa,SAAWA,EAAS,MAAM,GAAG,EAAE,CAAC,EAAI,IAEhF7F,IAEI,OAAOyF,EAAM,YAAgB,MAC7BA,EAAM,YAAc,OAAOA,EAAM,WAAW,GAEhDM,EAAK,MAAQN,GAEVM,CACX,CCtKO,MAAMC,GAAgB,GAc7B,eAAsBC,GAAY,CAAE,aAAAL,EAAc,WAAAM,CAAA,EAAcpR,EAA8D,CAC7H,MAAMqR,EAAe,CAAC,GAAIP,EAAcM,CAAU,EAAE,KAAK,GAAG,EACtDE,EAAWtR,EAAQ,SAAW,gBAAgBA,EAAQ,SAAS,YAAA,CAAa,iBAAmB,GAC/FgL,EAAW,MAAMjT,GAAO,cAAcsZ,EAAc,CACzD,OAAQ,SACR,KAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAMQrR,EAAQ,OAASkR,EAAa;AAAA,iBAC7BlR,EAAQ,QAAU,CAAC;AAAA,MAC9BsR,CAAQ;AAAA,0BAEZ,GAAGtR,CAAA,CACH,EAEKuR,EAAe,MAAMvG,EAAS,KAAA,EAC9B7R,EAAS,MAAMqY,GAASD,CAAY,EACpCN,EAAOQ,GAAkBtY,EAAQ,EAAI,EAE3C,OAAO4R,GAAuBC,EAAUiG,EAAM,EAAI,CACnD,CAQA,SAASQ,GACRtY,EACA+R,EAAa,GACK,CAElB,KAAM,CACL,YAAa,CAAE,SAAUwG,CAAA,CAAc,EACpCvY,EAGJ,OAAOuY,EAAc,IAAKC,GAAS,CAElC,MAAMhB,EAAQgB,EAAK,SAAU,KAE7B,OAAOjB,GAAqBC,EAAOA,EAAM,GAAI,SAAA,EAAYzF,CAAU,CACpE,CAAC,CACF","x_google_ignoreList":[2,3,4,5,6,7,8,9,10,11,12,13,14]}