@shopware/api-gen 1.4.0 → 1.5.0

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { a as getAugmentedNamespace, c as commonjsGlobal, g as generate, l as loadSchema, v as validateJson } from './shared/api-gen.BWZPGkRz.mjs';
+import { g as getAugmentedNamespace, c as commonjsGlobal, a as generate, l as loadSchema, v as validateJson } from './shared/api-gen.a71ec925.mjs';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { resolve as resolve$4 } from 'node:path';
 import require$$0$5 from 'fs';
@@ -18,9 +18,9 @@ import require$$0$6 from 'buffer';
 import { format as format$5 } from 'prettier';
 import 'openapi-typescript';
 import 'typescript';
+import 'crypto';
 import 'ofetch';
 import 'ts-morph';
-import 'crypto';
 import '@shopware/api-client';
 
 
@@ -33,7 +33,7 @@ const __filename = __cjs_url__.fileURLToPath(import.meta.url);
 const __dirname = __cjs_path__.dirname(__filename);
 const require = __cjs_mod__.createRequire(import.meta.url);
 const name$1 = "@shopware/api-gen";
-const version$2 = "1.4.0";
+const version$2 = "1.5.0";
 const description$2 = "Shopware CLI for API client generation.";
 const author = "Shopware";
 const type$b = "module";
@@ -73,7 +73,7 @@ const scripts = {
 	dev: "export NODE_ENV=development && unbuild --stub",
 	lint: "biome check .",
 	"lint:fix": "biome check --write . && pnpm run typecheck",
-	typecheck: "tsc --noEmit",
+	typecheck: "tsgo --noEmit",
 	test: "vitest run --typecheck",
 	"test:bench": "vitest bench",
 	"test:watch": "vitest --typecheck"
@@ -81,20 +81,21 @@ const scripts = {
 const devDependencies$1 = {
 	"@biomejs/biome": "1.8.3",
 	"@types/prettier": "3.0.0",
-	"@types/yargs": "17.0.33",
-	"@vitest/coverage-v8": "3.2.4",
+	"@types/yargs": "17.0.35",
+	"@typescript/native-preview": "7.0.0-dev.20260111.1",
+	"@vitest/coverage-v8": "4.0.18",
 	json5: "2.2.3",
 	picocolors: "1.1.1",
 	tsconfig: "workspace:*",
 	unbuild: "2.0.0",
-	vitest: "3.2.4"
+	vitest: "4.0.18"
 };
 const dependencies$2 = {
 	"@shopware/api-client": "workspace:*",
-	ofetch: "1.4.1",
+	ofetch: "1.5.1",
 	"openapi-typescript": "7.8.0",
 	prettier: "3.7.4",
-	"ts-morph": "26.0.0",
+	"ts-morph": "27.0.2",
 	typescript: "5.9.3",
 	yargs: "18.0.0"
 };
@@ -188,199 +189,207 @@ var commonjs = {};
 	
 } (commonjs));
 
