@j-ulrich/release-it-regex-bumper 3.0.0 → 4.0.0

package/index.js

@@ -1,22 +1,25 @@
-const fs = require( 'fs' );
-const assert = require( 'assert' ).strict;
-const util = require( 'util' );
-const glob = require( 'fast-glob' );
-const chalk = require( 'chalk' );
-const _ = require( 'lodash' );
-const XRegExp = require( 'xregexp' );
-const semver = require( 'semver' );
-const { Plugin } = require( 'release-it' );
-const dateFormat = require( 'date-fns/format' );
-const dateFormatIso = require( 'date-fns/formatISO' );
-const diff = optionalRequire( 'diff' );
-
-
-const readFile = util.promisify( fs.readFile );
-const writeFile = util.promisify( fs.writeFile );
-
-const semanticVersionRegex = XRegExp( /(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?/ );
-const placeholderRegex = XRegExp( /\{\{(?<placeholder>(?:[a-z][a-z0-9_]*|\{))(?::(?<format>.*))?\}\}/ig );
+
+import { readFile as fsReadFile, writeFile as fsWriteFile } from 'fs';
+import { strict as assert } from 'assert';
+import { promisify } from 'util';
+import glob from 'fast-glob';
+import chalk from 'chalk';
+import _ from 'lodash';
+import XRegExp from 'xregexp';
+import semver from 'semver';
+import { Plugin } from 'release-it';
+import dateFormat from 'date-fns/format/index.js';
+import dateFormatIso from 'date-fns/formatISO/index.js';
+
+
+const readFile = promisify( fsReadFile );
+const writeFile = promisify( fsWriteFile );
+
+const semanticVersionRegex = XRegExp(
+	// eslint-disable-next-line security/detect-unsafe-regex
+	/(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?/
+);
+const placeholderRegex = XRegExp( '\\{\\{(?<placeholder>(?:[a-z][a-z0-9_]*|\\{))(?::(?<format>.*))?\\}\\}', 'ig' );
 
 const prereleasePrefix = '-';
 const buildPrefix = '+';
@@ -28,38 +31,51 @@ const defaultReplace = '{{version}}';
 
 
 
-class RegExBumper extends Plugin {
+export default class RegExBumper extends Plugin {
 
-	constructor(...args) {
-		super(...args);
-		this.setContext({executionTime: new Date()});
+	constructor( ...args ) {
+		super( ...args );
+		this.setContext( { executionTime: new Date() } );
 	}
 
 	async getLatestVersion() {
 
 		const { in: inOptions, search: globalSearchOptions, encoding: globalEncoding } = this.options;
 		if ( _.isNil( inOptions ) ) {
-			return;
+			return undefined;
 		}
 
 		const context = Object.assign( {}, this.getContext(), this.config.contextOptions );
 
-		const { searchRegex: globalSearchRegex, flags: globalSearchFlags, versionCaptureGroup: globalVersionCaptureGroup } = parseSearchOptions.call( this, globalSearchOptions );
-		const { file, encoding, searchRegex, flags: searchFlags, versionCaptureGroup } = parseInOptions.call( this, inOptions );
+		const {
+			searchRegex: globalSearchRegex,
+			flags: globalSearchFlags,
+			versionCaptureGroup: globalVersionCaptureGroup,
+		} = parseSearchOptions( globalSearchOptions );
+		const { file, encoding, searchRegex, flags: searchFlags, versionCaptureGroup } = parseInOptions( inOptions );
 
 		const effectiveEncoding = firstNotNil( encoding, globalEncoding, defaultEncoding );
 		const fileContent = await readFile( file, { encoding: effectiveEncoding } );
-		const effectiveSearchRegex = mergeSearchRegExes( [searchRegex, globalSearchRegex, defaultSearchRegex], [searchFlags, globalSearchFlags] );
+		const effectiveSearchRegex = mergeSearchRegExes(
+			[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+			[ searchFlags, globalSearchFlags ]
+		);
 		const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
-		const version = await extractVersion.call( this, fileContent, replacedSearchRegex,
-			firstNotNil( versionCaptureGroup, globalVersionCaptureGroup, defaultVersionCaptureGroup ) );
+		const version = await extractVersion(
+			fileContent,
+			replacedSearchRegex,
+			firstNotNil( versionCaptureGroup, globalVersionCaptureGroup, defaultVersionCaptureGroup )
+		);
 		return version;
 	}
 
-
 	async bump( version ) {
-
-		const { out: outOptions, search: globalSearchOptions, replace: globalReplace, encoding: globalEncoding } = this.options;
+		const {
+			out: outOptions,
+			search: globalSearchOptions,
+			replace: globalReplace,
+			encoding: globalEncoding,
+		} = this.options;
 		const { isDryRun } = this.config;
 		if ( _.isNil( outOptions ) ) {
 			return;
@@ -69,15 +85,21 @@ class RegExBumper extends Plugin {
 			context.version = version;
 		}
 
-		const { searchRegex: globalSearchRegex, flags: globalSearchFlags } = parseSearchOptions.call( this, globalSearchOptions );
+		const { searchRegex: globalSearchRegex, flags: globalSearchFlags } = parseSearchOptions.call(
+			this,
+			globalSearchOptions
+		);
 		const expandedOutOptions = await expandOutOptionFiles.call( this, parseOutOptions.call( this, outOptions ) );
 
-		for ( const outOptions of expandedOutOptions ) {
-
-			const { files, encoding, searchRegex, flags: searchFlags, replace } = outOptions;
+		/* eslint-disable no-await-in-loop */
+		for ( const outOption of expandedOutOptions ) {
+			const { files, encoding, searchRegex, flags: searchFlags, replace } = outOption;
 
 			const effectiveEncoding = firstNotNil( encoding, globalEncoding, defaultEncoding );
-			const effectiveSearchRegex = mergeSearchRegExes( [searchRegex, globalSearchRegex, defaultSearchRegex], [searchFlags, globalSearchFlags] );
+			const effectiveSearchRegex = mergeSearchRegExes(
+				[ searchRegex, globalSearchRegex, defaultSearchRegex ],
+				[ searchFlags, globalSearchFlags ]
+			);
 			const effectiveReplacement = firstNotNil( replace, globalReplace, defaultReplace );
 
 			const replacedSearchRegex = prepareSearch( effectiveSearchRegex, context );
@@ -89,26 +111,105 @@ class RegExBumper extends Plugin {
 				const fileContent = await readFile( file, { encoding: effectiveEncoding } );
 
 				if ( isDryRun ) {
-					loadDiff.call( this );
+					await this.loadDiff();
 					if ( this.diff ) {
-						const processedFileContent = replaceVersion.call( this, fileContent, replacedSearchRegex, effectiveReplacement, context );
-						await diffAndReport.call( this, fileContent, processedFileContent, file );
+						const processedFileContent = replaceVersion( fileContent, replacedSearchRegex,
+						                                             effectiveReplacement, context );
+						await this.diffAndReport( fileContent, processedFileContent, file );
 						continue;
 					}
-					await searchAndReport.call( this, fileContent, replacedSearchRegex, file );
+					await this.searchAndReport( fileContent, replacedSearchRegex, file );
 					continue;
 				}
 
-				const processedFileContent = replaceVersion.call( this, fileContent, replacedSearchRegex, effectiveReplacement, context );
+				const processedFileContent = replaceVersion(
+					fileContent,
+					replacedSearchRegex,
+					effectiveReplacement,
+					context
+				);
 
-				if ( processedFileContent == fileContent ) {
-					warnNoFileChange.call( this, file );
+				if ( processedFileContent === fileContent ) {
+					this.warnNoFileChange( file );
 				}
 				else {
 					await writeFile( file, processedFileContent, effectiveEncoding );
 				}
 			}
 		}
+		/* eslint-enable no-await-in-loop */
+	}
+
+	async loadDiff() {
+		if ( this.diff ) {
+			return;
+		}
+		try {
+			const diff = await import( 'diff' );
+			if ( !diff || !diff.structuredPatch ) {
+				throw new Error( 'diff module no available' );
+			}
+			this.diff = diff;
+		}
+		catch ( e ) {
+			this.log.info( 'Optional "diff" package not available' );
+			this.log.verbose( 'Exception was:', e );
+		}
+	}
+
+	diffAndReport( oldContent, newContent, filePath ) {
+		const { isDryRun } = this.config;
+		const diffResult = this.diff.structuredPatch( filePath, filePath, oldContent, newContent, undefined, undefined,
+			{
+				context: 0,
+			}
+		);
+
+		if ( _.isEmpty( diffResult.hunks ) ) {
+			this.warnNoFileChange( filePath );
+		}
+		diffResult.hunks.forEach( ( hunk ) => {
+			this.log.exec(
+				`Replacing at line ${hunk.oldStart}:\n` +
+					hunk.lines
+						.map( ( line ) => {
+							const lineText = '\t' + line;
+							if ( line.startsWith( '-' ) ) {
+								return chalk.red( lineText );
+							}
+							if ( line.startsWith( '+' ) ) {
+								return chalk.green( lineText );
+							}
+							return lineText;
+						} )
+						.join( '\n' ),
+				{ isDryRun }
+			);
+		} );
+	}
+
+	searchAndReport( content, searchRegex, filePath ) {
+		const { isDryRun } = this.config;
+		let foundMatch = false;
+		const lineCounter = new LineCounter( content );
+		XRegExp.forEach( content, searchRegex, ( match ) => {
+			const matchText = match[0];
+			const matchIndex = searchRegex.lastIndex - matchText.length;
+			this.log.exec(
+				`Replacing match at line ${lineCounter.lineOfIndex( matchIndex )}, ` +
+					`column ${lineCounter.columnOfIndex( matchIndex )}:\n\t` +
+					matchText,
+				{ isDryRun }
+			);
+			foundMatch = true;
+		} );
+		if ( !foundMatch ) {
+			this.warnNoFileChange( filePath );
+		}
+	}
+
+	warnNoFileChange( filePath ) {
+		this.log.warn( `File "${filePath}" did not change!` );
 	}
 
 }
@@ -124,7 +225,7 @@ function parseInOptions( options ) {
 	const { file, encoding } = options;
 	const { searchRegex, flags, versionCaptureGroup } = parseSearchOptions( options.search );
 	if ( !file ) {
-		throw new Error( `Missing 'file' property in 'in' options` );
+		throw new Error( "Missing 'file' property in 'in' options" );
 	}
 	return { file, encoding, searchRegex, flags, versionCaptureGroup };
 }
@@ -139,7 +240,7 @@ function parseSearchOptions( options ) {
 		return { searchRegex, versionCaptureGroup };
 	}
 	const { pattern, flags, versionCaptureGroup } = options;
-	const searchRegex = _.isNil(pattern) ? pattern : XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
+	const searchRegex = _.isNil( pattern ) ? pattern : XRegExp( pattern, _.isNull( flags ) ? undefined : flags );
 	return { searchRegex, flags, versionCaptureGroup };
 }
 
@@ -149,37 +250,43 @@ function extractVersion( content, versionRegex, versionCaptureGroup ) {
 		throw new Error( 'Could not extract version from file' );
 	}
 	if ( !_.isNil( versionCaptureGroup ) ) {
-		if( match.hasOwnProperty( versionCaptureGroup ) ) {
-			return match[ versionCaptureGroup ];
+		if ( hasOwnProperty( match, versionCaptureGroup ) ) {
+			// object injection mitigated by checking hasOwnProperty()
+			// eslint-disable-next-line security/detect-object-injection
+			return match[versionCaptureGroup];
 		}
 	}
 	else {
-		if ( match.hasOwnProperty( 'version' ) ) {
-			return match[ 'version' ];
+		if ( hasOwnProperty( match, 'version' ) ) {
+			return match['version'];
 		}
-		if ( match.hasOwnProperty( 1 ) ) {
-			return match[ 1 ];
+		if ( hasOwnProperty( match, 1 ) ) {
+			return match[1];
 		}
 	}
 
-	return match[ 0 ];
+	return match[0];
+}
+
+function hasOwnProperty( obj, prop ) {
+	return Object.prototype.hasOwnProperty.call( obj, prop );
 }
 
 function parseOutOptions( options ) {
-	return _.castArray( options ).map( options => {
-		if ( _.isString( options ) ) {
+	return _.castArray( options ).map( ( option ) => {
+		if ( _.isString( option ) ) {
 			return {
-				files: [ options ],
+				files: [ option ],
 				encoding: null,
 				searchRegex: null,
 				replace: null,
 			};
 		}
-		const { encoding, replace } = options;
-		const { searchRegex, flags } = parseSearchOptions( options.search );
-		const files = options.files ? _.castArray( options.files ) : [];
-		if( options.file ) {
-			files.unshift( options.file );
+		const { encoding, replace } = option;
+		const { searchRegex, flags } = parseSearchOptions( option.search );
+		const files = option.files ? _.castArray( option.files ) : [];
+		if ( option.file ) {
+			files.unshift( option.file );
 		}
 		return { files, encoding, searchRegex, flags, replace };
 	} );
@@ -202,55 +309,6 @@ async function expandOutOptionFiles( options ) {
 	return options;
 }
 
-function loadDiff() {
-	if ( !diff || diff instanceof Error ) {
-		this.log.info( 'Optional "diff" package not available' );
-		this.log.verbose( 'Exception was:', diff );
-	}
-	this.diff = diff;
-}
-
-function diffAndReport( oldContent, newContent, filePath ) {
-	const { isDryRun } = this.config;
-	const diffResult = this.diff.structuredPatch( filePath, filePath, oldContent, newContent, undefined, undefined, { context: 0 } );
-
-	if ( _.isEmpty( diffResult.hunks ) ) {
-		warnNoFileChange.call( this, filePath );
-	}
-	diffResult.hunks.forEach( hunk => {
-		this.log.exec( `Replacing at line ${hunk.oldStart}:\n` + hunk.lines.map( line => {
-			const lineText = '\t' + line;
-			if ( line.startsWith( '-' ) ) {
-				return chalk.red( lineText );
-			}
-			if ( line.startsWith( '+' ) ) {
-				return chalk.green( lineText );
-			}
-			return lineText;
-		} ).join( '\n' ), { isDryRun } );
-	} );
-
-}
-
-function searchAndReport( content, searchRegex, filePath ) {
-	const { isDryRun } = this.config;
-	let foundMatch = false;
-	const lineCounter = new LineCounter( content );
-	XRegExp.forEach( content, searchRegex, ( match ) => {
-		const matchText = match[ 0 ];
-		const matchIndex = searchRegex.lastIndex - matchText.length;
-		this.log.exec( `Replacing match at line ${lineCounter.lineOfIndex( matchIndex )}, column ${lineCounter.columnOfIndex( matchIndex )}:\n\t` + matchText, { isDryRun } );
-		foundMatch = true;
-	} );
-	if ( !foundMatch ) {
-		warnNoFileChange.call( this, filePath );
-	}
-}
-
-function warnNoFileChange( filePath ) {
-	this.log.warn( `File "${filePath}" did not change!` );
-}
-
 function mergeSearchRegExes( regExCandidates, flagCandidates ) {
 	const searchRegEx = firstNotNil( ...regExCandidates );
 	const flags = firstNotNil( ...flagCandidates );
@@ -260,58 +318,69 @@ function mergeSearchRegExes( regExCandidates, flagCandidates ) {
 function prepareSearch( searchRegEx, context ) {
 	const pattern = searchRegEx.xregexp.source;
 	const placeholderMap = {
-		'now': ( format ) => {
-			if( _.isNil( format ) ) {
-				throw new Error( `Missing required parameter 'format' for placeholder {{now}}` );
+		now: ( format ) => {
+			if ( _.isNil( format ) ) {
+				throw new Error( "Missing required parameter 'format' for placeholder {{now}}" );
 			}
 			return XRegExp.escape( dateFormat( context.executionTime, format ) );
 		},
-		'semver': `${semanticVersionRegex.xregexp.source || semanticVersionRegex.source}`
+		semver: `${semanticVersionRegex.xregexp.source || semanticVersionRegex.source}`,
 	};
 	const parsedVer = semver.parse( context.latestVersion );
-	if( parsedVer ) {
+	if ( parsedVer ) {
 		Object.assign( placeholderMap, {
-			'version': XRegExp.escape( parsedVer.raw ),
-			'major': parsedVer.major,
-			'minor': parsedVer.minor,
-			'patch': parsedVer.patch,
-			'prerelease': XRegExp.escape( parsedVer.prerelease.join( '.' ) ),
-			'prefixedPrerelease': parsedVer.prerelease.length > 0 ? XRegExp.escape( prereleasePrefix + parsedVer.prerelease.join( '.' ) ) : "",
-			'build': XRegExp.escape( parsedVer.build.join( '.' ) ),
-			'prefixedBuild': parsedVer.build.length > 0 ? XRegExp.escape( buildPrefix + parsedVer.build.join( '.' ) ) : "",
-			'versionWithoutBuild': XRegExp.escape( parsedVer.version ),
-			'versionWithoutPrerelease': XRegExp.escape( `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}` ),
-
+			version: XRegExp.escape( parsedVer.raw ),
+			major: parsedVer.major,
+			minor: parsedVer.minor,
+			patch: parsedVer.patch,
+			prerelease: XRegExp.escape( parsedVer.prerelease.join( '.' ) ),
+			prefixedPrerelease:
+				parsedVer.prerelease.length > 0
+					? XRegExp.escape( prereleasePrefix + parsedVer.prerelease.join( '.' ) )
+					: '',
+			build: XRegExp.escape( parsedVer.build.join( '.' ) ),
+			prefixedBuild:
+				parsedVer.build.length > 0 ? XRegExp.escape( buildPrefix + parsedVer.build.join( '.' ) ) : '',
+			versionWithoutBuild: XRegExp.escape( parsedVer.version ),
+			versionWithoutPrerelease: XRegExp.escape( `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}` ),
 		} );
 	}
 	if ( context.latestTag ) {
-		Object.assign( placeholderMap, { 'tag': XRegExp.escape( context.latestTag ) } );
+		Object.assign( placeholderMap, { tag: XRegExp.escape( context.latestTag ) } );
 	}
 
 	if ( context.version ) {
-		Object.assign( placeholderMap, { 'newVersion': XRegExp.escape( context.version ) } );
+		Object.assign( placeholderMap, { newVersion: XRegExp.escape( context.version ) } );
 	}
 
-	for( const placeholder of Object.keys( placeholderMap ) ) {
+	wrapSearchPatternPlaceholders( placeholderMap );
+	const replacedPattern = replacePlaceholders( pattern, placeholderMap );
+	return XRegExp( replacedPattern, searchRegEx.xregexp.flags || undefined );
+}
+
+function wrapSearchPatternPlaceholders( placeholderMap ) {
+	for ( const placeholder of Object.keys( placeholderMap ) ) {
+		// object injection mitigated for placeholderMap since placeholder is from Object.keys( placeholderMap )
+		// eslint-disable-next-line security/detect-object-injection
 		const replacement = placeholderMap[ placeholder ];
-		if( _.isFunction( replacement ) ) {
+		if ( _.isFunction( replacement ) ) {
+			// eslint-disable-next-line security/detect-object-injection
 			placeholderMap[ placeholder ] = ( ...args ) => {
 				return wrapInRegexGroup( replacement( ...args ) );
 			};
 			continue;
 		}
+		// eslint-disable-next-line security/detect-object-injection
 		placeholderMap[ placeholder ] = wrapInRegexGroup( replacement );
 	}
-	const replacedPattern = replacePlaceholders( pattern, placeholderMap );
-	return XRegExp( replacedPattern, searchRegEx.xregexp.flags || undefined );
 }
 
 function wrapInRegexGroup( pattern ) {
-	return  `(?:${pattern})`;
+	return `(?:${pattern})`;
 }
 
 function replaceVersion( content, searchRegex, replace, context ) {
-	const processedReplace = prepareReplacement.call( this, replace, context );
+	const processedReplace = prepareReplacement( replace, context );
 	const processedContent = XRegExp.replace( content, searchRegex, processedReplace );
 	return processedContent;
 }
@@ -319,24 +388,25 @@ function replaceVersion( content, searchRegex, replace, context ) {
 function prepareReplacement( replace, context ) {
 	const parsedVer = semver.parse( context.version );
 	const placeholderMap = {
-		'version': parsedVer.raw,
-		'major': parsedVer.major,
-		'minor': parsedVer.minor,
-		'patch': parsedVer.patch,
-		'prerelease': parsedVer.prerelease.join( '.' ),
-		'prefixedPrerelease': parsedVer.prerelease.length > 0 ? prereleasePrefix + parsedVer.prerelease.join( '.' ) : '',
-		'build': parsedVer.build.join( '.' ),
-		'prefixedBuild': parsedVer.build.length > 0 ? buildPrefix + parsedVer.build.join( '.' ) : '',
-		'versionWithoutBuild': parsedVer.version,
-		'versionWithoutPrerelease': `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}`,
-		'latestVersion': context.latestVersion || '',
-		'latestTag': context.latestTag || '',
-		'now': ( format ) => {
-			if( _.isNil( format ) ) {
+		version: parsedVer.raw,
+		major: parsedVer.major,
+		minor: parsedVer.minor,
+		patch: parsedVer.patch,
+		prerelease: parsedVer.prerelease.join( '.' ),
+		prefixedPrerelease:
+			parsedVer.prerelease.length > 0 ? prereleasePrefix + parsedVer.prerelease.join( '.' ) : '',
+		build: parsedVer.build.join( '.' ),
+		prefixedBuild: parsedVer.build.length > 0 ? buildPrefix + parsedVer.build.join( '.' ) : '',
+		versionWithoutBuild: parsedVer.version,
+		versionWithoutPrerelease: `${parsedVer.major}.${parsedVer.minor}.${parsedVer.patch}`,
+		latestVersion: context.latestVersion || '',
+		latestTag: context.latestTag || '',
+		now: ( format ) => {
+			if ( _.isNil( format ) ) {
 				return dateFormatIso( context.executionTime );
 			}
 			return dateFormat( context.executionTime, format );
-		}
+		},
 	};
 	return replacePlaceholders( replace, placeholderMap );
 }
@@ -344,9 +414,11 @@ function prepareReplacement( replace, context ) {
 function replacePlaceholders( template, placeholderMap ) {
 	placeholderMap = Object.assign( {}, placeholderMap, { '{': '{' } );
 	return XRegExp.replace( template, placeholderRegex, ( match, placeholder, format ) => {
-		if ( !placeholderMap.hasOwnProperty( placeholder ) ) {
+		if ( !hasOwnProperty( placeholderMap, placeholder ) ) {
 			throw new Error( `Unknown placeholder encountered: {{${placeholder}}}` );
 		}
+		// object injection mitigated by checking hasOwnProperty()
+		// eslint-disable-next-line security/detect-object-injection
 		const replacement = placeholderMap[ placeholder ];
 		if ( _.isFunction( replacement ) ) {
 			if ( _.isString( format ) ) {
@@ -358,46 +430,35 @@ function replacePlaceholders( template, placeholderMap ) {
 	} );
 }
 
-
-function optionalRequire( packageName ) {
-	try {
-		return require( packageName );
-	}
-	/* c8 ignore next 4 */
-	/* rewiremock can't simulate the absence of a package so we can't test this case */
-	catch ( ex ) {
-		return ex;
-	}
-}
-
 function firstNotNil( ...args ) {
-	return args.find( ele => !_.isNil( ele ) );
+	return args.find( ( ele ) => !_.isNil( ele ) );
 }
 
 class LineCounter {
 	constructor( text ) {
 		let index = 0;
-		this.lineEndIndex = text.split( '\n' ).map( line => {
+		this.lineEndIndex = text.split( '\n' ).map( ( line ) => {
 			index += line.length + 1;
 			return index;
 		} );
 	}
 
 	lineOfIndex( index ) {
-		const arrayIndex = this.lineEndIndex.findIndex( lineEndIndex => ( index <= lineEndIndex ) );
+		// eslint-disable-next-line no-extra-parens
+		const arrayIndex = this.lineEndIndex.findIndex( ( lineEndIndex ) => index <= lineEndIndex );
 		assert( arrayIndex >= 0 );
 		return arrayIndex + 1;
 	}
 
 	columnOfIndex( index ) {
-		const line = this.lineOfIndex( index );
-		assert( line >= 1 );
-		if ( line === 1 ) {
+		const lineNumber = this.lineOfIndex( index );
+		assert( lineNumber >= 1 );
+		if ( lineNumber === 1 ) {
 			return index;
 		}
-		const previousLineEndIndex = this.lineEndIndex[ line - 2 ];
+		const previousLineNumber = lineNumber - 1;
+		const previousLineEndIndex = this.lineEndIndex[ previousLineNumber - 1 ];
 		return index - previousLineEndIndex;
 	}
 }
 
-module.exports = RegExBumper;

package/package.json

@@ -1,11 +1,16 @@
 {
 	"name": "@j-ulrich/release-it-regex-bumper",
-	"version": "3.0.0",
+	"version": "4.0.0",
 	"description": "Regular expression based version read/write plugin for release-it",
 	"main": "index.js",
+	"type": "module",
+	"files": [
+		"index.js"
+	],
 	"scripts": {
-		"test": "npx bron test.js",
-		"test+coverage": "npx c8 npx bron test.js",
+		"test": "node --experimental-loader=testdouble  ./node_modules/ava/entrypoints/cli.mjs --serial",
+		"test+coverage": "npx c8 node --experimental-loader=testdouble  ./node_modules/ava/entrypoints/cli.mjs --serial",
+		"lint": "npx eslint .",
 		"release": "npx release-it"
 	},
 	"keywords": [
@@ -42,20 +47,24 @@
 		"xregexp": "^4.3.0"
 	},
 	"peerDependencies": {
-		"release-it": "11 - 15"
+		"release-it": "15 - 16"
 	},
 	"optionalDependencies": {
 		"diff": "^3.0.0 || ^4.0.0"
 	},
 	"devDependencies": {
-		"bron": "^1.1.0",
+		"@j-ulrich/eslint-config": "^1.0.0",
+		"@release-it/keep-a-changelog": "^3.0.0",
+		"ava": "^4.0.1",
 		"c8": "^7.3.0",
-		"mock-fs": "^4.13.0",
-		"release-it": "^14.0.0",
-		"rewiremock": "^3.14.3",
-		"sinon": "^9.0.3"
+		"eslint": "^8.6.0",
+		"eslint-plugin-security": "^1.4.0",
+		"release-it": "^15.0.0",
+		"sinon": "^12.0.1",
+		"temp": "^0.9.4",
+		"testdouble": "^3.16.4"
 	},
 	"engines": {
-		"node": ">=10.12.0"
+		"node": ">=14.9"
 	}
 }