@volter/tabnode 0.2.14-volter.88 → 0.3.1

package/dist/assets/{runtime-worker-4MKaHFVb.js → runtime-worker-CUO9SNFs.js}

@@ -17,7 +17,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return __privateGet(obj, member, getter);
   }
 });
-var _a2, _b2, _asyncId, _triggerAsyncId, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j, _ptr, _type, _maxHeaderSize, _headerBytes, _headers, _field, _value, _readingValue, _url, _statusMessage, _headersSent, _paused, _buffer, _bufferPtr, _bufferSize, _connections, _HTTPParser_instances, reset_fn, copyIn_fn, pushHeader_fn, countHeaderBytes_fn, _parsers, _entries, _at, _encoding, _watcher, _timer, _previous, _strm, _writeState, _callback, _level, _strategy, _windowBits, _memLevel, _dictionary, _ended, _Zlib_instances, inflating_get, windowFor_fn, start_fn, fail_fn, report_fn, run_fn, end_fn, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options2, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, partsToRegExp_fn, parseGlob_fn, _resolveChain, _loadChain, _initializing, _initializeFailure, _RunModuleHooks_instances, run_fn2;
+var _a2, _b2, _asyncId, _triggerAsyncId, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j, _ptr, _type, _maxHeaderSize, _headerBytes, _headers, _field, _value, _readingValue, _url, _statusMessage, _headersSent, _paused, _buffer, _bufferPtr, _bufferSize, _connections, _HTTPParser_instances, reset_fn, copyIn_fn, pushHeader_fn, countHeaderBytes_fn, _parsers, _entries, _at, _encoding, _watcher, _timer, _previous, _strm, _writeState, _callback, _level, _strategy, _windowBits, _memLevel, _dictionary, _ended, _Zlib_instances, inflating_get, windowFor_fn, start_fn, fail_fn, report_fn, run_fn, end_fn, _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options2, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, canAdoptWithSpace_fn, canAdopt_fn, canAdoptType_fn, adoptWithSpace_fn, adopt_fn, canUsurpType_fn, canUsurp_fn, usurp_fn, flatten_fn, partsToRegExp_fn, parseGlob_fn, _Minimatch_instances, matchGlobstar_fn, matchGlobStarBodySections_fn, matchOne_fn, _resolveChain, _loadChain, _initializing, _initializeFailure, _RunModuleHooks_instances, run_fn2;
 function _mergeNamespaces(n8, m) {
   m.forEach(function(e2) {
     e2 && typeof e2 !== "string" && !Array.isArray(e2) && Object.keys(e2).forEach(function(k10) {
@@ -7913,11 +7913,11 @@ function answerFilesystem(method, args) {
   return answer2.apply(hostVfs, plain) ?? null;
 }
 const inodes = /* @__PURE__ */ new Map();
-let nextInode = 1;
+let nextInode$1 = 1;
 function inodeOf(path2) {
   let inode = inodes.get(path2);
   if (inode === void 0) {
-    inode = nextInode++;
+    inode = nextInode$1++;
     inodes.set(path2, inode);
   }
   return inode;
@@ -9431,6 +9431,8 @@ const fsBinding = {
       if ((flags & bits.excl) !== 0 && (flags & bits.create) !== 0 && exists) throw createNodeError$1("EEXIST", "open", name);
       if (!exists) {
         if ((flags & bits.create) === 0) throw createNodeError$1("ENOENT", "open", name);
+        const parent = name.slice(0, name.lastIndexOf("/")) || "/";
+        if (!tree2.statSync(parent).isDirectory()) throw createNodeError$1("ENOTDIR", "open", name);
         tree2.writeFileSync(name, "");
       } else if ((flags & bits.truncate) !== 0) {
         tree2.writeFileSync(name, "");
@@ -9443,6 +9445,7 @@ const fsBinding = {
   },
   close(fd2, req) {
     return answer(req, () => {
+      fileFor(fd2);
       openFiles.delete(fd2);
       return void 0;
     });
@@ -9451,6 +9454,7 @@ const fsBinding = {
   read(fd2, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 1) throw createNodeError$1("EBADF", "read", file.path);
       if (file.cached === void 0) file.cached = file.tree.readFileSync(file.path);
       const bytes2 = file.cached;
       const from = position === null || position === void 0 || position < 0 ? file.position : position;
@@ -9473,17 +9477,27 @@ const fsBinding = {
     });
   },
   /** Node's fast path for `readFile` with an encoding it can decode itself. */
-  readFileUtf8(path2, _flags) {
-    return vfs$1().readFileSync(asPath(path2), "utf8");
+  readFileUtf8(path2, flags) {
+    const owned = typeof path2 !== "number";
+    const fd2 = owned ? fsBinding.open(path2, flags, 438) : path2;
+    try {
+      const file = fileFor(fd2);
+      const bytes2 = new Uint8Array(file.tree.statSync(file.path).size);
+      const length = fsBinding.read(fd2, bytes2, 0, bytes2.length, -1);
+      return new TextDecoder().decode(bytes2.subarray(0, length));
+    } finally {
+      if (owned) fsBinding.close(fd2);
+    }
   },
   // ---- writing ------------------------------------------------------------
   writeBuffer(fd2, buffer2, offset2, length, position, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "write", file.path);
       const tree2 = file.tree;
       const slice = buffer2.subarray(offset2, offset2 + length);
       const existing = file.cached ?? (tree2.existsSync(file.path) ? tree2.readFileSync(file.path) : new Uint8Array(0));
-      const at3 = position === null || position === void 0 || position < 0 ? file.position : position;
+      const at3 = (file.flags & flagBits().append) !== 0 ? existing.length : position === null || position === void 0 || position < 0 ? file.position : position;
       const size = Math.max(existing.length, at3 + slice.length);
       const next2 = new Uint8Array(size);
       next2.set(existing, 0);
@@ -9513,15 +9527,14 @@ const fsBinding = {
     const bytes2 = encoding === "utf8" || encoding === void 0 || encoding === "utf-8" ? new TextEncoder().encode(value) : Uint8Array.from(value, (character) => character.charCodeAt(0) & 255);
     return fsBinding.writeBuffer(fd2, bytes2, 0, bytes2.length, position ?? null, req);
   },
-  writeFileUtf8(path2, data2, flags, _mode) {
-    const tree2 = vfs$1();
-    const name = asPath(path2);
-    if ((flags & flagBits().append) !== 0 && tree2.existsSync(name)) {
-      const existing = tree2.readFileSync(name, "utf8");
-      tree2.writeFileSync(name, existing + data2);
-      return void 0;
+  writeFileUtf8(path2, data2, flags, mode) {
+    const owned = typeof path2 !== "number";
+    const fd2 = owned ? fsBinding.open(path2, flags, mode) : path2;
+    try {
+      fsBinding.writeString(fd2, data2, null, "utf8");
+    } finally {
+      if (owned) fsBinding.close(fd2);
     }
-    tree2.writeFileSync(name, data2);
     return void 0;
   },
   // ---- metadata -----------------------------------------------------------
@@ -9802,6 +9815,7 @@ const fsBinding = {
   ftruncate(fd2, length, req) {
     return answer(req, () => {
       const file = fileFor(fd2);
+      if ((file.flags & 3) === 0) throw createNodeError$1("EBADF", "ftruncate", file.path);
       const tree2 = file.tree;
       const bytes2 = file.cached ?? tree2.readFileSync(file.path);
       const next2 = new Uint8Array(length);
@@ -16915,10 +16929,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -17038,7 +17059,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -17679,7 +17700,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -26091,6 +26112,16 @@ lazyExport("stream", "pipeline");
 lazyExport("stream", "finished");
 lazyModule("stream/promises");
 const streamPromisesModule = lazyModule("stream/promises");
+const nodeInodes = /* @__PURE__ */ new WeakMap();
+let nextInode = 1;
+function inodeFor(node) {
+  let inode = nodeInodes.get(node);
+  if (inode === void 0) {
+    inode = nextInode++;
+    nodeInodes.set(node, inode);
+  }
+  return inode;
+}
 function createNodeError(code2, syscall, path2, message) {
   const errno = {
     ENOENT: -2,
@@ -26407,7 +26438,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: Math.ceil(size / 512)
@@ -26446,7 +26477,7 @@ class VirtualFS {
       uid: 1e3,
       gid: 1e3,
       dev: 0,
-      ino: 0,
+      ino: inodeFor(node),
       rdev: 0,
       blksize: 4096,
       blocks: 0
@@ -27670,7 +27701,11 @@ const slashPattern = /\\\\/g;
 const openPattern = /\\{/g;
 const closePattern = /\\}/g;
 const commaPattern = /\\,/g;
-const periodPattern = /\\./g;
+const periodPattern = /\\\./g;
+const EXPANSION_MAX = 1e5;
+const EXPANSION_MAX_LENGTH = 4e6;
+const EXPANSION_MAX_DEPTH = 1e3;
+const EXPANSION_MAX_REWRITES = 1e3;
 function numeric(str) {
   return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
 }
@@ -27680,34 +27715,44 @@ function escapeBraces(str) {
 function unescapeBraces(str) {
   return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
 }
-function parseCommaParts(str) {
-  if (!str) {
-    return [""];
+function pushAll(target, items) {
+  for (let i10 = 0; i10 < items.length; i10++) {
+    target.push(items[i10]);
   }
+}
+function parseCommaParts(str) {
   const parts = [];
-  const m = balanced("{", "}", str);
-  if (!m) {
-    return str.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str) {
+  let carry = "";
+  for (; ; ) {
+    const m = balanced("{", "}", str);
+    if (!m) {
+      const tail = str.split(",");
+      tail[0] = carry + tail[0];
+      pushAll(parts, tail);
+      return parts;
+    }
+    const { pre, body, post } = m;
+    const p = pre.split(",");
+    p[0] = carry + p[0];
+    p[p.length - 1] += "{" + body + "}";
+    if (!post.length) {
+      pushAll(parts, p);
+      return parts;
+    }
+    carry = p.pop();
+    pushAll(parts, p);
+    str = post;
+  }
+}
+function expand(str, options = {}) {
   if (!str) {
     return [];
   }
+  const { max: max2 = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH, maxDepth = EXPANSION_MAX_DEPTH, maxRewrites = EXPANSION_MAX_REWRITES } = options;
   if (str.slice(0, 2) === "{}") {
     str = "\\{\\}" + str.slice(2);
   }
-  return expand_(escapeBraces(str), true).map(unescapeBraces);
+  return expand_(escapeBraces(str), max2, maxLength, maxDepth, 0, maxRewrites, true).map(unescapeBraces);
 }
 function embrace(str) {
   return "{" + str + "}";
@@ -27721,95 +27766,152 @@ function lte(i10, y) {
 function gte(i10, y) {
   return i10 >= y;
 }
-function expand_(str, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str);
-  if (!m)
+function combine(acc, pre, values, max2, maxLength, dropEmpties) {
+  const out = [];
+  let length = 0;
+  for (let a = 0; a < acc.length; a++) {
+    for (let v2 = 0; v2 < values.length; v2++) {
+      if (out.length >= max2)
+        return out;
+      const expansion = acc[a] + pre + values[v2];
+      if (dropEmpties && !expansion)
+        continue;
+      if (length + expansion.length > maxLength)
+        return out;
+      out.push(expansion);
+      length += expansion.length;
+    }
+  }
+  return out;
+}
+function expandSequence(body, isAlphaSequence, max2, maxLength) {
+  const n8 = body.split(/\.\./);
+  const N = [];
+  if (n8[0] === void 0 || n8[1] === void 0) {
+    return N;
+  }
+  const x = numeric(n8[0]);
+  const y = numeric(n8[1]);
+  const width = Math.max(n8[0].length, n8[1].length);
+  let incr = n8.length === 3 && n8[2] !== void 0 ? Math.max(Math.abs(numeric(n8[2])), 1) : 1;
+  let test = lte;
+  const reverse2 = y < x;
+  if (reverse2) {
+    incr *= -1;
+    test = gte;
+  }
+  const pad = n8.some(isPadded);
+  let length = 0;
+  for (let i10 = x; test(i10, y) && N.length < max2; i10 += incr) {
+    let c;
+    if (isAlphaSequence) {
+      c = String.fromCharCode(i10);
+      if (c === "\\") {
+        c = "";
+      }
+    } else {
+      c = String(i10);
+      if (pad) {
+        const need = width - c.length;
+        if (need > 0) {
+          const z10 = new Array(need + 1).join("0");
+          if (i10 < 0) {
+            c = "-" + z10 + c.slice(1);
+          } else {
+            c = z10 + c;
+          }
+        }
+      }
+    }
+    if (length + c.length > maxLength)
+      break;
+    N.push(c);
+    length += c.length;
+  }
+  return N;
+}
+function expand_(str, max2, maxLength, maxDepth, depth, maxRewrites, isTop) {
+  if (depth > maxDepth) {
     return [str];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k10 = 0; k10 < post.length; k10++) {
-      const expansion = pre + "{" + m.body + "}" + post[k10];
-      expansions.push(expansion);
+  }
+  let acc = [""];
+  let rewrites = 0;
+  let dropEmpties = false;
+  let firstGroup = true;
+  for (; ; ) {
+    const m = balanced("{", "}", str);
+    if (!m) {
+      return combine(acc, str, [""], max2, maxLength, dropEmpties);
+    }
+    const pre = m.pre;
+    if (/\$$/.test(pre)) {
+      acc = combine(acc, pre + "{" + m.body + "}", [""], max2, maxLength, dropEmpties && !m.post.length);
+      firstGroup = false;
+      if (!m.post.length)
+        break;
+      str = m.post;
+      continue;
     }
-  } else {
     const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
     const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
     const isSequence = isNumericSequence || isAlphaSequence;
     const isOptions = m.body.indexOf(",") >= 0;
     if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
+      if (rewrites < maxRewrites && m.post.match(/,(?!,).*\}/)) {
+        rewrites++;
         str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str);
+        isTop = true;
+        continue;
       }
-      return [str];
+      return combine(acc, pre + "{" + m.body + "}" + m.post, [""], max2, maxLength, dropEmpties);
+    }
+    if (firstGroup) {
+      dropEmpties = isTop && !isSequence;
+      firstGroup = false;
     }
-    let n8;
+    let values;
     if (isSequence) {
-      n8 = m.body.split(/\.\./);
+      values = expandSequence(m.body, isAlphaSequence, max2, maxLength);
     } else {
-      n8 = parseCommaParts(m.body);
+      let n8 = parseCommaParts(m.body);
       if (n8.length === 1 && n8[0] !== void 0) {
-        n8 = expand_(n8[0], false).map(embrace);
+        n8 = expand_(n8[0], max2, maxLength, maxDepth, depth + 1, maxRewrites, false).map(embrace);
         if (n8.length === 1) {
-          return post.map((p) => m.pre + n8[0] + p);
+          acc = combine(acc, pre + n8[0], [""], max2, maxLength, dropEmpties && !m.post.length);
+          if (!m.post.length)
+            break;
+          str = m.post;
+          continue;
         }
       }
-    }
-    let N;
-    if (isSequence && n8[0] !== void 0 && n8[1] !== void 0) {
-      const x = numeric(n8[0]);
-      const y = numeric(n8[1]);
-      const width = Math.max(n8[0].length, n8[1].length);
-      let incr = n8.length === 3 && n8[2] !== void 0 ? Math.abs(numeric(n8[2])) : 1;
-      let test = lte;
-      const reverse2 = y < x;
-      if (reverse2) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n8.some(isPadded);
-      N = [];
-      for (let i10 = x; test(i10, y); i10 += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i10);
-          if (c === "\\") {
-            c = "";
-          }
-        } else {
-          c = String(i10);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z10 = new Array(need + 1).join("0");
-              if (i10 < 0) {
-                c = "-" + z10 + c.slice(1);
-              } else {
-                c = z10 + c;
-              }
-            }
-          }
+      let dropsEmpties = dropEmpties && !m.post.length && !pre;
+      for (let d = 0; dropsEmpties && d < acc.length; d++) {
+        if (acc[d]) {
+          dropsEmpties = false;
         }
-        N.push(c);
       }
-    } else {
-      N = [];
-      for (let j = 0; j < n8.length; j++) {
-        N.push.apply(N, expand_(n8[j], false));
-      }
-    }
-    for (let j = 0; j < N.length; j++) {
-      for (let k10 = 0; k10 < post.length; k10++) {
-        const expansion = pre + N[j] + post[k10];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
+      values = [];
+      let valuesLength = 0;
+      outer: for (let j = 0; j < n8.length; j++) {
+        const expanded = expand_(n8[j], max2, maxLength, maxDepth, depth + 1, maxRewrites, false);
+        for (let k10 = 0; k10 < expanded.length; k10++) {
+          const v2 = expanded[k10];
+          if (dropsEmpties && !v2)
+            continue;
+          if (values.length >= max2 || valuesLength + v2.length > maxLength) {
+            break outer;
+          }
+          values.push(v2);
+          valuesLength += v2.length;
         }
       }
     }
+    acc = combine(acc, pre, values, max2, maxLength, dropEmpties && !m.post.length);
+    if (!m.post.length)
+      break;
+    str = m.post;
   }
-  return expansions;
+  return acc;
 }
 const MAX_PATTERN_LENGTH = 1024 * 64;
 const assertValidPattern = (pattern) => {
@@ -27929,12 +28031,60 @@ const parseClass = (glob, position) => {
 };
 const unescape = (s10, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
   if (magicalBraces) {
-    return windowsPathsNoEscape ? s10.replace(/\[([^\/\\])\]/g, "$1") : s10.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+    return windowsPathsNoEscape ? s10.replace(/\[([^/\\])\]/g, "$1") : s10.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
   }
-  return windowsPathsNoEscape ? s10.replace(/\[([^\/\\{}])\]/g, "$1") : s10.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+  return windowsPathsNoEscape ? s10.replace(/\[([^/\\{}])\]/g, "$1") : s10.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
 };
+var _a$1;
 const types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
 const isExtglobType = (c) => types.has(c);
+const isExtglobAST = (c) => isExtglobType(c.type);
+const adoptionMap = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]);
+const adoptionWithSpaceMap = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]);
+const adoptionAnyMap = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]);
+const usurpMap = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]);
 const startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
 const startNoDot = "(?!\\.)";
 const addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
@@ -27944,7 +28094,8 @@ const regExpEscape$1 = (s10) => s10.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 const qmark$1 = "[^/]";
 const star$1 = qmark$1 + "*?";
 const starNoEmpty = qmark$1 + "+?";
-const _AST = class _AST {
+let ID = 0;
+class AST {
   constructor(type2, parent, options = {}) {
     __privateAdd(this, _AST_instances);
     __publicField(this, "type");
@@ -27961,6 +28112,7 @@ const _AST = class _AST {
     // set to true if it's an extglob with no children
     // (which really means one child of '')
     __privateAdd(this, _emptyExt, false);
+    __publicField(this, "id", ++ID);
     this.type = type2;
     if (type2)
       __privateSet(this, _hasMagic, true);
@@ -27972,6 +28124,23 @@ const _AST = class _AST {
       __privateGet(this, _negs).push(this);
     __privateSet(this, _parentIndex, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0);
   }
+  get depth() {
+    var _a3;
+    return (((_a3 = __privateGet(this, _parent)) == null ? void 0 : _a3.depth) ?? -1) + 1;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    var _a3;
+    return {
+      "@@type": "AST",
+      id: this.id,
+      type: this.type,
+      root: __privateGet(this, _root).id,
+      parent: (_a3 = __privateGet(this, _parent)) == null ? void 0 : _a3.id,
+      depth: this.depth,
+      partsLength: __privateGet(this, _parts).length,
+      parts: __privateGet(this, _parts)
+    };
+  }
   get hasMagic() {
     if (__privateGet(this, _hasMagic) !== void 0)
       return __privateGet(this, _hasMagic);
@@ -27985,19 +28154,13 @@ const _AST = class _AST {
   }
   // reconstructs the pattern
   toString() {
-    if (__privateGet(this, _toString) !== void 0)
-      return __privateGet(this, _toString);
-    if (!this.type) {
-      return __privateSet(this, _toString, __privateGet(this, _parts).map((p) => String(p)).join(""));
-    } else {
-      return __privateSet(this, _toString, this.type + "(" + __privateGet(this, _parts).map((p) => String(p)).join("|") + ")");
-    }
+    return __privateGet(this, _toString) !== void 0 ? __privateGet(this, _toString) : !this.type ? __privateSet(this, _toString, __privateGet(this, _parts).map((p) => String(p)).join("")) : __privateSet(this, _toString, this.type + "(" + __privateGet(this, _parts).map((p) => String(p)).join("|") + ")");
   }
   push(...parts) {
     for (const p of parts) {
       if (p === "")
         continue;
-      if (typeof p !== "string" && !(p instanceof _AST && __privateGet(p, _parent) === this)) {
+      if (typeof p !== "string" && !(p instanceof _a$1 && __privateGet(p, _parent) === this)) {
         throw new Error("invalid part: " + p);
       }
       __privateGet(this, _parts).push(p);
@@ -28024,7 +28187,7 @@ const _AST = class _AST {
     const p = __privateGet(this, _parent);
     for (let i10 = 0; i10 < __privateGet(this, _parentIndex); i10++) {
       const pp2 = __privateGet(p, _parts)[i10];
-      if (!(pp2 instanceof _AST && pp2.type === "!")) {
+      if (!(pp2 instanceof _a$1 && pp2.type === "!")) {
         return false;
       }
     }
@@ -28050,7 +28213,7 @@ const _AST = class _AST {
       this.push(part.clone(this));
   }
   clone(parent) {
-    const c = new _AST(this.type, parent);
+    const c = new _a$1(this.type, parent);
     for (const p of __privateGet(this, _parts)) {
       c.copyIn(p);
     }
@@ -28058,8 +28221,8 @@ const _AST = class _AST {
   }
   static fromGlob(pattern, options = {}) {
     var _a3;
-    const ast = new _AST(null, void 0, options);
-    __privateMethod(_a3 = _AST, _AST_static, parseAST_fn).call(_a3, pattern, ast, 0, options);
+    const ast = new _a$1(null, void 0, options);
+    __privateMethod(_a3 = _a$1, _AST_static, parseAST_fn).call(_a3, pattern, ast, 0, options, 0);
     return ast;
   }
   // returns the regular expression if there's magic, or the unescaped
@@ -28154,13 +28317,15 @@ const _AST = class _AST {
   toRegExpSource(allowDot) {
     var _a3;
     const dot = allowDot ?? !!__privateGet(this, _options2).dot;
-    if (__privateGet(this, _root) === this)
+    if (__privateGet(this, _root) === this) {
+      __privateMethod(this, _AST_instances, flatten_fn).call(this);
       __privateMethod(this, _AST_instances, fillNegs_fn).call(this);
-    if (!this.type) {
+    }
+    if (!isExtglobAST(this)) {
       const noEmpty = this.isStart() && this.isEnd() && !__privateGet(this, _parts).some((s10) => typeof s10 !== "string");
       const src = __privateGet(this, _parts).map((p) => {
         var _a4;
-        const [re2, _, hasMagic, uflag] = typeof p === "string" ? __privateMethod(_a4 = _AST, _AST_static, parseGlob_fn).call(_a4, p, __privateGet(this, _hasMagic), noEmpty) : p.toRegExpSource(allowDot);
+        const [re2, _, hasMagic, uflag] = typeof p === "string" ? __privateMethod(_a4 = _a$1, _AST_static, parseGlob_fn).call(_a4, p, __privateGet(this, _hasMagic), noEmpty) : p.toRegExpSource(allowDot);
         __privateSet(this, _hasMagic, __privateGet(this, _hasMagic) || hasMagic);
         __privateSet(this, _uflag, __privateGet(this, _uflag) || uflag);
         return re2;
@@ -28199,9 +28364,10 @@ const _AST = class _AST {
     let body = __privateMethod(this, _AST_instances, partsToRegExp_fn).call(this, dot);
     if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
       const s10 = this.toString();
-      __privateSet(this, _parts, [s10]);
-      this.type = null;
-      __privateSet(this, _hasMagic, void 0);
+      const me = this;
+      __privateSet(me, _parts, [s10]);
+      me.type = null;
+      __privateSet(me, _hasMagic, void 0);
       return [s10, unescape(this.toString()), false, false];
     }
     let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : __privateMethod(this, _AST_instances, partsToRegExp_fn).call(this, true);
@@ -28228,7 +28394,7 @@ const _AST = class _AST {
       __privateGet(this, _uflag)
     ];
   }
-};
+}
 _root = new WeakMap();
 _hasMagic = new WeakMap();
 _uflag = new WeakMap();
@@ -28270,8 +28436,9 @@ fillNegs_fn = function() {
   return this;
 };
 _AST_static = new WeakSet();
-parseAST_fn = function(str, ast, pos, opt) {
-  var _a3, _b3;
+parseAST_fn = function(str, ast, pos, opt, extDepth) {
+  var _a3, _b3, _c3, _d3;
+  const maxDepth = opt.maxExtglobRecursion ?? 2;
   let escaping = false;
   let inBrace = false;
   let braceStart = -1;
@@ -28303,11 +28470,12 @@ parseAST_fn = function(str, ast, pos, opt) {
         acc2 += c;
         continue;
       }
-      if (!opt.noext && isExtglobType(c) && str.charAt(i11) === "(") {
+      const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i11) === "(" && extDepth <= maxDepth;
+      if (doRecurse) {
         ast.push(acc2);
         acc2 = "";
-        const ext2 = new _AST(c, ast);
-        i11 = __privateMethod(_a3 = _AST, _AST_static, parseAST_fn).call(_a3, str, ext2, i11, opt);
+        const ext2 = new _a$1(c, ast);
+        i11 = __privateMethod(_a3 = _a$1, _AST_static, parseAST_fn).call(_a3, str, ext2, i11, opt, extDepth + 1);
         ast.push(ext2);
         continue;
       }
@@ -28317,7 +28485,7 @@ parseAST_fn = function(str, ast, pos, opt) {
     return i11;
   }
   let i10 = pos + 1;
-  let part = new _AST(null, ast);
+  let part = new _a$1(null, ast);
   const parts = [];
   let acc = "";
   while (i10 < str.length) {
@@ -28344,19 +28512,22 @@ parseAST_fn = function(str, ast, pos, opt) {
       acc += c;
       continue;
     }
-    if (isExtglobType(c) && str.charAt(i10) === "(") {
+    const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i10) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+    (extDepth <= maxDepth || ast && __privateMethod(_b3 = ast, _AST_instances, canAdoptType_fn).call(_b3, c));
+    if (doRecurse) {
+      const depthAdd = ast && __privateMethod(_c3 = ast, _AST_instances, canAdoptType_fn).call(_c3, c) ? 0 : 1;
       part.push(acc);
       acc = "";
-      const ext2 = new _AST(c, part);
+      const ext2 = new _a$1(c, part);
       part.push(ext2);
-      i10 = __privateMethod(_b3 = _AST, _AST_static, parseAST_fn).call(_b3, str, ext2, i10, opt);
+      i10 = __privateMethod(_d3 = _a$1, _AST_static, parseAST_fn).call(_d3, str, ext2, i10, opt, extDepth + depthAdd);
       continue;
     }
     if (c === "|") {
       part.push(acc);
       acc = "";
       parts.push(part);
-      part = new _AST(null, ast);
+      part = new _a$1(null, ast);
       continue;
     }
     if (c === ")") {
@@ -28375,6 +28546,102 @@ parseAST_fn = function(str, ast, pos, opt) {
   __privateSet(ast, _parts, [str.substring(pos - 1)]);
   return i10;
 };
+canAdoptWithSpace_fn = function(child) {
+  return __privateMethod(this, _AST_instances, canAdopt_fn).call(this, child, adoptionWithSpaceMap);
+};
+canAdopt_fn = function(child, map = adoptionMap) {
+  if (!child || typeof child !== "object" || child.type !== null || __privateGet(child, _parts).length !== 1 || this.type === null) {
+    return false;
+  }
+  const gc2 = __privateGet(child, _parts)[0];
+  if (!gc2 || typeof gc2 !== "object" || gc2.type === null) {
+    return false;
+  }
+  return __privateMethod(this, _AST_instances, canAdoptType_fn).call(this, gc2.type, map);
+};
+canAdoptType_fn = function(c, map = adoptionAnyMap) {
+  var _a3;
+  return !!((_a3 = map.get(this.type)) == null ? void 0 : _a3.includes(c));
+};
+adoptWithSpace_fn = function(child, index2) {
+  const gc2 = __privateGet(child, _parts)[0];
+  const blank = new _a$1(null, gc2, this.options);
+  __privateGet(blank, _parts).push("");
+  gc2.push(blank);
+  __privateMethod(this, _AST_instances, adopt_fn).call(this, child, index2);
+};
+adopt_fn = function(child, index2) {
+  const gc2 = __privateGet(child, _parts)[0];
+  __privateGet(this, _parts).splice(index2, 1, ...__privateGet(gc2, _parts));
+  for (const p of __privateGet(gc2, _parts)) {
+    if (typeof p === "object")
+      __privateSet(p, _parent, this);
+  }
+  __privateSet(this, _toString, void 0);
+};
+canUsurpType_fn = function(c) {
+  const m = usurpMap.get(this.type);
+  return !!(m == null ? void 0 : m.has(c));
+};
+canUsurp_fn = function(child) {
+  if (!child || typeof child !== "object" || child.type !== null || __privateGet(child, _parts).length !== 1 || this.type === null || __privateGet(this, _parts).length !== 1) {
+    return false;
+  }
+  const gc2 = __privateGet(child, _parts)[0];
+  if (!gc2 || typeof gc2 !== "object" || gc2.type === null) {
+    return false;
+  }
+  return __privateMethod(this, _AST_instances, canUsurpType_fn).call(this, gc2.type);
+};
+usurp_fn = function(child) {
+  const m = usurpMap.get(this.type);
+  const gc2 = __privateGet(child, _parts)[0];
+  const nt2 = m == null ? void 0 : m.get(gc2.type);
+  if (!nt2)
+    return false;
+  __privateSet(this, _parts, __privateGet(gc2, _parts));
+  for (const p of __privateGet(this, _parts)) {
+    if (typeof p === "object") {
+      __privateSet(p, _parent, this);
+    }
+  }
+  this.type = nt2;
+  __privateSet(this, _toString, void 0);
+  __privateSet(this, _emptyExt, false);
+};
+flatten_fn = function() {
+  var _a3, _b3;
+  if (!isExtglobAST(this)) {
+    for (const p of __privateGet(this, _parts)) {
+      if (typeof p === "object") {
+        __privateMethod(_a3 = p, _AST_instances, flatten_fn).call(_a3);
+      }
+    }
+  } else {
+    let iterations = 0;
+    let done = false;
+    do {
+      done = true;
+      for (let i10 = 0; i10 < __privateGet(this, _parts).length; i10++) {
+        const c = __privateGet(this, _parts)[i10];
+        if (typeof c === "object") {
+          __privateMethod(_b3 = c, _AST_instances, flatten_fn).call(_b3);
+          if (__privateMethod(this, _AST_instances, canAdopt_fn).call(this, c)) {
+            done = false;
+            __privateMethod(this, _AST_instances, adopt_fn).call(this, c, i10);
+          } else if (__privateMethod(this, _AST_instances, canAdoptWithSpace_fn).call(this, c)) {
+            done = false;
+            __privateMethod(this, _AST_instances, adoptWithSpace_fn).call(this, c, i10);
+          } else if (__privateMethod(this, _AST_instances, canUsurp_fn).call(this, c)) {
+            done = false;
+            __privateMethod(this, _AST_instances, usurp_fn).call(this, c);
+          }
+        }
+      }
+    } while (!done && ++iterations < 10);
+  }
+  __privateSet(this, _toString, void 0);
+};
 partsToRegExp_fn = function(dot) {
   return __privateGet(this, _parts).map((p) => {
     if (typeof p === "string") {
@@ -28389,6 +28656,7 @@ parseGlob_fn = function(glob, hasMagic, noEmpty = false) {
   let escaping = false;
   let re2 = "";
   let uflag = false;
+  let inStar = false;
   for (let i10 = 0; i10 < glob.length; i10++) {
     const c = glob.charAt(i10);
     if (escaping) {
@@ -28396,6 +28664,16 @@ parseGlob_fn = function(glob, hasMagic, noEmpty = false) {
       re2 += (reSpecials.has(c) ? "\\" : "") + c;
       continue;
     }
+    if (c === "*") {
+      if (inStar)
+        continue;
+      inStar = true;
+      re2 += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star$1;
+      hasMagic = true;
+      continue;
+    } else {
+      inStar = false;
+    }
     if (c === "\\") {
       if (i10 === glob.length - 1) {
         re2 += "\\\\";
@@ -28414,11 +28692,6 @@ parseGlob_fn = function(glob, hasMagic, noEmpty = false) {
         continue;
       }
     }
-    if (c === "*") {
-      re2 += noEmpty && glob === "*" ? starNoEmpty : star$1;
-      hasMagic = true;
-      continue;
-    }
     if (c === "?") {
       re2 += qmark$1;
       hasMagic = true;
@@ -28428,8 +28701,8 @@ parseGlob_fn = function(glob, hasMagic, noEmpty = false) {
   }
   return [re2, unescape(glob), !!hasMagic, uflag];
 };
-__privateAdd(_AST, _AST_static);
-let AST = _AST;
+__privateAdd(AST, _AST_static);
+_a$1 = AST;
 const escape = (s10, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
   if (magicalBraces) {
     return windowsPathsNoEscape ? s10.replace(/[?*()[\]{}]/g, "[$&]") : s10.replace(/[?*()[\]\\{}]/g, "\\$&");
@@ -28444,7 +28717,7 @@ const minimatch = (p, pattern, options = {}) => {
   }
   return new Minimatch(pattern, options).match(p);
 };
-const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+const starDotExtRE = /^\*+([^+@!?*[(]*)$/;
 const starDotExtTest = (ext2) => (f10) => !f10.startsWith(".") && f10.endsWith(ext2);
 const starDotExtTestDot = (ext2) => (f10) => f10.endsWith(ext2);
 const starDotExtTestNocase = (ext2) => {
@@ -28463,7 +28736,7 @@ const dotStarTest = (f10) => f10 !== "." && f10 !== ".." && f10.startsWith(".");
 const starRE = /^\*+$/;
 const starTest = (f10) => f10.length !== 0 && !f10.startsWith(".");
 const starTestDot = (f10) => f10.length !== 0 && f10 !== "." && f10 !== "..";
-const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+const qmarksRE = /^\?+([^+@!?*[(]*)?$/;
 const qmarksTestNocase = ([$02, ext2 = ""]) => {
   const noext = qmarksTestNoExt([$02]);
   if (!ext2)
@@ -28552,7 +28825,7 @@ const braceExpand = (pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return expand(pattern);
+  return expand(pattern, { max: options.braceExpandMax });
 };
 minimatch.braceExpand = braceExpand;
 const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
@@ -28570,6 +28843,7 @@ const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
 const regExpEscape = (s10) => s10.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 class Minimatch {
   constructor(pattern, options = {}) {
+    __privateAdd(this, _Minimatch_instances);
     __publicField(this, "options");
     __publicField(this, "set");
     __publicField(this, "pattern");
@@ -28586,14 +28860,17 @@ class Minimatch {
     __publicField(this, "isWindows");
     __publicField(this, "platform");
     __publicField(this, "windowsNoMagicRoot");
+    __publicField(this, "maxGlobstarRecursion");
     __publicField(this, "regexp");
     assertValidPattern(pattern);
     options = options || {};
     this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
     this.pattern = pattern;
     this.platform = options.platform || defaultPlatform;
     this.isWindows = this.platform === "win32";
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    const awe = "allowWindowsEscape";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
     if (this.windowsPathsNoEscape) {
       this.pattern = this.pattern.replace(/\\/g, "/");
     }
@@ -28650,7 +28927,10 @@ class Minimatch {
         const isUNC = s10[0] === "" && s10[1] === "" && (s10[2] === "?" || !globMagic.test(s10[2])) && !globMagic.test(s10[3]);
         const isDrive = /^[a-z]:/i.test(s10[0]);
         if (isUNC) {
-          return [...s10.slice(0, 4), ...s10.slice(4).map((ss2) => this.parse(ss2))];
+          return [
+            ...s10.slice(0, 4),
+            ...s10.slice(4).map((ss2) => this.parse(ss2))
+          ];
         } else if (isDrive) {
           return [s10[0], ...s10.slice(1).map((ss2) => this.parse(ss2))];
         }
@@ -28676,10 +28956,10 @@ class Minimatch {
   // of patterns that we have to process.
   preprocess(globParts) {
     if (this.options.noglobstar) {
-      for (let i10 = 0; i10 < globParts.length; i10++) {
-        for (let j = 0; j < globParts[i10].length; j++) {
-          if (globParts[i10][j] === "**") {
-            globParts[i10][j] = "*";
+      for (const partset of globParts) {
+        for (let j = 0; j < partset.length; j++) {
+          if (partset[j] === "**") {
+            partset[j] = "*";
           }
         }
       }
@@ -28757,7 +29037,7 @@ class Minimatch {
       let dd2 = 0;
       while (-1 !== (dd2 = parts.indexOf("..", dd2 + 1))) {
         const p = parts[dd2 - 1];
-        if (p && p !== "." && p !== ".." && p !== "**") {
+        if (p && p !== "." && p !== ".." && p !== "**" && !(this.isWindows && /^[a-z]:$/i.test(p))) {
           didSomething = true;
           parts.splice(dd2 - 1, 2);
           dd2 -= 2;
@@ -28922,7 +29202,8 @@ class Minimatch {
   // out of pattern, then that's fine, as long as all
   // the parts match.
   matchOne(file, pattern, partial = false) {
-    const options = this.options;
+    let fileStartIndex = 0;
+    let patternStartIndex = 0;
     if (this.isWindows) {
       const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
       const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
@@ -28931,14 +29212,14 @@ class Minimatch {
       const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
       const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
       if (typeof fdi === "number" && typeof pdi === "number") {
-        const [fd2, pd2] = [file[fdi], pattern[pdi]];
+        const [fd2, pd2] = [
+          file[fdi],
+          pattern[pdi]
+        ];
         if (fd2.toLowerCase() === pd2.toLowerCase()) {
           pattern[pdi] = fd2;
-          if (pdi > fdi) {
-            pattern = pattern.slice(pdi);
-          } else if (fdi > pdi) {
-            file = file.slice(fdi);
-          }
+          patternStartIndex = pdi;
+          fileStartIndex = fdi;
         }
       }
     }
@@ -28946,71 +29227,10 @@ class Minimatch {
     if (optimizationLevel >= 2) {
       file = this.levelTwoFileOptimize(file);
     }
-    this.debug("matchOne", this, { file, pattern });
-    this.debug("matchOne", file.length, pattern.length);
-    for (var fi2 = 0, pi2 = 0, fl2 = file.length, pl2 = pattern.length; fi2 < fl2 && pi2 < pl2; fi2++, pi2++) {
-      this.debug("matchOne loop");
-      var p = pattern[pi2];
-      var f10 = file[fi2];
-      this.debug(pattern, p, f10);
-      if (p === false) {
-        return false;
-      }
-      if (p === GLOBSTAR) {
-        this.debug("GLOBSTAR", [pattern, p, f10]);
-        var fr2 = fi2;
-        var pr2 = pi2 + 1;
-        if (pr2 === pl2) {
-          this.debug("** at the end");
-          for (; fi2 < fl2; fi2++) {
-            if (file[fi2] === "." || file[fi2] === ".." || !options.dot && file[fi2].charAt(0) === ".")
-              return false;
-          }
-          return true;
-        }
-        while (fr2 < fl2) {
-          var swallowee = file[fr2];
-          this.debug("\nglobstar while", file, fr2, pattern, pr2, swallowee);
-          if (this.matchOne(file.slice(fr2), pattern.slice(pr2), partial)) {
-            this.debug("globstar found match!", fr2, fl2, swallowee);
-            return true;
-          } else {
-            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-              this.debug("dot detected!", file, fr2, pattern, pr2);
-              break;
-            }
-            this.debug("globstar swallow a segment, and continue");
-            fr2++;
-          }
-        }
-        if (partial) {
-          this.debug("\n>>> no match, partial?", file, fr2, pattern, pr2);
-          if (fr2 === fl2) {
-            return true;
-          }
-        }
-        return false;
-      }
-      let hit;
-      if (typeof p === "string") {
-        hit = f10 === p;
-        this.debug("string match", p, f10, hit);
-      } else {
-        hit = p.test(f10);
-        this.debug("pattern match", p, f10, hit);
-      }
-      if (!hit)
-        return false;
-    }
-    if (fi2 === fl2 && pi2 === pl2) {
-      return true;
-    } else if (fi2 === fl2) {
-      return partial;
-    } else if (pi2 === pl2) {
-      return fi2 === fl2 - 1 && file[fi2] === "";
-    } else {
-      throw new Error("wtf?");
+    if (pattern.includes(GLOBSTAR)) {
+      return __privateMethod(this, _Minimatch_instances, matchGlobstar_fn).call(this, file, pattern, partial, fileStartIndex, patternStartIndex);
     }
+    return __privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, pattern, partial, fileStartIndex, patternStartIndex);
   }
   braceExpand() {
     return braceExpand(this.pattern, this.options);
@@ -29098,7 +29318,7 @@ class Minimatch {
       re2 = "^(?!" + re2 + ").+$";
     try {
       this.regexp = new RegExp(re2, [...flags].join(""));
-    } catch (ex2) {
+    } catch {
       this.regexp = false;
     }
     return this.regexp;
@@ -29106,7 +29326,7 @@ class Minimatch {
   slashSplit(p) {
     if (this.preserveMultipleSlashes) {
       return p.split("/");
-    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+    } else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
       return ["", ...p.split(/\/+/)];
     } else {
       return p.split(/\/+/);
@@ -29137,8 +29357,7 @@ class Minimatch {
         filename = ff2[i10];
       }
     }
-    for (let i10 = 0; i10 < set.length; i10++) {
-      const pattern = set[i10];
+    for (const pattern of set) {
       let file = ff2;
       if (options.matchBase && pattern.length === 1) {
         file = [filename];
@@ -29160,6 +29379,142 @@ class Minimatch {
     return minimatch.defaults(def).Minimatch;
   }
 }
+_Minimatch_instances = new WeakSet();
+matchGlobstar_fn = function(file, pattern, partial, fileIndex, patternIndex) {
+  const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+  const lastgs = pattern.lastIndexOf(GLOBSTAR);
+  const [head, body, tail] = partial ? [
+    pattern.slice(patternIndex, firstgs),
+    pattern.slice(firstgs + 1),
+    []
+  ] : [
+    pattern.slice(patternIndex, firstgs),
+    pattern.slice(firstgs + 1, lastgs),
+    pattern.slice(lastgs + 1)
+  ];
+  if (head.length) {
+    const fileHead = file.slice(fileIndex, fileIndex + head.length);
+    if (!__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, fileHead, head, partial, 0, 0)) {
+      return false;
+    }
+    fileIndex += head.length;
+    patternIndex += head.length;
+  }
+  let fileTailMatch = 0;
+  if (tail.length) {
+    if (tail.length + fileIndex > file.length)
+      return false;
+    let tailStart = file.length - tail.length;
+    if (__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, tail, partial, tailStart, 0)) {
+      fileTailMatch = tail.length;
+    } else {
+      if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
+        return false;
+      }
+      tailStart--;
+      if (!__privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file, tail, partial, tailStart, 0)) {
+        return false;
+      }
+      fileTailMatch = tail.length + 1;
+    }
+  }
+  if (!body.length) {
+    let sawSome = !!fileTailMatch;
+    for (let i22 = fileIndex; i22 < file.length - fileTailMatch; i22++) {
+      const f10 = String(file[i22]);
+      sawSome = true;
+      if (f10 === "." || f10 === ".." || !this.options.dot && f10.startsWith(".")) {
+        return false;
+      }
+    }
+    return partial || sawSome;
+  }
+  const bodySegments = [[[], 0]];
+  let currentBody = bodySegments[0];
+  let nonGsParts = 0;
+  const nonGsPartsSums = [0];
+  for (const b of body) {
+    if (b === GLOBSTAR) {
+      nonGsPartsSums.push(nonGsParts);
+      currentBody = [[], 0];
+      bodySegments.push(currentBody);
+    } else {
+      currentBody[0].push(b);
+      nonGsParts++;
+    }
+  }
+  let i10 = bodySegments.length - 1;
+  const fileLength = file.length - fileTailMatch;
+  for (const b of bodySegments) {
+    b[1] = fileLength - (nonGsPartsSums[i10--] + b[0].length);
+  }
+  return !!__privateMethod(this, _Minimatch_instances, matchGlobStarBodySections_fn).call(this, file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+};
+// return false for "nope, not matching"
+// return null for "not matching, cannot keep trying"
+matchGlobStarBodySections_fn = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+  const bs2 = bodySegments[bodyIndex];
+  if (!bs2) {
+    for (let i10 = fileIndex; i10 < file.length; i10++) {
+      sawTail = true;
+      const f10 = file[i10];
+      if (f10 === "." || f10 === ".." || !this.options.dot && f10.startsWith(".")) {
+        return false;
+      }
+    }
+    return sawTail;
+  }
+  const [body, after] = bs2;
+  while (fileIndex <= after) {
+    const m = __privateMethod(this, _Minimatch_instances, matchOne_fn).call(this, file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+    if (m && globStarDepth < this.maxGlobstarRecursion) {
+      const sub = __privateMethod(this, _Minimatch_instances, matchGlobStarBodySections_fn).call(this, file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+      if (sub !== false) {
+        return sub;
+      }
+    }
+    const f10 = file[fileIndex];
+    if (f10 === "." || f10 === ".." || !this.options.dot && f10.startsWith(".")) {
+      return false;
+    }
+    fileIndex++;
+  }
+  return partial || null;
+};
+matchOne_fn = function(file, pattern, partial, fileIndex, patternIndex) {
+  let fi2;
+  let pi2;
+  let pl2;
+  let fl2;
+  for (fi2 = fileIndex, pi2 = patternIndex, fl2 = file.length, pl2 = pattern.length; fi2 < fl2 && pi2 < pl2; fi2++, pi2++) {
+    this.debug("matchOne loop");
+    let p = pattern[pi2];
+    let f10 = file[fi2];
+    this.debug(pattern, p, f10);
+    if (p === false || p === GLOBSTAR) {
+      return false;
+    }
+    let hit;
+    if (typeof p === "string") {
+      hit = f10 === p;
+      this.debug("string match", p, f10, hit);
+    } else {
+      hit = p.test(f10);
+      this.debug("pattern match", p, f10, hit);
+    }
+    if (!hit)
+      return false;
+  }
+  if (fi2 === fl2 && pi2 === pl2) {
+    return true;
+  } else if (fi2 === fl2) {
+    return partial;
+  } else if (pi2 === pl2) {
+    return fi2 === fl2 - 1 && file[fi2] === "";
+  } else {
+    throw new Error("wtf?");
+  }
+};
 minimatch.AST = AST;
 minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
@@ -75218,4 +75573,3 @@ var index = /* @__PURE__ */ Object.freeze({
   Registry,
   parsePackageSpec
 });
-//# sourceMappingURL=runtime-worker-4MKaHFVb.js.map