-Object.defineProperty(commonjs$1, "__esModule", { value: true });
-commonjs$1.expand = expand;
-const balanced_match_1 = commonjs;
-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;
-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) {
-    if (!str) {
-        return [];
-    }
-    // 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), 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;
-}
-function expand_(str, isTop) {
-    /** @type {string[]} */
-    const expansions = [];
-    const m = (0, balanced_match_1.balanced)('{', '}', str);
-    if (!m)
-        return [str];
-    // no need to expand pre, since it is guaranteed to be free of brace-sets
-    const pre = m.pre;
-    const post = m.post.length ? expand_(m.post, false) : [''];
-    if (/\$$/.test(m.pre)) {
-        for (let k = 0; k < post.length; k++) {
-            const expansion = pre + '{' + m.body + '}' + post[k];
-            expansions.push(expansion);
-        }
-    }
-    else {
-        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        const isSequence = isNumericSequence || isAlphaSequence;
-        const isOptions = m.body.indexOf(',') >= 0;
-        if (!isSequence && !isOptions) {
-            // {a},b}
-            if (m.post.match(/,(?!,).*\}/)) {
-                str = m.pre + '{' + m.body + escClose + m.post;
-                return expand_(str);
-            }
-            return [str];
-        }
-        let n;
-        if (isSequence) {
-            n = m.body.split(/\.\./);
-        }
-        else {
-            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], false).map(embrace);
-                //XXX is this necessary? Can't seem to hit it in tests.
-                /* c8 ignore start */
-                if (n.length === 1) {
-                    return post.map(p => m.pre + n[0] + p);
-                }
-                /* c8 ignore stop */
-            }
-        }
-        // at this point, n is the parts, and we know it's not a comma set
-        // with a single entry.
-        let N;
-        if (isSequence && n[0] !== undefined && n[1] !== undefined) {
-            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.abs(numeric(n[2])) : 1;
-            let test = lte;
-            const reverse = y < x;
-            if (reverse) {
-                incr *= -1;
-                test = gte;
-            }
-            const pad = n.some(isPadded);
-            N = [];
-            for (let i = x; test(i, y); 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);
-            }
-        }
-        else {
-            N = [];
-            for (let j = 0; j < n.length; j++) {
-                N.push.apply(N, expand_(n[j], false));
-            }
-        }
-        for (let j = 0; j < N.length; j++) {
-            for (let k = 0; k < post.length; k++) {
-                const expansion = pre + N[j] + post[k];
-                if (!isTop || isSequence || expansion) {
-                    expansions.push(expansion);
-                }
-            }
-        }
-    }
-    return expansions;
-}
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.EXPANSION_MAX = void 0;
+	exports.expand = expand;
+	const balanced_match_1 = commonjs;
+	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;
+	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 } = 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, 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;
+	}
+	function expand_(str, max, isTop) {
+	    /** @type {string[]} */
+	    const expansions = [];
+	    const m = (0, balanced_match_1.balanced)('{', '}', str);
+	    if (!m)
+	        return [str];
+	    // no need to expand pre, since it is guaranteed to be free of brace-sets
+	    const pre = m.pre;
+	    const post = m.post.length ? expand_(m.post, max, false) : [''];
+	    if (/\$$/.test(m.pre)) {
+	        for (let k = 0; k < post.length && k < max; k++) {
+	            const expansion = pre + '{' + m.body + '}' + post[k];
+	            expansions.push(expansion);
+	        }
+	    }
+	    else {
+	        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+	        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+	        const isSequence = isNumericSequence || isAlphaSequence;
+	        const isOptions = m.body.indexOf(',') >= 0;
+	        if (!isSequence && !isOptions) {
+	            // {a},b}
+	            if (m.post.match(/,(?!,).*\}/)) {
+	                str = m.pre + '{' + m.body + escClose + m.post;
+	                return expand_(str, max, true);
+	            }
+	            return [str];
+	        }
+	        let n;
+	        if (isSequence) {
+	            n = m.body.split(/\.\./);
+	        }
+	        else {
+	            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, false).map(embrace);
+	                //XXX is this necessary? Can't seem to hit it in tests.
+	                /* c8 ignore start */
+	                if (n.length === 1) {
+	                    return post.map(p => m.pre + n[0] + p);
+	                }
+	                /* c8 ignore stop */
+	            }
+	        }
+	        // at this point, n is the parts, and we know it's not a comma set
+	        // with a single entry.
+	        let N;
+	        if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+	            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);
+	            N = [];
+	            for (let i = x; test(i, y); 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);
+	            }
+	        }
+	        else {
+	            N = [];
+	            for (let j = 0; j < n.length; j++) {
+	                N.push.apply(N, expand_(n[j], max, false));
+	            }
+	        }
+	        for (let j = 0; j < N.length; j++) {
+	            for (let k = 0; k < post.length && expansions.length < max; k++) {
+	                const expansion = pre + N[j] + post[k];
+	                if (!isTop || isSequence || expansion) {
+	                    expansions.push(expansion);
+	                }
+	            }
+	        }
+	    }
+	    return expansions;
+	}
+	
+} (commonjs$1));
 
 var assertValidPattern$1 = {};
 
@@ -543,10 +552,8 @@ const parseClass = (glob, position) => {
     }
     const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
     const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
-    const comb = ranges.length && negs.length
-        ? '(' + sranges + '|' + snegs + ')'
-        : ranges.length
-            ? sranges
+    const comb = ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
+        : ranges.length ? sranges
             : snegs;
     return [comb, uflag, endPos - pos, true];
 };
