@shopware/api-gen 1.5.1 → 1.5.2

package/dist/cli.mjs

@@ -32,7 +32,7 @@ import __cjs_mod__ from 'module';
 const __filename = __cjs_url__.fileURLToPath(import.meta.url);
 const __dirname = __cjs_path__.dirname(__filename);
 const require = __cjs_mod__.createRequire(import.meta.url);
-const version$1 = "1.5.1";
+const version$1 = "1.5.2";
 const packageJson = {
 	version: version$1};
 
@@ -40,2607 +40,1439 @@ var lib = {};
 
 var utils$3 = {};
 
-var commonjs$2 = {};
+var path;
+var hasRequiredPath;
+
+function requirePath () {
+	if (hasRequiredPath) return path;
+	hasRequiredPath = 1;
+	const isWindows = typeof process === 'object' &&
+	  process &&
+	  process.platform === 'win32';
+	path = isWindows ? { sep: '\\' } : { sep: '/' };
+	return path;
+}
+
+var balancedMatch;
+var hasRequiredBalancedMatch;
+
+function requireBalancedMatch () {
+	if (hasRequiredBalancedMatch) return balancedMatch;
+	hasRequiredBalancedMatch = 1;
+	balancedMatch = balanced;
+	function balanced(a, b, str) {
+	  if (a instanceof RegExp) a = maybeMatch(a, str);
+	  if (b instanceof RegExp) b = maybeMatch(b, str);
+
+	  var r = range(a, b, str);
+
+	  return r && {
+	    start: r[0],
+	    end: r[1],
+	    pre: str.slice(0, r[0]),
+	    body: str.slice(r[0] + a.length, r[1]),
+	    post: str.slice(r[1] + b.length)
+	  };
+	}
 
-var commonjs$1 = {};
+	function maybeMatch(reg, str) {
+	  var m = str.match(reg);
+	  return m ? m[0] : null;
+	}
 
-var commonjs = {};
+	balanced.range = range;
+	function range(a, b, str) {
+	  var begs, beg, left, right, result;
+	  var ai = str.indexOf(a);
+	  var bi = str.indexOf(b, ai + 1);
+	  var i = ai;
 
-var hasRequiredCommonjs$2;
+	  if (ai >= 0 && bi > 0) {
+	    if(a===b) {
+	      return [ai, bi];
+	    }
+	    begs = [];
+	    left = str.length;
 
-function requireCommonjs$2 () {
-	if (hasRequiredCommonjs$2) return commonjs;
-	hasRequiredCommonjs$2 = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.range = exports.balanced = void 0;
-		const balanced = (a, b, str) => {
-		    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-		    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-		    const r = ma !== null && mb != null && (0, exports.range)(ma, mb, str);
-		    return (r && {
-		        start: r[0],
-		        end: r[1],
-		        pre: str.slice(0, r[0]),
-		        body: str.slice(r[0] + ma.length, r[1]),
-		        post: str.slice(r[1] + mb.length),
-		    });
-		};
-		exports.balanced = balanced;
-		const maybeMatch = (reg, str) => {
-		    const m = str.match(reg);
-		    return m ? m[0] : null;
-		};
-		const range = (a, b, str) => {
-		    let begs, beg, left, right = undefined, result;
-		    let ai = str.indexOf(a);
-		    let bi = str.indexOf(b, ai + 1);
-		    let i = ai;
-		    if (ai >= 0 && bi > 0) {
-		        if (a === b) {
-		            return [ai, bi];
-		        }
-		        begs = [];
-		        left = str.length;
-		        while (i >= 0 && !result) {
-		            if (i === ai) {
-		                begs.push(i);
-		                ai = str.indexOf(a, i + 1);
-		            }
-		            else if (begs.length === 1) {
-		                const r = begs.pop();
-		                if (r !== undefined)
-		                    result = [r, bi];
-		            }
-		            else {
-		                beg = begs.pop();
-		                if (beg !== undefined && beg < left) {
-		                    left = beg;
-		                    right = bi;
-		                }
-		                bi = str.indexOf(b, i + 1);
-		            }
-		            i = ai < bi && ai >= 0 ? ai : bi;
-		        }
-		        if (begs.length && right !== undefined) {
-		            result = [left, right];
-		        }
-		    }
-		    return result;
-		};
-		exports.range = range;
-		
-	} (commonjs));
-	return commonjs;
-}
+	    while (i >= 0 && !result) {
+	      if (i == ai) {
+	        begs.push(i);
+	        ai = str.indexOf(a, i + 1);
+	      } else if (begs.length == 1) {
+	        result = [ begs.pop(), bi ];
+	      } else {
+	        beg = begs.pop();
+	        if (beg < left) {
+	          left = beg;
+	          right = bi;
+	        }
 
-var hasRequiredCommonjs$1;
+	        bi = str.indexOf(b, i + 1);
+	      }
 
-function requireCommonjs$1 () {
-	if (hasRequiredCommonjs$1) return commonjs$1;
-	hasRequiredCommonjs$1 = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.EXPANSION_MAX_LENGTH = exports.EXPANSION_MAX = void 0;
-		exports.expand = expand;
-		const balanced_match_1 = requireCommonjs$2();
-		const escSlash = '\0SLASH' + Math.random() + '\0';
-		const escOpen = '\0OPEN' + Math.random() + '\0';
-		const escClose = '\0CLOSE' + Math.random() + '\0';
-		const escComma = '\0COMMA' + Math.random() + '\0';
-		const escPeriod = '\0PERIOD' + Math.random() + '\0';
-		const escSlashPattern = new RegExp(escSlash, 'g');
-		const escOpenPattern = new RegExp(escOpen, 'g');
-		const escClosePattern = new RegExp(escClose, 'g');
-		const escCommaPattern = new RegExp(escComma, 'g');
-		const escPeriodPattern = new RegExp(escPeriod, 'g');
-		const slashPattern = /\\\\/g;
-		const openPattern = /\\{/g;
-		const closePattern = /\\}/g;
-		const commaPattern = /\\,/g;
-		const periodPattern = /\\\./g;
-		exports.EXPANSION_MAX = 100_000;
-		// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An
-		// input like `'{a,b}'.repeat(1500)` stays under that count - its output is
-		// truncated to 100k results - while making every result ~1500 characters
-		// long. The result set, and the intermediate arrays built while combining
-		// brace sets, then grow large enough to exhaust memory and crash the process
-		// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of
-		// characters the accumulator may hold at any point, so memory stays flat no
-		// matter how many brace groups are chained. The limit sits well above any
-		// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M
-		// characters) so legitimate input is unaffected.
-		exports.EXPANSION_MAX_LENGTH = 4_000_000;
-		function numeric(str) {
-		    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-		}
-		function escapeBraces(str) {
-		    return str
-		        .replace(slashPattern, escSlash)
-		        .replace(openPattern, escOpen)
-		        .replace(closePattern, escClose)
-		        .replace(commaPattern, escComma)
-		        .replace(periodPattern, escPeriod);
-		}
-		function unescapeBraces(str) {
-		    return str
-		        .replace(escSlashPattern, '\\')
-		        .replace(escOpenPattern, '{')
-		        .replace(escClosePattern, '}')
-		        .replace(escCommaPattern, ',')
-		        .replace(escPeriodPattern, '.');
-		}
-		/**
-		 * Basically just str.split(","), but handling cases
-		 * where we have nested braced sections, which should be
-		 * treated as individual members, like {a,{b,c},d}
-		 */
-		function parseCommaParts(str) {
-		    if (!str) {
-		        return [''];
-		    }
-		    const parts = [];
-		    const m = (0, balanced_match_1.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, options = {}) {
-		    if (!str) {
-		        return [];
-		    }
-		    const { max = exports.EXPANSION_MAX, maxLength = exports.EXPANSION_MAX_LENGTH } = options;
-		    // I don't know why Bash 4.3 does this, but it does.
-		    // Anything starting with {} will have the first two bytes preserved
-		    // but *only* at the top level, so {},a}b will not expand to anything,
-		    // but a{},b}c will be expanded to [a}c,abc].
-		    // One could argue that this is a bug in Bash, but since the goal of
-		    // this module is to match Bash's rules, we escape a leading {}
-		    if (str.slice(0, 2) === '{}') {
-		        str = '\\{\\}' + str.slice(2);
-		    }
-		    return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
-		}
-		function embrace(str) {
-		    return '{' + str + '}';
-		}
-		function isPadded(el) {
-		    return /^-?0\d/.test(el);
-		}
-		function lte(i, y) {
-		    return i <= y;
-		}
-		function gte(i, y) {
-		    return i >= y;
-		}
-		// Build `{ acc[a] + pre + values[v] }` for every combination, capping the
-		// number of results at `max` and the total number of characters at `maxLength`.
-		// This is the one place output grows, so bounding it here keeps the single
-		// accumulator - and therefore memory - flat regardless of how many brace groups
-		// are combined (CVE-2026-14257).
-		function combine(acc, pre, values, max, maxLength, dropEmpties) {
-		    const out = [];
-		    let length = 0;
-		    for (let a = 0; a < acc.length; a++) {
-		        for (let v = 0; v < values.length; v++) {
-		            if (out.length >= max)
-		                return out;
-		            const expansion = acc[a] + pre + values[v];
-		            // Bash drops empty results at the top level. Skip them before they count
-		            // against `max`, so `max` bounds the number of *kept* results.
-		            if (dropEmpties && !expansion)
-		                continue;
-		            if (length + expansion.length > maxLength)
-		                return out;
-		            out.push(expansion);
-		            length += expansion.length;
-		        }
-		    }
-		    return out;
-		}
-		// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)
-		// sequence body.
-		function expandSequence(body, isAlphaSequence, max) {
-		    const n = body.split(/\.\./);
-		    const N = [];
-		    // A sequence body always splits into two or three parts, but the compiler
-		    // can't know that.
-		    /* c8 ignore start */
-		    if (n[0] === undefined || n[1] === undefined) {
-		        return N;
-		    }
-		    /* c8 ignore stop */
-		    const x = numeric(n[0]);
-		    const y = numeric(n[1]);
-		    const width = Math.max(n[0].length, n[1].length);
-		    let incr = n.length === 3 && n[2] !== undefined ?
-		        Math.max(Math.abs(numeric(n[2])), 1)
-		        : 1;
-		    let test = lte;
-		    const reverse = y < x;
-		    if (reverse) {
-		        incr *= -1;
-		        test = gte;
-		    }
-		    const pad = n.some(isPadded);
-		    for (let i = x; test(i, y) && N.length < max; i += incr) {
-		        let c;
-		        if (isAlphaSequence) {
-		            c = String.fromCharCode(i);
-		            if (c === '\\') {
-		                c = '';
-		            }
-		        }
-		        else {
-		            c = String(i);
-		            if (pad) {
-		                const need = width - c.length;
-		                if (need > 0) {
-		                    const z = new Array(need + 1).join('0');
-		                    if (i < 0) {
-		                        c = '-' + z + c.slice(1);
-		                    }
-		                    else {
-		                        c = z + c;
-		                    }
-		                }
-		            }
-		        }
-		        N.push(c);
-		    }
-		    return N;
-		}
-		function expand_(str, max, maxLength, isTop) {
-		    // Consume the string's top-level brace groups left to right, threading a
-		    // running set of combined prefixes (`acc`). Expanding the tail iteratively -
-		    // rather than recursing on `m.post` once per group - keeps the native stack
-		    // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no
-		    // longer overflow the stack, and leaves a single accumulator whose size
-		    // `maxLength` bounds directly (CVE-2026-14257).
-		    let acc = [''];
-		    // Bash drops empty results, but only when the *first* top-level group is a
-		    // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop
-		    // is on the final strings, so it is applied to whichever `combine` produces
-		    // them (the one with no brace set left in the tail).
-		    let dropEmpties = false;
-		    let firstGroup = true;
-		    for (;;) {
-		        const m = (0, balanced_match_1.balanced)('{', '}', str);
-		        // No brace set left: the rest of the string is literal.
-		        if (!m) {
-		            return combine(acc, str, [''], max, maxLength, dropEmpties);
-		        }
-		        // no need to expand pre, since it is guaranteed to be free of brace-sets
-		        const pre = m.pre;
-		        if (/\$$/.test(pre)) {
-		            acc = combine(acc, pre + '{' + m.body + '}', [''], max, maxLength, dropEmpties && !m.post.length);
-		            firstGroup = false;
-		            if (!m.post.length)
-		                break;
-		            str = m.post;
-		            continue;
-		        }
-		        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) {
-		            // {a},b}
-		            if (m.post.match(/,(?!,).*\}/)) {
-		                str = m.pre + '{' + m.body + escClose + m.post;
-		                isTop = true;
-		                continue;
-		            }
-		            // Nothing here expands, so the whole remaining string is literal.
-		            return combine(acc, pre + '{' + m.body + '}' + m.post, [''], max, maxLength, dropEmpties);
-		        }
-		        if (firstGroup) {
-		            dropEmpties = isTop && !isSequence;
-		            firstGroup = false;
-		        }
-		        let values;
-		        if (isSequence) {
-		            values = expandSequence(m.body, isAlphaSequence, max);
-		        }
-		        else {
-		            let n = parseCommaParts(m.body);
-		            if (n.length === 1 && n[0] !== undefined) {
-		                // x{{a,b}}y ==> x{a}y x{b}y
-		                n = expand_(n[0], max, maxLength, false).map(embrace);
-		                //XXX is this necessary? Can't seem to hit it in tests.
-		                /* c8 ignore start */
-		                if (n.length === 1) {
-		                    acc = combine(acc, pre + n[0], [''], max, maxLength, dropEmpties && !m.post.length);
-		                    if (!m.post.length)
-		                        break;
-		                    str = m.post;
-		                    continue;
-		                }
-		                /* c8 ignore stop */
-		            }
-		            values = [];
-		            for (let j = 0; j < n.length; j++) {
-		                values.push.apply(values, expand_(n[j], max, maxLength, false));
-		            }
-		        }
-		        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
-		        if (!m.post.length)
-		            break;
-		        str = m.post;
-		    }
-		    return acc;
-		}
-		
-	} (commonjs$1));
-	return commonjs$1;
+	      i = ai < bi && ai >= 0 ? ai : bi;
+	    }
+
+	    if (begs.length) {
+	      result = [ left, right ];
+	    }
+	  }
+
+	  return result;
+	}
+	return balancedMatch;
 }
 
-var assertValidPattern = {};
+var braceExpansion;
+var hasRequiredBraceExpansion;
 
