Update Bot

node_modules/@eslint/plugin-kit/dist/cjs/index.cjs

@@ -12,12 +12,10 @@ var levn = require('levn');
 // Type Definitions
 //-----------------------------------------------------------------------------
 
-/** @import * as $eslintcore from "@eslint/core"; */
-/** @typedef {$eslintcore.RuleConfig} RuleConfig */
-/** @typedef {$eslintcore.RulesConfig} RulesConfig */
-/** @import * as $typests from "./types.ts"; */
-/** @typedef {$typests.StringConfig} StringConfig */
-/** @typedef {$typests.BooleanConfig} BooleanConfig */
+/** @typedef {import("@eslint/core").RuleConfig} RuleConfig */
+/** @typedef {import("@eslint/core").RulesConfig} RulesConfig */
+/** @typedef {import("./types.ts").StringConfig} StringConfig */
+/** @typedef {import("./types.ts").BooleanConfig} BooleanConfig */
 
 //-----------------------------------------------------------------------------
 // Helpers
@@ -155,7 +153,7 @@ class ConfigCommentParser {
 		 */
 		const normalizedString = string
 			.replace(/(?<![-a-zA-Z0-9/])([-a-zA-Z0-9/]+):/gu, '"$1":')
-			.replace(/([\]0-9])\s+(?=")/u, "$1,");
+			.replace(/(\]|[0-9])\s+(?=")/u, "$1,");
 
 		try {
 			const items = JSON.parse(`{${normalizedString}}`);
@@ -256,15 +254,15 @@ class ConfigCommentParser {
 // Type Definitions
 //-----------------------------------------------------------------------------
 
-/** @typedef {$eslintcore.VisitTraversalStep} VisitTraversalStep */
-/** @typedef {$eslintcore.CallTraversalStep} CallTraversalStep */
-/** @typedef {$eslintcore.TraversalStep} TraversalStep */
-/** @typedef {$eslintcore.SourceLocation} SourceLocation */
-/** @typedef {$eslintcore.SourceLocationWithOffset} SourceLocationWithOffset */
-/** @typedef {$eslintcore.SourceRange} SourceRange */
-/** @typedef {$eslintcore.Directive} IDirective */
-/** @typedef {$eslintcore.DirectiveType} DirectiveType */
-/** @typedef {$eslintcore.SourceCodeBaseTypeOptions} SourceCodeBaseTypeOptions */
+/** @typedef {import("@eslint/core").VisitTraversalStep} VisitTraversalStep */
+/** @typedef {import("@eslint/core").CallTraversalStep} CallTraversalStep */
+/** @typedef {import("@eslint/core").TraversalStep} TraversalStep */
+/** @typedef {import("@eslint/core").SourceLocation} SourceLocation */
+/** @typedef {import("@eslint/core").SourceLocationWithOffset} SourceLocationWithOffset */
+/** @typedef {import("@eslint/core").SourceRange} SourceRange */
+/** @typedef {import("@eslint/core").Directive} IDirective */
+/** @typedef {import("@eslint/core").DirectiveType} DirectiveType */
+/** @typedef {import("@eslint/core").SourceCodeBaseTypeOptions} SourceCodeBaseTypeOptions */
 /**
  * @typedef {import("@eslint/core").TextSourceCode<Options>} TextSourceCode<Options>
  * @template {SourceCodeBaseTypeOptions} [Options=SourceCodeBaseTypeOptions]
@@ -310,32 +308,6 @@ function hasPosStyleRange(node) {
 	return "position" in node;
 }
 
-/**
- * Performs binary search to find the line number containing a given target index.
- * Returns the lower bound - the index of the first element greater than the target.
- * **Please note that the `lineStartIndices` should be sorted in ascending order**.
- * - Time Complexity: O(log n) - Significantly faster than linear search for large files.
- * @param {number[]} lineStartIndices Sorted array of line start indices.
- * @param {number} targetIndex The target index to find the line number for.
- * @returns {number} The line number for the target index.
- */
-function findLineNumberBinarySearch(lineStartIndices, targetIndex) {
-	let low = 0;
-	let high = lineStartIndices.length - 1;
-
-	while (low < high) {
-		const mid = ((low + high) / 2) | 0; // Use bitwise OR to floor the division.
-
-		if (targetIndex < lineStartIndices[mid]) {
-			high = mid;
-		} else {
-			low = mid + 1;
-		}
-	}
-
-	return low;
-}
-
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -489,7 +461,7 @@ class Directive {
 
 /**
  * Source Code Base Object
- * @template {SourceCodeBaseTypeOptions & {RootNode: object, SyntaxElementWithLoc: object}} [Options=SourceCodeBaseTypeOptions & {RootNode: object, SyntaxElementWithLoc: object}]
+ * @template {SourceCodeBaseTypeOptions & {SyntaxElementWithLoc: object}} [Options=SourceCodeBaseTypeOptions & {SyntaxElementWithLoc: object}]
  * @implements {TextSourceCode<Options>}
  */
 class TextSourceCodeBase {
@@ -497,19 +469,7 @@ class TextSourceCodeBase {
 	 * The lines of text in the source code.
 	 * @type {Array<string>}
 	 */
-	#lines = [];
-
-	/**
-	 * The indices of the start of each line in the source code.
-	 * @type {Array<number>}
-	 */
-	#lineStartIndices = [0];
-
-	/**
-	 * The pattern to match lineEndings in the source code.
-	 * @type {RegExp}
-	 */
-	#lineEndingPattern;
+	#lines;
 
 	/**
 	 * The AST of the source code.
@@ -528,105 +488,12 @@ class TextSourceCodeBase {
 	 * @param {Object} options The options for the instance.
 	 * @param {string} options.text The source code text.
 	 * @param {Options['RootNode']} options.ast The root AST node.
-	 * @param {RegExp} [options.lineEndingPattern] The pattern to match lineEndings in the source code. Defaults to `/\r?\n/u`.
+	 * @param {RegExp} [options.lineEndingPattern] The pattern to match lineEndings in the source code.
 	 */
 	constructor({ text, ast, lineEndingPattern = /\r?\n/u }) {
 		this.ast = ast;
 		this.text = text;
-		// Remove the global(`g`) and sticky(`y`) flags from the `lineEndingPattern` to avoid issues with lastIndex.
-		this.#lineEndingPattern = new RegExp(
-			lineEndingPattern.source,
-			lineEndingPattern.flags.replace(/[gy]/gu, ""),
-		);
-	}
-
-	/**
-	 * Finds the next line in the source text and updates `#lines` and `#lineStartIndices`.
-	 * @param {string} text The text to search for the next line.
-	 * @returns {boolean} `true` if a next line was found, `false` otherwise.
-	 */
-	#findNextLine(text) {
-		const match = this.#lineEndingPattern.exec(text);
-
-		if (!match) {
-			return false;
-		}
-
-		this.#lines.push(text.slice(0, match.index));
-		this.#lineStartIndices.push(
-			(this.#lineStartIndices.at(-1) ?? 0) +
-				match.index +
-				match[0].length,
-		);
-
-		return true;
-	}
-
-	/**
-	 * Ensures `#lines` is lazily calculated from the source text.
-	 * @returns {void}
-	 */
-	#ensureLines() {
-		// If `#lines` has already been calculated, do nothing.
-		if (this.#lines.length === this.#lineStartIndices.length) {
-			return;
-		}
-
-		while (
-			this.#findNextLine(this.text.slice(this.#lineStartIndices.at(-1)))
-		) {
-			// Continue parsing until no more matches are found.
-		}
-
-		this.#lines.push(this.text.slice(this.#lineStartIndices.at(-1)));
-
-		Object.freeze(this.#lines);
-	}
-
-	/**
-	 * Ensures `#lineStartIndices` is lazily calculated up to the specified index.
-	 * @param {number} index The index of a character in a file.
-	 * @returns {void}
-	 */
-	#ensureLineStartIndicesFromIndex(index) {
-		// If we've already parsed up to or beyond this index, do nothing.
-		if (index <= (this.#lineStartIndices.at(-1) ?? 0)) {
-			return;
-		}
-
-		while (
-			index > (this.#lineStartIndices.at(-1) ?? 0) &&
-			this.#findNextLine(this.text.slice(this.#lineStartIndices.at(-1)))
-		) {
-			// Continue parsing until no more matches are found.
-		}
-	}
-
-	/**
-	 * Ensures `#lineStartIndices` is lazily calculated up to the specified loc.
-	 * @param {Object} loc A line/column location.
-	 * @param {number} loc.line The line number of the location. (0 or 1-indexed based on language.)
-	 * @param {number} lineStart The line number at which the parser starts counting.
-	 * @returns {void}
-	 */
-	#ensureLineStartIndicesFromLoc(loc, lineStart) {
-		// Calculate line indices up to the potentially next line, as it is needed for the follow‑up calculation.
-		const nextLocLineIndex = loc.line - lineStart + 1;
-		const lastCalculatedLineIndex = this.#lineStartIndices.length - 1;
-		let additionalLinesNeeded = nextLocLineIndex - lastCalculatedLineIndex;
-
-		// If we've already parsed up to or beyond this line, do nothing.
-		if (additionalLinesNeeded <= 0) {
-			return;
-		}
-
-		while (
-			additionalLinesNeeded > 0 &&
-			this.#findNextLine(this.text.slice(this.#lineStartIndices.at(-1)))
-		) {
-			// Continue parsing until no more matches are found or we have enough lines.
-			additionalLinesNeeded -= 1;
-		}
+		this.#lines = text.split(lineEndingPattern);
 	}
 
 	/**
@@ -649,135 +516,6 @@ class TextSourceCodeBase {
 		);
 	}
 
-	/**
-	 * Converts a source text index into a `{ line: number, column: number }` pair.
-	 * @param {number} index The index of a character in a file.
-	 * @throws {TypeError|RangeError} If non-numeric index or index out of range.
-	 * @returns {{line: number, column: number}} A `{ line: number, column: number }` location object with 0 or 1-indexed line and 0 or 1-indexed column based on language.
-	 * @public
-	 */
-	getLocFromIndex(index) {
-		if (typeof index !== "number") {
-			throw new TypeError("Expected `index` to be a number.");
-		}
-
-		if (index < 0 || index > this.text.length) {
-			throw new RangeError(
-				`Index out of range (requested index ${index}, but source text has length ${this.text.length}).`,
-			);
-		}
-
-		const {
-			start: { line: lineStart, column: columnStart },
-			end: { line: lineEnd, column: columnEnd },
-		} = this.getLoc(this.ast);
-
-		// If the index is at the start, return the start location of the root node.
-		if (index === 0) {
-			return {
-				line: lineStart,
-				column: columnStart,
-			};
-		}
-
-		// If the index is `this.text.length`, return the location one "spot" past the last character of the file.
-		if (index === this.text.length) {
-			return {
-				line: lineEnd,
-				column: columnEnd,
-			};
-		}
-
-		// Ensure `#lineStartIndices` are lazily calculated.
-		this.#ensureLineStartIndicesFromIndex(index);
-
-		/*
-		 * To figure out which line `index` is on, determine the last place at which index could
-		 * be inserted into `#lineStartIndices` to keep the list sorted.
-		 */
-		const lineNumber =
-			(index >= (this.#lineStartIndices.at(-1) ?? 0)
-				? this.#lineStartIndices.length
-				: findLineNumberBinarySearch(this.#lineStartIndices, index)) -
-			1 +
-			lineStart;
-
-		return {
-			line: lineNumber,
-			column:
-				index -
-				this.#lineStartIndices[lineNumber - lineStart] +
-				columnStart,
-		};
-	}
-
-	/**
-	 * Converts a `{ line: number, column: number }` pair into a source text index.
-	 * @param {Object} loc A line/column location.
-	 * @param {number} loc.line The line number of the location. (0 or 1-indexed based on language.)
-	 * @param {number} loc.column The column number of the location. (0 or 1-indexed based on language.)
-	 * @throws {TypeError|RangeError} If `loc` is not an object with a numeric
-	 * `line` and `column`, if the `line` is less than or equal to zero or
-	 * the `line` or `column` is out of the expected range.
-	 * @returns {number} The index of the line/column location in a file.
-	 * @public
-	 */
-	getIndexFromLoc(loc) {
-		if (
-			loc === null ||
-			typeof loc !== "object" ||
-			typeof loc.line !== "number" ||
-			typeof loc.column !== "number"
-		) {
-			throw new TypeError(
-				"Expected `loc` to be an object with numeric `line` and `column` properties.",
-			);
-		}
-
-		const {
-			start: { line: lineStart, column: columnStart },
-			end: { line: lineEnd, column: columnEnd },
-		} = this.getLoc(this.ast);
-
-		if (loc.line < lineStart || lineEnd < loc.line) {
-			throw new RangeError(
-				`Line number out of range (line ${loc.line} requested). Valid range: ${lineStart}-${lineEnd}`,
-			);
-		}
-
-		// If the loc is at the start, return the start index of the root node.
-		if (loc.line === lineStart && loc.column === columnStart) {
-			return 0;
-		}
-
-		// If the loc is at the end, return the index one "spot" past the last character of the file.
-		if (loc.line === lineEnd && loc.column === columnEnd) {
-			return this.text.length;
-		}
-
-		// Ensure `#lineStartIndices` are lazily calculated.
-		this.#ensureLineStartIndicesFromLoc(loc, lineStart);
-
-		const isLastLine = loc.line === lineEnd;
-		const lineStartIndex = this.#lineStartIndices[loc.line - lineStart];
-		const lineEndIndex = isLastLine
-			? this.text.length
-			: this.#lineStartIndices[loc.line - lineStart + 1];
-		const positionIndex = lineStartIndex + loc.column - columnStart;
-
-		if (
-			loc.column < columnStart ||
-			(isLastLine && positionIndex > lineEndIndex) ||
-			(!isLastLine && positionIndex >= lineEndIndex)
-		) {
-			throw new RangeError(
-				`Column number out of range (column ${loc.column} requested). Valid range for line ${loc.line}: ${columnStart}-${lineEndIndex - lineStartIndex + columnStart + (isLastLine ? 0 : -1)}`,
-			);
-		}
-
-		return positionIndex;
-	}
-
 	/**
 	 * Returns the range information for the given node or token.
 	 * @param {Options['SyntaxElementWithLoc']} nodeOrToken The node or token to get the range information for.
@@ -863,8 +601,6 @@ class TextSourceCodeBase {
 	 * @public
 	 */
 	get lines() {
-		this.#ensureLines(); // Ensure `#lines` is lazily calculated.
-
 		return this.#lines;
 	}