@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/ast.js

@@ -0,0 +1,495 @@
+import { __exports as ast } from "../../../../../../../_virtual/ast.js";
+import { __require as requireBraceExpressions } from "./brace-expressions.js";
+import { __require as require_unescape } from "./unescape.js";
+var hasRequiredAst;
+function requireAst() {
+  if (hasRequiredAst) return ast;
+  hasRequiredAst = 1;
+  Object.defineProperty(ast, "__esModule", { value: true });
+  ast.AST = void 0;
+  const brace_expressions_js_1 = requireBraceExpressions();
+  const unescape_js_1 = require_unescape();
+  const types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+  const isExtglobType = (c) => types.has(c);
+  const startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+  const startNoDot = "(?!\\.)";
+  const addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+  const justDots = /* @__PURE__ */ new Set(["..", "."]);
+  const reSpecials = new Set("().*{}+?[]^$\\!");
+  const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+  const qmark = "[^/]";
+  const star = qmark + "*?";
+  const starNoEmpty = qmark + "+?";
+  class AST {
+    type;
+    #root;
+    #hasMagic;
+    #uflag = false;
+    #parts = [];
+    #parent;
+    #parentIndex;
+    #negs;
+    #filledNegs = false;
+    #options;
+    #toString;
+    // set to true if it's an extglob with no children
+    // (which really means one child of '')
+    #emptyExt = false;
+    constructor(type, parent, options = {}) {
+      this.type = type;
+      if (type)
+        this.#hasMagic = true;
+      this.#parent = parent;
+      this.#root = this.#parent ? this.#parent.#root : this;
+      this.#options = this.#root === this ? options : this.#root.#options;
+      this.#negs = this.#root === this ? [] : this.#root.#negs;
+      if (type === "!" && !this.#root.#filledNegs)
+        this.#negs.push(this);
+      this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+    }
+    get hasMagic() {
+      if (this.#hasMagic !== void 0)
+        return this.#hasMagic;
+      for (const p of this.#parts) {
+        if (typeof p === "string")
+          continue;
+        if (p.type || p.hasMagic)
+          return this.#hasMagic = true;
+      }
+      return this.#hasMagic;
+    }
+    // reconstructs the pattern
+    toString() {
+      if (this.#toString !== void 0)
+        return this.#toString;
+      if (!this.type) {
+        return this.#toString = this.#parts.map((p) => String(p)).join("");
+      } else {
+        return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+      }
+    }
+    #fillNegs() {
+      if (this !== this.#root)
+        throw new Error("should only call on root");
+      if (this.#filledNegs)
+        return this;
+      this.toString();
+      this.#filledNegs = true;
+      let n;
+      while (n = this.#negs.pop()) {
+        if (n.type !== "!")
+          continue;
+        let p = n;
+        let pp = p.#parent;
+        while (pp) {
+          for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+            for (const part of n.#parts) {
+              if (typeof part === "string") {
+                throw new Error("string part in extglob AST??");
+              }
+              part.copyIn(pp.#parts[i]);
+            }
+          }
+          p = pp;
+          pp = p.#parent;
+        }
+      }
+      return this;
+    }
+    push(...parts) {
+      for (const p of parts) {
+        if (p === "")
+          continue;
+        if (typeof p !== "string" && !(p instanceof AST && p.#parent === this)) {
+          throw new Error("invalid part: " + p);
+        }
+        this.#parts.push(p);
+      }
+    }
+    toJSON() {
+      const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+      if (this.isStart() && !this.type)
+        ret.unshift([]);
+      if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+        ret.push({});
+      }
+      return ret;
+    }
+    isStart() {
+      if (this.#root === this)
+        return true;
+      if (!this.#parent?.isStart())
+        return false;
+      if (this.#parentIndex === 0)
+        return true;
+      const p = this.#parent;
+      for (let i = 0; i < this.#parentIndex; i++) {
+        const pp = p.#parts[i];
+        if (!(pp instanceof AST && pp.type === "!")) {
+          return false;
+        }
+      }
+      return true;
+    }
+    isEnd() {
+      if (this.#root === this)
+        return true;
+      if (this.#parent?.type === "!")
+        return true;
+      if (!this.#parent?.isEnd())
+        return false;
+      if (!this.type)
+        return this.#parent?.isEnd();
+      const pl = this.#parent ? this.#parent.#parts.length : 0;
+      return this.#parentIndex === pl - 1;
+    }
+    copyIn(part) {
+      if (typeof part === "string")
+        this.push(part);
+      else
+        this.push(part.clone(this));
+    }
+    clone(parent) {
+      const c = new AST(this.type, parent);
+      for (const p of this.#parts) {
+        c.copyIn(p);
+      }
+      return c;
+    }
+    static #parseAST(str, ast2, pos, opt) {
+      let escaping = false;
+      let inBrace = false;
+      let braceStart = -1;
+      let braceNeg = false;
+      if (ast2.type === null) {
+        let i2 = pos;
+        let acc2 = "";
+        while (i2 < str.length) {
+          const c = str.charAt(i2++);
+          if (escaping || c === "\\") {
+            escaping = !escaping;
+            acc2 += c;
+            continue;
+          }
+          if (inBrace) {
+            if (i2 === braceStart + 1) {
+              if (c === "^" || c === "!") {
+                braceNeg = true;
+              }
+            } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+              inBrace = false;
+            }
+            acc2 += c;
+            continue;
+          } else if (c === "[") {
+            inBrace = true;
+            braceStart = i2;
+            braceNeg = false;
+            acc2 += c;
+            continue;
+          }
+          if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+            ast2.push(acc2);
+            acc2 = "";
+            const ext = new AST(c, ast2);
+            i2 = AST.#parseAST(str, ext, i2, opt);
+            ast2.push(ext);
+            continue;
+          }
+          acc2 += c;
+        }
+        ast2.push(acc2);
+        return i2;
+      }
+      let i = pos + 1;
+      let part = new AST(null, ast2);
+      const parts = [];
+      let acc = "";
+      while (i < str.length) {
+        const c = str.charAt(i++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i;
+          braceNeg = false;
+          acc += c;
+          continue;
+        }
+        if (isExtglobType(c) && str.charAt(i) === "(") {
+          part.push(acc);
+          acc = "";
+          const ext = new AST(c, part);
+          part.push(ext);
+          i = AST.#parseAST(str, ext, i, opt);
+          continue;
+        }
+        if (c === "|") {
+          part.push(acc);
+          acc = "";
+          parts.push(part);
+          part = new AST(null, ast2);
+          continue;
+        }
+        if (c === ")") {
+          if (acc === "" && ast2.#parts.length === 0) {
+            ast2.#emptyExt = true;
+          }
+          part.push(acc);
+          acc = "";
+          ast2.push(...parts, part);
+          return i;
+        }
+        acc += c;
+      }
+      ast2.type = null;
+      ast2.#hasMagic = void 0;
+      ast2.#parts = [str.substring(pos - 1)];
+      return i;
+    }
+    static fromGlob(pattern, options = {}) {
+      const ast2 = new AST(null, void 0, options);
+      AST.#parseAST(pattern, ast2, 0, options);
+      return ast2;
+    }
+    // returns the regular expression if there's magic, or the unescaped
+    // string if not.
+    toMMPattern() {
+      if (this !== this.#root)
+        return this.#root.toMMPattern();
+      const glob = this.toString();
+      const [re, body, hasMagic, uflag] = this.toRegExpSource();
+      const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
+      if (!anyMagic) {
+        return body;
+      }
+      const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+      return Object.assign(new RegExp(`^${re}$`, flags), {
+        _src: re,
+        _glob: glob
+      });
+    }
+    get options() {
+      return this.#options;
+    }
+    // returns the string match, the regexp source, whether there's magic
+    // in the regexp (so a regular expression is required) and whether or
+    // not the uflag is needed for the regular expression (for posix classes)
+    // TODO: instead of injecting the start/end at this point, just return
+    // the BODY of the regexp, along with the start/end portions suitable
+    // for binding the start/end in either a joined full-path makeRe context
+    // (where we bind to (^|/), or a standalone matchPart context (where
+    // we bind to ^, and not /).  Otherwise slashes get duped!
+    //
+    // In part-matching mode, the start is:
+    // - if not isStart: nothing
+    // - if traversal possible, but not allowed: ^(?!\.\.?$)
+    // - if dots allowed or not possible: ^
+    // - if dots possible and not allowed: ^(?!\.)
+    // end is:
+    // - if not isEnd(): nothing
+    // - else: $
+    //
+    // In full-path matching mode, we put the slash at the START of the
+    // pattern, so start is:
+    // - if first pattern: same as part-matching mode
+    // - if not isStart(): nothing
+    // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+    // - if dots allowed or not possible: /
+    // - if dots possible and not allowed: /(?!\.)
+    // end is:
+    // - if last pattern, same as part-matching mode
+    // - else nothing
+    //
+    // Always put the (?:$|/) on negated tails, though, because that has to be
+    // there to bind the end of the negated pattern portion, and it's easier to
+    // just stick it in now rather than try to inject it later in the middle of
+    // the pattern.
+    //
+    // We can just always return the same end, and leave it up to the caller
+    // to know whether it's going to be used joined or in parts.
+    // And, if the start is adjusted slightly, can do the same there:
+    // - if not isStart: nothing
+    // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+    // - if dots allowed or not possible: (?:/|^)
+    // - if dots possible and not allowed: (?:/|^)(?!\.)
+    //
+    // But it's better to have a simpler binding without a conditional, for
+    // performance, so probably better to return both start options.
+    //
+    // Then the caller just ignores the end if it's not the first pattern,
+    // and the start always gets applied.
+    //
+    // But that's always going to be $ if it's the ending pattern, or nothing,
+    // so the caller can just attach $ at the end of the pattern when building.
+    //
+    // So the todo is:
+    // - better detect what kind of start is needed
+    // - return both flavors of starting pattern
+    // - attach $ at the end of the pattern when creating the actual RegExp
+    //
+    // Ah, but wait, no, that all only applies to the root when the first pattern
+    // is not an extglob. If the first pattern IS an extglob, then we need all
+    // that dot prevention biz to live in the extglob portions, because eg
+    // +(*|.x*) can match .xy but not .yx.
+    //
+    // So, return the two flavors if it's #root and the first child is not an
+    // AST, otherwise leave it to the child AST to handle it, and there,
+    // use the (?:^|/) style of start binding.
+    //
+    // Even simplified further:
+    // - Since the start for a join is eg /(?!\.) and the start for a part
+    // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+    // or start or whatever) and prepend ^ or / at the Regexp construction.
+    toRegExpSource(allowDot) {
+      const dot = allowDot ?? !!this.#options.dot;
+      if (this.#root === this)
+        this.#fillNegs();
+      if (!this.type) {
+        const noEmpty = this.isStart() && this.isEnd();
+        const src = this.#parts.map((p) => {
+          const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+          this.#hasMagic = this.#hasMagic || hasMagic;
+          this.#uflag = this.#uflag || uflag;
+          return re;
+        }).join("");
+        let start2 = "";
+        if (this.isStart()) {
+          if (typeof this.#parts[0] === "string") {
+            const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+            if (!dotTravAllowed) {
+              const aps = addPatternStart;
+              const needNoTrav = (
+                // dots are allowed, and the pattern starts with [ or .
+                dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+                src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+                src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+              );
+              const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+              start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+            }
+          }
+        }
+        let end = "";
+        if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+          end = "(?:$|\\/)";
+        }
+        const final2 = start2 + src + end;
+        return [
+          final2,
+          (0, unescape_js_1.unescape)(src),
+          this.#hasMagic = !!this.#hasMagic,
+          this.#uflag
+        ];
+      }
+      const repeated = this.type === "*" || this.type === "+";
+      const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+      let body = this.#partsToRegExp(dot);
+      if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+        const s = this.toString();
+        this.#parts = [s];
+        this.type = null;
+        this.#hasMagic = void 0;
+        return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
+      }
+      let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+      if (bodyDotAllowed === body) {
+        bodyDotAllowed = "";
+      }
+      if (bodyDotAllowed) {
+        body = `(?:${body})(?:${bodyDotAllowed})*?`;
+      }
+      let final = "";
+      if (this.type === "!" && this.#emptyExt) {
+        final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+      } else {
+        const close = this.type === "!" ? (
+          // !() must match something,but !(x) can match ''
+          "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+        ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+        final = start + body + close;
+      }
+      return [
+        final,
+        (0, unescape_js_1.unescape)(body),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    #partsToRegExp(dot) {
+      return this.#parts.map((p) => {
+        if (typeof p === "string") {
+          throw new Error("string type in extglob ast??");
+        }
+        const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+    }
+    static #parseGlob(glob, hasMagic, noEmpty = false) {
+      let escaping = false;
+      let re = "";
+      let uflag = false;
+      for (let i = 0; i < glob.length; i++) {
+        const c = glob.charAt(i);
+        if (escaping) {
+          escaping = false;
+          re += (reSpecials.has(c) ? "\\" : "") + c;
+          continue;
+        }
+        if (c === "\\") {
+          if (i === glob.length - 1) {
+            re += "\\\\";
+          } else {
+            escaping = true;
+          }
+          continue;
+        }
+        if (c === "[") {
+          const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(glob, i);
+          if (consumed) {
+            re += src;
+            uflag = uflag || needUflag;
+            i += consumed - 1;
+            hasMagic = hasMagic || magic;
+            continue;
+          }
+        }
+        if (c === "*") {
+          if (noEmpty && glob === "*")
+            re += starNoEmpty;
+          else
+            re += star;
+          hasMagic = true;
+          continue;
+        }
+        if (c === "?") {
+          re += qmark;
+          hasMagic = true;
+          continue;
+        }
+        re += regExpEscape(c);
+      }
+      return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];
+    }
+  }
+  ast.AST = AST;
+  return ast;
+}
+export {
+  requireAst as __require
+};
+//# sourceMappingURL=ast.js.map

package/dist/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sources":["../../../../../../../../node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/dist/commonjs/ast.js"],"sourcesContent":["\"use strict\";\n// parse a single path portion\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AST = void 0;\nconst brace_expressions_js_1 = require(\"./brace-expressions.js\");\nconst unescape_js_1 = require(\"./unescape.js\");\nconst types = new Set(['!', '?', '+', '*', '@']);\nconst isExtglobType = (c) => types.has(c);\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')\nclass 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 AST && 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 AST && 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 AST(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) {\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                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {\n                    ast.push(acc);\n                    acc = '';\n                    const ext = new AST(c, ast);\n                    i = AST.#parseAST(str, ext, i, opt);\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 AST(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            if (isExtglobType(c) && str.charAt(i) === '(') {\n                part.push(acc);\n                acc = '';\n                const ext = new AST(c, part);\n                part.push(ext);\n                i = AST.#parseAST(str, ext, i, opt);\n                continue;\n            }\n            if (c === '|') {\n                part.push(acc);\n                acc = '';\n                parts.push(part);\n                part = new AST(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    static fromGlob(pattern, options = {}) {\n        const ast = new AST(null, undefined, options);\n        AST.#parseAST(pattern, ast, 0, options);\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.#fillNegs();\n        if (!this.type) {\n            const noEmpty = this.isStart() && this.isEnd();\n            const src = this.#parts\n                .map(p => {\n                const [re, _, hasMagic, uflag] = typeof p === 'string'\n                    ? AST.#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                (0, unescape_js_1.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            this.#parts = [s];\n            this.type = null;\n            this.#hasMagic = undefined;\n            return [s, (0, unescape_js_1.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            (0, unescape_js_1.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        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                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] = (0, brace_expressions_js_1.parseClass)(glob, i);\n                if (consumed) {\n                    re += src;\n                    uflag = uflag || needUflag;\n                    i += consumed - 1;\n                    hasMagic = hasMagic || magic;\n                    continue;\n                }\n            }\n            if (c === '*') {\n                if (noEmpty && glob === '*')\n                    re += starNoEmpty;\n                else\n                    re += star;\n                hasMagic = true;\n                continue;\n            }\n            if (c === '?') {\n                re += qmark;\n                hasMagic = true;\n                continue;\n            }\n            re += regExpEscape(c);\n        }\n        return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];\n    }\n}\nexports.AST = AST;\n//# sourceMappingURL=ast.js.map"],"names":["require$$0","require$$1","ast","i","acc","start","final"],"mappings":";;;;;;;AAEA,SAAO,eAAe,KAAS,cAAc,EAAE,OAAO,MAAM;AAC5D,MAAA,MAAc;AACd,QAAM,yBAAyBA,wBAAA;AAC/B,QAAM,gBAAgBC,iBAAA;AACtB,QAAM,QAAQ,oBAAI,IAAI,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG,CAAC;AAC/C,QAAM,gBAAgB,CAAC,MAAM,MAAM,IAAI,CAAC;AAKxC,QAAM,mBAAmB;AACzB,QAAM,aAAa;AAInB,QAAM,kBAAkB,oBAAI,IAAI,CAAC,KAAK,GAAG,CAAC;AAE1C,QAAM,WAAW,oBAAI,IAAI,CAAC,MAAM,GAAG,CAAC;AACpC,QAAM,aAAa,IAAI,IAAI,iBAAiB;AAC5C,QAAM,eAAe,CAAC,MAAM,EAAE,QAAQ,4BAA4B,MAAM;AAExE,QAAM,QAAQ;AAEd,QAAM,OAAO,QAAQ;AAGrB,QAAM,cAAc,QAAQ;AAAA,EAG5B,MAAM,IAAI;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT,SAAS,CAAA;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd;AAAA,IACA;AAAA;AAAA;AAAA,IAGA,YAAY;AAAA,IACZ,YAAY,MAAM,QAAQ,UAAU,CAAA,GAAI;AACpC,WAAK,OAAO;AAEZ,UAAI;AACA,aAAK,YAAY;AACrB,WAAK,UAAU;AACf,WAAK,QAAQ,KAAK,UAAU,KAAK,QAAQ,QAAQ;AACjD,WAAK,WAAW,KAAK,UAAU,OAAO,UAAU,KAAK,MAAM;AAC3D,WAAK,QAAQ,KAAK,UAAU,OAAO,KAAK,KAAK,MAAM;AACnD,UAAI,SAAS,OAAO,CAAC,KAAK,MAAM;AAC5B,aAAK,MAAM,KAAK,IAAI;AACxB,WAAK,eAAe,KAAK,UAAU,KAAK,QAAQ,OAAO,SAAS;AAAA,IACxE;AAAA,IACI,IAAI,WAAW;AAEX,UAAI,KAAK,cAAc;AACnB,eAAO,KAAK;AAEhB,iBAAW,KAAK,KAAK,QAAQ;AACzB,YAAI,OAAO,MAAM;AACb;AACJ,YAAI,EAAE,QAAQ,EAAE;AACZ,iBAAQ,KAAK,YAAY;AAAA,MACzC;AAEQ,aAAO,KAAK;AAAA,IACpB;AAAA;AAAA,IAEI,WAAW;AACP,UAAI,KAAK,cAAc;AACnB,eAAO,KAAK;AAChB,UAAI,CAAC,KAAK,MAAM;AACZ,eAAQ,KAAK,YAAY,KAAK,OAAO,IAAI,OAAK,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE;AAAA,MAC5E,OACa;AACD,eAAQ,KAAK,YACT,KAAK,OAAO,MAAM,KAAK,OAAO,IAAI,OAAK,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI;AAAA,MAC9E;AAAA,IACA;AAAA,IACI,YAAY;AAER,UAAI,SAAS,KAAK;AACd,cAAM,IAAI,MAAM,0BAA0B;AAC9C,UAAI,KAAK;AACL,eAAO;AAGX,WAAK,SAAQ;AACb,WAAK,cAAc;AACnB,UAAI;AACJ,aAAQ,IAAI,KAAK,MAAM,IAAG,GAAK;AAC3B,YAAI,EAAE,SAAS;AACX;AAEJ,YAAI,IAAI;AACR,YAAI,KAAK,EAAE;AACX,eAAO,IAAI;AACP,mBAAS,IAAI,EAAE,eAAe,GAAG,CAAC,GAAG,QAAQ,IAAI,GAAG,OAAO,QAAQ,KAAK;AACpE,uBAAW,QAAQ,EAAE,QAAQ;AAEzB,kBAAI,OAAO,SAAS,UAAU;AAC1B,sBAAM,IAAI,MAAM,8BAA8B;AAAA,cAC1E;AAEwB,mBAAK,OAAO,GAAG,OAAO,CAAC,CAAC;AAAA,YAChD;AAAA,UACA;AACgB,cAAI;AACJ,eAAK,EAAE;AAAA,QACvB;AAAA,MACA;AACQ,aAAO;AAAA,IACf;AAAA,IACI,QAAQ,OAAO;AACX,iBAAW,KAAK,OAAO;AACnB,YAAI,MAAM;AACN;AAEJ,YAAI,OAAO,MAAM,YAAY,EAAE,aAAa,OAAO,EAAE,YAAY,OAAO;AACpE,gBAAM,IAAI,MAAM,mBAAmB,CAAC;AAAA,QACpD;AAEY,aAAK,OAAO,KAAK,CAAC;AAAA,MAC9B;AAAA,IACA;AAAA,IACI,SAAS;AACL,YAAM,MAAM,KAAK,SAAS,OACpB,KAAK,OAAO,MAAK,EAAG,IAAI,OAAM,OAAO,MAAM,WAAW,IAAI,EAAE,OAAM,CAAG,IACrE,CAAC,KAAK,MAAM,GAAG,KAAK,OAAO,IAAI,OAAK,EAAE,OAAM,CAAE,CAAC;AACrD,UAAI,KAAK,aAAa,CAAC,KAAK;AACxB,YAAI,QAAQ,EAAE;AAClB,UAAI,KAAK,MAAK,MACT,SAAS,KAAK,SACV,KAAK,MAAM,eAAe,KAAK,SAAS,SAAS,MAAO;AAC7D,YAAI,KAAK,EAAE;AAAA,MACvB;AACQ,aAAO;AAAA,IACf;AAAA,IACI,UAAU;AACN,UAAI,KAAK,UAAU;AACf,eAAO;AAEX,UAAI,CAAC,KAAK,SAAS,QAAO;AACtB,eAAO;AACX,UAAI,KAAK,iBAAiB;AACtB,eAAO;AAEX,YAAM,IAAI,KAAK;AACf,eAAS,IAAI,GAAG,IAAI,KAAK,cAAc,KAAK;AACxC,cAAM,KAAK,EAAE,OAAO,CAAC;AACrB,YAAI,EAAE,cAAc,OAAO,GAAG,SAAS,MAAM;AACzC,iBAAO;AAAA,QACvB;AAAA,MACA;AACQ,aAAO;AAAA,IACf;AAAA,IACI,QAAQ;AACJ,UAAI,KAAK,UAAU;AACf,eAAO;AACX,UAAI,KAAK,SAAS,SAAS;AACvB,eAAO;AACX,UAAI,CAAC,KAAK,SAAS,MAAK;AACpB,eAAO;AACX,UAAI,CAAC,KAAK;AACN,eAAO,KAAK,SAAS,MAAK;AAG9B,YAAM,KAAK,KAAK,UAAU,KAAK,QAAQ,OAAO,SAAS;AAEvD,aAAO,KAAK,iBAAiB,KAAK;AAAA,IAC1C;AAAA,IACI,OAAO,MAAM;AACT,UAAI,OAAO,SAAS;AAChB,aAAK,KAAK,IAAI;AAAA;AAEd,aAAK,KAAK,KAAK,MAAM,IAAI,CAAC;AAAA,IACtC;AAAA,IACI,MAAM,QAAQ;AACV,YAAM,IAAI,IAAI,IAAI,KAAK,MAAM,MAAM;AACnC,iBAAW,KAAK,KAAK,QAAQ;AACzB,UAAE,OAAO,CAAC;AAAA,MACtB;AACQ,aAAO;AAAA,IACf;AAAA,IACI,OAAO,UAAU,KAAKC,MAAK,KAAK,KAAK;AACjC,UAAI,WAAW;AACf,UAAI,UAAU;AACd,UAAI,aAAa;AACjB,UAAI,WAAW;AACf,UAAIA,KAAI,SAAS,MAAM;AAEnB,YAAIC,KAAI;AACR,YAAIC,OAAM;AACV,eAAOD,KAAI,IAAI,QAAQ;AACnB,gBAAM,IAAI,IAAI,OAAOA,IAAG;AAGxB,cAAI,YAAY,MAAM,MAAM;AACxB,uBAAW,CAAC;AACZ,YAAAC,QAAO;AACP;AAAA,UACpB;AACgB,cAAI,SAAS;AACT,gBAAID,OAAM,aAAa,GAAG;AACtB,kBAAI,MAAM,OAAO,MAAM,KAAK;AACxB,2BAAW;AAAA,cACvC;AAAA,YACA,WAC6B,MAAM,OAAO,EAAEA,OAAM,aAAa,KAAK,WAAW;AACvD,wBAAU;AAAA,YAClC;AACoB,YAAAC,QAAO;AACP;AAAA,UACpB,WACyB,MAAM,KAAK;AAChB,sBAAU;AACV,yBAAaD;AACb,uBAAW;AACX,YAAAC,QAAO;AACP;AAAA,UACpB;AACgB,cAAI,CAAC,IAAI,SAAS,cAAc,CAAC,KAAK,IAAI,OAAOD,EAAC,MAAM,KAAK;AACzD,YAAAD,KAAI,KAAKE,IAAG;AACZ,YAAAA,OAAM;AACN,kBAAM,MAAM,IAAI,IAAI,GAAGF,IAAG;AAC1B,YAAAC,KAAI,IAAI,UAAU,KAAK,KAAKA,IAAG,GAAG;AAClC,YAAAD,KAAI,KAAK,GAAG;AACZ;AAAA,UACpB;AACgB,UAAAE,QAAO;AAAA,QACvB;AACY,QAAAF,KAAI,KAAKE,IAAG;AACZ,eAAOD;AAAA,MACnB;AAGQ,UAAI,IAAI,MAAM;AACd,UAAI,OAAO,IAAI,IAAI,MAAMD,IAAG;AAC5B,YAAM,QAAQ,CAAA;AACd,UAAI,MAAM;AACV,aAAO,IAAI,IAAI,QAAQ;AACnB,cAAM,IAAI,IAAI,OAAO,GAAG;AAGxB,YAAI,YAAY,MAAM,MAAM;AACxB,qBAAW,CAAC;AACZ,iBAAO;AACP;AAAA,QAChB;AACY,YAAI,SAAS;AACT,cAAI,MAAM,aAAa,GAAG;AACtB,gBAAI,MAAM,OAAO,MAAM,KAAK;AACxB,yBAAW;AAAA,YACnC;AAAA,UACA,WACyB,MAAM,OAAO,EAAE,MAAM,aAAa,KAAK,WAAW;AACvD,sBAAU;AAAA,UAC9B;AACgB,iBAAO;AACP;AAAA,QAChB,WACqB,MAAM,KAAK;AAChB,oBAAU;AACV,uBAAa;AACb,qBAAW;AACX,iBAAO;AACP;AAAA,QAChB;AACY,YAAI,cAAc,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,KAAK;AAC3C,eAAK,KAAK,GAAG;AACb,gBAAM;AACN,gBAAM,MAAM,IAAI,IAAI,GAAG,IAAI;AAC3B,eAAK,KAAK,GAAG;AACb,cAAI,IAAI,UAAU,KAAK,KAAK,GAAG,GAAG;AAClC;AAAA,QAChB;AACY,YAAI,MAAM,KAAK;AACX,eAAK,KAAK,GAAG;AACb,gBAAM;AACN,gBAAM,KAAK,IAAI;AACf,iBAAO,IAAI,IAAI,MAAMA,IAAG;AACxB;AAAA,QAChB;AACY,YAAI,MAAM,KAAK;AACX,cAAI,QAAQ,MAAMA,KAAI,OAAO,WAAW,GAAG;AACvC,YAAAA,KAAI,YAAY;AAAA,UACpC;AACgB,eAAK,KAAK,GAAG;AACb,gBAAM;AACN,UAAAA,KAAI,KAAK,GAAG,OAAO,IAAI;AACvB,iBAAO;AAAA,QACvB;AACY,eAAO;AAAA,MACnB;AAIQ,MAAAA,KAAI,OAAO;AACX,MAAAA,KAAI,YAAY;AAChB,MAAAA,KAAI,SAAS,CAAC,IAAI,UAAU,MAAM,CAAC,CAAC;AACpC,aAAO;AAAA,IACf;AAAA,IACI,OAAO,SAAS,SAAS,UAAU,IAAI;AACnC,YAAMA,OAAM,IAAI,IAAI,MAAM,QAAW,OAAO;AAC5C,UAAI,UAAU,SAASA,MAAK,GAAG,OAAO;AACtC,aAAOA;AAAA,IACf;AAAA;AAAA;AAAA,IAGI,cAAc;AAGV,UAAI,SAAS,KAAK;AACd,eAAO,KAAK,MAAM,YAAW;AAEjC,YAAM,OAAO,KAAK,SAAQ;AAC1B,YAAM,CAAC,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK,eAAc;AAIvD,YAAM,WAAW,YACb,KAAK,aACJ,KAAK,SAAS,UACX,CAAC,KAAK,SAAS,mBACf,KAAK,YAAW,MAAO,KAAK,YAAW;AAC/C,UAAI,CAAC,UAAU;AACX,eAAO;AAAA,MACnB;AACQ,YAAM,SAAS,KAAK,SAAS,SAAS,MAAM,OAAO,QAAQ,MAAM;AACjE,aAAO,OAAO,OAAO,IAAI,OAAO,IAAI,EAAE,KAAK,KAAK,GAAG;AAAA,QAC/C,MAAM;AAAA,QACN,OAAO;AAAA,MACnB,CAAS;AAAA,IACT;AAAA,IACI,IAAI,UAAU;AACV,aAAO,KAAK;AAAA,IACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAsEI,eAAe,UAAU;AACrB,YAAM,MAAM,YAAY,CAAC,CAAC,KAAK,SAAS;AACxC,UAAI,KAAK,UAAU;AACf,aAAK,UAAS;AAClB,UAAI,CAAC,KAAK,MAAM;AACZ,cAAM,UAAU,KAAK,QAAO,KAAM,KAAK,MAAK;AAC5C,cAAM,MAAM,KAAK,OACZ,IAAI,OAAK;AACV,gBAAM,CAAC,IAAI,GAAG,UAAU,KAAK,IAAI,OAAO,MAAM,WACxC,IAAI,WAAW,GAAG,KAAK,WAAW,OAAO,IACzC,EAAE,eAAe,QAAQ;AAC/B,eAAK,YAAY,KAAK,aAAa;AACnC,eAAK,SAAS,KAAK,UAAU;AAC7B,iBAAO;AAAA,QACvB,CAAa,EACI,KAAK,EAAE;AACZ,YAAIG,SAAQ;AACZ,YAAI,KAAK,WAAW;AAChB,cAAI,OAAO,KAAK,OAAO,CAAC,MAAM,UAAU;AAKpC,kBAAM,iBAAiB,KAAK,OAAO,WAAW,KAAK,SAAS,IAAI,KAAK,OAAO,CAAC,CAAC;AAC9E,gBAAI,CAAC,gBAAgB;AACjB,oBAAM,MAAM;AAGZ,oBAAM;AAAA;AAAA,gBAEL,OAAO,IAAI,IAAI,IAAI,OAAO,CAAC,CAAC;AAAA,gBAExB,IAAI,WAAW,KAAK,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,CAAC;AAAA,gBAE9C,IAAI,WAAW,QAAQ,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,CAAC;AAAA;AAGtD,oBAAM,YAAY,CAAC,OAAO,CAAC,YAAY,IAAI,IAAI,IAAI,OAAO,CAAC,CAAC;AAC5D,cAAAA,SAAQ,aAAa,mBAAmB,YAAY,aAAa;AAAA,YACzF;AAAA,UACA;AAAA,QACA;AAEY,YAAI,MAAM;AACV,YAAI,KAAK,MAAK,KACV,KAAK,MAAM,eACX,KAAK,SAAS,SAAS,KAAK;AAC5B,gBAAM;AAAA,QACtB;AACY,cAAMC,SAAQD,SAAQ,MAAM;AAC5B,eAAO;AAAA,UACHC;AAAA,cACI,cAAc,UAAU,GAAG;AAAA,UAC9B,KAAK,YAAY,CAAC,CAAC,KAAK;AAAA,UACzB,KAAK;AAAA;MAErB;AAIQ,YAAM,WAAW,KAAK,SAAS,OAAO,KAAK,SAAS;AAEpD,YAAM,QAAQ,KAAK,SAAS,MAAM,cAAc;AAChD,UAAI,OAAO,KAAK,eAAe,GAAG;AAClC,UAAI,KAAK,QAAO,KAAM,KAAK,WAAW,CAAC,QAAQ,KAAK,SAAS,KAAK;AAG9D,cAAM,IAAI,KAAK,SAAQ;AACvB,aAAK,SAAS,CAAC,CAAC;AAChB,aAAK,OAAO;AACZ,aAAK,YAAY;AACjB,eAAO,CAAC,IAAG,GAAI,cAAc,UAAU,KAAK,SAAQ,CAAE,GAAG,OAAO,KAAK;AAAA,MACjF;AAEQ,UAAI,iBAAiB,CAAC,YAAY,YAAY,OAAO,CAAC,aAChD,KACA,KAAK,eAAe,IAAI;AAC9B,UAAI,mBAAmB,MAAM;AACzB,yBAAiB;AAAA,MAC7B;AACQ,UAAI,gBAAgB;AAChB,eAAO,MAAM,IAAI,OAAO,cAAc;AAAA,MAClD;AAEQ,UAAI,QAAQ;AACZ,UAAI,KAAK,SAAS,OAAO,KAAK,WAAW;AACrC,iBAAS,KAAK,QAAO,KAAM,CAAC,MAAM,aAAa,MAAM;AAAA,MACjE,OACa;AACD,cAAM,QAAQ,KAAK,SAAS;AAAA;AAAA,UAEpB,QACK,KAAK,QAAO,KAAM,CAAC,OAAO,CAAC,WAAW,aAAa,MACpD,OACA;AAAA,YACN,KAAK,SAAS,MACV,MACA,KAAK,SAAS,MACV,OACA,KAAK,SAAS,OAAO,iBACjB,MACA,KAAK,SAAS,OAAO,iBACjB,OACA,IAAI,KAAK,IAAI;AACnC,gBAAQ,QAAQ,OAAO;AAAA,MACnC;AACQ,aAAO;AAAA,QACH;AAAA,YACI,cAAc,UAAU,IAAI;AAAA,QAC/B,KAAK,YAAY,CAAC,CAAC,KAAK;AAAA,QACzB,KAAK;AAAA;IAEjB;AAAA,IACI,eAAe,KAAK;AAChB,aAAO,KAAK,OACP,IAAI,OAAK;AAGV,YAAI,OAAO,MAAM,UAAU;AACvB,gBAAM,IAAI,MAAM,8BAA8B;AAAA,QAC9D;AAGY,cAAM,CAAC,IAAI,GAAG,WAAW,KAAK,IAAI,EAAE,eAAe,GAAG;AACtD,aAAK,SAAS,KAAK,UAAU;AAC7B,eAAO;AAAA,MACnB,CAAS,EACI,OAAO,OAAK,EAAE,KAAK,QAAO,KAAM,KAAK,MAAK,MAAO,CAAC,CAAC,CAAC,EACpD,KAAK,GAAG;AAAA,IACrB;AAAA,IACI,OAAO,WAAW,MAAM,UAAU,UAAU,OAAO;AAC/C,UAAI,WAAW;AACf,UAAI,KAAK;AACT,UAAI,QAAQ;AACZ,eAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AAClC,cAAM,IAAI,KAAK,OAAO,CAAC;AACvB,YAAI,UAAU;AACV,qBAAW;AACX,iBAAO,WAAW,IAAI,CAAC,IAAI,OAAO,MAAM;AACxC;AAAA,QAChB;AACY,YAAI,MAAM,MAAM;AACZ,cAAI,MAAM,KAAK,SAAS,GAAG;AACvB,kBAAM;AAAA,UAC1B,OACqB;AACD,uBAAW;AAAA,UAC/B;AACgB;AAAA,QAChB;AACY,YAAI,MAAM,KAAK;AACX,gBAAM,CAAC,KAAK,WAAW,UAAU,KAAK,KAAI,GAAI,uBAAuB,YAAY,MAAM,CAAC;AACxF,cAAI,UAAU;AACV,kBAAM;AACN,oBAAQ,SAAS;AACjB,iBAAK,WAAW;AAChB,uBAAW,YAAY;AACvB;AAAA,UACpB;AAAA,QACA;AACY,YAAI,MAAM,KAAK;AACX,cAAI,WAAW,SAAS;AACpB,kBAAM;AAAA;AAEN,kBAAM;AACV,qBAAW;AACX;AAAA,QAChB;AACY,YAAI,MAAM,KAAK;AACX,gBAAM;AACN,qBAAW;AACX;AAAA,QAChB;AACY,cAAM,aAAa,CAAC;AAAA,MAChC;AACQ,aAAO,CAAC,KAAI,GAAI,cAAc,UAAU,IAAI,GAAG,CAAC,CAAC,UAAU,KAAK;AAAA,IACxE;AAAA,EACA;AACA,MAAA,MAAc;;;","x_google_ignoreList":[0]}