@@ -559,31 +566,147 @@ _unescape.unescape = void 0;
 /**
  * Un-escape a string that has been escaped with {@link escape}.
  *
- * If the {@link windowsPathsNoEscape} option is used, then square-brace
- * escapes are removed, but not backslash escapes.  For example, it will turn
- * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
- * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
+ * 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 brace escapes and
+ * 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, } = {}) => {
-    return windowsPathsNoEscape
-        ? s.replace(/\[([^\/\\])\]/g, '$1')
-        : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+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;
 
 // parse a single path portion
+var _a;
 Object.defineProperty(ast$3, "__esModule", { value: true });
 ast$3.AST = void 0;
 const brace_expressions_js_1 = braceExpressions;
 const unescape_js_1 = _unescape;
 const types$3 = new Set(['!', '?', '+', '*', '@']);
 const isExtglobType = (c) => types$3.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.
@@ -607,6 +730,7 @@ const star = qmark + '*?';
 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;
@@ -622,6 +746,22 @@ class AST {
     // 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,
+        };
+    }
     constructor(type, parent, options = {}) {
         this.type = type;
         // extglobs are inherently magical
@@ -700,7 +840,8 @@ class AST {
             if (p === '')
                 continue;
             /* c8 ignore start */
-            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {
+            if (typeof p !== 'string' &&
+                !(p instanceof _a && p.#parent === this)) {
                 throw new Error('invalid part: ' + p);
             }
             /* c8 ignore stop */
@@ -708,8 +849,10 @@ class AST {
         }
     }
     toJSON() {
-        const ret = this.type === null
-            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : 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([]);
@@ -732,7 +875,7 @@ class AST {
         const p = this.#parent;
         for (let i = 0; i < this.#parentIndex; i++) {
             const pp = p.#parts[i];
-            if (!(pp instanceof AST && pp.type === '!')) {
+            if (!(pp instanceof _a && pp.type === '!')) {
                 return false;
             }
         }
@@ -760,13 +903,14 @@ class AST {
             this.push(part.clone(this));
     }
     clone(parent) {
-        const c = new AST(this.type, 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) {
+    static #parseAST(str, ast, pos, opt, extDepth) {
+        const maxDepth = opt.maxExtglobRecursion ?? 2;
         let escaping = false;
         let inBrace = false;
         let braceStart = -1;
@@ -803,11 +947,17 @@ class AST {
                     acc += c;
                     continue;
                 }
-                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
+                // 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 AST(c, ast);
-                    i = AST.#parseAST(str, ext, i, opt);
+                    const ext = new _a(c, ast);
+                    i = _a.#parseAST(str, ext, i, opt, extDepth + 1);
                     ast.push(ext);
                     continue;
                 }
@@ -819,7 +969,7 @@ class AST {
         // some kind of extglob, pos is at the (
         // find the next | or )
         let i = pos + 1;
-        let part = new AST(null, ast);
+        let part = new _a(null, ast);
         const parts = [];
         let acc = '';
         while (i < str.length) {
@@ -850,19 +1000,26 @@ class AST {
                 acc += c;
                 continue;
             }
-            if (isExtglobType(c) && str.charAt(i) === '(') {
+            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 AST(c, part);
+                const ext = new _a(c, part);
                 part.push(ext);
-                i = AST.#parseAST(str, ext, i, opt);
+                i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
                 continue;
             }
             if (c === '|') {
                 part.push(acc);
                 acc = '';
                 parts.push(part);
-                part = new AST(null, ast);
+                part = new _a(null, ast);
                 continue;
             }
             if (c === ')') {
@@ -884,9 +1041,82 @@ class AST {
         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;
+        }
+        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;
+        }
+        const gc = child.#parts[0];
+        if (!gc || typeof gc !== 'object' || gc.type === null) {
+            return false;
+        }
+        return this.#canUsurpType(gc.type);
+    }
+    #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;
+            }
+        }
+        this.type = nt;
+        this.#toString = undefined;
+        this.#emptyExt = false;
+    }
     static fromGlob(pattern, options = {}) {
-        const ast = new AST(null, undefined, options);
-        AST.#parseAST(pattern, ast, 0, options);
+        const ast = new _a(null, undefined, options);
+        _a.#parseAST(pattern, ast, 0, options, 0);
         return ast;
     }
     // returns the regular expression if there's magic, or the unescaped
@@ -990,14 +1220,18 @@ class AST {
     // or start or whatever) and prepend ^ or / at the Regexp construction.
     toRegExpSource(allowDot) {
         const dot = allowDot ?? !!this.#options.dot;
-        if (this.#root === this)
+        if (this.#root === this) {
+            this.#flatten();
             this.#fillNegs();
-        if (!this.type) {
-            const noEmpty = this.isStart() && this.isEnd();
+        }
+        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'
-                    ? AST.#parseGlob(p, this.#hasMagic, noEmpty)
+                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;
@@ -1026,7 +1260,10 @@ class AST {
                         // 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 : '';
+                        start =
+                            needNoTrav ? startNoTraversal
+                                : needNoDot ? startNoDot
+                                    : '';
                     }
                 }
             }
@@ -1056,14 +1293,14 @@ class AST {
             // invalid extglob, has to at least be *something* present, if it's
             // the entire path portion.
             const s = this.toString();
-            this.#parts = [s];
-            this.type = null;
-            this.#hasMagic = undefined;
+            const me = this;
+            me.#parts = [s];
+            me.type = null;
+            me.#hasMagic = undefined;
             return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
         }
-        // XXX abstract out this map method
-        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot
-            ? ''
+        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ?
+            ''
             : this.#partsToRegExp(true);
         if (bodyDotAllowed === body) {
             bodyDotAllowed = '';
@@ -1077,20 +1314,16 @@ class AST {
             final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
         }
         else {
-            const close = this.type === '!'
-                ? // !() must match something,but !(x) can match ''
-                    '))' +
-                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +
-                        star +
-                        ')'
-                : this.type === '@'
-                    ? ')'
-                    : this.type === '?'
-                        ? ')?'
-                        : this.type === '+' && bodyDotAllowed
-                            ? ')'
-                            : this.type === '*' && bodyDotAllowed
-                                ? `)?`
+            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;
         }
@@ -1101,6 +1334,42 @@ class AST {
             this.#uflag,
         ];
     }
+    #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 => {
@@ -1122,6 +1391,8 @@ class AST {
         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) {
@@ -1129,6 +1400,17 @@ class AST {
                 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 += '\\\\';
@@ -1148,14 +1430,6 @@ class AST {
                     continue;
                 }
             }
-            if (c === '*') {
-                if (noEmpty && glob === '*')
-                    re += starNoEmpty;
-                else
-                    re += star;
-                hasMagic = true;
-                continue;
-            }
             if (c === '?') {
                 re += qmark;
                 hasMagic = true;
@@ -1167,6 +1441,7 @@ class AST {
     }
 }
 ast$3.AST = AST;
+_a = AST;
 
 var _escape = {};
 
@@ -1175,18 +1450,26 @@ _escape.escape = void 0;
 /**
  * Escape all magic characters in a glob pattern.
  *
- * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * 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, } = {}) => {
+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 ']'.
-    return windowsPathsNoEscape
-        ? s.replace(/[?*()[\]]/g, '[$&]')
+    if (magicalBraces) {
+        return windowsPathsNoEscape ?
+            s.replace(/[?*()[\]{}]/g, '[$&]')
+            : s.replace(/[?*()[\]\\{}]/g, '\\$&');
+    }
+    return windowsPathsNoEscape ?
+        s.replace(/[?*()[\]]/g, '[$&]')
         : s.replace(/[?*()[\]\\]/g, '\\$&');
 };
 _escape.escape = escape;
@@ -1260,8 +1543,8 @@ _escape.escape = escape;
 	    return (f) => f.length === len && f !== '.' && f !== '..';
 	};
 	/* c8 ignore start */
-	const defaultPlatform = (typeof process === 'object' && process
-	    ? (typeof process.env === 'object' &&
+	const defaultPlatform = (typeof process === 'object' && process ?
+	    (typeof process.env === 'object' &&
 	        process.env &&
 	        process.env.__MINIMATCH_TESTING_PLATFORM__) ||
 	        process.platform
@@ -1347,7 +1630,7 @@ _escape.escape = escape;
 	        // shortcut. no need to expand.
 	        return [pattern];
 	    }
-	    return (0, brace_expansion_1.expand)(pattern);
+	    return (0, brace_expansion_1.expand)(pattern, { max: options.braceExpandMax });
 	};
 	exports.braceExpand = braceExpand;
 	exports.minimatch.braceExpand = exports.braceExpand;
@@ -1395,16 +1678,20 @@ _escape.escape = escape;
 	    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.allowWindowsEscape === false;
+	            !!options.windowsPathsNoEscape || options[awe] === false;
 	        if (this.windowsPathsNoEscape) {
 	            this.pattern = this.pattern.replace(/\\/g, '/');
 	        }
@@ -1417,8 +1704,8 @@ _escape.escape = escape;
 	        this.partial = !!options.partial;
 	        this.nocase = !!this.options.nocase;
 	        this.windowsNoMagicRoot =
-	            options.windowsNoMagicRoot !== undefined
-	                ? options.windowsNoMagicRoot
+	            options.windowsNoMagicRoot !== undefined ?
+	                options.windowsNoMagicRoot
 	                : !!(this.isWindows && this.nocase);
 	        this.globSet = [];
 	        this.globParts = [];
@@ -1481,7 +1768,10 @@ _escape.escape = escape;
 	                    !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))];
+	                    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))];
@@ -1513,7 +1803,7 @@ _escape.escape = escape;
 	    // 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 all ** into *
+	        // if we're not in globstar mode, then turn ** into *
 	        if (this.options.noglobstar) {
 	            for (let i = 0; i < globParts.length; i++) {
 	                for (let j = 0; j < globParts[i].length; j++) {
@@ -1799,7 +2089,8 @@ _escape.escape = escape;
 	    // out of pattern, then that's fine, as long as all
 	    // the parts match.
 	    matchOne(file, pattern, partial = false) {
-	        const options = this.options;
+	        let fileStartIndex = 0;
+	        let patternStartIndex = 0;
 	        // UNC paths like //?/X:/... can match X:/... and vice versa
 	        // Drive letters in absolute drive or unc paths are always compared
 	        // case-insensitively.
@@ -1817,120 +2108,210 @@ _escape.escape = escape;
 	                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;
+	            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]];
+	                const [fd, pd] = [
+	                    file[fdi],
+	                    pattern[pdi],
+	                ];
+	                // start matching at the drive letter index of each
 	                if (fd.toLowerCase() === pd.toLowerCase()) {
 	                    pattern[pdi] = fd;
-	                    if (pdi > fdi) {
-	                        pattern = pattern.slice(pdi);
-	                    }
-	                    else if (fdi > pdi) {
-	                        file = file.slice(fdi);
-	                    }
+	                    patternStartIndex = pdi;
+	                    fileStartIndex = fdi;
 	                }
 	            }
 	        }
 	        // resolve and reduce . and .. portions in the file as well.
-	        // dont' need to do the second phase, because it's only one string[]
+	        // 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);
 	        }