-var hasRequiredAssertValidPattern;
+function requireBraceExpansion () {
+	if (hasRequiredBraceExpansion) return braceExpansion;
+	hasRequiredBraceExpansion = 1;
+	var balanced = requireBalancedMatch();
 
-function requireAssertValidPattern () {
-	if (hasRequiredAssertValidPattern) return assertValidPattern;
-	hasRequiredAssertValidPattern = 1;
-	Object.defineProperty(assertValidPattern, "__esModule", { value: true });
-	assertValidPattern.assertValidPattern = void 0;
-	const MAX_PATTERN_LENGTH = 1024 * 64;
-	const assertValidPattern$1 = (pattern) => {
-	    if (typeof pattern !== 'string') {
-	        throw new TypeError('invalid pattern');
-	    }
-	    if (pattern.length > MAX_PATTERN_LENGTH) {
-	        throw new TypeError('pattern is too long');
+	braceExpansion = expandTop;
+
+	var escSlash = '\0SLASH'+Math.random()+'\0';
+	var escOpen = '\0OPEN'+Math.random()+'\0';
+	var escClose = '\0CLOSE'+Math.random()+'\0';
+	var escComma = '\0COMMA'+Math.random()+'\0';
+	var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+	var EXPANSION_MAX = 100000;
+
+	// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An
+	// input like `'{a,b}'.repeat(1500)` stays under that count - its output is
+	// truncated to 100k results - while making every result ~1500 characters
+	// long. The result set, and the intermediate arrays built while combining
+	// brace sets, then grow large enough to exhaust memory and crash the process
+	// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of
+	// characters the accumulator may hold at any point, so memory stays flat no
+	// matter how many brace groups are chained. The limit sits well above any
+	// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M
+	// characters) so legitimate input is unaffected.
+	var EXPANSION_MAX_LENGTH = 4000000;
+
+	function numeric(str) {
+	  return parseInt(str, 10) == str
+	    ? parseInt(str, 10)
+	    : str.charCodeAt(0);
+	}
+
+	function escapeBraces(str) {
+	  return str.split('\\\\').join(escSlash)
+	            .split('\\{').join(escOpen)
+	            .split('\\}').join(escClose)
+	            .split('\\,').join(escComma)
+	            .split('\\.').join(escPeriod);
+	}
+
+	function unescapeBraces(str) {
+	  return str.split(escSlash).join('\\')
+	            .split(escOpen).join('{')
+	            .split(escClose).join('}')
+	            .split(escComma).join(',')
+	            .split(escPeriod).join('.');
+	}
+
+
+	// Basically just str.split(","), but handling cases
+	// where we have nested braced sections, which should be
+	// treated as individual members, like {a,{b,c},d}
+	function parseCommaParts(str) {
+	  if (!str)
+	    return [''];
+
+	  var parts = [];
+	  var m = balanced('{', '}', str);
+
+	  if (!m)
+	    return str.split(',');
+
+	  var pre = m.pre;
+	  var body = m.body;
+	  var post = m.post;
+	  var p = pre.split(',');
+
+	  p[p.length-1] += '{' + body + '}';
+	  var 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 expandTop(str, options) {
+	  if (!str)
+	    return [];
+
+	  options = options || {};
+	  var max = options.max == null ? EXPANSION_MAX : options.max;
+	  var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;
+
+	  // I don't know why Bash 4.3 does this, but it does.
+	  // Anything starting with {} will have the first two bytes preserved
+	  // but *only* at the top level, so {},a}b will not expand to anything,
+	  // but a{},b}c will be expanded to [a}c,abc].
+	  // One could argue that this is a bug in Bash, but since the goal of
+	  // this module is to match Bash's rules, we escape a leading {}
+	  if (str.substr(0, 2) === '{}') {
+	    str = '\\{\\}' + str.substr(2);
+	  }
+
+	  return expand(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
+	}
+
+	function embrace(str) {
+	  return '{' + str + '}';
+	}
+	function isPadded(el) {
+	  return /^-?0\d/.test(el);
+	}
+
+	function lte(i, y) {
+	  return i <= y;
+	}
+	function gte(i, y) {
+	  return i >= y;
+	}
+
+	// Build `{ acc[a] + pre + values[v] }` for every combination, capping the
+	// number of results at `max` and the total number of characters at `maxLength`.
+	// This is the one place output grows, so bounding it here keeps the single
+	// accumulator - and therefore memory - flat regardless of how many brace groups
+	// are combined (CVE-2026-14257).
+	function combine(
+	  acc,
+	  pre,
+	  values,
+	  max,
+	  maxLength,
+	  dropEmpties
+	) {
+	  var out = [];
+	  var length = 0;
+	  for (var a = 0; a < acc.length; a++) {
+	    for (var v = 0; v < values.length; v++) {
+	      if (out.length >= max) return out
+	      var expansion = acc[a] + pre + values[v];
+	      // Bash drops empty results at the top level. Skip them before they count
+	      // against `max`, so `max` bounds the number of *kept* results.
+	      if (dropEmpties && !expansion) continue
+	      if (length + expansion.length > maxLength) return out
+	      out.push(expansion);
+	      length += expansion.length;
 	    }
-	};
-	assertValidPattern.assertValidPattern = assertValidPattern$1;
-	
-	return assertValidPattern;
-}
-
-var ast = {};
-
-var braceExpressions = {};
-
-var hasRequiredBraceExpressions;
-
-function requireBraceExpressions () {
-	if (hasRequiredBraceExpressions) return braceExpressions;
-	hasRequiredBraceExpressions = 1;
-	// translate the various posix character classes into unicode properties
-	// this works across all unicode locales
-	Object.defineProperty(braceExpressions, "__esModule", { value: true });
-	braceExpressions.parseClass = void 0;
-	// { <posix class>: [<translation>, /u flag required, negated]
-	const posixClasses = {
-	    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
-	    '[:alpha:]': ['\\p{L}\\p{Nl}', true],
-	    '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
-	    '[:blank:]': ['\\p{Zs}\\t', true],
-	    '[:cntrl:]': ['\\p{Cc}', true],
-	    '[:digit:]': ['\\p{Nd}', true],
-	    '[:graph:]': ['\\p{Z}\\p{C}', true, true],
-	    '[:lower:]': ['\\p{Ll}', true],
-	    '[:print:]': ['\\p{C}', true],
-	    '[:punct:]': ['\\p{P}', true],
-	    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
-	    '[:upper:]': ['\\p{Lu}', true],
-	    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
-	    '[:xdigit:]': ['A-Fa-f0-9', false],
-	};
-	// only need to escape a few things inside of brace expressions
-	// escapes: [ \ ] -
-	const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
-	// escape all regexp magic characters
-	const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-	// everything has already been escaped, we just have to join
-	const rangesToString = (ranges) => ranges.join('');
-	// takes a glob string at a posix brace expression, and returns
-	// an equivalent regular expression source, and boolean indicating
-	// whether the /u flag needs to be applied, and the number of chars
-	// consumed to parse the character class.
-	// This also removes out of order ranges, and returns ($.) if the
-	// entire class just no good.
-	const parseClass = (glob, position) => {
-	    const pos = position;
-	    /* c8 ignore start */
-	    if (glob.charAt(pos) !== '[') {
-	        throw new Error('not in a brace expression');
-	    }
-	    /* c8 ignore stop */
-	    const ranges = [];
-	    const negs = [];
-	    let i = pos + 1;
-	    let sawStart = false;
-	    let uflag = false;
-	    let escaping = false;
-	    let negate = false;
-	    let endPos = pos;
-	    let rangeStart = '';
-	    WHILE: while (i < glob.length) {
-	        const c = glob.charAt(i);
-	        if ((c === '!' || c === '^') && i === pos + 1) {
-	            negate = true;
-	            i++;
-	            continue;
-	        }
-	        if (c === ']' && sawStart && !escaping) {
-	            endPos = i + 1;
-	            break;
-	        }
-	        sawStart = true;
-	        if (c === '\\') {
-	            if (!escaping) {
-	                escaping = true;
-	                i++;
-	                continue;
-	            }
-	            // escaped \ char, fall through and treat like normal char
-	        }
-	        if (c === '[' && !escaping) {
-	            // either a posix class, a collation equivalent, or just a [
-	            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-	                if (glob.startsWith(cls, i)) {
-	                    // invalid, [a-[] is fine, but not [a-[:alpha]]
-	                    if (rangeStart) {
-	                        return ['$.', false, glob.length - pos, true];
-	                    }
-	                    i += cls.length;
-	                    if (neg)
-	                        negs.push(unip);
-	                    else
-	                        ranges.push(unip);
-	                    uflag = uflag || u;
-	                    continue WHILE;
-	                }
-	            }
+	  }
+	  return out
+	}
+
+	// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)
+	// sequence body.
+	function expandSequence(
+	  body,
+	  isAlphaSequence,
+	  max,
+	  maxLength
+	) {
+	  var n = body.split(/\.\./);
+	  var N = [];
+	  // A sequence body always splits into two or three parts, but the compiler
+	  // can't know that.
+	  /* c8 ignore start */
+	  if (n[0] === undefined || n[1] === undefined) {
+	    return N
+	  }
+	  /* c8 ignore stop */
+	  var x = numeric(n[0]);
+	  var y = numeric(n[1]);
+	  var width = Math.max(n[0].length, n[1].length);
+	  var incr =
+	    n.length === 3 && n[2] !== undefined ?
+	      Math.max(Math.abs(numeric(n[2])), 1)
+	    : 1;
+	  var test = lte;
+	  var reverse = y < x;
+	  if (reverse) {
+	    incr *= -1;
+	    test = gte;
+	  }
+	  var pad = n.some(isPadded);
+
+	  var length = 0;
+	  for (var i = x; test(i, y) && N.length < max; i += incr) {
+	    var c;
+	    if (isAlphaSequence) {
+	      c = String.fromCharCode(i);
+	      if (c === '\\') {
+	        c = '';
+	      }
+	    } else {
+	      c = String(i);
+	      if (pad) {
+	        var need = width - c.length;
+	        if (need > 0) {
+	          var z = new Array(need + 1).join('0');
+	          if (i < 0) {
+	            c = '-' + z + c.slice(1);
+	          } else {
+	            c = z + c;
+	          }
 	        }
-	        // now it's just a normal character, effectively
-	        escaping = false;
-	        if (rangeStart) {
-	            // throw this range away if it's not valid, but others
-	            // can still match.
-	            if (c > rangeStart) {
-	                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
-	            }
-	            else if (c === rangeStart) {
-	                ranges.push(braceEscape(c));
-	            }
-	            rangeStart = '';
-	            i++;
-	            continue;
+	      }
+	    }
+	    if (length + c.length > maxLength) break
+	    N.push(c);
+	    length += c.length;
+	  }
+	  return N
+	}
+
+	function expand(
+	  str,
+	  max,
+	  maxLength,
+	  isTop
+	) {
+	  // Consume the string's top-level brace groups left to right, threading a
+	  // running set of combined prefixes (`acc`). Expanding the tail iteratively -
+	  // rather than recursing on `m.post` once per group - keeps the native stack
+	  // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no
+	  // longer overflow the stack, and leaves a single accumulator whose size
+	  // `maxLength` bounds directly (CVE-2026-14257).
+	  var acc = [''];
+
+	  // Bash drops empty results, but only when the *first* top-level group is a
+	  // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop
+	  // is on the final strings, so it is applied to whichever `combine` produces
+	  // them (the one with no brace set left in the tail).
+	  var dropEmpties = false;
+	  var firstGroup = true;
+
+	  for (;;) {
+	    const m = balanced('{', '}', str);
+
+	    // No brace set left: the rest of the string is literal.
+	    if (!m) {
+	      return combine(acc, str, [''], max, maxLength, dropEmpties)
+	    }
+
+	    // no need to expand pre, since it is guaranteed to be free of brace-sets
+	    const pre = m.pre;
+
+	    if (/\$$/.test(pre)) {
+	      acc = combine(
+	        acc,
+	        pre + '{' + m.body + '}',
+	        [''],
+	        max,
+	        maxLength,
+	        dropEmpties && !m.post.length
+	      );
+	      firstGroup = false;
+	      if (!m.post.length) break
+	      str = m.post;
+	      continue
+	    }
+
+	    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+	    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+	    var isSequence = isNumericSequence || isAlphaSequence;
+	    var isOptions = m.body.indexOf(',') >= 0;
+	    if (!isSequence && !isOptions) {
+	      // {a},b}
+	      if (m.post.match(/,(?!,).*\}/)) {
+	        str = m.pre + '{' + m.body + escClose + m.post;
+	        isTop = true;
+	        continue;
+	      }
+	      // Nothing here expands, so the whole remaining string is literal.
+	      return combine(
+	        acc,
+	        pre + '{' + m.body + '}' + m.post,
+	        [''],
+	        max,
+	        maxLength,
+	        dropEmpties
+	      )
+	    }
+
+	    if (firstGroup) {
+	      dropEmpties = isTop && !isSequence;
+	      firstGroup = false;
+	    }
+
+	    var values;
+	    if (isSequence) {
+	      values = expandSequence(m.body, isAlphaSequence, max, maxLength);
+	    } else {
+	      var n = parseCommaParts(m.body);
+	      if (n.length === 1 && n[0] !== undefined) {
+	        // x{{a,b}}y ==> x{a}y x{b}y
+	        n = expand(n[0], max, maxLength, false).map(embrace);
+	        //XXX is this necessary? Can't seem to hit it in tests.
+	        /* c8 ignore start */
+	        if (n.length === 1) {
+	          acc = combine(
+	            acc,
+	            pre + n[0],
+	            [''],
+	            max,
+	            maxLength,
+	            dropEmpties && !m.post.length
+	          );
+	          if (!m.post.length) break
+	          str = m.post;
+	          continue
 	        }
-	        // now might be the start of a range.
-	        // can be either c-d or c-] or c<more...>] or c] at this point
-	        if (glob.startsWith('-]', i + 1)) {
-	            ranges.push(braceEscape(c + '-'));
-	            i += 2;
-	            continue;
+	        /* c8 ignore stop */
+	      }
+
+	      // Values that `combine` is going to drop as empty produce no result, so
+	      // they must not count against `max` - otherwise `{a,,b}` with `max: 2`
+	      // would stop at `['a', '']` and yield one result instead of two. Skipping
+	      // them outright keeps `values` bounded while leaving `max` a bound on
+	      // *kept* results.
+	      var dropsEmpties = dropEmpties && !m.post.length && !pre;
+	      for (var d = 0; dropsEmpties && d < acc.length; d++) {
+	        if (acc[d]) {
+	          dropsEmpties = false;
 	        }
-	        if (glob.startsWith('-', i + 1)) {
-	            rangeStart = c;
-	            i += 2;
-	            continue;
+	      }
+
+	      values = [];
+	      var valuesLength = 0;
+	      outer: for (var j = 0; j < n.length; j++) {
+	        var expanded = expand(n[j], max, maxLength, false);
+	        for (var k = 0; k < expanded.length; k++) {
+	          var v = expanded[k];
+	          if (dropsEmpties && !v) continue
+	          if (values.length >= max || valuesLength + v.length > maxLength) {
+	            break outer
+	          }
+	          values.push(v);
+	          valuesLength += v.length;
 	        }
-	        // not the start of a range, just a single character
-	        ranges.push(braceEscape(c));
-	        i++;
-	    }
-	    if (endPos < i) {
-	        // didn't see the end of the class, not a valid class,
-	        // but might still be valid as a literal match.
-	        return ['', false, 0, false];
-	    }
-	    // if we got no ranges and no negates, then we have a range that
-	    // cannot possibly match anything, and that poisons the whole glob
-	    if (!ranges.length && !negs.length) {
-	        return ['$.', false, glob.length - pos, true];
-	    }
-	    // if we got one positive range, and it's a single character, then that's
-	    // not actually a magic pattern, it's just that one literal character.
-	    // we should not treat that as "magic", we should just return the literal
-	    // character. [_] is a perfectly valid way to escape glob magic chars.
-	    if (negs.length === 0 &&
-	        ranges.length === 1 &&
-	        /^\\?.$/.test(ranges[0]) &&
-	        !negate) {
-	        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-	        return [regexpEscape(r), false, endPos - pos, false];
-	    }
-	    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
-	    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
-	    const comb = ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
-	        : ranges.length ? sranges
-	            : snegs;
-	    return [comb, uflag, endPos - pos, true];
-	};
-	braceExpressions.parseClass = parseClass;
-	
-	return braceExpressions;
+	      }
+	    }
+
+	    acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
+	    if (!m.post.length) break
+	    str = m.post;
+	  }
+
+	  return acc
+	}
+	return braceExpansion;
 }
 
-var _unescape = {};
+var minimatch_1;
+var hasRequiredMinimatch;
 
-var hasRequired_unescape;
+function requireMinimatch () {
+	if (hasRequiredMinimatch) return minimatch_1;
+	hasRequiredMinimatch = 1;
+	const minimatch = minimatch_1 = (p, pattern, options = {}) => {
+	  assertValidPattern(pattern);
+
+	  // shortcut: comments match nothing.
+	  if (!options.nocomment && pattern.charAt(0) === '#') {
+	    return false
+	  }
+
+	  return new Minimatch(pattern, options).match(p)
+	};
+
+	minimatch_1 = minimatch;
+
+	const path = requirePath();
+	minimatch.sep = path.sep;
+
+	const GLOBSTAR = Symbol('globstar **');
+	minimatch.GLOBSTAR = GLOBSTAR;
+	const expand = requireBraceExpansion();
+
+	const plTypes = {
+	  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+	  '?': { open: '(?:', close: ')?' },
+	  '+': { open: '(?:', close: ')+' },
+	  '*': { open: '(?:', close: ')*' },
+	  '@': { open: '(?:', close: ')' }
+	};
 
-function require_unescape () {
-	if (hasRequired_unescape) return _unescape;
-	hasRequired_unescape = 1;
-	Object.defineProperty(_unescape, "__esModule", { value: true });
-	_unescape.unescape = void 0;
-	/**
-	 * Un-escape a string that has been escaped with {@link escape}.
-	 *
-	 * If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then
-	 * square-bracket escapes are removed, but not backslash escapes.
-	 *
-	 * For example, it will turn the string `'[*]'` into `*`, but it will not
-	 * turn `'\\*'` into `'*'`, because `\` is a path separator in
-	 * `windowsPathsNoEscape` mode.
-	 *
-	 * When `windowsPathsNoEscape` is not set, then both square-bracket escapes and
-	 * backslash escapes are removed.
-	 *
-	 * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
-	 * or unescaped.
-	 *
-	 * When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be
-	 * unescaped.
-	 */
-	const unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {}) => {
-	    if (magicalBraces) {
-	        return windowsPathsNoEscape ?
-	            s.replace(/\[([^/\\])\]/g, '$1')
-	            : s
-	                .replace(/((?!\\).|^)\[([^/\\])\]/g, '$1$2')
-	                .replace(/\\([^/])/g, '$1');
-	    }
-	    return windowsPathsNoEscape ?
-	        s.replace(/\[([^/\\{}])\]/g, '$1')
-	        : s
-	            .replace(/((?!\\).|^)\[([^/\\{}])\]/g, '$1$2')
-	            .replace(/\\([^/{}])/g, '$1');
-	};
-	_unescape.unescape = unescape;
-	
-	return _unescape;
-}
-
-var hasRequiredAst;
-
-function requireAst () {
-	if (hasRequiredAst) return ast;
-	hasRequiredAst = 1;
-	// parse a single path portion
-	var _a;
-	Object.defineProperty(ast, "__esModule", { value: true });
-	ast.AST = void 0;
-	const brace_expressions_js_1 = requireBraceExpressions();
-	const unescape_js_1 = require_unescape();
-	const types = new Set(['!', '?', '+', '*', '@']);
-	const isExtglobType = (c) => types.has(c);
-	const isExtglobAST = (c) => isExtglobType(c.type);
-	// Map of which extglob types can adopt the children of a nested extglob
-	//
-	// anything but ! can adopt a matching type:
-	// +(a|+(b|c)|d) => +(a|b|c|d)
-	// *(a|*(b|c)|d) => *(a|b|c|d)
-	// @(a|@(b|c)|d) => @(a|b|c|d)
-	// ?(a|?(b|c)|d) => ?(a|b|c|d)
-	//
-	// * can adopt anything, because 0 or repetition is allowed
-	// *(a|?(b|c)|d) => *(a|b|c|d)
-	// *(a|+(b|c)|d) => *(a|b|c|d)
-	// *(a|@(b|c)|d) => *(a|b|c|d)
-	//
-	// + can adopt @, because 1 or repetition is allowed
-	// +(a|@(b|c)|d) => +(a|b|c|d)
-	//
-	// + and @ CANNOT adopt *, because 0 would be allowed
-	// +(a|*(b|c)|d) => would match "", on *(b|c)
-	// @(a|*(b|c)|d) => would match "", on *(b|c)
-	//
-	// + and @ CANNOT adopt ?, because 0 would be allowed
-	// +(a|?(b|c)|d) => would match "", on ?(b|c)
-	// @(a|?(b|c)|d) => would match "", on ?(b|c)
-	//
-	// ? can adopt @, because 0 or 1 is allowed
-	// ?(a|@(b|c)|d) => ?(a|b|c|d)
-	//
-	// ? and @ CANNOT adopt * or +, because >1 would be allowed
-	// ?(a|*(b|c)|d) => would match bbb on *(b|c)
-	// @(a|*(b|c)|d) => would match bbb on *(b|c)
-	// ?(a|+(b|c)|d) => would match bbb on +(b|c)
-	// @(a|+(b|c)|d) => would match bbb on +(b|c)
-	//
-	// ! CANNOT adopt ! (nothing else can either)
-	// !(a|!(b|c)|d) => !(a|b|c|d) would fail to match on b (not not b|c)
-	//
-	// ! can adopt @
-	// !(a|@(b|c)|d) => !(a|b|c|d)
-	//
-	// ! CANNOT adopt *
-	// !(a|*(b|c)|d) => !(a|b|c|d) would match on bbb, not allowed
-	//
-	// ! CANNOT adopt +
-	// !(a|+(b|c)|d) => !(a|b|c|d) would match on bbb, not allowed
-	//
-	// ! CANNOT adopt ?
-	// x!(a|?(b|c)|d) => x!(a|b|c|d) would fail to match "x"
-	const adoptionMap = new Map([
-	    ['!', ['@']],
-	    ['?', ['?', '@']],
-	    ['@', ['@']],
-	    ['*', ['*', '+', '?', '@']],
-	    ['+', ['+', '@']],
-	]);
-	// nested extglobs that can be adopted in, but with the addition of
-	// a blank '' element.
-	const adoptionWithSpaceMap = new Map([
-	    ['!', ['?']],
-	    ['@', ['?']],
-	    ['+', ['?', '*']],
-	]);
-	// union of the previous two maps
-	const adoptionAnyMap = new Map([
-	    ['!', ['?', '@']],
-	    ['?', ['?', '@']],
-	    ['@', ['?', '@']],
-	    ['*', ['*', '+', '?', '@']],
-	    ['+', ['+', '@', '?', '*']],
-	]);
-	// Extglobs that can take over their parent if they are the only child
-	// the key is parent, value maps child to resulting extglob parent type
-	// '@' is omitted because it's a special case. An `@` extglob with a single
-	// member can always be usurped by that subpattern.
-	const usurpMap = new Map([
-	    ['!', new Map([['!', '@']])],
-	    [
-	        '?',
-	        new Map([
-	            ['*', '*'],
-	            ['+', '*'],
-	        ]),
-	    ],
-	    [
-	        '@',
-	        new Map([
-	            ['!', '!'],
-	            ['?', '?'],
-	            ['@', '@'],
-	            ['*', '*'],
-	            ['+', '+'],
-	        ]),
-	    ],
-	    [
-	        '+',
-	        new Map([
-	            ['?', '*'],
-	            ['*', '*'],
-	        ]),
-	    ],
-	]);
-	// Patterns that get prepended to bind to the start of either the
-	// entire string, or just a single path portion, to prevent dots
-	// and/or traversal patterns, when needed.
-	// Exts don't need the ^ or / bit, because the root binds that already.
-	const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
-	const startNoDot = '(?!\\.)';
-	// characters that indicate a start of pattern needs the "no dots" bit,
-	// because a dot *might* be matched. ( is not in the list, because in
-	// the case of a child extglob, it will handle the prevention itself.
-	const addPatternStart = new Set(['[', '.']);
-	// cases where traversal is A-OK, no dot prevention needed
-	const justDots = new Set(['..', '.']);
-	const reSpecials = new Set('().*{}+?[]^$\\!');
-	const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 	// any single thing other than /
+	// don't need to escape / when using new RegExp()
 	const qmark = '[^/]';
+
 	// * => any number of characters
 	const star = qmark + '*?';
-	// use + when we need to ensure that *something* matches, because the * is
-	// the only thing in the path portion.
-	const starNoEmpty = qmark + '+?';
-	// remove the \ chars that we added if we end up doing a nonmagic compare
-	// const deslash = (s: string) => s.replace(/\\(.)/g, '$1')
-	let ID = 0;
-	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;
-	    id = ++ID;
-	    get depth() {
-	        return (this.#parent?.depth ?? -1) + 1;
-	    }
-	    [Symbol.for('nodejs.util.inspect.custom')]() {
-	        return {
-	            '@@type': 'AST',
-	            id: this.id,
-	            type: this.type,
-	            root: this.#root.id,
-	            parent: this.#parent?.id,
-	            depth: this.depth,
-	            partsLength: this.#parts.length,
-	            parts: this.#parts,
-	        };
+
+	// ** when dots are allowed.  Anything goes, except .. and .
+	// not (^ or / followed by one or two dots followed by $ or /),
+	// followed by anything, any number of times.
+	const twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
+
+	// not a ^ or / followed by a dot,
+	// followed by anything, any number of times.
+	const twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
+
+	// "abc" -> { a:true, b:true, c:true }
+	const charSet = s => s.split('').reduce((set, c) => {
+	  set[c] = true;
+	  return set
+	}, {});
+
+	// characters that need to be escaped in RegExp.
+	const reSpecials = charSet('().*{}+?[]^$\\!');
+
+	// characters that indicate we have to add the pattern start
+	const addPatternStartSet = charSet('[.(');
+
+	// normalizes slashes.
+	const slashSplit = /\/+/;
+
+	minimatch.filter = (pattern, options = {}) =>
+	  (p, i, list) => minimatch(p, pattern, options);
+
+	const ext = (a, b = {}) => {
+	  const t = {};
+	  Object.keys(a).forEach(k => t[k] = a[k]);
+	  Object.keys(b).forEach(k => t[k] = b[k]);
+	  return t
+	};
+
+	minimatch.defaults = def => {
+	  if (!def || typeof def !== 'object' || !Object.keys(def).length) {
+	    return minimatch
+	  }
+
+	  const orig = minimatch;
+
+	  const m = (p, pattern, options) => orig(p, pattern, ext(def, options));
+	  m.Minimatch = class Minimatch extends orig.Minimatch {
+	    constructor (pattern, options) {
+	      super(pattern, ext(def, options));
 	    }
-	    constructor(type, parent, options = {}) {
-	        this.type = type;
-	        // extglobs are inherently magical
-	        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() {
-	        /* c8 ignore start */
-	        if (this.#hasMagic !== undefined)
-	            return this.#hasMagic;
-	        /* c8 ignore stop */
-	        for (const p of this.#parts) {
-	            if (typeof p === 'string')
-	                continue;
-	            if (p.type || p.hasMagic)
-	                return (this.#hasMagic = true);
-	        }
-	        // note: will be undefined until we generate the regexp src and find out
-	        return this.#hasMagic;
-	    }
-	    // reconstructs the pattern
-	    toString() {
-	        return (this.#toString !== undefined ? this.#toString
-	            : !this.type ?
-	                (this.#toString = this.#parts.map(p => String(p)).join(''))
-	                : (this.#toString =
-	                    this.type +
-	                        '(' +
-	                        this.#parts.map(p => String(p)).join('|') +
-	                        ')'));
-	    }
-	    #fillNegs() {
-	        /* c8 ignore start */
-	        if (this !== this.#root)
-	            throw new Error('should only call on root');
-	        if (this.#filledNegs)
-	            return this;
-	        /* c8 ignore stop */
-	        // call toString() once to fill this out
-	        this.toString();
-	        this.#filledNegs = true;
-	        let n;
-	        while ((n = this.#negs.pop())) {
-	            if (n.type !== '!')
-	                continue;
-	            // walk up the tree, appending everthing that comes AFTER parentIndex
-	            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) {
-	                        /* c8 ignore start */
-	                        if (typeof part === 'string') {
-	                            throw new Error('string part in extglob AST??');
-	                        }
-	                        /* c8 ignore stop */
-	                        part.copyIn(pp.#parts[i]);
-	                    }
-	                }
-	                p = pp;
-	                pp = p.#parent;
-	            }
-	        }
-	        return this;
+	  };
+	  m.Minimatch.defaults = options => orig.defaults(ext(def, options)).Minimatch;
+	  m.filter = (pattern, options) => orig.filter(pattern, ext(def, options));
+	  m.defaults = options => orig.defaults(ext(def, options));
+	  m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options));
+	  m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options));
+	  m.match = (list, pattern, options) => orig.match(list, pattern, ext(def, options));
+
+	  return m
+	};
+
+
+
+
+
+	// Brace expansion:
+	// a{b,c}d -> abd acd
+	// a{b,}c -> abc ac
+	// a{0..3}d -> a0d a1d a2d a3d
+	// a{b,c{d,e}f}g -> abg acdfg acefg
+	// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+	//
+	// Invalid sets are not expanded.
+	// a{2..}b -> a{2..}b
+	// a{b}c -> a{b}c
+	minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
+
+	const braceExpand = (pattern, options = {}) => {
+	  assertValidPattern(pattern);
+
+	  // Thanks to Yeting Li <https://github.com/yetingli> for
+	  // improving this regexp to avoid a ReDOS vulnerability.
+	  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+	    // shortcut. no need to expand.
+	    return [pattern]
+	  }
+
+	  return expand(pattern)
+	};
+
+	const MAX_PATTERN_LENGTH = 1024 * 64;
+	const assertValidPattern = pattern => {
+	  if (typeof pattern !== 'string') {
+	    throw new TypeError('invalid pattern')
+	  }
+
+	  if (pattern.length > MAX_PATTERN_LENGTH) {
+	    throw new TypeError('pattern is too long')
+	  }
+	};
+
+	// parse a component of the expanded set.
+	// At this point, no pattern may contain "/" in it
+	// so we're going to return a 2d array, where each entry is the full
+	// pattern, split on '/', and then turned into a regular expression.
+	// A regexp is made at the end which joins each array with an
+	// escaped /, and another full one which joins each regexp with |.
+	//
+	// Following the lead of Bash 4.1, note that "**" only has special meaning
+	// when it is the *only* thing in a path portion.  Otherwise, any series
+	// of * is equivalent to a single *.  Globstar behavior is enabled by
+	// default, and can be disabled by setting options.noglobstar.
+	const SUBPARSE = Symbol('subparse');
+
+	minimatch.makeRe = (pattern, options) =>
+	  new Minimatch(pattern, options || {}).makeRe();
+
+	minimatch.match = (list, pattern, options = {}) => {
+	  const mm = new Minimatch(pattern, options);
+	  list = list.filter(f => mm.match(f));
+	  if (mm.options.nonull && !list.length) {
+	    list.push(pattern);
+	  }
+	  return list
+	};
+
+	// replace stuff like \* with *
+	const globUnescape = s => s.replace(/\\(.)/g, '$1');
+	const charUnescape = s => s.replace(/\\([^-\]])/g, '$1');
+	const regExpEscape = s => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+	const braExpEscape = s => s.replace(/[[\]\\]/g, '\\$&');
+
+	class Minimatch {
+	  constructor (pattern, options) {
+	    assertValidPattern(pattern);
+
+	    if (!options) options = {};
+
+	    this.options = options;
+	    this.maxGlobstarRecursion = options.maxGlobstarRecursion !== undefined
+	      ? options.maxGlobstarRecursion : 200;
+	    this.set = [];
+	    this.pattern = pattern;
+	    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape ||
+	      options.allowWindowsEscape === false;
+	    if (this.windowsPathsNoEscape) {
+	      this.pattern = this.pattern.replace(/\\/g, '/');
+	    }
+	    this.regexp = null;
+	    this.negate = false;
+	    this.comment = false;
+	    this.empty = false;
+	    this.partial = !!options.partial;
+
+	    // make the set of regexps etc.
+	    this.make();
+	  }
+
+	  debug () {}
+
+	  make () {
+	    const pattern = this.pattern;
+	    const options = this.options;
+
+	    // empty patterns and comments match nothing.
+	    if (!options.nocomment && pattern.charAt(0) === '#') {
+	      this.comment = true;
+	      return
 	    }
-	    push(...parts) {
-	        for (const p of parts) {
-	            if (p === '')
-	                continue;
-	            /* c8 ignore start */
-	            if (typeof p !== 'string' &&
-	                !(p instanceof _a && p.#parent === this)) {
-	                throw new Error('invalid part: ' + p);
-	            }
-	            /* c8 ignore stop */
-	            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.type) return !!this.#parent?.isStart()
-	        if (!this.#parent?.isStart())
-	            return false;
-	        if (this.#parentIndex === 0)
-	            return true;
-	        // if everything AHEAD of this is a negation, then it's still the "start"
-	        const p = this.#parent;
-	        for (let i = 0; i < this.#parentIndex; i++) {
-	            const pp = p.#parts[i];
-	            if (!(pp instanceof _a && pp.type === '!')) {
-	                return false;
-	            }
-	        }
-	        return true;
+	    if (!pattern) {
+	      this.empty = true;
+	      return
 	    }
-	    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();
-	        // if not root, it'll always have a parent
-	        /* c8 ignore start */
-	        const pl = this.#parent ? this.#parent.#parts.length : 0;
-	        /* c8 ignore stop */
-	        return this.#parentIndex === pl - 1;
+
+	    // step 1: figure out negation, etc.
+	    this.parseNegate();
+
+	    // step 2: expand braces
+	    let set = this.globSet = this.braceExpand();
+
+	    if (options.debug) this.debug = (...args) => console.error(...args);
+
+	    this.debug(this.pattern, set);
+
+	    // step 3: now we have a set, so turn each one into a series of path-portion
+	    // matching patterns.
+	    // These will be regexps, except in the case of "**", which is
+	    // set to the GLOBSTAR object for globstar behavior,
+	    // and will not contain any / characters
+	    set = this.globParts = set.map(s => s.split(slashSplit));
+
+	    this.debug(this.pattern, set);
+
+	    // glob --> regexps
+	    set = set.map((s, si, set) => s.map(this.parse, this));
+
+	    this.debug(this.pattern, set);
+
+	    // filter out everything that didn't compile properly.
+	    set = set.filter(s => s.indexOf(false) === -1);
+
+	    this.debug(this.pattern, set);
+
+	    this.set = set;
+	  }
+
+	  parseNegate () {
+	    if (this.options.nonegate) return
+
+	    const pattern = this.pattern;
+	    let negate = false;
+	    let negateOffset = 0;
+
+	    for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
+	      negate = !negate;
+	      negateOffset++;
 	    }
-	    copyIn(part) {
-	        if (typeof part === 'string')
-	            this.push(part);
-	        else
-	            this.push(part.clone(this));
-	    }
-	    clone(parent) {
-	        const c = new _a(this.type, parent);
-	        for (const p of this.#parts) {
-	            c.copyIn(p);
-	        }
-	        return c;
-	    }
-	    static #parseAST(str, ast, pos, opt, extDepth) {
-	        const maxDepth = opt.maxExtglobRecursion ?? 2;
-	        let escaping = false;
-	        let inBrace = false;
-	        let braceStart = -1;
-	        let braceNeg = false;
-	        if (ast.type === null) {
-	            // outside of a extglob, append until we find a start
-	            let i = pos;
-	            let acc = '';
-	            while (i < str.length) {
-	                const c = str.charAt(i++);
-	                // still accumulate escapes at this point, but we do ignore
-	                // starts that are escaped
-	                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;
-	                }
-	                // we don't have to check for adoption here, because that's
-	                // done at the other recursion point.
-	                const doRecurse = !opt.noext &&
-	                    isExtglobType(c) &&
-	                    str.charAt(i) === '(' &&
-	                    extDepth <= maxDepth;
-	                if (doRecurse) {
-	                    ast.push(acc);
-	                    acc = '';
-	                    const ext = new _a(c, ast);
-	                    i = _a.#parseAST(str, ext, i, opt, extDepth + 1);
-	                    ast.push(ext);
-	                    continue;
-	                }
-	                acc += c;
-	            }
-	            ast.push(acc);
-	            return i;
-	        }
-	        // some kind of extglob, pos is at the (
-	        // find the next | or )
-	        let i = pos + 1;
-	        let part = new _a(null, ast);
-	        const parts = [];
-	        let acc = '';
-	        while (i < str.length) {
-	            const c = str.charAt(i++);
-	            // still accumulate escapes at this point, but we do ignore
-	            // starts that are escaped
-	            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;
-	            }
-	            const doRecurse = !opt.noext &&
-	                isExtglobType(c) &&
-	                str.charAt(i) === '(' &&
-	                /* c8 ignore start - the maxDepth is sufficient here */
-	                (extDepth <= maxDepth || (ast && ast.#canAdoptType(c)));
-	            /* c8 ignore stop */
-	            if (doRecurse) {
-	                const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
-	                part.push(acc);
-	                acc = '';
-	                const ext = new _a(c, part);
-	                part.push(ext);
-	                i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
-	                continue;
-	            }
-	            if (c === '|') {
-	                part.push(acc);
-	                acc = '';
-	                parts.push(part);
-	                part = new _a(null, ast);
-	                continue;
-	            }
-	            if (c === ')') {
-	                if (acc === '' && ast.#parts.length === 0) {
-	                    ast.#emptyExt = true;
-	                }
-	                part.push(acc);
-	                acc = '';
-	                ast.push(...parts, part);
-	                return i;
-	            }
-	            acc += c;
-	        }
-	        // unfinished extglob
-	        // if we got here, it was a malformed extglob! not an extglob, but
-	        // maybe something else in there.
-	        ast.type = null;
-	        ast.#hasMagic = undefined;
-	        ast.#parts = [str.substring(pos - 1)];
-	        return i;
-	    }
-	    #canAdoptWithSpace(child) {
-	        return this.#canAdopt(child, adoptionWithSpaceMap);
-	    }
-	    #canAdopt(child, map = adoptionMap) {
-	        if (!child ||
-	            typeof child !== 'object' ||
-	            child.type !== null ||
-	            child.#parts.length !== 1 ||
-	            this.type === null) {
-	            return false;
-	        }
-	        const gc = child.#parts[0];
-	        if (!gc || typeof gc !== 'object' || gc.type === null) {
-	            return false;
+
+	    if (negateOffset) this.pattern = pattern.slice(negateOffset);
+	    this.negate = negate;
+	  }
+
+	  // set partial to true to test if, for example,
+	  // "/a/b" matches the start of "/*/b/*/d"
+	  // Partial means, if you run out of file before you run
+	  // out of pattern, then that's fine, as long as all
+	  // the parts match.
+	  matchOne (file, pattern, partial) {
+	    if (pattern.indexOf(GLOBSTAR) !== -1) {
+	      return this._matchGlobstar(file, pattern, partial, 0, 0)
+	    }
+	    return this._matchOne(file, pattern, partial, 0, 0)
+	  }
+
+	  _matchGlobstar (file, pattern, partial, fileIndex, patternIndex) {
+	    // find first globstar from patternIndex
+	    let firstgs = -1;
+	    for (let i = patternIndex; i < pattern.length; i++) {
+	      if (pattern[i] === GLOBSTAR) { firstgs = i; break }
+	    }
+
+	    // find last globstar
+	    let lastgs = -1;
+	    for (let i = pattern.length - 1; i >= 0; i--) {
+	      if (pattern[i] === GLOBSTAR) { lastgs = i; break }
+	    }
+
+	    const head = pattern.slice(patternIndex, firstgs);
+	    const body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs);
+	    const tail = partial ? [] : pattern.slice(lastgs + 1);
+
+	    // check the head
+	    if (head.length) {
+	      const fileHead = file.slice(fileIndex, fileIndex + head.length);
+	      if (!this._matchOne(fileHead, head, partial, 0, 0)) {
+	        return false
+	      }
+	      fileIndex += head.length;
+	    }
+
+	    // check the tail
+	    let fileTailMatch = 0;
+	    if (tail.length) {
+	      if (tail.length + fileIndex > file.length) return false
+
+	      const tailStart = file.length - tail.length;
+	      if (this._matchOne(file, tail, partial, tailStart, 0)) {
+	        fileTailMatch = tail.length;
+	      } else {
+	        // affordance for stuff like a/**/* matching a/b/
+	        if (file[file.length - 1] !== '' ||
+	            fileIndex + tail.length === file.length) {
+	          return false
 	        }
-	        return this.#canAdoptType(gc.type, map);
-	    }
-	    #canAdoptType(c, map = adoptionAnyMap) {
-	        return !!map.get(this.type)?.includes(c);
-	    }
-	    #adoptWithSpace(child, index) {
-	        const gc = child.#parts[0];
-	        const blank = new _a(null, gc, this.options);
-	        blank.#parts.push('');
-	        gc.push(blank);
-	        this.#adopt(child, index);
-	    }
-	    #adopt(child, index) {
-	        const gc = child.#parts[0];
-	        this.#parts.splice(index, 1, ...gc.#parts);
-	        for (const p of gc.#parts) {
-	            if (typeof p === 'object')
-	                p.#parent = this;
-	        }
-	        this.#toString = undefined;
-	    }
-	    #canUsurpType(c) {
-	        const m = usurpMap.get(this.type);
-	        return !!m?.has(c);
-	    }
-	    #canUsurp(child) {
-	        if (!child ||
-	            typeof child !== 'object' ||
-	            child.type !== null ||
-	            child.#parts.length !== 1 ||
-	            this.type === null ||
-	            this.#parts.length !== 1) {
-	            return false;
+	        if (!this._matchOne(file, tail, partial, tailStart - 1, 0)) {
+	          return false
 	        }
-	        const gc = child.#parts[0];
-	        if (!gc || typeof gc !== 'object' || gc.type === null) {
-	            return false;
+	        fileTailMatch = tail.length + 1;
+	      }
+	    }
+
+	    // if body is empty (single ** between head and tail)
+	    if (!body.length) {
+	      let sawSome = !!fileTailMatch;
+	      for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
+	        const f = String(file[i]);
+	        sawSome = true;
+	        if (f === '.' || f === '..' ||
+	            (!this.options.dot && f.charAt(0) === '.')) {
+	          return false
 	        }
-	        return this.#canUsurpType(gc.type);
+	      }
+	      return partial || sawSome
+	    }
+
+	    // split body into segments at each GLOBSTAR
+	    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++;
+	      }
 	    }
-	    #usurp(child) {
-	        const m = usurpMap.get(this.type);
-	        const gc = child.#parts[0];
-	        const nt = m?.get(gc.type);
-	        /* c8 ignore start - impossible */
-	        if (!nt)
-	            return false;
-	        /* c8 ignore stop */
-	        this.#parts = gc.#parts;
-	        for (const p of this.#parts) {
-	            if (typeof p === 'object') {
-	                p.#parent = this;
-	            }
+
+	    let idx = bodySegments.length - 1;
+	    const fileLength = file.length - fileTailMatch;
+	    for (const b of bodySegments) {
+	      b[1] = fileLength - (nonGsPartsSums[idx--] + b[0].length);
+	    }
+
+	    return !!this._matchGlobStarBodySections(
+	      file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch
+	    )
+	  }
+
+	  // return false for "nope, not matching"
+	  // return null for "not matching, cannot keep trying"
+	  _matchGlobStarBodySections (
+	    file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail
+	  ) {
+	    const bs = bodySegments[bodyIndex];
+	    if (!bs) {
+	      // just make sure there are no bad dots
+	      for (let i = fileIndex; i < file.length; i++) {
+	        sawTail = true;
+	        const f = file[i];
+	        if (f === '.' || f === '..' ||
+	            (!this.options.dot && f.charAt(0) === '.')) {
+	          return false
+	        }
+	      }
+	      return sawTail
+	    }
+
+	    const [body, after] = bs;
+	    while (fileIndex <= after) {
+	      const m = this._matchOne(
+	        file.slice(0, fileIndex + body.length),
+	        body,
+	        partial,
+	        fileIndex,
+	        0
+	      );
+	      // if limit exceeded, no match. intentional false negative,
+	      // acceptable break in correctness for security.
+	      if (m && globStarDepth < this.maxGlobstarRecursion) {
+	        const sub = this._matchGlobStarBodySections(
+	          file, bodySegments,
+	          fileIndex + body.length, bodyIndex + 1,
+	          partial, globStarDepth + 1, sawTail
+	        );
+	        if (sub !== false) {
+	          return sub
 	        }
-	        this.type = nt;
-	        this.#toString = undefined;
-	        this.#emptyExt = false;
+	      }
+	      const f = file[fileIndex];
+	      if (f === '.' || f === '..' ||
+	          (!this.options.dot && f.charAt(0) === '.')) {
+	        return false
+	      }
+	      fileIndex++;
 	    }
-	    static fromGlob(pattern, options = {}) {
-	        const ast = new _a(null, undefined, options);
-	        _a.#parseAST(pattern, ast, 0, options, 0);
-	        return ast;
+	    return partial || null
+	  }
+
+	  _matchOne (file, pattern, partial, fileIndex, patternIndex) {
+	    let fi, pi, fl, pl;
+	    for (
+	      fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length
+	      ; (fi < fl) && (pi < pl)
+	      ; fi++, pi++
+	    ) {
+	      this.debug('matchOne loop');
+	      const p = pattern[pi];
+	      const f = file[fi];
+
+	      this.debug(pattern, p, f);
+
+	      // should be impossible.
+	      // some invalid regexp stuff in the set.
+	      /* istanbul ignore if */
+	      if (p === false || p === GLOBSTAR) return false
+
+	      // something other than **
+	      // non-magic patterns just have to match exactly
+	      // patterns with magic have been turned into regexps.
+	      let hit;
+	      if (typeof p === 'string') {
+	        hit = f === p;
+	        this.debug('string match', p, f, hit);
+	      } else {
+	        hit = f.match(p);
+	        this.debug('pattern match', p, f, hit);
+	      }
+
+	      if (!hit) return false
 	    }
-	    // returns the regular expression if there's magic, or the unescaped
-	    // string if not.
-	    toMMPattern() {
-	        // should only be called on root
-	        /* c8 ignore start */
-	        if (this !== this.#root)
-	            return this.#root.toMMPattern();
-	        /* c8 ignore stop */
-	        const glob = this.toString();
-	        const [re, body, hasMagic, uflag] = this.toRegExpSource();
-	        // if we're in nocase mode, and not nocaseMagicOnly, then we do
-	        // still need a regular expression if we have to case-insensitively
-	        // match capital/lowercase characters.
-	        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,
-	        });
+
+	    // now either we fell off the end of the pattern, or we're done.
+	    if (fi === fl && pi === pl) {
+	      // ran out of pattern and filename at the same time.
+	      // an exact hit!
+	      return true
+	    } else if (fi === fl) {
+	      // ran out of file, but still had pattern left.
+	      // this is ok if we're doing the match as part of
+	      // a glob fs traversal.
+	      return partial
+	    } else /* istanbul ignore else */ if (pi === pl) {
+	      // ran out of pattern, still have file left.
+	      // this is only acceptable if we're on the very last
+	      // empty segment of a file with a trailing slash.
+	      // a/* should match a/b/
+	      return (fi === fl - 1) && (file[fi] === '')
+	    }
+
+	    // should be unreachable.
+	    /* istanbul ignore next */
+	    throw new Error('wtf?')
+	  }
+
+	  braceExpand () {
+	    return braceExpand(this.pattern, this.options)
+	  }
+
+	  parse (pattern, isSub) {
+	    assertValidPattern(pattern);
+
+	    const options = this.options;
+
+	    // shortcuts
+	    if (pattern === '**') {
+	      if (!options.noglobstar)
+	        return GLOBSTAR
+	      else
+	        pattern = '*';
 	    }
-	    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.#flatten();
-	            this.#fillNegs();
-	        }
-	        if (!isExtglobAST(this)) {
-	            const noEmpty = this.isStart() &&
-	                this.isEnd() &&
-	                !this.#parts.some(s => typeof s !== 'string');
-	            const src = this.#parts
-	                .map(p => {
-	                const [re, _, hasMagic, uflag] = typeof p === 'string' ?
-	                    _a.#parseGlob(p, this.#hasMagic, noEmpty)
-	                    : p.toRegExpSource(allowDot);
-	                this.#hasMagic = this.#hasMagic || hasMagic;
-	                this.#uflag = this.#uflag || uflag;
-	                return re;
-	            })
-	                .join('');
-	            let start = '';
-	            if (this.isStart()) {
-	                if (typeof this.#parts[0] === 'string') {
-	                    // this is the string that will match the start of the pattern,
-	                    // so we need to protect against dots and such.
-	                    // '.' and '..' cannot match unless the pattern is that exactly,
-	                    // even if it starts with . or dot:true is set.
-	                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
-	                    if (!dotTravAllowed) {
-	                        const aps = addPatternStart;
-	                        // check if we have a possibility of matching . or ..,
-	                        // and prevent that.
-	                        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)));
-	                        // no need to prevent dots if it can't match a dot, or if a
-	                        // sub-pattern will be preventing it anyway.
-	                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-	                        start =
-	                            needNoTrav ? startNoTraversal
-	                                : needNoDot ? startNoDot
-	                                    : '';
-	                    }
-	                }
-	            }
-	            // append the "end of path portion" pattern to negation tails
-	            let end = '';
-	            if (this.isEnd() &&
-	                this.#root.#filledNegs &&
-	                this.#parent?.type === '!') {
-	                end = '(?:$|\\/)';
-	            }
-	            const final = start + src + end;
-	            return [
-	                final,
-	                (0, unescape_js_1.unescape)(src),
-	                (this.#hasMagic = !!this.#hasMagic),
-	                this.#uflag,
-	            ];
+	    if (pattern === '') return ''
+
+	    let re = '';
+	    let hasMagic = false;
+	    let escaping = false;
+	    // ? => one single character
+	    const patternListStack = [];
+	    const negativeLists = [];
+	    let stateChar;
+	    let inClass = false;
+	    let reClassStart = -1;
+	    let classStart = -1;
+	    let cs;
+	    let pl;
+	    let sp;
+	    // . and .. never match anything that doesn't start with .,
+	    // even when options.dot is set.  However, if the pattern
+	    // starts with ., then traversal patterns can match.
+	    let dotTravAllowed = pattern.charAt(0) === '.';
+	    let dotFileAllowed = options.dot || dotTravAllowed;
+	    const patternStart = () =>
+	      dotTravAllowed
+	        ? ''
+	        : dotFileAllowed
+	        ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))'
+	        : '(?!\\.)';
+	    const subPatternStart = (p) =>
+	      p.charAt(0) === '.'
+	        ? ''
+	        : options.dot
+	        ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))'
+	        : '(?!\\.)';
+
+
+	    const clearStateChar = () => {
+	      if (stateChar) {
+	        // we had some state-tracking character
+	        // that wasn't consumed by this pass.
+	        switch (stateChar) {
+	          case '*':
+	            re += star;
+	            hasMagic = true;
+	          break
+	          case '?':
+	            re += qmark;
+	            hasMagic = true;
+	          break
+	          default:
+	            re += '\\' + stateChar;
+	          break
+	        }
+	        this.debug('clearStateChar %j %j', stateChar, re);
+	        stateChar = false;
+	      }
+	    };
+
+	    for (let i = 0, c; (i < pattern.length) && (c = pattern.charAt(i)); i++) {
+	      this.debug('%s\t%s %s %j', pattern, i, re, c);
+
+	      // skip over any that are escaped.
+	      if (escaping) {
+	        /* istanbul ignore next - completely not allowed, even escaped. */
+	        if (c === '/') {
+	          return false
 	        }
-	        // We need to calculate the body *twice* if it's a repeat pattern
-	        // at the start, once in nodot mode, then again in dot mode, so a
-	        // pattern like *(?) can match 'x.y'
-	        const repeated = this.type === '*' || this.type === '+';
-	        // some kind of extglob
-	        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';
-	        let body = this.#partsToRegExp(dot);
-	        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {
-	            // invalid extglob, has to at least be *something* present, if it's
-	            // the entire path portion.
-	            const s = this.toString();
-	            const me = this;
-	            me.#parts = [s];
-	            me.type = null;
-	            me.#hasMagic = undefined;
-	            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})*?`;
-	        }
-	        // an empty !() is exactly equivalent to a starNoEmpty
-	        let final = '';
-	        if (this.type === '!' && this.#emptyExt) {
-	            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
+
+	        if (reSpecials[c]) {
+	          re += '\\';
 	        }
-	        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;
+	        re += c;
+	        escaping = false;
+	        continue
+	      }
+
+	      switch (c) {
+	        /* istanbul ignore next */
+	        case '/': {
+	          // Should already be path-split by now.
+	          return false
 	        }
-	        return [
-	            final,
-	            (0, unescape_js_1.unescape)(body),
-	            (this.#hasMagic = !!this.#hasMagic),
-	            this.#uflag,
-	        ];
+
+	        case '\\':
+	          if (inClass && pattern.charAt(i + 1) === '-') {
+	            re += c;
+	            continue
+	          }
+
+	          clearStateChar();
+	          escaping = true;
+	        continue
+
+	        // the various stateChar values
+	        // for the "extglob" stuff.
+	        case '?':
+	        case '*':
+	        case '+':
+	        case '@':
+	        case '!':
+	          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
+
+	          // all of those are literals inside a class, except that
+	          // the glob [!a] means [^a] in regexp
+	          if (inClass) {
+	            this.debug('  in class');
+	            if (c === '!' && i === classStart + 1) c = '^';
+	            re += c;
+	            continue
+	          }
+
+	          // coalesce consecutive non-globstar * characters
+	          if (c === '*' && stateChar === '*') continue
+
+	          // if we already have a stateChar, then it means
+	          // that there was something like ** or +? in there.
+	          // Handle the stateChar, then proceed with this one.
+	          this.debug('call clearStateChar %j', stateChar);
+	          clearStateChar();
+	          stateChar = c;
+	          // if extglob is disabled, then +(asdf|foo) isn't a thing.
+	          // just clear the statechar *now*, rather than even diving into
+	          // the patternList stuff.
+	          if (options.noext) clearStateChar();
+	        continue
+
+	        case '(': {
+	          if (inClass) {
+	            re += '(';
+	            continue
+	          }
+
+	          if (!stateChar) {
+	            re += '\\(';
+	            continue
+	          }
+
+	          const plEntry = {
+	            type: stateChar,
+	            start: i - 1,
+	            reStart: re.length,
+	            open: plTypes[stateChar].open,
+	            close: plTypes[stateChar].close,
+	          };
+	          this.debug(this.pattern, '\t', plEntry);
+	          patternListStack.push(plEntry);
+	          // negation is (?:(?!(?:js)(?:<rest>))[^/]*)
+	          re += plEntry.open;
+	          // next entry starts with a dot maybe?
+	          if (plEntry.start === 0 && plEntry.type !== '!') {
+	            dotTravAllowed = true;
+	            re += subPatternStart(pattern.slice(i + 1));
+	          }
+	          this.debug('plType %j %j', stateChar, re);
+	          stateChar = false;
+	          continue
+	        }
+
+	        case ')': {
+	          const plEntry = patternListStack[patternListStack.length - 1];
+	          if (inClass || !plEntry) {
+	            re += '\\)';
+	            continue
+	          }
+	          patternListStack.pop();
+
+	          // closing an extglob
+	          clearStateChar();
+	          hasMagic = true;
+	          pl = plEntry;
+	          // negation is (?:(?!js)[^/]*)
+	          // The others are (?:<pattern>)<type>
+	          re += pl.close;
+	          if (pl.type === '!') {
+	            negativeLists.push(Object.assign(pl, { reEnd: re.length }));
+	          }
+	          continue
+	        }
+
+	        case '|': {
+	          const plEntry = patternListStack[patternListStack.length - 1];
+	          if (inClass || !plEntry) {
+	            re += '\\|';
+	            continue
+	          }
+
+	          clearStateChar();
+	          re += '|';
+	          // next subpattern can start with a dot?
+	          if (plEntry.start === 0 && plEntry.type !== '!') {
+	            dotTravAllowed = true;
+	            re += subPatternStart(pattern.slice(i + 1));
+	          }
+	          continue
+	        }
+
+	        // these are mostly the same in regexp and glob
+	        case '[':
+	          // swallow any state-tracking char before the [
+	          clearStateChar();
+
+	          if (inClass) {
+	            re += '\\' + c;
+	            continue
+	          }
+
+	          inClass = true;
+	          classStart = i;
+	          reClassStart = re.length;
+	          re += c;
+	        continue
+
+	        case ']':
+	          //  a right bracket shall lose its special
+	          //  meaning and represent itself in
+	          //  a bracket expression if it occurs
+	          //  first in the list.  -- POSIX.2 2.8.3.2
+	          if (i === classStart + 1 || !inClass) {
+	            re += '\\' + c;
+	            continue
+	          }
+
+	          // split where the last [ was, make sure we don't have
+	          // an invalid re. if so, re-walk the contents of the
+	          // would-be class to re-translate any characters that
+	          // were passed through as-is
+	          // TODO: It would probably be faster to determine this
+	          // without a try/catch and a new RegExp, but it's tricky
+	          // to do safely.  For now, this is safe and works.
+	          cs = pattern.substring(classStart + 1, i);
+	          try {
+	            RegExp('[' + braExpEscape(charUnescape(cs)) + ']');
+	            // looks good, finish up the class.
+	            re += c;
+	          } catch (er) {
+	            // out of order ranges in JS are errors, but in glob syntax,
+	            // they're just a range that matches nothing.
+	            re = re.substring(0, reClassStart) + '(?:$.)'; // match nothing ever
+	          }
+	          hasMagic = true;
+	          inClass = false;
+	        continue
+
+	        default:
+	          // swallow any state char that wasn't consumed
+	          clearStateChar();
+
+	          if (reSpecials[c] && !(c === '^' && inClass)) {
+	            re += '\\';
+	          }
+
+	          re += c;
+	          break
+
+	      } // switch
+	    } // for
+
+	    // handle the case where we left a class open.
+	    // "[abc" is valid, equivalent to "\[abc"
+	    if (inClass) {
+	      // split where the last [ was, and escape it
+	      // this is a huge pita.  We now have to re-walk
+	      // the contents of the would-be class to re-translate
+	      // any characters that were passed through as-is
+	      cs = pattern.slice(classStart + 1);
+	      sp = this.parse(cs, SUBPARSE);
+	      re = re.substring(0, reClassStart) + '\\[' + sp[0];
+	      hasMagic = hasMagic || sp[1];
+	    }
+
+	    // handle the case where we had a +( thing at the *end*
+	    // of the pattern.
+	    // each pattern list stack adds 3 chars, and we need to go through
+	    // and escape any | chars that were passed through as-is for the regexp.
+	    // Go through and escape them, taking care not to double-escape any
+	    // | chars that were already escaped.
+	    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+	      let tail;
+	      tail = re.slice(pl.reStart + pl.open.length);
+	      this.debug('setting tail', re, pl);
+	      // maybe some even number of \, then maybe 1 \, followed by a |
+	      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+	        /* istanbul ignore else - should already be done */
+	        if (!$2) {
+	          // the | isn't already escaped, so escape it.
+	          $2 = '\\';
+	        }
+
+	        // need to escape all those slashes *again*, without escaping the
+	        // one that we need for escaping the | character.  As it works out,
+	        // escaping an even number of slashes can be done by simply repeating
+	        // it exactly after itself.  That's why this trick works.
+	        //
+	        // I am sorry that you have to see this.
+	        return $1 + $1 + $2 + '|'
+	      });
+
+	      this.debug('tail=%j\n   %s', tail, tail, pl, re);
+	      const t = pl.type === '*' ? star
+	        : pl.type === '?' ? qmark
+	        : '\\' + pl.type;
+
+	      hasMagic = true;
+	      re = re.slice(0, pl.reStart) + t + '\\(' + tail;
+	    }
+
+	    // handle trailing things that only matter at the very end.
+	    clearStateChar();
+	    if (escaping) {
+	      // trailing \\
+	      re += '\\\\';
+	    }
+
+	    // only need to apply the nodot start if the re starts with
+	    // something that could conceivably capture a dot
+	    const addPatternStart = addPatternStartSet[re.charAt(0)];
+
+	    // Hack to work around lack of negative lookbehind in JS
+	    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+	    // like 'a.xyz.yz' doesn't match.  So, the first negative
+	    // lookahead, has to look ALL the way ahead, to the end of
+	    // the pattern.
+	    for (let n = negativeLists.length - 1; n > -1; n--) {
+	      const nl = negativeLists[n];
+
+	      const nlBefore = re.slice(0, nl.reStart);
+	      const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+	      let nlAfter = re.slice(nl.reEnd);
+	      const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+
+	      // Handle nested stuff like *(*.js|!(*.json)), where open parens
+	      // mean that we should *not* include the ) in the bit that is considered
+	      // "after" the negated section.
+	      const closeParensBefore = nlBefore.split(')').length;
+	      const openParensBefore = nlBefore.split('(').length - closeParensBefore;
+	      let cleanAfter = nlAfter;
+	      for (let i = 0; i < openParensBefore; i++) {
+	        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
+	      }
+	      nlAfter = cleanAfter;
+
+	      const dollar = nlAfter === '' && isSub !== SUBPARSE ? '(?:$|\\/)' : '';
+
+	      re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+	    }
+
+	    // if the re is not "" at this point, then we need to make sure
+	    // it doesn't match against an empty path part.
+	    // Otherwise a/* will match a/, which it should not.
+	    if (re !== '' && hasMagic) {
+	      re = '(?=.)' + re;
+	    }
+
+	    if (addPatternStart) {
+	      re = patternStart() + re;
+	    }
+
+	    // parsing just a piece of a larger pattern.
+	    if (isSub === SUBPARSE) {
+	      return [re, hasMagic]
+	    }
+
+	    // if it's nocase, and the lcase/uppercase don't match, it's magic
+	    if (options.nocase && !hasMagic) {
+	      hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
+	    }
+
+	    // skip the regexp for non-magical patterns
+	    // unescape anything in it, though, so that it'll be
+	    // an exact match against a file etc.
+	    if (!hasMagic) {
+	      return globUnescape(pattern)
 	    }
-	    #flatten() {
-	        if (!isExtglobAST(this)) {
-	            for (const p of this.#parts) {
-	                if (typeof p === 'object') {
-	                    p.#flatten();
-	                }
-	            }
-	        }
-	        else {
-	            // do up to 10 passes to flatten as much as possible
-	            let iterations = 0;
-	            let done = false;
-	            do {
-	                done = true;
-	                for (let i = 0; i < this.#parts.length; i++) {
-	                    const c = this.#parts[i];
-	                    if (typeof c === 'object') {
-	                        c.#flatten();
-	                        if (this.#canAdopt(c)) {
-	                            done = false;
-	                            this.#adopt(c, i);
-	                        }
-	                        else if (this.#canAdoptWithSpace(c)) {
-	                            done = false;
-	                            this.#adoptWithSpace(c, i);
-	                        }
-	                        else if (this.#canUsurp(c)) {
-	                            done = false;
-	                            this.#usurp(c);
-	                        }
-	                    }
-	                }
-	            } while (!done && ++iterations < 10);
-	        }
-	        this.#toString = undefined;
-	    }
-	    #partsToRegExp(dot) {
-	        return this.#parts
-	            .map(p => {
-	            // extglob ASTs should only contain parent ASTs
-	            /* c8 ignore start */
-	            if (typeof p === 'string') {
-	                throw new Error('string type in extglob ast??');
-	            }
-	            /* c8 ignore stop */
-	            // can ignore hasMagic, because extglobs are already always magic
-	            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;
-	        // multiple stars that aren't globstars coalesce into one *
-	        let inStar = 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 (inStar)
-	                    continue;
-	                inStar = true;
-	                re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
-	                hasMagic = true;
-	                continue;
-	            }
-	            else {
-	                inStar = false;
-	            }
-	            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 === '?') {
-	                re += qmark;
-	                hasMagic = true;
-	                continue;
-	            }
-	            re += regExpEscape(c);
+
+	    const flags = options.nocase ? 'i' : '';
+	    try {
+	      return Object.assign(new RegExp('^' + re + '$', flags), {
+	        _glob: pattern,
+	        _src: re,
+	      })
+	    } catch (er) /* istanbul ignore next - should be impossible */ {
+	      // If it was an invalid regular expression, then it can't match
+	      // anything.  This trick looks for a character after the end of
+	      // the string, which is of course impossible, except in multi-line
+	      // mode, but it's not a /m regex.
+	      return new RegExp('$.')
+	    }
+	  }
+
+	  makeRe () {
+	    if (this.regexp || this.regexp === false) return this.regexp
+
+	    // at this point, this.set is a 2d array of partial
+	    // pattern strings, or "**".
+	    //
+	    // It's better to use .match().  This function shouldn't
+	    // be used, really, but it's pretty convenient sometimes,
+	    // when you just want to work with a regex.
+	    const set = this.set;
+
+	    if (!set.length) {
+	      this.regexp = false;
+	      return this.regexp
+	    }
+	    const options = this.options;
+
+	    const twoStar = options.noglobstar ? star
+	      : options.dot ? twoStarDot
+	      : twoStarNoDot;
+	    const flags = options.nocase ? 'i' : '';
+
+	    // coalesce globstars and regexpify non-globstar patterns
+	    // if it's the only item, then we just do one twoStar
+	    // if it's the first, and there are more, prepend (\/|twoStar\/)? to next
+	    // if it's the last, append (\/twoStar|) to previous
+	    // if it's in the middle, append (\/|\/twoStar\/) to previous
+	    // then filter out GLOBSTAR symbols
+	    let re = set.map(pattern => {
+	      pattern = pattern.map(p =>
+	        typeof p === 'string' ? regExpEscape(p)
+	        : p === GLOBSTAR ? GLOBSTAR
+	        : p._src
+	      ).reduce((set, p) => {
+	        if (!(set[set.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+	          set.push(p);
+	        }
+	        return set
+	      }, []);
+	      pattern.forEach((p, i) => {
+	        if (p !== GLOBSTAR || pattern[i-1] === GLOBSTAR) {
+	          return
+	        }
+	        if (i === 0) {
+	          if (pattern.length > 1) {
+	            pattern[i+1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i+1];
+	          } else {
+	            pattern[i] = twoStar;
+	          }
+	        } else if (i === pattern.length - 1) {
+	          pattern[i-1] += '(?:\\\/|' + twoStar + ')?';
+	        } else {
+	          pattern[i-1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i+1];
+	          pattern[i+1] = GLOBSTAR;
 	        }
-	        return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];
+	      });
+	      return pattern.filter(p => p !== GLOBSTAR).join('/')
+	    }).join('|');
+
+	    // must match entire pattern
+	    // ending in a * or ** will make it less strict.
+	    re = '^(?:' + re + ')$';
+
+	    // can match anything, as long as it's not this.
+	    if (this.negate) re = '^(?!' + re + ').*$';
+
+	    try {
+	      this.regexp = new RegExp(re, flags);
+	    } catch (ex) /* istanbul ignore next - should be impossible */ {
+	      this.regexp = false;
 	    }
-	}
-	ast.AST = AST;
-	_a = AST;
-	
-	return ast;
-}
+	    return this.regexp
+	  }
 
-var _escape = {};
+	  match (f, partial = this.partial) {
+	    this.debug('match', f, this.pattern);
+	    // short-circuit in the case of busted things.
+	    // comments, etc.
+	    if (this.comment) return false
+	    if (this.empty) return f === ''
 
-var hasRequired_escape;
+	    if (f === '/' && partial) return true
 
-function require_escape () {
-	if (hasRequired_escape) return _escape;
-	hasRequired_escape = 1;
-	Object.defineProperty(_escape, "__esModule", { value: true });
-	_escape.escape = void 0;
-	/**
-	 * Escape all magic characters in a glob pattern.
-	 *
-	 * If the {@link MinimatchOptions.windowsPathsNoEscape}
-	 * option is used, then characters are escaped by wrapping in `[]`, because
-	 * a magic character wrapped in a character class can only be satisfied by
-	 * that exact character.  In this mode, `\` is _not_ escaped, because it is
-	 * not interpreted as a magic character, but instead as a path separator.
-	 *
-	 * If the {@link MinimatchOptions.magicalBraces} option is used,
-	 * then braces (`{` and `}`) will be escaped.
-	 */
-	const escape = (s, { windowsPathsNoEscape = false, magicalBraces = false, } = {}) => {
-	    // don't need to escape +@! because we escape the parens
-	    // that make those magic, and escaping ! as [!] isn't valid,
-	    // because [!]] is a valid glob class meaning not ']'.
-	    if (magicalBraces) {
-	        return windowsPathsNoEscape ?
-	            s.replace(/[?*()[\]{}]/g, '[$&]')
-	            : s.replace(/[?*()[\]\\{}]/g, '\\$&');
-	    }
-	    return windowsPathsNoEscape ?
-	        s.replace(/[?*()[\]]/g, '[$&]')
-	        : s.replace(/[?*()[\]\\]/g, '\\$&');
-	};
-	_escape.escape = escape;
-	
-	return _escape;
-}
+	    const options = this.options;
 
-var hasRequiredCommonjs;
+	    // windows: need to use /, not \
+	    if (path.sep !== '/') {
+	      f = f.split(path.sep).join('/');
+	    }
 
-function requireCommonjs () {
-	if (hasRequiredCommonjs) return commonjs$2;
-	hasRequiredCommonjs = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;
-		const brace_expansion_1 = requireCommonjs$1();
-		const assert_valid_pattern_js_1 = requireAssertValidPattern();
-		const ast_js_1 = requireAst();
-		const escape_js_1 = require_escape();
-		const unescape_js_1 = require_unescape();
-		const minimatch = (p, pattern, options = {}) => {
-		    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-		    // shortcut: comments match nothing.
-		    if (!options.nocomment && pattern.charAt(0) === '#') {
-		        return false;
-		    }
-		    return new Minimatch(pattern, options).match(p);
-		};
-		exports.minimatch = minimatch;
-		// Optimized checking for the most common glob patterns.
-		const starDotExtRE = /^\*+([^+@!?*[(]*)$/;
-		const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
-		const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
-		const starDotExtTestNocase = (ext) => {
-		    ext = ext.toLowerCase();
-		    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);
-		};
-		const starDotExtTestNocaseDot = (ext) => {
-		    ext = ext.toLowerCase();
-		    return (f) => f.toLowerCase().endsWith(ext);
-		};
-		const starDotStarRE = /^\*+\.\*+$/;
-		const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');
-		const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');
-		const dotStarRE = /^\.\*+$/;
-		const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');
-		const starRE = /^\*+$/;
-		const starTest = (f) => f.length !== 0 && !f.startsWith('.');
-		const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
-		const qmarksRE = /^\?+([^+@!?*[(]*)?$/;
-		const qmarksTestNocase = ([$0, ext = '']) => {
-		    const noext = qmarksTestNoExt([$0]);
-		    if (!ext)
-		        return noext;
-		    ext = ext.toLowerCase();
-		    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
-		};
-		const qmarksTestNocaseDot = ([$0, ext = '']) => {
-		    const noext = qmarksTestNoExtDot([$0]);
-		    if (!ext)
-		        return noext;
-		    ext = ext.toLowerCase();
-		    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
-		};
-		const qmarksTestDot = ([$0, ext = '']) => {
-		    const noext = qmarksTestNoExtDot([$0]);
-		    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
-		};
-		const qmarksTest = ([$0, ext = '']) => {
-		    const noext = qmarksTestNoExt([$0]);
-		    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
-		};
-		const qmarksTestNoExt = ([$0]) => {
-		    const len = $0.length;
-		    return (f) => f.length === len && !f.startsWith('.');
-		};
-		const qmarksTestNoExtDot = ([$0]) => {
-		    const len = $0.length;
-		    return (f) => f.length === len && f !== '.' && f !== '..';
-		};
-		/* c8 ignore start */
-		const defaultPlatform = (typeof process === 'object' && process ?
-		    (typeof process.env === 'object' &&
-		        process.env &&
-		        process.env.__MINIMATCH_TESTING_PLATFORM__) ||
-		        process.platform
-		    : 'posix');
-		const path = {
-		    win32: { sep: '\\' },
-		    posix: { sep: '/' },
-		};
-		/* c8 ignore stop */
-		exports.sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;
-		exports.minimatch.sep = exports.sep;
-		exports.GLOBSTAR = Symbol('globstar **');
-		exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
-		// any single thing other than /
-		// don't need to escape / when using new RegExp()
-		const qmark = '[^/]';
-		// * => any number of characters
-		const star = qmark + '*?';
-		// ** when dots are allowed.  Anything goes, except .. and .
-		// not (^ or / followed by one or two dots followed by $ or /),
-		// followed by anything, any number of times.
-		const twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?';
-		// not a ^ or / followed by a dot,
-		// followed by anything, any number of times.
-		const twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?';
-		const filter = (pattern, options = {}) => (p) => (0, exports.minimatch)(p, pattern, options);
-		exports.filter = filter;
-		exports.minimatch.filter = exports.filter;
-		const ext = (a, b = {}) => Object.assign({}, a, b);
-		const defaults = (def) => {
-		    if (!def || typeof def !== 'object' || !Object.keys(def).length) {
-		        return exports.minimatch;
-		    }
-		    const orig = exports.minimatch;
-		    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
-		    return Object.assign(m, {
-		        Minimatch: class Minimatch extends orig.Minimatch {
-		            constructor(pattern, options = {}) {
-		                super(pattern, ext(def, options));
-		            }
-		            static defaults(options) {
-		                return orig.defaults(ext(def, options)).Minimatch;
-		            }
-		        },
-		        AST: class AST extends orig.AST {
-		            /* c8 ignore start */
-		            constructor(type, parent, options = {}) {
-		                super(type, parent, ext(def, options));
-		            }
-		            /* c8 ignore stop */
-		            static fromGlob(pattern, options = {}) {
-		                return orig.AST.fromGlob(pattern, ext(def, options));
-		            }
-		        },
-		        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
-		        escape: (s, options = {}) => orig.escape(s, ext(def, options)),
-		        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
-		        defaults: (options) => orig.defaults(ext(def, options)),
-		        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
-		        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-		        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
-		        sep: orig.sep,
-		        GLOBSTAR: exports.GLOBSTAR,
-		    });
-		};
-		exports.defaults = defaults;
-		exports.minimatch.defaults = exports.defaults;
-		// Brace expansion:
-		// a{b,c}d -> abd acd
-		// a{b,}c -> abc ac
-		// a{0..3}d -> a0d a1d a2d a3d
-		// a{b,c{d,e}f}g -> abg acdfg acefg
-		// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-		//
-		// Invalid sets are not expanded.
-		// a{2..}b -> a{2..}b
-		// a{b}c -> a{b}c
-		const braceExpand = (pattern, options = {}) => {
-		    (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-		    // Thanks to Yeting Li <https://github.com/yetingli> for
-		    // improving this regexp to avoid a ReDOS vulnerability.
-		    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-		        // shortcut. no need to expand.
-		        return [pattern];
-		    }
-		    return (0, brace_expansion_1.expand)(pattern, { max: options.braceExpandMax });
-		};
-		exports.braceExpand = braceExpand;
-		exports.minimatch.braceExpand = exports.braceExpand;
-		// parse a component of the expanded set.
-		// At this point, no pattern may contain "/" in it
-		// so we're going to return a 2d array, where each entry is the full
-		// pattern, split on '/', and then turned into a regular expression.
-		// A regexp is made at the end which joins each array with an
-		// escaped /, and another full one which joins each regexp with |.
-		//
-		// Following the lead of Bash 4.1, note that "**" only has special meaning
-		// when it is the *only* thing in a path portion.  Otherwise, any series
-		// of * is equivalent to a single *.  Globstar behavior is enabled by
-		// default, and can be disabled by setting options.noglobstar.
-		const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
-		exports.makeRe = makeRe;
-		exports.minimatch.makeRe = exports.makeRe;
-		const match = (list, pattern, options = {}) => {
-		    const mm = new Minimatch(pattern, options);
-		    list = list.filter(f => mm.match(f));
-		    if (mm.options.nonull && !list.length) {
-		        list.push(pattern);
-		    }
-		    return list;
-		};
-		exports.match = match;
-		exports.minimatch.match = exports.match;
-		// replace stuff like \* with *
-		const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
-		const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-		class Minimatch {
-		    options;
-		    set;
-		    pattern;
-		    windowsPathsNoEscape;
-		    nonegate;
-		    negate;
-		    comment;
-		    empty;
-		    preserveMultipleSlashes;
-		    partial;
-		    globSet;
-		    globParts;
-		    nocase;
-		    isWindows;
-		    platform;
-		    windowsNoMagicRoot;
-		    maxGlobstarRecursion;
-		    regexp;
-		    constructor(pattern, options = {}) {
-		        (0, assert_valid_pattern_js_1.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';
-		        // avoid the annoying deprecation flag lol
-		        const awe = ('allowWindow' + 'sEscape');
-		        this.windowsPathsNoEscape =
-		            !!options.windowsPathsNoEscape || options[awe] === false;
-		        if (this.windowsPathsNoEscape) {
-		            this.pattern = this.pattern.replace(/\\/g, '/');
-		        }
-		        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
-		        this.regexp = null;
-		        this.negate = false;
-		        this.nonegate = !!options.nonegate;
-		        this.comment = false;
-		        this.empty = false;
-		        this.partial = !!options.partial;
-		        this.nocase = !!this.options.nocase;
-		        this.windowsNoMagicRoot =
-		            options.windowsNoMagicRoot !== undefined ?
-		                options.windowsNoMagicRoot
-		                : !!(this.isWindows && this.nocase);
-		        this.globSet = [];
-		        this.globParts = [];
-		        this.set = [];
-		        // make the set of regexps etc.
-		        this.make();
-		    }
-		    hasMagic() {
-		        if (this.options.magicalBraces && this.set.length > 1) {
-		            return true;
-		        }
-		        for (const pattern of this.set) {
-		            for (const part of pattern) {
-		                if (typeof part !== 'string')
-		                    return true;
-		            }
-		        }
-		        return false;
-		    }
-		    debug(..._) { }
-		    make() {
-		        const pattern = this.pattern;
-		        const options = this.options;
-		        // empty patterns and comments match nothing.
-		        if (!options.nocomment && pattern.charAt(0) === '#') {
-		            this.comment = true;
-		            return;
-		        }
-		        if (!pattern) {
-		            this.empty = true;
-		            return;
-		        }
-		        // step 1: figure out negation, etc.
-		        this.parseNegate();
-		        // step 2: expand braces
-		        this.globSet = [...new Set(this.braceExpand())];
-		        if (options.debug) {
-		            //oxlint-disable-next-line no-console
-		            this.debug = (...args) => console.error(...args);
-		        }
-		        this.debug(this.pattern, this.globSet);
-		        // step 3: now we have a set, so turn each one into a series of
-		        // path-portion matching patterns.
-		        // These will be regexps, except in the case of "**", which is
-		        // set to the GLOBSTAR object for globstar behavior,
-		        // and will not contain any / characters
-		        //
-		        // First, we preprocess to make the glob pattern sets a bit simpler
-		        // and deduped.  There are some perf-killing patterns that can cause
-		        // problems with a glob walk, but we can simplify them down a bit.
-		        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));
-		        this.globParts = this.preprocess(rawGlobParts);
-		        this.debug(this.pattern, this.globParts);
-		        // glob --> regexps
-		        let set = this.globParts.map((s, _, __) => {
-		            if (this.isWindows && this.windowsNoMagicRoot) {
-		                // check if it's a drive or unc path.
-		                const isUNC = s[0] === '' &&
-		                    s[1] === '' &&
-		                    (s[2] === '?' || !globMagic.test(s[2])) &&
-		                    !globMagic.test(s[3]);
-		                const isDrive = /^[a-z]:/i.test(s[0]);
-		                if (isUNC) {
-		                    return [
-		                        ...s.slice(0, 4),
-		                        ...s.slice(4).map(ss => this.parse(ss)),
-		                    ];
-		                }
-		                else if (isDrive) {
-		                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];
-		                }
-		            }
-		            return s.map(ss => this.parse(ss));
-		        });
-		        this.debug(this.pattern, set);
-		        // filter out everything that didn't compile properly.
-		        this.set = set.filter(s => s.indexOf(false) === -1);
-		        // do not treat the ? in UNC paths as magic
-		        if (this.isWindows) {
-		            for (let i = 0; i < this.set.length; i++) {
-		                const p = this.set[i];
-		                if (p[0] === '' &&
-		                    p[1] === '' &&
-		                    this.globParts[i][2] === '?' &&
-		                    typeof p[3] === 'string' &&
-		                    /^[a-z]:$/i.test(p[3])) {
-		                    p[2] = '?';
-		                }
-		            }
-		        }
-		        this.debug(this.pattern, this.set);
-		    }
-		    // various transforms to equivalent pattern sets that are
-		    // faster to process in a filesystem walk.  The goal is to
-		    // eliminate what we can, and push all ** patterns as far
-		    // to the right as possible, even if it increases the number
-		    // of patterns that we have to process.
-		    preprocess(globParts) {
-		        // if we're not in globstar mode, then turn ** into *
-		        if (this.options.noglobstar) {
-		            for (const partset of globParts) {
-		                for (let j = 0; j < partset.length; j++) {
-		                    if (partset[j] === '**') {
-		                        partset[j] = '*';
-		                    }
-		                }
-		            }
-		        }
-		        const { optimizationLevel = 1 } = this.options;
-		        if (optimizationLevel >= 2) {
-		            // aggressive optimization for the purpose of fs walking
-		            globParts = this.firstPhasePreProcess(globParts);
-		            globParts = this.secondPhasePreProcess(globParts);
-		        }
-		        else if (optimizationLevel >= 1) {
-		            // just basic optimizations to remove some .. parts
-		            globParts = this.levelOneOptimize(globParts);
-		        }
-		        else {
-		            // just collapse multiple ** portions into one
-		            globParts = this.adjascentGlobstarOptimize(globParts);
-		        }
-		        return globParts;
-		    }
-		    // just get rid of adjascent ** portions
-		    adjascentGlobstarOptimize(globParts) {
-		        return globParts.map(parts => {
-		            let gs = -1;
-		            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
-		                let i = gs;
-		                while (parts[i + 1] === '**') {
-		                    i++;
-		                }
-		                if (i !== gs) {
-		                    parts.splice(gs, i - gs);
-		                }
-		            }
-		            return parts;
-		        });
-		    }
-		    // get rid of adjascent ** and resolve .. portions
-		    levelOneOptimize(globParts) {
-		        return globParts.map(parts => {
-		            parts = parts.reduce((set, part) => {
-		                const prev = set[set.length - 1];
-		                if (part === '**' && prev === '**') {
-		                    return set;
-		                }
-		                if (part === '..') {
-		                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {
-		                        set.pop();
-		                        return set;
-		                    }
-		                }
-		                set.push(part);
-		                return set;
-		            }, []);
-		            return parts.length === 0 ? [''] : parts;
-		        });
-		    }
-		    levelTwoFileOptimize(parts) {
-		        if (!Array.isArray(parts)) {
-		            parts = this.slashSplit(parts);
-		        }
-		        let didSomething = false;
-		        do {
-		            didSomething = false;
-		            // <pre>/<e>/<rest> -> <pre>/<rest>
-		            if (!this.preserveMultipleSlashes) {
-		                for (let i = 1; i < parts.length - 1; i++) {
-		                    const p = parts[i];
-		                    // don't squeeze out UNC patterns
-		                    if (i === 1 && p === '' && parts[0] === '')
-		                        continue;
-		                    if (p === '.' || p === '') {
-		                        didSomething = true;
-		                        parts.splice(i, 1);
-		                        i--;
-		                    }
-		                }
-		                if (parts[0] === '.' &&
-		                    parts.length === 2 &&
-		                    (parts[1] === '.' || parts[1] === '')) {
-		                    didSomething = true;
-		                    parts.pop();
-		                }
-		            }
-		            // <pre>/<p>/../<rest> -> <pre>/<rest>
-		            let dd = 0;
-		            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
-		                const p = parts[dd - 1];
-		                if (p &&
-		                    p !== '.' &&
-		                    p !== '..' &&
-		                    p !== '**' &&
-		                    !(this.isWindows && /^[a-z]:$/i.test(p))) {
-		                    didSomething = true;
-		                    parts.splice(dd - 1, 2);
-		                    dd -= 2;
-		                }
-		            }
-		        } while (didSomething);
-		        return parts.length === 0 ? [''] : parts;
-		    }
-		    // First phase: single-pattern processing
-		    // <pre> is 1 or more portions
-		    // <rest> is 1 or more portions
-		    // <p> is any portion other than ., .., '', or **
-		    // <e> is . or ''
-		    //
-		    // **/.. is *brutal* for filesystem walking performance, because
-		    // it effectively resets the recursive walk each time it occurs,
-		    // and ** cannot be reduced out by a .. pattern part like a regexp
-		    // or most strings (other than .., ., and '') can be.
-		    //
-		    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-		    // <pre>/<e>/<rest> -> <pre>/<rest>
-		    // <pre>/<p>/../<rest> -> <pre>/<rest>
-		    // **/**/<rest> -> **/<rest>
-		    //
-		    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
-		    // this WOULD be allowed if ** did follow symlinks, or * didn't
-		    firstPhasePreProcess(globParts) {
-		        let didSomething = false;
-		        do {
-		            didSomething = false;
-		            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-		            for (let parts of globParts) {
-		                let gs = -1;
-		                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
-		                    let gss = gs;
-		                    while (parts[gss + 1] === '**') {
-		                        // <pre>/**/**/<rest> -> <pre>/**/<rest>
-		                        gss++;
-		                    }
-		                    // eg, if gs is 2 and gss is 4, that means we have 3 **
-		                    // parts, and can remove 2 of them.
-		                    if (gss > gs) {
-		                        parts.splice(gs + 1, gss - gs);
-		                    }
-		                    let next = parts[gs + 1];
-		                    const p = parts[gs + 2];
-		                    const p2 = parts[gs + 3];
-		                    if (next !== '..')
-		                        continue;
-		                    if (!p ||
-		                        p === '.' ||
-		                        p === '..' ||
-		                        !p2 ||
-		                        p2 === '.' ||
-		                        p2 === '..') {
-		                        continue;
-		                    }
-		                    didSomething = true;
-		                    // edit parts in place, and push the new one
-		                    parts.splice(gs, 1);
-		                    const other = parts.slice(0);
-		                    other[gs] = '**';
-		                    globParts.push(other);
-		                    gs--;
-		                }
-		                // <pre>/<e>/<rest> -> <pre>/<rest>
-		                if (!this.preserveMultipleSlashes) {
-		                    for (let i = 1; i < parts.length - 1; i++) {
-		                        const p = parts[i];
-		                        // don't squeeze out UNC patterns
-		                        if (i === 1 && p === '' && parts[0] === '')
-		                            continue;
-		                        if (p === '.' || p === '') {
-		                            didSomething = true;
-		                            parts.splice(i, 1);
-		                            i--;
-		                        }
-		                    }
-		                    if (parts[0] === '.' &&
-		                        parts.length === 2 &&
-		                        (parts[1] === '.' || parts[1] === '')) {
-		                        didSomething = true;
-		                        parts.pop();
-		                    }
-		                }
-		                // <pre>/<p>/../<rest> -> <pre>/<rest>
-		                let dd = 0;
-		                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
-		                    const p = parts[dd - 1];
-		                    if (p && p !== '.' && p !== '..' && p !== '**') {
-		                        didSomething = true;
-		                        const needDot = dd === 1 && parts[dd + 1] === '**';
-		                        const splin = needDot ? ['.'] : [];
-		                        parts.splice(dd - 1, 2, ...splin);
-		                        if (parts.length === 0)
-		                            parts.push('');
-		                        dd -= 2;
-		                    }
-		                }
-		            }
-		        } while (didSomething);
-		        return globParts;
-		    }
-		    // second phase: multi-pattern dedupes
-		    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
-		    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
-		    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
-		    //
-		    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
-		    // ^-- not valid because ** doens't follow symlinks
-		    secondPhasePreProcess(globParts) {
-		        for (let i = 0; i < globParts.length - 1; i++) {
-		            for (let j = i + 1; j < globParts.length; j++) {
-		                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-		                if (matched) {
-		                    globParts[i] = [];
-		                    globParts[j] = matched;
-		                    break;
-		                }
-		            }
-		        }
-		        return globParts.filter(gs => gs.length);
-		    }
-		    partsMatch(a, b, emptyGSMatch = false) {
-		        let ai = 0;
-		        let bi = 0;
-		        let result = [];
-		        let which = '';
-		        while (ai < a.length && bi < b.length) {
-		            if (a[ai] === b[bi]) {
-		                result.push(which === 'b' ? b[bi] : a[ai]);
-		                ai++;
-		                bi++;
-		            }
-		            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {
-		                result.push(a[ai]);
-		                ai++;
-		            }
-		            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {
-		                result.push(b[bi]);
-		                bi++;
-		            }
-		            else if (a[ai] === '*' &&
-		                b[bi] &&
-		                (this.options.dot || !b[bi].startsWith('.')) &&
-		                b[bi] !== '**') {
-		                if (which === 'b')
-		                    return false;
-		                which = 'a';
-		                result.push(a[ai]);
-		                ai++;
-		                bi++;
-		            }
-		            else if (b[bi] === '*' &&
-		                a[ai] &&
-		                (this.options.dot || !a[ai].startsWith('.')) &&
-		                a[ai] !== '**') {
-		                if (which === 'a')
-		                    return false;
-		                which = 'b';
-		                result.push(b[bi]);
-		                ai++;
-		                bi++;
-		            }
-		            else {
-		                return false;
-		            }
-		        }
-		        // if we fall out of the loop, it means they two are identical
-		        // as long as their lengths match
-		        return a.length === b.length && result;
-		    }
-		    parseNegate() {
-		        if (this.nonegate)
-		            return;
-		        const pattern = this.pattern;
-		        let negate = false;
-		        let negateOffset = 0;
-		        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
-		            negate = !negate;
-		            negateOffset++;
-		        }
-		        if (negateOffset)
-		            this.pattern = pattern.slice(negateOffset);
-		        this.negate = negate;
-		    }
-		    // set partial to true to test if, for example,
-		    // "/a/b" matches the start of "/*/b/*/d"
-		    // Partial means, if you run out of file before you run
-		    // out of pattern, then that's fine, as long as all
-		    // the parts match.
-		    matchOne(file, pattern, partial = false) {
-		        let fileStartIndex = 0;
-		        let patternStartIndex = 0;
-		        // UNC paths like //?/X:/... can match X:/... and vice versa
-		        // Drive letters in absolute drive or unc paths are always compared
-		        // case-insensitively.
-		        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]);
-		            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);
-		            const patternUNC = !patternDrive &&
-		                pattern[0] === '' &&
-		                pattern[1] === '' &&
-		                pattern[2] === '?' &&
-		                typeof pattern[3] === 'string' &&
-		                /^[a-z]:$/i.test(pattern[3]);
-		            const fdi = fileUNC ? 3
-		                : fileDrive ? 0
-		                    : undefined;
-		            const pdi = patternUNC ? 3
-		                : patternDrive ? 0
-		                    : undefined;
-		            if (typeof fdi === 'number' && typeof pdi === 'number') {
-		                const [fd, pd] = [
-		                    file[fdi],
-		                    pattern[pdi],
-		                ];
-		                // start matching at the drive letter index of each
-		                if (fd.toLowerCase() === pd.toLowerCase()) {
-		                    pattern[pdi] = fd;
-		                    patternStartIndex = pdi;
-		                    fileStartIndex = fdi;
-		                }
-		            }
-		        }
-		        // resolve and reduce . and .. portions in the file as well.
-		        // don't need to do the second phase, because it's only one string[]
-		        const { optimizationLevel = 1 } = this.options;
-		        if (optimizationLevel >= 2) {
-		            file = this.levelTwoFileOptimize(file);
-		        }
-		        if (pattern.includes(exports.GLOBSTAR)) {
-		            return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
-		        }
-		        return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
-		    }
-		    #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
-		        // split the pattern into head, tail, and middle of ** delimited parts
-		        const firstgs = pattern.indexOf(exports.GLOBSTAR, patternIndex);
-		        const lastgs = pattern.lastIndexOf(exports.GLOBSTAR);
-		        // split the pattern up into globstar-delimited sections
-		        // the tail has to be at the end, and the others just have
-		        // to be found in order from the head.
-		        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),
-		            ];
-		        // check the head, from the current file/pattern index.
-		        if (head.length) {
-		            const fileHead = file.slice(fileIndex, fileIndex + head.length);
-		            if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
-		                return false;
-		            }
-		            fileIndex += head.length;
-		            patternIndex += head.length;
-		        }
-		        // now we know the head matches!
-		        // if the last portion is not empty, it MUST match the end
-		        // check the tail
-		        let fileTailMatch = 0;
-		        if (tail.length) {
-		            // if head + tail > file, then we cannot possibly match
-		            if (tail.length + fileIndex > file.length)
-		                return false;
-		            // try to match the tail
-		            let tailStart = file.length - tail.length;
-		            if (this.#matchOne(file, tail, partial, tailStart, 0)) {
-		                fileTailMatch = tail.length;
-		            }
-		            else {
-		                // affordance for stuff like a/**/* matching a/b/
-		                // if the last file portion is '', and there's more to the pattern
-		                // then try without the '' bit.
-		                if (file[file.length - 1] !== '' ||
-		                    fileIndex + tail.length === file.length) {
-		                    return false;
-		                }
-		                tailStart--;
-		                if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
-		                    return false;
-		                }
-		                fileTailMatch = tail.length + 1;
-		            }
-		        }
-		        // now we know the tail matches!
-		        // the middle is zero or more portions wrapped in **, possibly
-		        // containing more ** sections.
-		        // so a/**/b/**/c/**/d has become **/b/**/c/**
-		        // if it's empty, it means a/**/b, just verify we have no bad dots
-		        // if there's no tail, so it ends on /**, then we must have *something*
-		        // after the head, or it's not a matc
-		        if (!body.length) {
-		            let sawSome = !!fileTailMatch;
-		            for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
-		                const f = String(file[i]);
-		                sawSome = true;
-		                if (f === '.' ||
-		                    f === '..' ||
-		                    (!this.options.dot && f.startsWith('.'))) {
-		                    return false;
-		                }
-		            }
-		            // in partial mode, we just need to get past all file parts
-		            return partial || sawSome;
-		        }
-		        // now we know that there's one or more body sections, which can
-		        // be matched anywhere from the 0 index (because the head was pruned)
-		        // through to the length-fileTailMatch index.
-		        // split the body up into sections, and note the minimum index it can
-		        // be found at (start with the length of all previous segments)
-		        // [section, before, after]
-		        const bodySegments = [[[], 0]];
-		        let currentBody = bodySegments[0];
-		        let nonGsParts = 0;
-		        const nonGsPartsSums = [0];
-		        for (const b of body) {
-		            if (b === exports.GLOBSTAR) {
-		                nonGsPartsSums.push(nonGsParts);
-		                currentBody = [[], 0];
-		                bodySegments.push(currentBody);
-		            }
-		            else {
-		                currentBody[0].push(b);
-		                nonGsParts++;
-		            }
-		        }
-		        let i = bodySegments.length - 1;
-		        const fileLength = file.length - fileTailMatch;
-		        for (const b of bodySegments) {
-		            b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
-		        }
-		        return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
-		    }
-		    // return false for "nope, not matching"
-		    // return null for "not matching, cannot keep trying"
-		    #matchGlobStarBodySections(file, 
-		    // pattern section, last possible position for it
-		    bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
-		        // take the first body segment, and walk from fileIndex to its "after"
-		        // value at the end
-		        // If it doesn't match at that position, we increment, until we hit
-		        // that final possible position, and give up.
-		        // If it does match, then advance and try to rest.
-		        // If any of them fail we keep walking forward.
-		        // this is still a bit recursively painful, but it's more constrained
-		        // than previous implementations, because we never test something that
-		        // can't possibly be a valid matching condition.
-		        const bs = bodySegments[bodyIndex];
-		        if (!bs) {
-		            // just make sure that there's no bad dots
-		            for (let i = fileIndex; i < file.length; i++) {
-		                sawTail = true;
-		                const f = file[i];
-		                if (f === '.' ||
-		                    f === '..' ||
-		                    (!this.options.dot && f.startsWith('.'))) {
-		                    return false;
-		                }
-		            }
-		            return sawTail;
-		        }
-		        // have a non-globstar body section to test
-		        const [body, after] = bs;
-		        while (fileIndex <= after) {
-		            const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
-		            // if limit exceeded, no match. intentional false negative,
-		            // acceptable break in correctness for security.
-		            if (m && globStarDepth < this.maxGlobstarRecursion) {
-		                // match! see if the rest match. if so, we're done!
-		                const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
-		                if (sub !== false) {
-		                    return sub;
-		                }
-		            }
-		            const f = file[fileIndex];
-		            if (f === '.' ||
-		                f === '..' ||
-		                (!this.options.dot && f.startsWith('.'))) {
-		                return false;
-		            }
-		            fileIndex++;
-		        }
-		        // walked off. no point continuing
-		        return partial || null;
-		    }
-		    #matchOne(file, pattern, partial, fileIndex, patternIndex) {
-		        let fi;
-		        let pi;
-		        let pl;
-		        let fl;
-		        for (fi = fileIndex,
-		            pi = patternIndex,
-		            fl = file.length,
-		            pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-		            this.debug('matchOne loop');
-		            let p = pattern[pi];
-		            let f = file[fi];
-		            this.debug(pattern, p, f);
-		            // should be impossible.
-		            // some invalid regexp stuff in the set.
-		            /* c8 ignore start */
-		            if (p === false || p === exports.GLOBSTAR) {
-		                return false;
-		            }
-		            /* c8 ignore stop */
-		            // something other than **
-		            // non-magic patterns just have to match exactly
-		            // patterns with magic have been turned into regexps.
-		            let hit;
-		            if (typeof p === 'string') {
-		                hit = f === p;
-		                this.debug('string match', p, f, hit);
-		            }
-		            else {
-		                hit = p.test(f);
-		                this.debug('pattern match', p, f, hit);
-		            }
-		            if (!hit)
-		                return false;
-		        }
-		        // Note: ending in / means that we'll get a final ""
-		        // at the end of the pattern.  This can only match a
-		        // corresponding "" at the end of the file.
-		        // If the file ends in /, then it can only match a
-		        // a pattern that ends in /, unless the pattern just
-		        // doesn't have any more for it. But, a/b/ should *not*
-		        // match "a/b/*", even though "" matches against the
-		        // [^/]*? pattern, except in partial mode, where it might
-		        // simply not be reached yet.
-		        // However, a/b/ should still satisfy a/*
-		        // now either we fell off the end of the pattern, or we're done.
-		        if (fi === fl && pi === pl) {
-		            // ran out of pattern and filename at the same time.
-		            // an exact hit!
-		            return true;
-		        }
-		        else if (fi === fl) {
-		            // ran out of file, but still had pattern left.
-		            // this is ok if we're doing the match as part of
-		            // a glob fs traversal.
-		            return partial;
-		        }
-		        else if (pi === pl) {
-		            // ran out of pattern, still have file left.
-		            // this is only acceptable if we're on the very last
-		            // empty segment of a file with a trailing slash.
-		            // a/* should match a/b/
-		            return fi === fl - 1 && file[fi] === '';
-		            /* c8 ignore start */
-		        }
-		        else {
-		            // should be unreachable.
-		            throw new Error('wtf?');
-		        }
-		        /* c8 ignore stop */
-		    }
-		    braceExpand() {
-		        return (0, exports.braceExpand)(this.pattern, this.options);
-		    }
-		    parse(pattern) {
-		        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-		        const options = this.options;
-		        // shortcuts
-		        if (pattern === '**')
-		            return exports.GLOBSTAR;
-		        if (pattern === '')
-		            return '';
-		        // far and away, the most common glob pattern parts are
-		        // *, *.*, and *.<ext>  Add a fast check method for those.
-		        let m;
-		        let fastTest = null;
-		        if ((m = pattern.match(starRE))) {
-		            fastTest = options.dot ? starTestDot : starTest;
-		        }
-		        else if ((m = pattern.match(starDotExtRE))) {
-		            fastTest = (options.nocase ?
-		                options.dot ?
-		                    starDotExtTestNocaseDot
-		                    : starDotExtTestNocase
-		                : options.dot ? starDotExtTestDot
-		                    : starDotExtTest)(m[1]);
-		        }
-		        else if ((m = pattern.match(qmarksRE))) {
-		            fastTest = (options.nocase ?
-		                options.dot ?
-		                    qmarksTestNocaseDot
-		                    : qmarksTestNocase
-		                : options.dot ? qmarksTestDot
-		                    : qmarksTest)(m);
-		        }
-		        else if ((m = pattern.match(starDotStarRE))) {
-		            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
-		        }
-		        else if ((m = pattern.match(dotStarRE))) {
-		            fastTest = dotStarTest;
-		        }
-		        const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();
-		        if (fastTest && typeof re === 'object') {
-		            // Avoids overriding in frozen environments
-		            Reflect.defineProperty(re, 'test', { value: fastTest });
-		        }
-		        return re;
-		    }
-		    makeRe() {
-		        if (this.regexp || this.regexp === false)
-		            return this.regexp;
-		        // at this point, this.set is a 2d array of partial
-		        // pattern strings, or "**".
-		        //
-		        // It's better to use .match().  This function shouldn't
-		        // be used, really, but it's pretty convenient sometimes,
-		        // when you just want to work with a regex.
-		        const set = this.set;
-		        if (!set.length) {
-		            this.regexp = false;
-		            return this.regexp;
-		        }
-		        const options = this.options;
-		        const twoStar = options.noglobstar ? star
-		            : options.dot ? twoStarDot
-		                : twoStarNoDot;
-		        const flags = new Set(options.nocase ? ['i'] : []);
-		        // regexpify non-globstar patterns
-		        // if ** is only item, then we just do one twoStar
-		        // if ** is first, and there are more, prepend (\/|twoStar\/)? to next
-		        // if ** is last, append (\/twoStar|) to previous
-		        // if ** is in the middle, append (\/|\/twoStar\/) to previous
-		        // then filter out GLOBSTAR symbols
-		        let re = set
-		            .map(pattern => {
-		            const pp = pattern.map(p => {
-		                if (p instanceof RegExp) {
-		                    for (const f of p.flags.split(''))
-		                        flags.add(f);
-		                }
-		                return (typeof p === 'string' ? regExpEscape(p)
-		                    : p === exports.GLOBSTAR ? exports.GLOBSTAR
-		                        : p._src);
-		            });
-		            pp.forEach((p, i) => {
-		                const next = pp[i + 1];
-		                const prev = pp[i - 1];
-		                if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {
-		                    return;
-		                }
-		                if (prev === undefined) {
-		                    if (next !== undefined && next !== exports.GLOBSTAR) {
-		                        pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
-		                    }
-		                    else {
-		                        pp[i] = twoStar;
-		                    }
-		                }
-		                else if (next === undefined) {
-		                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
-		                }
-		                else if (next !== exports.GLOBSTAR) {
-		                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
-		                    pp[i + 1] = exports.GLOBSTAR;
-		                }
-		            });
-		            const filtered = pp.filter(p => p !== exports.GLOBSTAR);
-		            // For partial matches, we need to make the pattern match
-		            // any prefix of the full path. We do this by generating
-		            // alternative patterns that match progressively longer prefixes.
-		            if (this.partial && filtered.length >= 1) {
-		                const prefixes = [];
-		                for (let i = 1; i <= filtered.length; i++) {
-		                    prefixes.push(filtered.slice(0, i).join('/'));
-		                }
-		                return '(?:' + prefixes.join('|') + ')';
-		            }
-		            return filtered.join('/');
-		        })
-		            .join('|');
-		        // need to wrap in parens if we had more than one thing with |,
-		        // otherwise only the first will be anchored to ^ and the last to $
-		        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];
-		        // must match entire pattern
-		        // ending in a * or ** will make it less strict.
-		        re = '^' + open + re + close + '$';
-		        // In partial mode, '/' should always match as it's a valid prefix for any pattern
-		        if (this.partial) {
-		            re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
-		        }
-		        // can match anything, as long as it's not this.
-		        if (this.negate)
-		            re = '^(?!' + re + ').+$';
-		        try {
-		            this.regexp = new RegExp(re, [...flags].join(''));
-		            /* c8 ignore start */
-		        }
-		        catch {
-		            // should be impossible
-		            this.regexp = false;
-		        }
-		        /* c8 ignore stop */
-		        return this.regexp;
-		    }
-		    slashSplit(p) {
-		        // if p starts with // on windows, we preserve that
-		        // so that UNC paths aren't broken.  Otherwise, any number of
-		        // / characters are coalesced into one, unless
-		        // preserveMultipleSlashes is set to true.
-		        if (this.preserveMultipleSlashes) {
-		            return p.split('/');
-		        }
-		        else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
-		            // add an extra '' for the one we lose
-		            return ['', ...p.split(/\/+/)];
-		        }
-		        else {
-		            return p.split(/\/+/);
-		        }
-		    }
-		    match(f, partial = this.partial) {
-		        this.debug('match', f, this.pattern);
-		        // short-circuit in the case of busted things.
-		        // comments, etc.
-		        if (this.comment) {
-		            return false;
-		        }
-		        if (this.empty) {
-		            return f === '';
-		        }
-		        if (f === '/' && partial) {
-		            return true;
-		        }
-		        const options = this.options;
-		        // windows: need to use /, not \
-		        if (this.isWindows) {
-		            f = f.split('\\').join('/');
-		        }
-		        // treat the test path as a set of pathparts.
-		        const ff = this.slashSplit(f);
-		        this.debug(this.pattern, 'split', ff);
-		        // just ONE of the pattern sets in this.set needs to match
-		        // in order for it to be valid.  If negating, then just one
-		        // match means that we have failed.
-		        // Either way, return on the first hit.
-		        const set = this.set;
-		        this.debug(this.pattern, 'set', set);
-		        // Find the basename of the path by looking for the last non-empty segment
-		        let filename = ff[ff.length - 1];
-		        if (!filename) {
-		            for (let i = ff.length - 2; !filename && i >= 0; i--) {
-		                filename = ff[i];
-		            }
-		        }
-		        for (const pattern of set) {
-		            let file = ff;
-		            if (options.matchBase && pattern.length === 1) {
-		                file = [filename];
-		            }
-		            const hit = this.matchOne(file, pattern, partial);
-		            if (hit) {
-		                if (options.flipNegate) {
-		                    return true;
-		                }
-		                return !this.negate;
-		            }
-		        }
-		        // didn't get any hits.  this is success if it's a negative
-		        // pattern, failure otherwise.
-		        if (options.flipNegate) {
-		            return false;
-		        }
-		        return this.negate;
-		    }
-		    static defaults(def) {
-		        return exports.minimatch.defaults(def).Minimatch;
-		    }
-		}
-		exports.Minimatch = Minimatch;
-		/* c8 ignore start */
-		var ast_js_2 = requireAst();
-		Object.defineProperty(exports, "AST", { enumerable: true, get: function () { return ast_js_2.AST; } });
-		var escape_js_2 = require_escape();
-		Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return escape_js_2.escape; } });
-		var unescape_js_2 = require_unescape();
-		Object.defineProperty(exports, "unescape", { enumerable: true, get: function () { return unescape_js_2.unescape; } });
-		/* c8 ignore stop */
-		exports.minimatch.AST = ast_js_1.AST;
-		exports.minimatch.Minimatch = Minimatch;
-		exports.minimatch.escape = escape_js_1.escape;
-		exports.minimatch.unescape = unescape_js_1.unescape;
-		
-	} (commonjs$2));
-	return commonjs$2;
+	    // treat the test path as a set of pathparts.
+	    f = f.split(slashSplit);
+	    this.debug(this.pattern, 'split', f);
+
+	    // just ONE of the pattern sets in this.set needs to match
+	    // in order for it to be valid.  If negating, then just one
+	    // match means that we have failed.
+	    // Either way, return on the first hit.
+
+	    const set = this.set;
+	    this.debug(this.pattern, 'set', set);
+
+	    // Find the basename of the path by looking for the last non-empty segment
+	    let filename;
+	    for (let i = f.length - 1; i >= 0; i--) {
+	      filename = f[i];
+	      if (filename) break
+	    }
+
+	    for (let i = 0; i < set.length; i++) {
+	      const pattern = set[i];
+	      let file = f;
+	      if (options.matchBase && pattern.length === 1) {
+	        file = [filename];
+	      }
+	      const hit = this.matchOne(file, pattern, partial);
+	      if (hit) {
+	        if (options.flipNegate) return true
+	        return !this.negate
+	      }
+	    }
+
+	    // didn't get any hits.  this is success if it's a negative
+	    // pattern, failure otherwise.
+	    if (options.flipNegate) return false
+	    return this.negate
+	  }
+
+	  static defaults (def) {
+	    return minimatch.defaults(def).Minimatch
+	  }
+	}
+
+	minimatch.Minimatch = Minimatch;
+	return minimatch_1;
 }
 
 var jsYaml$1 = {};
@@ -3760,7 +2592,7 @@ function requireOmap$1 () {
 	function resolveYamlOmap (data) {
 	  if (data === null) return true
 
-	  const objectKeys = [];
+	  const objectKeys = {};
 	  const object = data;
 
 	  for (let index = 0, length = object.length; index < length; index += 1) {
@@ -3779,8 +2611,8 @@ function requireOmap$1 () {
 
 	    if (!pairHasKey) return false
 
-	    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-	    else return false
+	    if (_hasOwnProperty.call(objectKeys, pairKey)) return false
+	    Object.defineProperty(objectKeys, pairKey, { value: true });
 	  }
 
 	  return true
@@ -9099,7 +7931,7 @@ function requireUtils$3 () {
 		exports.dequal = dequal;
 		const fs = require$$0$5;
 		const path_1 = require$$1$4;
-		const minimatch = requireCommonjs();
+		const minimatch = requireMinimatch();
 		const js_yaml_1 = requireJsYaml();
 		const env_1 = requireEnv();
 		const logger_1 = requireLogger();
@@ -13464,10 +12296,6 @@ const navItemSchema = {
         },
         // Allow users to eject the navbar and implement additional levels of nesting
         items: { type: 'array', items: { type: 'object', additionalProperties: true } },
-        rbac: {
-            type: 'object',
-            additionalProperties: { type: 'string' },
-        },
     },
 };
 const navItemsSchema = {
@@ -14745,7 +13573,9 @@ function requireOasTypes () {
 	    if (typeof root.openapi === 'string' && root.openapi.startsWith('3.0')) {
 	        return SpecVersion.OAS3_0;
 	    }
-	    if (typeof root.openapi === 'string' && root.openapi.startsWith('3.1')) {
+	    if (typeof root.openapi === 'string' &&
+	        (root.openapi.startsWith('3.1') || root.openapi.startsWith('3.2')) // temporary support for 3.2
+	    ) {
 	        return SpecVersion.OAS3_1;
 	    }
 	    if (root.swagger && root.swagger === '2.0') {
@@ -30807,7 +29637,7 @@ var redocly = {};
 var registryApi = {};
 
 const name = "@redocly/openapi-core";
-const version = "1.34.5";
+const version = "1.34.19";
 const description = "";
 const main = "lib/index.js";
 const engines = {
@@ -30842,14 +29672,14 @@ const contributors = [
 	"Roman Hotsiy <roman@redocly.com> (https://redocly.com/)"
 ];
 const dependencies = {
-	"@redocly/ajv": "^8.11.2",
-	"@redocly/config": "^0.22.0",
-	colorette: "^1.2.0",
-	"https-proxy-agent": "^7.0.5",
-	"js-levenshtein": "^1.1.6",
-	"js-yaml": "^4.1.0",
-	minimatch: "^5.0.1",
-	pluralize: "^8.0.0",
+	"@redocly/ajv": "8.11.2",
+	"@redocly/config": "0.22.0",
+	colorette: "1.4.0",
+	"https-proxy-agent": "7.0.6",
+	"js-levenshtein": "1.1.6",
+	"js-yaml": "4.3.1",
+	minimatch: "5.1.9",
+	pluralize: "8.0.0",
 	"yaml-ast-parser": "0.0.43"
 };
 const devDependencies = {