oxlint-plugin-eslint 1.52.0

package/common/fix-tracker.cjs

@@ -0,0 +1,89 @@
+const require_chunk = require("./chunk.cjs"), require_ast_utils$1 = require("./ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/utils/fix-tracker.js
+/**
+* @fileoverview Helper class to aid in constructing fix commands.
+* @author Alan Pierce
+*/
+var require_fix_tracker = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	/**
+	* @import { SourceRange } from "@eslint/core";
+	*/
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* A helper class to combine fix options into a fix command. Currently, it
+	* exposes some "retain" methods that extend the range of the text being
+	* replaced so that other fixes won't touch that region in the same pass.
+	*/
+	var FixTracker = class {
+		/**
+		* Create a new FixTracker.
+		* @param {ruleFixer} fixer A ruleFixer instance.
+		* @param {SourceCode} sourceCode A SourceCode object for the current code.
+		*/
+		constructor(fixer, sourceCode) {
+			this.fixer = fixer, this.sourceCode = sourceCode, this.retainedRange = null;
+		}
+		/**
+		* Mark the given range as "retained", meaning that other fixes may not
+		* may not modify this region in the same pass.
+		* @param {SourceRange} range The range to retain.
+		* @returns {FixTracker} The same RuleFixer, for chained calls.
+		*/
+		retainRange(range) {
+			return this.retainedRange = range, this;
+		}
+		/**
+		* Given a node, find the function containing it (or the entire program) and
+		* mark it as retained, meaning that other fixes may not modify it in this
+		* pass. This is useful for avoiding conflicts in fixes that modify control
+		* flow.
+		* @param {ASTNode} node The node to use as a starting point.
+		* @returns {FixTracker} The same RuleFixer, for chained calls.
+		*/
+		retainEnclosingFunction(node) {
+			let functionNode = astUtils.getUpperFunction(node);
+			return this.retainRange(functionNode ? functionNode.range : this.sourceCode.ast.range);
+		}
+		/**
+		* Given a node or token, find the token before and afterward, and mark that
+		* range as retained, meaning that other fixes may not modify it in this
+		* pass. This is useful for avoiding conflicts in fixes that make a small
+		* change to the code where the AST should not be changed.
+		* @param {ASTNode|Token} nodeOrToken The node or token to use as a starting
+		*      point. The token to the left and right are use in the range.
+		* @returns {FixTracker} The same RuleFixer, for chained calls.
+		*/
+		retainSurroundingTokens(nodeOrToken) {
+			let tokenBefore = this.sourceCode.getTokenBefore(nodeOrToken) || nodeOrToken, tokenAfter = this.sourceCode.getTokenAfter(nodeOrToken) || nodeOrToken;
+			return this.retainRange([tokenBefore.range[0], tokenAfter.range[1]]);
+		}
+		/**
+		* Create a fix command that replaces the given range with the given text,
+		* accounting for any retained ranges.
+		* @param {SourceRange} range The range to remove in the fix.
+		* @param {string} text The text to insert in place of the range.
+		* @returns {Object} The fix command.
+		*/
+		replaceTextRange(range, text) {
+			let actualRange;
+			return actualRange = this.retainedRange ? [Math.min(this.retainedRange[0], range[0]), Math.max(this.retainedRange[1], range[1])] : range, this.fixer.replaceTextRange(actualRange, this.sourceCode.text.slice(actualRange[0], range[0]) + text + this.sourceCode.text.slice(range[1], actualRange[1]));
+		}
+		/**
+		* Create a fix command that removes the given node or token, accounting for
+		* any retained ranges.
+		* @param {ASTNode|Token} nodeOrToken The node or token to remove.
+		* @returns {Object} The fix command.
+		*/
+		remove(nodeOrToken) {
+			return this.replaceTextRange(nodeOrToken.range, "");
+		}
+	};
+	module.exports = FixTracker;
+}));
+//#endregion
+Object.defineProperty(exports, "t", {
+	enumerable: !0,
+	get: function() {
+		return require_fix_tracker;
+	}
+});

package/common/ignore.cjs

