getLocFromIndexBefore(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}).`,
			);
		}

		/*
		 * For an argument of this.text.length, return the location one "spot" past the last character
		 * of the file. If the last character is a linebreak, the location will be column 0 of the next
		 * line; otherwise, the location will be in the next column on the same line.
		 *
		 * See getIndexFromLoc for the motivation for this special case.
		 */
		if (index === this.text.length) {
			return {
				line: this.lines.length,
				column: this.lines.at(-1).length,
			};
		}
		/*
		 * 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)
				? this.lineStartIndices.length
				: this.lineStartIndices.findIndex(el => index < el);

		return {
			line: lineNumber,
			column: index - this.lineStartIndices[lineNumber - 1],
		};
	}

	getLocFromIndexWithoutCache(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}).`,
			);
		}

		/*
		 * For an argument of this.text.length, return the location one "spot" past the last character
		 * of the file. If the last character is a linebreak, the location will be column 0 of the next
		 * line; otherwise, the location will be in the next column on the same line.
		 *
		 * See getIndexFromLoc for the motivation for this special case.
		 */
		if (index === this.text.length) {
			return {
				line: this.lines.length,
				column: this.lines.at(-1).length,
			};
		}

		/*
		 * 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)
				? this.lineStartIndices.length
				: findLineNumberBinarySearch(this.lineStartIndices, index);

		return {
			line: lineNumber,
			column: index - this.lineStartIndices[lineNumber - 1],
		};
	}

"use strict";

/* eslint-disable no-console, jsdoc/require-jsdoc -- Benchmarking */

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const { readFileSync } = require('node:fs');
const SourceCode = require('./lib/languages/js/source-code/source-code');
const espree = require("espree");

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

const ITER = 1_000;
const CODE = readFileSync('./lib/eslint/eslint.js', 'utf8'); // 1,162 lines of code.
const DEFAULT_CONFIG = {
	ecmaVersion: 2024,
	comment: true,
	tokens: true,
	range: true,
	loc: true,
};

function runBefore() {
	const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

	console.time('getLocFromIndexBefore');

	for(let i = 0; i < ITER; i++) {
		for( let j = 0; j < CODE.length; j++) {
			sourceCode.getLocFromIndexBefore(j);
		}
	}

	console.timeEnd('getLocFromIndexBefore');
}

function runAfter() {
	const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

	console.time('getLocFromIndexAfter');

	for(let i = 0; i < ITER; i++) {
		for( let j = 0; j < CODE.length; j++) {
			sourceCode.getLocFromIndex(j);
		}
	}

	console.timeEnd('getLocFromIndexAfter');
}

function runAfterWithoutCache() {
	const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

	console.time('getLocFromIndexAfterWithoutCache');

	for(let i = 0; i < ITER; i++) {
		for( let j = 0; j < CODE.length; j++) {
			sourceCode.getLocFromIndexWithoutCache(j);
		}
	}

	console.timeEnd('getLocFromIndexAfterWithoutCache');
}

//------------------------------------------------------------------------------
// Benchmark
//------------------------------------------------------------------------------

console.log('Running benchmark...(1/5)');
runBefore();
runAfterWithoutCache();
runAfter();

console.log('Running benchmark...(2/5)');
runBefore();
runAfterWithoutCache();
runAfter();

console.log('Running benchmark...(3/5)');
runBefore();
runAfterWithoutCache();
runAfter();

console.log('Running benchmark...(4/5)');
runBefore();
runAfterWithoutCache();
runAfter();

console.log('Running benchmark...(5/5)');
runBefore();
runAfterWithoutCache();
runAfter();

/* eslint-enable no-console, jsdoc/require-jsdoc -- Benchmarking */

"use strict";

/* eslint-disable no-console, jsdoc/require-jsdoc, prefer-arrow-callback, no-invalid-this -- Benchmarking */

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const { readFileSync } = require('node:fs');
const SourceCode = require('./lib/languages/js/source-code/source-code');
const Benchmark = require('benchmark');
const espree = require("espree");

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

const ITER = 100;
const CODE = readFileSync('./lib/eslint/eslint.js', 'utf8'); // 1,162 lines of code.
const DEFAULT_CONFIG = {
    ecmaVersion: 2024,
    comment: true,
    tokens: true,
    range: true,
    loc: true,
};

function runBefore() {
    const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

    for(let i = 0; i < ITER; i++) {
        for( let j = 0; j < CODE.length; j++) {
            sourceCode.getLocFromIndexBefore(j);
        }
    }
}

function runAfter() {
    const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

    for(let i = 0; i < ITER; i++) {
        for( let j = 0; j < CODE.length; j++) {
            sourceCode.getLocFromIndex(j);
        }
    }
}

function runAfterWithoutCache() {
    const sourceCode = new SourceCode(CODE, espree.parse(CODE, DEFAULT_CONFIG));

    for(let i = 0; i < ITER; i++) {
        for( let j = 0; j < CODE.length; j++) {
            sourceCode.getLocFromIndexWithoutCache(j);
        }
    }
}

//------------------------------------------------------------------------------
// Benchmark
//------------------------------------------------------------------------------

new Benchmark.Suite()
    .add('getLocFromIndexBefore', function() {
        runBefore();
    })
    .add('getLocFromIndexAfterWithoutCache', function() {
        runAfterWithoutCache();
    })
    .add('getLocFromIndexAfter', function() {
        runAfter();
    })
    .on('cycle', function(event) {
        console.log(String(event.target));
    })
    .on('complete', function() {
        console.log(`\nFastest is ${this.filter('fastest').map('name')}`);

        // Calculate improvement percentages
        const before = this[0].stats;
        const withoutCache = this[1].stats;
        const withCache = this[2].stats;

        const binarySearchImprovement = ((before.mean - withoutCache.mean) / before.mean * 100).toFixed(2);
        const cachingImprovement = ((withoutCache.mean - withCache.mean) / withoutCache.mean * 100).toFixed(2);
        const totalImprovement = ((before.mean - withCache.mean) / before.mean * 100).toFixed(2);

        console.log('\nPerformance improvements:\n');
        console.log(`Binary search optimization: ${binarySearchImprovement}% faster than original`);
        console.log(`Caching optimization: ${cachingImprovement}% faster than without cache`);
        console.log(`Total improvement: ${totalImprovement}% faster than original`);
    })
	.run({ 'async': true });

/* eslint-enable no-console, jsdoc/require-jsdoc, prefer-arrow-callback, no-invalid-this -- Benchmarking */