-	        this.debug('matchOne', this, { file, pattern });
-	        this.debug('matchOne', file.length, pattern.length);
-	        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+	        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');
-	            var p = pattern[pi];
-	            var f = file[fi];
+	            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) {
+	            if (p === false || p === exports.GLOBSTAR) {
 	                return false;
 	            }
 	            /* c8 ignore stop */
-	            if (p === exports.GLOBSTAR) {
-	                this.debug('GLOBSTAR', [pattern, p, f]);
-	                // "**"
-	                // a/**/b/**/c would match the following:
-	                // a/b/x/y/z/c
-	                // a/x/y/z/b/c
-	                // a/b/x/b/x/c
-	                // a/b/c
-	                // To do this, take the rest of the pattern after
-	                // the **, and see if it would match the file remainder.
-	                // If so, return success.
-	                // If not, the ** "swallows" a segment, and try again.
-	                // This is recursively awful.
-	                //
-	                // a/**/b/**/c matching a/b/x/y/z/c
-	                // - a matches a
-	                // - doublestar
-	                //   - matchOne(b/x/y/z/c, b/**/c)
-	                //     - b matches b
-	                //     - doublestar
-	                //       - matchOne(x/y/z/c, c) -> no
-	                //       - matchOne(y/z/c, c) -> no
-	                //       - matchOne(z/c, c) -> no
-	                //       - matchOne(c, c) yes, hit
-	                var fr = fi;
-	                var pr = pi + 1;
-	                if (pr === pl) {
-	                    this.debug('** at the end');
-	                    // a ** at the end will just swallow the rest.
-	                    // We have found a match.
-	                    // however, it will not swallow /.x, unless
-	                    // options.dot is set.
-	                    // . and .. are *never* matched by **, for explosively
-	                    // exponential reasons.
-	                    for (; fi < fl; fi++) {
-	                        if (file[fi] === '.' ||
-	                            file[fi] === '..' ||
-	                            (!options.dot && file[fi].charAt(0) === '.'))
-	                            return false;
-	                    }
-	                    return true;
-	                }
-	                // ok, let's see if we can swallow whatever we can.
-	                while (fr < fl) {
-	                    var swallowee = file[fr];
-	                    this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
-	                    // XXX remove this slice.  Just pass the start index.
-	                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-	                        this.debug('globstar found match!', fr, fl, swallowee);
-	                        // found a match.
-	                        return true;
-	                    }
-	                    else {
-	                        // can't swallow "." or ".." ever.
-	                        // can only swallow ".foo" when explicitly asked.
-	                        if (swallowee === '.' ||
-	                            swallowee === '..' ||
-	                            (!options.dot && swallowee.charAt(0) === '.')) {
-	                            this.debug('dot detected!', file, fr, pattern, pr);
-	                            break;
-	                        }
-	                        // ** swallows a segment, and continue.
-	                        this.debug('globstar swallow a segment, and continue');
-	                        fr++;
-	                    }
-	                }
-	                // no match was found.
-	                // However, in partial mode, we can't say this is necessarily over.
-	                /* c8 ignore start */
-	                if (partial) {
-	                    // ran out of file
-	                    this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-	                    if (fr === fl) {
-	                        return true;
-	                    }
-	                }
-	                /* c8 ignore stop */
-	                return false;
-	            }
 	            // something other than **
 	            // non-magic patterns just have to match exactly
 	            // patterns with magic have been turned into regexps.