@@ -0,0 +1,123 @@
+//#region ../../node_modules/.pnpm/ignore@5.3.2/node_modules/ignore/index.js
+var require_ignore = /* @__PURE__ */ require("./chunk.cjs").t(((exports, module) => {
+	function makeArray(subject) {
+		return Array.isArray(subject) ? subject : [subject];
+	}
+	let REGEX_TEST_BLANK_LINE = /^\s+$/, REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/, REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/, REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/, REGEX_SPLITALL_CRLF = /\r?\n/g, REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/, TMP_KEY_IGNORE = "node-ignore";
+	/* istanbul ignore else */
+	typeof Symbol < "u" && (TMP_KEY_IGNORE = Symbol.for("node-ignore"));
+	let KEY_IGNORE = TMP_KEY_IGNORE, define = (object, key, value) => Object.defineProperty(object, key, { value }), REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g, RETURN_FALSE = () => !1, sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : ""), cleanRangeBackSlash = (slashes) => {
+		let { length } = slashes;
+		return slashes.slice(0, length - length % 2);
+	}, REPLACERS = [
+		[/^\uFEFF/, () => ""],
+		[/((?:\\\\)*?)(\\?\s+)$/, (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? " " : "")],
+		[/(\\+?)\s/g, (_, m1) => {
+			let { length } = m1;
+			return m1.slice(0, length - length % 2) + " ";
+		}],
+		[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
+		[/(?!\\)\?/g, () => "[^/]"],
+		[/^\//, () => "^"],
+		[/\//g, () => "\\/"],
+		[/^\^*\\\*\\\*\\\//, () => "^(?:.*\\/)?"],
+		[/^(?=[^^])/, function startingReplacer() {
+			return /\/(?!$)/.test(this) ? "^" : "(?:^|\\/)";
+		}],
+		[/\\\/\\\*\\\*(?=\\\/|$)/g, (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"],
+		[/(^|[^\\]+)(\\\*)+(?=.+)/g, (_, p1, p2) => p1 + p2.replace(/\\\*/g, "[^\\/]*")],
+		[/\\\\\\(?=[$.|*+(){^])/g, () => "\\"],
+		[/\\\\/g, () => "\\"],
+		[/(\\)?\[([^\]/]*?)(\\*)($|\])/g, (match, leadEscape, range, endEscape, close) => leadEscape === "\\" ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" && endEscape.length % 2 == 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]"],
+		[/(?:[^*])$/, (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`],
+		[/(\^|\\\/)?\\\*$/, (_, p1) => `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`]
+	], regexCache = Object.create(null), makeRegex = (pattern, ignoreCase) => {
+		let source = regexCache[pattern];
+		return source || (source = REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern), regexCache[pattern] = source), ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+	}, isString = (subject) => typeof subject == "string", checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0, splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+	var IgnoreRule = class {
+		constructor(origin, pattern, negative, regex) {
+			this.origin = origin, this.pattern = pattern, this.negative = negative, this.regex = regex;
+		}
+	};
+	let createRule = (pattern, ignoreCase) => {
+		let origin = pattern, negative = !1;
+		pattern.indexOf("!") === 0 && (negative = !0, pattern = pattern.substr(1)), pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+		let regex = makeRegex(pattern, ignoreCase);
+		return new IgnoreRule(origin, pattern, negative, regex);
+	}, throwError = (message, Ctor) => {
+		throw new Ctor(message);
+	}, checkPath = (path, originalPath, doThrow) => isString(path) ? path ? checkPath.isNotRelative(path) ? doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError) : !0 : doThrow("path must not be empty", TypeError) : doThrow(`path must be a string, but got \`${originalPath}\``, TypeError), isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+	checkPath.isNotRelative = isNotRelative, checkPath.convert = (p) => p;
+	var Ignore = class {
+		constructor({ ignorecase = !0, ignoreCase = ignorecase, allowRelativePaths = !1 } = {}) {
+			define(this, KEY_IGNORE, !0), this._rules = [], this._ignoreCase = ignoreCase, this._allowRelativePaths = allowRelativePaths, this._initCache();
+		}
+		_initCache() {
+			this._ignoreCache = Object.create(null), this._testCache = Object.create(null);
+		}
+		_addPattern(pattern) {
+			if (pattern && pattern[KEY_IGNORE]) {
+				this._rules = this._rules.concat(pattern._rules), this._added = !0;
+				return;
+			}
+			if (checkPattern(pattern)) {
+				let rule = createRule(pattern, this._ignoreCase);
+				this._added = !0, this._rules.push(rule);
+			}
+		}
+		add(pattern) {
+			return this._added = !1, makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this), this._added && this._initCache(), this;
+		}
+		addPattern(pattern) {
+			return this.add(pattern);
+		}
+		_testOne(path, checkUnignored) {
+			let ignored = !1, unignored = !1;
+			return this._rules.forEach((rule) => {
+				let { negative } = rule;
+				unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored || rule.regex.test(path) && (ignored = !negative, unignored = negative);
+			}), {
+				ignored,
+				unignored
+			};
+		}
+		_test(originalPath, cache, checkUnignored, slices) {
+			let path = originalPath && checkPath.convert(originalPath);
+			return checkPath(path, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError), this._t(path, cache, checkUnignored, slices);
+		}
+		_t(path, cache, checkUnignored, slices) {
+			if (path in cache) return cache[path];
+			if (slices ||= path.split("/"), slices.pop(), !slices.length) return cache[path] = this._testOne(path, checkUnignored);
+			let parent = this._t(slices.join("/") + "/", cache, checkUnignored, slices);
+			return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+		}
+		ignores(path) {
+			return this._test(path, this._ignoreCache, !1).ignored;
+		}
+		createFilter() {
+			return (path) => !this.ignores(path);
+		}
+		filter(paths) {
+			return makeArray(paths).filter(this.createFilter());
+		}
+		test(path) {
+			return this._test(path, this._testCache, !0);
+		}
+	};
+	let factory = (options) => new Ignore(options), isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+	/* istanbul ignore if */
+	if (factory.isPathValid = isPathValid, factory.default = factory, module.exports = factory, typeof process < "u" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
+		let makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+		checkPath.convert = makePosix;
+		let REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+		checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+	}
+}));
+//#endregion
+Object.defineProperty(exports, "t", {
+	enumerable: !0,
+	get: function() {
+		return require_ignore;
+	}
+});

package/common/keywords.cjs

@@ -0,0 +1,15 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/utils/keywords.js
+/**
+* @fileoverview A shared list of ES3 keywords.
+* @author Josh Perez
+*/
+var require_keywords = /* @__PURE__ */ require("./chunk.cjs").t(((exports, module) => {
+	module.exports = /* @__PURE__ */ "abstract.boolean.break.byte.case.catch.char.class.const.continue.debugger.default.delete.do.double.else.enum.export.extends.false.final.finally.float.for.function.goto.if.implements.import.in.instanceof.int.interface.long.native.new.null.package.private.protected.public.return.short.static.super.switch.synchronized.this.throw.throws.transient.true.try.typeof.var.void.volatile.while.with".split(".");
+}));
+//#endregion
+Object.defineProperty(exports, "t", {
+	enumerable: !0,
+	get: function() {
+		return require_keywords;
+	}
+});