@j-ulrich/release-it-regex-bumper 3.0.1 → 4.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2021 Jochen Ulrich
+Copyright (c) 2020-2022 Jochen Ulrich
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,9 +2,9 @@
 
 > Regular expression based version read/write plugin for release-it
 
-![CI](https://github.com/j-ulrich/release-it-regex-bumper/workflows/CI/badge.svg)
-[![Test Coverage](https://app.codacy.com/project/badge/Coverage/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/manual/j-ulrich/release-it-regex-bumper?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Coverage)
-[![Code Quality](https://app.codacy.com/project/badge/Grade/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/manual/j-ulrich/release-it-regex-bumper?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Grade)
+[![CI](https://github.com/j-ulrich/release-it-regex-bumper/actions/workflows/CI.yml/badge.svg)](https://github.com/j-ulrich/release-it-regex-bumper/actions/workflows/CI.yml)
+[![Test Coverage](https://app.codacy.com/project/badge/Coverage/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/gh/j-ulrich/release-it-regex-bumper/dashboard?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Coverage)
+[![Code Quality](https://app.codacy.com/project/badge/Grade/bf3c6e8740a9472b9acd7dac231adf4e)](https://www.codacy.com/gh/j-ulrich/release-it-regex-bumper/dashboard?utm_source=github.com&utm_medium=referral&utm_content=j-ulrich/release-it-regex-bumper&utm_campaign=Badge_Grade)
 
 This [release-it](https://github.com/release-it/release-it) plugin reads and/or writes versions
 using regular expressions.
@@ -18,6 +18,10 @@ below for details.
 
 # Installation #
 
+> ⚠️ **Note:**  
+> Version 4 and later of release-it-regex-bumper require version 15 or later of release-it.   
+> When you are using release-it version 14.x or earlier, then use release-it-regex-bumper version 3.x or earlier.
+
 ```
 npm install --save-dev @j-ulrich/release-it-regex-bumper
 ```
@@ -48,7 +52,7 @@ For example:
 }
 ```
 
-For a more complex example, see [.release-it.json](.release-it.json).
+For a more complex example, see [here](https://gitlab.com/julrich/MockNetworkAccessManager/-/blob/main/.release-it.json).
 
 
 ## Regular Expressions ##
@@ -421,9 +425,18 @@ encodings are the ones supported by Node's `fs` module.
 
 If this option is not defined or set to `null`, the default value is used.
 
+## Tips ##
+
+### Disable Output via Command-Line Parameter ###
+To completely disable changing any files by the plugin, you can use the command-line parameter `--no-plugins.@j-ulrich/release-it-regex-bumper.out`.
+For example:
+```
+npx release-it --no-plugins.@j-ulrich/release-it-regex-bumper.out
+```
+
 
 # License #
 
-Copyright (c) 2020-2021 Jochen Ulrich
+Copyright (c) 2020-2022 Jochen Ulrich
 
 Licensed under [MIT license](LICENSE).

package/index.js

@@ -1,28 +1,24 @@
-const fs = require( 'fs' );
-const assert = require( 'assert' ).strict;
-const util = require( 'util' );
-const glob = require( 'fast-glob' );
-const chalk = require( 'chalk' );
-const _ = {
-	isEmpty: require( 'lodash/isEmpty' ),
-	isNil: require( 'lodash/isNil' ),
-	isNull: require( 'lodash/isNull' ),
-	isString: require( 'lodash/isString' ),
-	isFunction: require( 'lodash/isFunction' ),
-	castArray: require( 'lodash/castArray' )
-};
-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-]+)*)?/ );
+
+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 = '-';
@@ -35,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;
@@ -76,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 );
@@ -96,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!` );
 	}
 
 }
@@ -146,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 };
 }
 
@@ -156,22 +250,27 @@ function extractVersion( content, versionRegex, versionCaptureGroup ) {
 		throw new Error( 'Could not extract version from file' );
 	}
 	if ( !_.isNil( versionCaptureGroup ) ) {
-		if( hasOwnProperty( match, versionCaptureGroup ) ) {
+		if ( typeof versionCaptureGroup === 'number' && hasOwnProperty( match, versionCaptureGroup ) ) {
 			// object injection mitigated by checking hasOwnProperty()
 			// eslint-disable-next-line security/detect-object-injection
-			return match[ versionCaptureGroup ];
+			return match[versionCaptureGroup];
+		}
+		if ( match.groups && hasOwnProperty( match.groups, versionCaptureGroup ) ) {
+			// object injection mitigated by checking hasOwnProperty()
+			// eslint-disable-next-line security/detect-object-injection
+			return match.groups[versionCaptureGroup];
 		}
 	}
 	else {
-		if ( hasOwnProperty( match, 'version' ) ) {
-			return match[ 'version' ];
+		if ( match.groups && hasOwnProperty( match.groups, 'version' ) ) {
+			return match.groups.version;
 		}
 		if ( hasOwnProperty( match, 1 ) ) {
-			return match[ 1 ];
+			return match[1];
 		}
 	}
 
-	return match[ 0 ];
+	return match[0];
 }
 
 function hasOwnProperty( obj, prop ) {
@@ -179,20 +278,20 @@ function hasOwnProperty( 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 };
 	} );
@@ -215,55 +314,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 );
@@ -273,36 +323,39 @@ function mergeSearchRegExes( regExCandidates, flagCandidates ) {
 function prepareSearch( searchRegEx, context ) {
 	const pattern = searchRegEx.xregexp.source;
 	const placeholderMap = {
-		'now': ( format ) => {
-			if( _.isNil( format ) ) {
+		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 ) } );
 	}
 
 	wrapSearchPatternPlaceholders( placeholderMap );
@@ -311,11 +364,11 @@ function prepareSearch( searchRegEx, context ) {
 }
 
 function wrapSearchPatternPlaceholders( placeholderMap ) {
-	for( const placeholder of Object.keys( 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 ) );
@@ -332,7 +385,7 @@ function wrapInRegexGroup( 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;
 }
@@ -340,24 +393,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 );
 }
@@ -381,34 +435,22 @@ function replacePlaceholders( template, placeholderMap ) {
 	} );
 }
 
-
-function optionalRequire( packageName ) {
-	try {
-		// eslint-disable-next-line security/detect-non-literal-require
-		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;
 	}
@@ -425,4 +467,3 @@ class LineCounter {
 	}
 }
 
-module.exports = RegExBumper;

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "@j-ulrich/release-it-regex-bumper",
-	"version": "3.0.1",
+	"version": "4.1.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"
 	},
@@ -35,30 +39,32 @@
 		"name": "Jochen Ulrich"
 	},
 	"dependencies": {
-		"chalk": "^4.0.0",
+		"chalk": "^5.0.0",
 		"date-fns": "^2.8.0",
 		"fast-glob": "^3.2.0",
 		"lodash": "^4.17.20",
 		"semver": "^7.3.0",
-		"xregexp": "^4.3.0"
+		"xregexp": "^5.0.0"
 	},
 	"peerDependencies": {
-		"release-it": "11 - 15"
+		"release-it": "15"
 	},
 	"optionalDependencies": {
-		"diff": "^3.0.0 || ^4.0.0"
+		"diff": "3 - 5"
 	},
 	"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",
-		"eslint": "^8.0.1",
+		"eslint": "^8.6.0",
 		"eslint-plugin-security": "^1.4.0",
-		"mock-fs": "^5.1.1",
-		"release-it": "^14.0.0",
-		"rewiremock": "^3.14.3",
-		"sinon": "^9.0.3"
+		"release-it": "^15.0.0",
+		"sinon": "^13.0.2",
+		"temp": "^0.9.4",
+		"testdouble": "^3.16.4"
 	},
 	"engines": {
-		"node": ">=10.12.0"
+		"node": ">=14.9"
 	}
 }