@@ -2001,21 +2382,19 @@ _escape.escape = escape;
 	            fastTest = options.dot ? starTestDot : starTest;
 	        }
 	        else if ((m = pattern.match(starDotExtRE))) {
-	            fastTest = (options.nocase
-	                ? options.dot
-	                    ? starDotExtTestNocaseDot
+	            fastTest = (options.nocase ?
+	                options.dot ?
+	                    starDotExtTestNocaseDot
 	                    : starDotExtTestNocase
-	                : options.dot
-	                    ? starDotExtTestDot
+	                : options.dot ? starDotExtTestDot
 	                    : starDotExtTest)(m[1]);
 	        }
 	        else if ((m = pattern.match(qmarksRE))) {
-	            fastTest = (options.nocase
-	                ? options.dot
-	                    ? qmarksTestNocaseDot
+	            fastTest = (options.nocase ?
+	                options.dot ?
+	                    qmarksTestNocaseDot
 	                    : qmarksTestNocase
-	                : options.dot
-	                    ? qmarksTestDot
+	                : options.dot ? qmarksTestDot
 	                    : qmarksTest)(m);
 	        }
 	        else if ((m = pattern.match(starDotStarRE))) {
@@ -2046,10 +2425,8 @@ _escape.escape = escape;
 	            return this.regexp;
 	        }
 	        const options = this.options;
-	        const twoStar = options.noglobstar
-	            ? star
-	            : options.dot
-	                ? twoStarDot
+	        const twoStar = options.noglobstar ? star
+	            : options.dot ? twoStarDot
 	                : twoStarNoDot;
 	        const flags = new Set(options.nocase ? ['i'] : []);
 	        // regexpify non-globstar patterns
@@ -2065,11 +2442,9 @@ _escape.escape = escape;
 	                    for (const f of p.flags.split(''))
 	                        flags.add(f);
 	                }
-	                return typeof p === 'string'
-	                    ? regExpEscape(p)
-	                    : p === exports.GLOBSTAR
-	                        ? exports.GLOBSTAR
-	                        : p._src;
+	                return (typeof p === 'string' ? regExpEscape(p)
+	                    : p === exports.GLOBSTAR ? exports.GLOBSTAR
+	                        : p._src);
 	            });
 	            pp.forEach((p, i) => {
 	                const next = pp[i + 1];
@@ -2086,14 +2461,25 @@ _escape.escape = escape;
 	                    }
 	                }
 	                else if (next === undefined) {
-	                    pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
+	                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
 	                }
 	                else if (next !== exports.GLOBSTAR) {
 	                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
 	                    pp[i + 1] = exports.GLOBSTAR;
 	                }
 	            });
-	            return pp.filter(p => p !== exports.GLOBSTAR).join('/');
+	            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 |,
@@ -2102,6 +2488,10 @@ _escape.escape = escape;
 	        // 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 + ').+$';