eslint-linter-browserify 10.0.2 → 10.1.0

package/linter.cjs

@@ -4003,7 +4003,7 @@ function requireEslintScope () {
 	}
 
 	/** @name module:escope.version */
-	const version = "9.1.1"; // x-release-please-version
+	const version = "9.1.2"; // x-release-please-version
 
 	/* vim: set sw=4 ts=4 et tw=80 : */
 
@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.0.2";
+var version = "10.1.0";
 var require$$3$1 = {
 	version: version};
 
@@ -8346,7 +8346,6 @@ function requireUtils$1 () {
 		for (
 			let minIndex = 0, maxIndex = tokens.length - 1;
 			minIndex <= maxIndex;
-
 		) {
 			/*
 			 * Calculate the index in the middle between minIndex and maxIndex.
@@ -22788,7 +22787,7 @@ function requireCommonjs$1 () {
 		const openPattern = /\\{/g;
 		const closePattern = /\\}/g;
 		const commaPattern = /\\,/g;
-		const periodPattern = /\\./g;
+		const periodPattern = /\\\./g;
 		exports$1.EXPANSION_MAX = 100_000;
 		function numeric(str) {
 		    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
@@ -23208,12 +23207,114 @@ function requireAst$1 () {
 	if (hasRequiredAst$1) return ast$1;
 	hasRequiredAst$1 = 1;
 	// parse a single path portion
+	var _a;
 	Object.defineProperty(ast$1, "__esModule", { value: true });
 	ast$1.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.
@@ -23237,6 +23338,7 @@ function requireAst$1 () {
 	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;
@@ -23252,6 +23354,22 @@ function requireAst$1 () {
 	    // 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
@@ -23331,7 +23449,7 @@ function requireAst$1 () {
 	                continue;
 	            /* c8 ignore start */
 	            if (typeof p !== 'string' &&
-	                !(p instanceof AST && p.#parent === this)) {
+	                !(p instanceof _a && p.#parent === this)) {
 	                throw new Error('invalid part: ' + p);
 	            }
 	            /* c8 ignore stop */
@@ -23365,7 +23483,7 @@ function requireAst$1 () {
 	        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;
 	            }
 	        }
@@ -23393,13 +23511,14 @@ function requireAst$1 () {
 	            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;
@@ -23436,11 +23555,17 @@ function requireAst$1 () {
 	                    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;
 	                }
@@ -23452,7 +23577,7 @@ function requireAst$1 () {
 	        // 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) {
@@ -23483,19 +23608,26 @@ function requireAst$1 () {
 	                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 === ')') {
@@ -23517,9 +23649,82 @@ function requireAst$1 () {
 	        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
@@ -23623,16 +23828,18 @@ function requireAst$1 () {
 	    // 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) {
+	        }
+	        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)
+	                    _a.#parseGlob(p, this.#hasMagic, noEmpty)
 	                    : p.toRegExpSource(allowDot);
 	                this.#hasMagic = this.#hasMagic || hasMagic;
 	                this.#uflag = this.#uflag || uflag;
@@ -23694,12 +23901,12 @@ function requireAst$1 () {
 	            // 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 ?
 	            ''
 	            : this.#partsToRegExp(true);
@@ -23735,6 +23942,42 @@ function requireAst$1 () {
 	            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 => {
@@ -23806,6 +24049,7 @@ function requireAst$1 () {
 	    }
 	}
 	ast$1.AST = AST;
+	_a = AST;
 	
 	return ast$1;
 }
@@ -24058,11 +24302,13 @@ function requireCommonjs () {
 		    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';
@@ -24467,7 +24713,8 @@ function requireCommonjs () {
 		    // 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.
@@ -24496,14 +24743,11 @@ function requireCommonjs () {
 		                    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;
 		                }
 		            }
 		        }
@@ -24513,99 +24757,185 @@ function requireCommonjs () {
 		        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$1.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$1.GLOBSTAR, patternIndex);
+		        const lastgs = pattern.lastIndexOf(exports$1.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$1.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$1.GLOBSTAR) {
 		                return false;
 		            }
 		            /* c8 ignore stop */
-		            if (p === exports$1.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.
@@ -25065,8 +25395,12 @@ function requireCjs$1 () {
 	/** @import * as $typests from "./types.ts"; */
 	/** @typedef {$typests.BuiltInMergeStrategy} BuiltInMergeStrategy */
 	/** @typedef {$typests.BuiltInValidationStrategy} BuiltInValidationStrategy */
+	/** @typedef {$typests.CustomMergeStrategy} CustomMergeStrategy */
+	/** @typedef {$typests.CustomValidationStrategy} CustomValidationStrategy */
 	/** @typedef {$typests.ObjectDefinition} ObjectDefinition */
 	/** @typedef {$typests.PropertyDefinition} PropertyDefinition */
+	/** @typedef {$typests.PropertyDefinitionWithSchema} PropertyDefinitionWithSchema */
+	/** @typedef {$typests.PropertyDefinitionWithStrategies} PropertyDefinitionWithStrategies */
 
 	//-----------------------------------------------------------------------------
 	// Private
@@ -25579,6 +25913,9 @@ function requireCjs () {
 
 		/** @import * as $typests from "./types.ts"; */
 		/** @typedef {$typests.ConfigObject} ConfigObject */
+		/** @typedef {$typests.FileMatcher} FileMatcher */
+		/** @typedef {$typests.FilesMatcher} FilesMatcher */
+		/** @typedef {$typests.ExtraConfigType} ExtraConfigType */
 		/** @import * as $minimatch from "minimatch"; */
 		/** @typedef {$minimatch.MinimatchOptions} MinimatchOptions */
 		/** @import * as PathImpl from "@jsr/std__path" */
@@ -25621,7 +25958,7 @@ function requireCjs () {
 
 		/**
 		 * The types of config objects that are supported.
-		 * @type {Set<string>}
+		 * @type {Set<ExtraConfigType>}
 		 */
 		const CONFIG_TYPES = new Set(["array", "function"]);
 
@@ -25706,7 +26043,7 @@ function requireCjs () {
 
 		/**
 		 * Rethrows a config error with additional information about the config object.
-		 * @param {object} config The config object to get the name of.
+		 * @param {ConfigObject} config The config object to get the name of.
 		 * @param {number} index The index of the config object in the array.
 		 * @param {Error} error The error to rethrow.
 		 * @throws {ConfigError} When the error is rethrown for a config.
@@ -25719,7 +26056,7 @@ function requireCjs () {
 		/**
 		 * Shorthand for checking if a value is a string.
 		 * @param {any} value The value to check.
-		 * @returns {boolean} True if a string, false if not.
+		 * @returns {value is string} True if a string, false if not.
 		 */
 		function isString(value) {
 			return typeof value === "string";
@@ -25779,8 +26116,8 @@ function requireCjs () {
 		 * faster matching speed over multiple file path evaluations.
 		 * @param {string} filepath The file path to match.
 		 * @param {string} pattern The glob pattern to match against.
-		 * @param {object} options The minimatch options to use.
-		 * @returns
+		 * @param {MinimatchOptions} options The minimatch options to use.
+		 * @returns {boolean} True if the file path matches, false if not.
 		 */
 		function doMatch(filepath, pattern, options = {}) {
 			let cache = minimatchCache;
@@ -25804,8 +26141,8 @@ function requireCjs () {
 
 		/**
 		 * Normalizes a pattern by removing the leading "./" if present.
-		 * @param {string} pattern The pattern to normalize.
-		 * @returns {string} The normalized pattern.
+		 * @param {FileMatcher} pattern The pattern to normalize.
+		 * @returns {FileMatcher} The normalized pattern.
 		 */
 		function normalizePattern(pattern) {
 			if (isString(pattern)) {
@@ -25906,7 +26243,7 @@ function requireCjs () {
 		 * @param {Array} items The items in a `ConfigArray`.
 		 * @param {Object} context The context object to pass into any function
 		 *      found.
-		 * @param {Array<string>} extraConfigTypes The config types to check.
+		 * @param {ReadonlyArray<ExtraConfigType>} extraConfigTypes The config types to check.
 		 * @param {string} namespacedBasePath The namespaced base path of the directory to which config base paths are relative.
 		 * @param {PathImpl} path Path-handling implementation.
 		 * @returns {Promise<Array>} A flattened array containing only config objects.
@@ -25954,7 +26291,7 @@ function requireCjs () {
 			 * Async iterables cannot be used with the spread operator, so we need to manually
 			 * create the array to return.
 			 */
-			const asyncIterable = await flatTraverse(items);
+			const asyncIterable = flatTraverse(items);
 			const configs = [];
 
 			for await (const config of asyncIterable) {
@@ -25970,7 +26307,7 @@ function requireCjs () {
 		 * @param {Array} items The items in a `ConfigArray`.
 		 * @param {Object} context The context object to pass into any function
 		 *      found.
-		 * @param {Array<string>} extraConfigTypes The config types to check.
+		 * @param {ReadonlyArray<ExtraConfigType>} extraConfigTypes The config types to check.
 		 * @param {string} namespacedBasePath The namespaced base path of the directory to which config base paths are relative.
 		 * @param {PathImpl} path Path-handling implementation
 		 * @returns {Array} A flattened array containing only config objects.
@@ -26043,13 +26380,13 @@ function requireCjs () {
 		/**
 		 * Determines if a given file path should be ignored based on the given
 		 * matcher.
-		 * @param {Array<{ basePath?: string, ignores: Array<string|((string) => boolean)>}>} configs Configuration objects containing `ignores`.
+		 * @param {Array<{ basePath?: string, ignores: FileMatcher[] }>} configs Configuration objects containing `ignores`.
 		 * @param {string} filePath The unprocessed file path to check.
 		 * @param {string} relativeFilePath The path of the file to check relative to the base path,
 		 * 		using forward slash (`"/"`) as a separator.
 		 * @param {Object} [basePathData] Additional data needed to recalculate paths for configuration objects
 		 *  	that have `basePath` property.
-		 * @param {string} [basePathData.basePath] Namespaced path to witch `relativeFilePath` is relative.
+		 * @param {string} [basePathData.basePath] Namespaced path to which `relativeFilePath` is relative.
 		 * @param {PathImpl} [basePathData.path] Path-handling implementation.
 		 * @returns {boolean} True if the path should be ignored and false if not.
 		 */
@@ -26118,7 +26455,7 @@ function requireCjs () {
 		 * @param {string} filePath The unprocessed file path to check.
 		 * @param {string} relativeFilePath The path of the file to check relative to the base path,
 		 * 		using forward slash (`"/"`) as a separator.
-		 * @param {Object} config The config object to check.
+		 * @param {ConfigObject & { files: FilesMatcher[] }} config The config object to check.
 		 * @returns {boolean} True if the file path is matched by the config,
 		 *      false if not.
 		 */
@@ -26181,21 +26518,23 @@ function requireCjs () {
 
 		/**
 		 * Ensures that config types are valid.
-		 * @param {Array<string>} extraConfigTypes The config types to check.
+		 * @param {ReadonlyArray<ExtraConfigType>} extraConfigTypes The config types to check.
 		 * @returns {void}
 		 * @throws {TypeError} When the config types array is invalid.
 		 */
 		function assertExtraConfigTypes(extraConfigTypes) {
+			if (!Array.isArray(extraConfigTypes)) {
+				throw new TypeError("extraConfigTypes must be an array.");
+			}
+
 			if (extraConfigTypes.length > 2) {
-				throw new TypeError(
-					"configTypes must be an array with at most two items.",
-				);
+				throw new TypeError("extraConfigTypes must contain at most two items.");
 			}
 
 			for (const configType of extraConfigTypes) {
 				if (!CONFIG_TYPES.has(configType)) {
 					throw new TypeError(
-						`Unexpected config type "${configType}" found. Expected one of: "object", "array", "function".`,
+						`Unexpected config type "${configType}" in extraConfigTypes. Expected one of: "array", "function".`,
 					);
 				}
 			}
@@ -26266,9 +26605,9 @@ function requireCjs () {
 			 * 		Defaults to `"/"`.
 			 * @param {boolean} [options.normalized=false] Flag indicating if the
 			 *      configs have already been normalized.
-			 * @param {Object} [options.schema] The additional schema
+			 * @param {ObjectDefinition} [options.schema] The additional schema
 			 *      definitions to use for the ConfigArray schema.
-			 * @param {Array<string>} [options.extraConfigTypes] List of config types supported.
+			 * @param {ReadonlyArray<ExtraConfigType>} [options.extraConfigTypes] List of config types supported.
 			 * @throws {TypeError} When the `basePath` is not a non-empty string,
 			 */
 			constructor(
@@ -26316,7 +26655,7 @@ function requireCjs () {
 
 				/**
 				 * The supported config types.
-				 * @type {Array<string>}
+				 * @type {ReadonlyArray<ExtraConfigType>}
 				 */
 				this.extraConfigTypes = [...extraConfigTypes];
 				Object.freeze(this.extraConfigTypes);
@@ -26369,7 +26708,7 @@ function requireCjs () {
 			 * This can be used to determine which files will be matched by a
 			 * config array or to use as a glob pattern when no patterns are provided
 			 * for a command line interface.
-			 * @returns {Array<string|Function>} An array of matchers.
+			 * @returns {Array<FilesMatcher>} An array of matchers.
 			 */
 			get files() {
 				assertNormalized(this);
@@ -26405,7 +26744,7 @@ function requireCjs () {
 			 * the matching `files` fields in any configs. This is necessary to mimic
 			 * the behavior of things like .gitignore and .eslintignore, allowing a
 			 * globbing operation to be faster.
-			 * @returns {Object[]} An array of config objects representing global ignores.
+			 * @returns {Array<{ basePath?: string, name?: string, ignores: FileMatcher[] }>} An array of config objects representing global ignores.
 			 */
 			get ignores() {
 				assertNormalized(this);
@@ -26424,7 +26763,7 @@ function requireCjs () {
 				for (const config of this) {
 					/*
 					 * We only count ignores if there are no other keys in the object.
-					 * In this case, it acts list a globally ignored pattern. If there
+					 * In this case, it acts like a globally ignored pattern. If there
 					 * are additional keys, then ignores act like exclusions.
 					 */
 					if (
@@ -44771,24 +45110,24 @@ function requireEspree () {
 		 * Normalize sourceType from the initial config
 		 * @param {string} sourceType to normalize
 		 * @throws {Error} throw an error if sourceType is invalid
-		 * @returns {"script"|"module"} normalized sourceType
+		 * @returns {"script"|"module"|"commonjs"} normalized sourceType
 		 */
 		function normalizeSourceType(sourceType = "script") {
-			if (sourceType === "script" || sourceType === "module") {
+			if (
+				sourceType === "script" ||
+				sourceType === "module" ||
+				sourceType === "commonjs"
+			) {
 				return sourceType;
 			}
 
-			if (sourceType === "commonjs") {
-				return "script";
-			}
-
 			throw new Error("Invalid sourceType.");
 		}
 
 		/**
 		 * @typedef {{
 		 *   ecmaVersion: NormalizedEcmaVersion,
-		 *   sourceType: "script"|"module",
+		 *   sourceType: "script"|"module"|"commonjs",
 		 *   range?: boolean,
 		 *   loc?: boolean,
 		 *   allowReserved: boolean | "never",
@@ -45593,7 +45932,7 @@ function requireEspree () {
 		//------------------------------------------------------------------------------
 
 		/** @type {string} */
-		const version = "11.1.1"; // x-release-please-version
+		const version = "11.2.0"; // x-release-please-version
 		const name = "espree";
 
 		// Derive node types from VisitorKeys
@@ -46079,9 +46418,9 @@ function requireAstUtils () {
 			if (left.regex || right.regex) {
 				return Boolean(
 					left.regex &&
-						right.regex &&
-						left.regex.pattern === right.regex.pattern &&
-						left.regex.flags === right.regex.flags,
+					right.regex &&
+					left.regex.pattern === right.regex.pattern &&
+					left.regex.flags === right.regex.flags,
 				);
 			}
 
@@ -46722,9 +47061,9 @@ function requireAstUtils () {
 
 			return Boolean(
 				reference &&
-					reference.resolved &&
-					reference.resolved.scope.type === "global" &&
-					reference.resolved.defs.length === 0,
+				reference.resolved &&
+				reference.resolved.scope.type === "global" &&
+				reference.resolved.defs.length === 0,
 			);
 		}
 
@@ -52814,9 +53153,9 @@ function requireCapitalizedComments () {
 
 				return Boolean(
 					previousToken &&
-						nextToken &&
-						comment.loc.start.line === previousToken.loc.end.line &&
-						comment.loc.end.line === nextToken.loc.start.line,
+					nextToken &&
+					comment.loc.start.line === previousToken.loc.end.line &&
+					comment.loc.end.line === nextToken.loc.start.line,
 				);
 			}
 
@@ -52832,7 +53171,7 @@ function requireCapitalizedComments () {
 
 				return Boolean(
 					previousTokenOrComment &&
-						["Block", "Line"].includes(previousTokenOrComment.type),
+					["Block", "Line"].includes(previousTokenOrComment.type),
 				);
 			}
 
@@ -82018,11 +82357,11 @@ function requireNoExtendNative () {
 			function isPrototypePropertyAccessed(identifierNode) {
 				return Boolean(
 					identifierNode &&
-						identifierNode.parent &&
-						identifierNode.parent.type === "MemberExpression" &&
-						identifierNode.parent.object === identifierNode &&
-						astUtils.getStaticPropertyName(identifierNode.parent) ===
-							"prototype",
+					identifierNode.parent &&
+					identifierNode.parent.type === "MemberExpression" &&
+					identifierNode.parent.object === identifierNode &&
+					astUtils.getStaticPropertyName(identifierNode.parent) ===
+						"prototype",
 				);
 			}
 
@@ -88985,10 +89324,10 @@ function requireIsCombiningCharacter () {
 	/**
 	 * Check whether a given character is a combining mark or not.
 	 * @param {number} codePoint The character code to check.
-	 * @returns {boolean} `true` if the character belongs to the category, any of `Mc`, `Me`, and `Mn`.
+	 * @returns {boolean} `true` if the character has the General Category of Combining Mark (M), consisting of `Mc`, `Me`, and `Mn`.
 	 */
 	isCombiningCharacter = function isCombiningCharacter(codePoint) {
-		return /^[\p{Mc}\p{Me}\p{Mn}]$/u.test(String.fromCodePoint(codePoint));
+		return /^\p{M}$/u.test(String.fromCodePoint(codePoint));
 	};
 	return isCombiningCharacter;
 }
@@ -99383,9 +99722,7 @@ function requireNoThisBeforeSuper () {
 							isConstructor: true,
 							hasExtends: Boolean(
 								classNode.superClass &&
-									!astUtils.isNullOrUndefined(
-										classNode.superClass,
-									),
+								!astUtils.isNullOrUndefined(classNode.superClass),
 							),
 							codePath,
 							currentSegments: new Set(),
@@ -100938,11 +101275,11 @@ function requireNoUnmodifiedLoopCondition () {
 					condition.isInLoop(modifier) ||
 					Boolean(
 						(funcNode = getEncloseFunctionDeclaration(modifier)) &&
-							(funcVar = astUtils.getVariableByName(
-								modifier.from.upper,
-								funcNode.id.name,
-							)) &&
-							funcVar.references.some(condition.isInLoop),
+						(funcVar = astUtils.getVariableByName(
+							modifier.from.upper,
+							funcNode.id.name,
+						)) &&
+						funcVar.references.some(condition.isInLoop),
 					);
 
 				condition.modified = inLoop;
@@ -105404,7 +105741,7 @@ function requireNoUselessAssignment () {
 
 			messages: {
 				unnecessaryAssignment:
-					"This assigned value is not used in subsequent statements.",
+					"The value assigned to '{{name}}' is not used in subsequent statements.",
 			},
 		},
 
@@ -105752,6 +106089,7 @@ function requireNoUselessAssignment () {
 					context.report({
 						node: targetAssignment.identifier,
 						messageId: "unnecessaryAssignment",
+						data: { name: targetAssignment.identifier.name },
 					});
 				}
 
@@ -108217,6 +108555,28 @@ function requireNoVar () {
 		return variable.name === "let";
 	}
 
+	/**
+	 * Checks whether a given variable has any references before its declaration.
+	 * This is important because var allows hoisting, but let/const do not.
+	 * @param {Variable} variable The variable to check.
+	 * @returns {boolean} `true` if the variable is referenced before its declaration.
+	 */
+	function hasReferenceBeforeDeclaration(variable) {
+		const declarationStart = variable.defs[0].node.range[0];
+
+		return variable.references.some(reference => {
+			const referenceStart = reference.identifier.range[0];
+
+			/*
+			 * Check if the reference occurs before the declaration.
+			 * We don't need to check scopes because all references to this variable
+			 * are already in variable.references (which only includes references
+			 * that resolve to this specific variable binding).
+			 */
+			return !reference.init && referenceStart < declarationStart;
+		});
+	}
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -108270,6 +108630,7 @@ function requireNoVar () {
 			 * - A variable is used from a closure within a loop.
 			 * - A variable might be used before it is assigned within a loop.
 			 * - A variable might be used in TDZ.
+			 * - A variable is referenced before its declaration.
 			 * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
 			 * - A variable has name that is disallowed for `let` declarations.
 			 *
@@ -108314,6 +108675,10 @@ function requireNoVar () {
 			function canFix(node) {
 				const variables = sourceCode.getDeclaredVariables(node);
 				const scopeNode = getScopeNode(node);
+				const parentStatementList = new Set([
+					...astUtils.STATEMENT_LIST_PARENTS,
+					"TSModuleBlock",
+				]);
 
 				if (
 					node.parent.type === "SwitchCase" ||
@@ -108321,7 +108686,8 @@ function requireNoVar () {
 					variables.some(isGlobal) ||
 					variables.some(isRedeclared) ||
 					variables.some(isUsedFromOutsideOf(scopeNode)) ||
-					variables.some(hasNameDisallowedForLetDeclarations)
+					variables.some(hasNameDisallowedForLetDeclarations) ||
+					variables.some(hasReferenceBeforeDeclaration)
 				) {
 					return false;
 				}
@@ -108341,7 +108707,7 @@ function requireNoVar () {
 						node.parent.type === "ForStatement" &&
 						node.parent.init === node
 					) &&
-					!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)
+					!parentStatementList.has(node.parent.type)
 				) {
 					// If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.
 					return false;
@@ -112644,11 +113010,11 @@ function requirePaddingLineBetweenStatements () {
 		const nextToken = sourceCode.getTokenAfter(semiToken);
 		const isSemicolonLessStyle = Boolean(
 			prevToken &&
-				nextToken &&
-				prevToken.range[0] >= node.range[0] &&
-				astUtils.isSemicolonToken(semiToken) &&
-				semiToken.loc.start.line !== prevToken.loc.end.line &&
-				semiToken.loc.end.line === nextToken.loc.start.line,
+			nextToken &&
+			prevToken.range[0] >= node.range[0] &&
+			astUtils.isSemicolonToken(semiToken) &&
+			semiToken.loc.start.line !== prevToken.loc.end.line &&
+			semiToken.loc.end.line === nextToken.loc.start.line,
 		);
 
 		return isSemicolonLessStyle ? prevToken : semiToken;