eslint-plugin-jsdoc 51.4.0 → 52.0.0

package/src/jsdocUtils.js

@@ -647,12 +647,12 @@ const getPreferredTagNameSimple = (
         value,
       ]) => {
         return [
-          key.replace(/^tag /u, ''), value,
+          key.replace(/^tag /v, ''), value,
         ];
       }),
   );
 
-  if (Object.prototype.hasOwnProperty.call(tagPreferenceFixed, name)) {
+  if (Object.hasOwn(tagPreferenceFixed, name)) {
     return tagPreferenceFixed[name];
   }
 
@@ -1480,7 +1480,7 @@ const hasThrowValue = (node, innerFunction) => {
  */
 /*
 const isInlineTag = (tag) => {
-  return /^(@link|@linkcode|@linkplain|@tutorial) /u.test(tag);
+  return /^(@link|@linkcode|@linkplain|@tutorial) /v.test(tag);
 };
 */
 
@@ -1495,7 +1495,7 @@ const parseClosureTemplateTag = (tag) => {
   return tag.name
     .split(',')
     .map((type) => {
-      return type.trim().replace(/^\[?(?<name>.*?)=.*$/u, '$<name>');
+      return type.trim().replace(/^\[?(?<name>.*?)=.*$/v, '$<name>');
     });
 };
 
@@ -1649,7 +1649,7 @@ const getTagsByType = (context, mode, tags) => {
  * @returns {string}
  */
 const getIndent = (sourceCode) => {
-  return (sourceCode.text.match(/^\n*([ \t]+)/u)?.[1] ?? '') + ' ';
+  return (sourceCode.text.match(/^\n*([ \t]+)/v)?.[1] ?? '') + ' ';
 };
 
 /**
@@ -1789,7 +1789,7 @@ const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
  * @returns {string}
  */
 const dropPathSegmentQuotes = (str) => {
-  return str.replaceAll(/\.(['"])(.*)\1/gu, '.$2');
+  return str.replaceAll(/\.(['"])(.*)\1/gv, '.$2');
 };
 
 /**
@@ -1822,8 +1822,8 @@ const pathDoesNotBeginWith = (name, otherPathName) => {
  * @returns {RegExp}
  */
 const getRegexFromString = (regexString, requiredFlags) => {
-  const match = regexString.match(/^\/(.*)\/([gimyus]*)$/us);
-  let flags = 'u';
+  const match = regexString.match(/^\/(.*)\/([gimyvus]*)$/vs);
+  let flags = 'v';
   let regex = regexString;
   if (match) {
     [
@@ -1831,7 +1831,7 @@ const getRegexFromString = (regexString, requiredFlags) => {
       flags,
     ] = match;
     if (!flags) {
-      flags = 'u';
+      flags = 'v';
     }
   }
 

package/src/rules/checkAlignment.js

@@ -5,7 +5,7 @@ import iterateJsdoc from '../iterateJsdoc.js';
  * @returns {string}
  */
 const trimStart = (string) => {
-  return string.replace(/^\s+/u, '');
+  return string.replace(/^\s+/v, '');
 };
 
 export default iterateJsdoc(({

package/src/rules/checkExamples.js

@@ -16,14 +16,14 @@ const preTagSpaceLength = 1;
 // If a space is present, we should ignore it
 const firstLinePrefixLength = preTagSpaceLength;
 
-const hasCaptionRegex = /^\s*<caption>([\s\S]*?)<\/caption>/u;
+const hasCaptionRegex = /^\s*<caption>([\s\S]*?)<\/caption>/v;
 
 /**
  * @param {string} str
  * @returns {string}
  */
 const escapeStringRegexp = (str) => {
-  return str.replaceAll(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+  return str.replaceAll(/[.*+?^$\{\}\(\)\|\[\]\\]/gv, '\\$&');
 };
 
 /**
@@ -32,7 +32,7 @@ const escapeStringRegexp = (str) => {
  * @returns {import('../iterateJsdoc.js').Integer}
  */
 const countChars = (str, ch) => {
-  return (str.match(new RegExp(escapeStringRegexp(ch), 'gu')) || []).length;
+  return (str.match(new RegExp(escapeStringRegexp(ch), 'gv')) || []).length;
 };
 
 /** @type {import('eslint').Linter.RulesRecord} */
@@ -244,7 +244,7 @@ export default iterateJsdoc(({
       const cliConfigStr = JSON.stringify(cliConfig);
 
       const src = paddedIndent ?
-        string.replaceAll(new RegExp(`(^|\n) {${paddedIndent}}(?!$)`, 'gu'), '\n') :
+        string.replaceAll(new RegExp(`(^|\n) {${paddedIndent}}(?!$)`, 'gv'), '\n') :
         string;
 
       // Programmatic ESLint API: https://eslint.org/docs/developer-guide/nodejs-api
@@ -345,7 +345,7 @@ export default iterateJsdoc(({
     if (!filename) {
       const jsFileName = context.getFilename();
       if (typeof jsFileName === 'string' && jsFileName.includes('.')) {
-        defaultFileName = jsFileName.replace(/\.[^.]*$/u, `.${ext}`);
+        defaultFileName = jsFileName.replace(/\.[^.]*$/v, `.${ext}`);
       } else {
         defaultFileName = `dummy.${ext}`;
       }

package/src/rules/checkIndentation.js

@@ -6,10 +6,10 @@ import iterateJsdoc from '../iterateJsdoc.js';
  * @returns {string}
  */
 const maskExcludedContent = (str, excludeTags) => {
-  const regContent = new RegExp(`([ \\t]+\\*)[ \\t]@(?:${excludeTags.join('|')})(?=[ \\n])([\\w|\\W]*?\\n)(?=[ \\t]*\\*(?:[ \\t]*@\\w+\\s|\\/))`, 'gu');
+  const regContent = new RegExp(`([ \\t]+\\*)[ \\t]@(?:${excludeTags.join('|')})(?=[ \\n])([\\w\\|\\W]*?\\n)(?=[ \\t]*\\*(?:[ \\t]*@\\w+\\s|\\/))`, 'gv');
 
   return str.replace(regContent, (_match, margin, code) => {
-    return (margin + '\n').repeat(code.match(/\n/gu).length);
+    return (margin + '\n').repeat(code.match(/\n/gv).length);
   });
 };
 
@@ -18,10 +18,10 @@ const maskExcludedContent = (str, excludeTags) => {
  * @returns {string}
  */
 const maskCodeBlocks = (str) => {
-  const regContent = /([ \t]+\*)[ \t]```[^\n]*?([\w|\W]*?\n)(?=[ \t]*\*(?:[ \t]*(?:```|@\w+\s)|\/))/gu;
+  const regContent = /([ \t]+\*)[ \t]```[^\n]*?([\w\|\W]*?\n)(?=[ \t]*\*(?:[ \t]*(?:```|@\w+\s)|\/))/gv;
 
   return str.replaceAll(regContent, (_match, margin, code) => {
-    return (margin + '\n').repeat(code.match(/\n/gu).length);
+    return (margin + '\n').repeat(code.match(/\n/gv).length);
   });
 };
 
@@ -38,12 +38,12 @@ export default iterateJsdoc(({
     ],
   } = options;
 
-  const reg = /^(?:\/?\**|[ \t]*)\*[ \t]{2}/gmu;
+  const reg = /^(?:\/?\**|[ \t]*)\*[ \t]{2}/gmv;
   const textWithoutCodeBlocks = maskCodeBlocks(sourceCode.getText(jsdocNode));
   const text = excludeTags.length ? maskExcludedContent(textWithoutCodeBlocks, excludeTags) : textWithoutCodeBlocks;
 
   if (reg.test(text)) {
-    const lineBreaks = text.slice(0, reg.lastIndex).match(/\n/gu) || [];
+    const lineBreaks = text.slice(0, reg.lastIndex).match(/\n/gv) || [];
     report('There must be no indentation.', null, {
       line: lineBreaks.length,
     });

package/src/rules/checkLineAlignment.js

@@ -93,8 +93,8 @@ const checkNotAlignedPerTag = (utils, tag, customSpacings) => {
   };
 
   const postHyphenSpacing = customSpacings?.postHyphen ?? 1;
-  const exactHyphenSpacing = new RegExp(`^\\s*-\\s{${postHyphenSpacing},${postHyphenSpacing}}(?!\\s)`, 'u');
-  const hasNoHyphen = !(/^\s*-(?!$)(?=\s)/u).test(tokens.description);
+  const exactHyphenSpacing = new RegExp(`^\\s*-\\s{${postHyphenSpacing},${postHyphenSpacing}}(?!\\s)`, 'v');
+  const hasNoHyphen = !(/^\s*-(?!$)(?=\s)/v).test(tokens.description);
   const hasExactHyphenSpacing = exactHyphenSpacing.test(
     tokens.description,
   );
@@ -144,7 +144,7 @@ const checkNotAlignedPerTag = (utils, tag, customSpacings) => {
     }
 
     if (!hasExactHyphenSpacing) {
-      const hyphenSpacing = /^\s*-\s+/u;
+      const hyphenSpacing = /^\s*-\s+/v;
       tokens.description = tokens.description.replace(
         hyphenSpacing, '-' + ''.padStart(postHyphenSpacing, ' '),
       );

package/src/rules/checkTagNames.js

@@ -267,7 +267,7 @@ export default iterateJsdoc(({
       if (preferredTagName !== tagName) {
         report(message, (fixer) => {
           const replacement = sourceCode.getText(jsdocNode).replace(
-            new RegExp(`@${escapeStringRegexp(tagName)}\\b`, 'u'),
+            new RegExp(`@${escapeStringRegexp(tagName)}\\b`, 'v'),
             `@${preferredTagName}`,
           );
 

package/src/rules/checkTemplateNames.js

@@ -73,7 +73,7 @@ export default iterateJsdoc(({
       const {
         name,
       } = tag;
-      const names = name.split(/,\s*/u);
+      const names = name.split(/,\s*/v);
       for (const nme of names) {
         if (!usedNames.has(nme)) {
           report(`@template ${nme} not in use`, null, tag);

package/src/rules/checkTypes.js

@@ -43,7 +43,7 @@ const adjustNames = (type, preferred, isGenericMatch, typeNodeName, node, parent
       parentMeta.dot = false;
       ret = 'Array';
     } else {
-      const dotBracketEnd = preferred.match(/\.(?:<>)?$/u);
+      const dotBracketEnd = preferred.match(/\.(?:<>)?$/v);
       if (dotBracketEnd) {
         parentMeta.brackets = 'angle';
         parentMeta.dot = true;
@@ -69,7 +69,7 @@ const adjustNames = (type, preferred, isGenericMatch, typeNodeName, node, parent
 
   /** @type {import('jsdoc-type-pratt-parser').NameResult} */ (
     node
-  ).value = ret.replace(/(?:\.|<>|\.<>|\[\])$/u, '');
+  ).value = ret.replace(/(?:\.|<>|\.<>|\[\])$/v, '');
 
   // For bare pseudo-types like `<>`
   if (!ret) {

package/src/rules/checkValues.js

@@ -29,7 +29,7 @@ export default iterateJsdoc(({
   const {
     allowedAuthors = null,
     allowedLicenses = null,
-    licensePattern = '/([^\n\r]*)/gu',
+    licensePattern = '/([^\n\r]*)/gv',
     numericOnlyVariation = false,
   } = options;
 

package/src/rules/emptyTags.js

@@ -53,7 +53,7 @@ export default iterateJsdoc(({
     const content = tag.name || tag.description || tag.type;
     if (content.trim() && (
       // Allow for JSDoc-block final asterisks
-      key !== emptyTags.length - 1 || !(/^\s*\*+$/u).test(content)
+      key !== emptyTags.length - 1 || !(/^\s*\*+$/v).test(content)
     )) {
       const fix = () => {
         // By time of call in fixer, `tag` will have `line` added

package/src/rules/importsAsDependencies.js

@@ -83,10 +83,10 @@ export default iterateJsdoc(({
 
       if (nde.type === 'JsdocTypeImport') {
         let mod = nde.element.value.replace(
-          /^(@[^/]+\/[^/]+|[^/]+).*$/u, '$1',
+          /^(@[^\/]+\/[^\/]+|[^\/]+).*$/v, '$1',
         );
 
-        if ((/^[./]/u).test(mod)) {
+        if ((/^[.\/]/v).test(mod)) {
           return;
         }
 

package/src/rules/linesBeforeBlock.js

@@ -68,7 +68,7 @@ export default iterateJsdoc(({
         // @ts-expect-error Should be a comment
         indent = /** @type {import('estree').Comment} */ (
           jsdocNode
-        ).value.match(/^\*\n([\t ]*) \*/u)?.[1]?.slice(spaceDiff);
+        ).value.match(/^\*\n([\t ]*) \*/v)?.[1]?.slice(spaceDiff);
         if (!indent) {
           /** @type {import('eslint').AST.Token|import('estree').Comment|undefined} */
           let tokenPrior = tokenBefore;

package/src/rules/matchDescription.js

@@ -2,7 +2,7 @@ import iterateJsdoc from '../iterateJsdoc.js';
 
 // If supporting Node >= 10, we could loosen the default to this for the
 //   initial letter: \\p{Upper}
-const matchDescriptionDefault = '^\n?([A-Z`\\d_][\\s\\S]*[.?!`]\\s*)?$';
+const matchDescriptionDefault = '^\n?([A-Z`\\d_][\\s\\S]*[.?!`\\p{RGI_Emoji}]\\s*)?$';
 
 /**
  * @param {string} value
@@ -43,7 +43,7 @@ export default iterateJsdoc(({
     }
 
     if (mainDescriptionMatch === false && (
-      !tag || !Object.prototype.hasOwnProperty.call(tags, tag.tag))
+      !tag || !Object.hasOwn(tags, tag.tag))
     ) {
       return;
     }
@@ -114,7 +114,7 @@ export default iterateJsdoc(({
       utils.forEachPreferredTag(tag, (matchingJsdocTag, targetTagName) => {
         const desc = (matchingJsdocTag.name + ' ' + utils.getTagDescription(matchingJsdocTag)).trim();
 
-        if (hasNoTag(targetTagName) && !(/.+/u).test(desc)) {
+        if (hasNoTag(targetTagName) && !(/.+/v).test(desc)) {
           report(
             'JSDoc description must not be empty.',
             null,
@@ -150,7 +150,7 @@ export default iterateJsdoc(({
   tagsWithNames.some((tag) => {
     const desc = /** @type {string} */ (
       utils.getTagDescription(tag)
-    ).replace(/^[- ]*/u, '')
+    ).replace(/^[\- ]*/v, '')
       .trim();
 
     return validateDescription(desc, tag);

package/src/rules/matchName.js

@@ -38,7 +38,7 @@ export default iterateJsdoc(({
 
   let reported = false;
   for (const tag of applicableTags) {
-    const tagName = tag.name.replace(/^\[/u, '').replace(/(=.*)?\]$/u, '');
+    const tagName = tag.name.replace(/^\[/v, '').replace(/(=.*)?\]$/v, '');
     const allowed = !allowNameRegex || allowNameRegex.test(tagName);
     const disallowed = disallowNameRegex && disallowNameRegex.test(tagName);
     const hasRegex = allowNameRegex || disallowNameRegex;
@@ -107,8 +107,8 @@ export default iterateJsdoc(({
         additionalProperties: false,
         properties: {
           match: {
-            additionalProperties: false,
             items: {
+              additionalProperties: false,
               properties: {
                 allowName: {
                   type: 'string',
@@ -125,6 +125,9 @@ export default iterateJsdoc(({
                 message: {
                   type: 'string',
                 },
+                replacement: {
+                  type: 'string',
+                },
                 tags: {
                   items: {
                     type: 'string',

package/src/rules/noBadBlocks.js

@@ -5,8 +5,8 @@ import {
 
 // Neither a single nor 3+ asterisks are valid jsdoc per
 //  https://jsdoc.app/about-getting-started.html#adding-documentation-comments-to-your-code
-const commentRegexp = /^\/\*(?!\*)/u;
-const extraAsteriskCommentRegexp = /^\/\*{3,}/u;
+const commentRegexp = /^\/\*(?!\*)/v;
+const extraAsteriskCommentRegexp = /^\/\*{3,}/v;
 
 export default iterateJsdoc(({
   allComments,

package/src/rules/noBlankBlockDescriptions.js

@@ -1,7 +1,7 @@
 import iterateJsdoc from '../iterateJsdoc.js';
 
-const anyWhitespaceLines = /^\s*$/u;
-const atLeastTwoLinesWhitespace = /^[ \t]*\n[ \t]*\n\s*$/u;
+const anyWhitespaceLines = /^\s*$/v;
+const atLeastTwoLinesWhitespace = /^[ \t]*\n[ \t]*\n\s*$/v;
 
 export default iterateJsdoc(({
   jsdoc,

package/src/rules/noDefaults.js

@@ -14,13 +14,13 @@ export default iterateJsdoc(({
     if (noOptionalParamNames && tag.optional) {
       utils.reportJSDoc(`Optional param names are not permitted on @${tag.tag}.`, tag, () => {
         utils.changeTag(tag, {
-          name: tag.name.replace(/([^=]*)(=.+)?/u, '$1'),
+          name: tag.name.replace(/([^=]*)(=.+)?/v, '$1'),
         });
       });
     } else if (tag.default) {
       utils.reportJSDoc(`Defaults are not permitted on @${tag.tag}.`, tag, () => {
         utils.changeTag(tag, {
-          name: tag.name.replace(/([^=]*)(=.+)?/u, '[$1]'),
+          name: tag.name.replace(/([^=]*)(=.+)?/v, '[$1]'),
         });
       });
     }

package/src/rules/noMultiAsterisks.js

@@ -1,13 +1,13 @@
 import iterateJsdoc from '../iterateJsdoc.js';
 
-const middleAsterisksBlockWS = /^([\t ]|\*(?!\*))+/u;
-const middleAsterisksNoBlockWS = /^\*+/u;
+const middleAsterisksBlockWS = /^([\t ]|\*(?!\*))+/v;
+const middleAsterisksNoBlockWS = /^\*+/v;
 
-const endAsterisksSingleLineBlockWS = /\*((?:\*|(?: |\t))*)\*$/u;
-const endAsterisksMultipleLineBlockWS = /((?:\*|(?: |\t))*)\*$/u;
+const endAsterisksSingleLineBlockWS = /\*((?:\*|(?: |\t))*)\*$/v;
+const endAsterisksMultipleLineBlockWS = /((?:\*|(?: |\t))*)\*$/v;
 
-const endAsterisksSingleLineNoBlockWS = /\*(\**)\*$/u;
-const endAsterisksMultipleLineNoBlockWS = /(\**)\*$/u;
+const endAsterisksSingleLineNoBlockWS = /\*(\**)\*$/v;
+const endAsterisksMultipleLineNoBlockWS = /(\**)\*$/v;
 
 export default iterateJsdoc(({
   context,

package/src/rules/noUndefinedTypes.js

@@ -50,7 +50,7 @@ const typescriptGlobals = [
  * @returns {undefined|string|false}
  */
 const stripPseudoTypes = (str) => {
-  return str && str.replace(/(?:\.|<>|\.<>|\[\])$/u, '');
+  return str && str.replace(/(?:\.|<>|\.<>|\[\])$/v, '');
 };
 
 export default iterateJsdoc(({
@@ -115,7 +115,7 @@ export default iterateJsdoc(({
   const allComments = sourceCode.getAllComments();
   const comments = allComments
     .filter((comment) => {
-      return (/^\*\s/u).test(comment.value);
+      return (/^\*\s/v).test(comment.value);
     })
     .map((commentNode) => {
       return parseComment(commentNode, '');
@@ -123,9 +123,9 @@ export default iterateJsdoc(({
 
   const globals = allComments
     .filter((comment) => {
-      return (/^\s*globals/u).test(comment.value);
+      return (/^\s*globals/v).test(comment.value);
     }).flatMap((commentNode) => {
-      return commentNode.value.replace(/^\s*globals/u, '').trim().split(/,\s*/u);
+      return commentNode.value.replace(/^\s*globals/v, '').trim().split(/,\s*/v);
     }).concat(Object.keys(context.languageOptions.globals ?? []));
 
   const typedefDeclarations = comments

package/src/rules/requireAsteriskPrefix.js

@@ -158,6 +158,7 @@ export default iterateJsdoc(({
         additionalProperties: false,
         properties: {
           tags: {
+            additionalProperties: false,
             properties: {
               always: {
                 items: {

package/src/rules/requireDescriptionCompleteSentence.js

@@ -14,7 +14,7 @@ const otherDescriptiveTags = new Set([
  * @returns {string[]}
  */
 const extractParagraphs = (text) => {
-  return text.split(/(?<![;:])\n\n+/u);
+  return text.split(/(?<![;:])\n\n+/v);
 };
 
 /**
@@ -25,12 +25,12 @@ const extractParagraphs = (text) => {
 const extractSentences = (text, abbreviationsRegex) => {
   const txt = text
     // Remove all {} tags.
-    .replaceAll(/(?<!^)\{[\s\S]*?\}\s*/gu, '')
+    .replaceAll(/(?<!^)\{[\s\S]*?\}\s*/gv, '')
 
     // Remove custom abbreviations
     .replace(abbreviationsRegex, '');
 
-  const sentenceEndGrouping = /([.?!])(?:\s+|$)/ug;
+  const sentenceEndGrouping = /([.?!])(?:\s+|$)/gv;
 
   const puncts = [
     ...txt.matchAll(sentenceEndGrouping),
@@ -39,11 +39,11 @@ const extractSentences = (text, abbreviationsRegex) => {
   });
 
   return txt
-    .split(/[.?!](?:\s+|$)/u)
+    .split(/[.?!](?:\s+|$)/v)
 
     // Re-add the dot.
     .map((sentence, idx) => {
-      return !puncts[idx] && /^\s*$/u.test(sentence) ? sentence : `${sentence}${puncts[idx] || ''}`;
+      return !puncts[idx] && /^\s*$/v.test(sentence) ? sentence : `${sentence}${puncts[idx] || ''}`;
     });
 };
 
@@ -58,11 +58,11 @@ const isNewLinePrecededByAPeriod = (text) => {
   const lines = text.split('\n');
 
   return !lines.some((line) => {
-    if (lastLineEndsSentence === false && /^[A-Z][a-z]/u.test(line)) {
+    if (lastLineEndsSentence === false && /^[A-Z][a-z]/v.test(line)) {
       return true;
     }
 
-    lastLineEndsSentence = /[.:?!|]$/u.test(line);
+    lastLineEndsSentence = /[.:?!\|]$/v.test(line);
 
     return false;
   });
@@ -108,11 +108,11 @@ const validateDescription = (
   description, reportOrig, jsdocNode, abbreviationsRegex,
   sourceCode, tag, newlineBeforeCapsAssumesBadSentenceEnd,
 ) => {
-  if (!description || (/^\n+$/u).test(description)) {
+  if (!description || (/^\n+$/v).test(description)) {
     return false;
   }
 
-  const descriptionNoHeadings = description.replaceAll(/^\s*#[^\n]*(\n|$)/gmu, '');
+  const descriptionNoHeadings = description.replaceAll(/^\s*#[^\n]*(\n|$)/gmv, '');
 
   const paragraphs = extractParagraphs(descriptionNoHeadings).filter(Boolean);
 
@@ -122,28 +122,28 @@ const validateDescription = (
     const fix = /** @type {import('eslint').Rule.ReportFixer} */ (fixer) => {
       let text = sourceCode.getText(jsdocNode);
 
-      if (!/[.:?!]$/u.test(paragraph)) {
+      if (!/[.:?!]$/v.test(paragraph)) {
         const line = paragraph.split('\n').findLast(Boolean);
         text = text.replace(new RegExp(`${escapeStringRegexp(
           /** @type {string} */
           (line),
-        )}$`, 'mu'), `${line}.`);
+        )}$`, 'mv'), `${line}.`);
       }
 
       for (const sentence of sentences.filter((sentence_) => {
-        return !(/^\s*$/u).test(sentence_) && !isCapitalized(sentence_) &&
+        return !(/^\s*$/v).test(sentence_) && !isCapitalized(sentence_) &&
           !isTable(sentence_);
       })) {
         const beginning = sentence.split('\n')[0];
 
         if ('tag' in tag && tag.tag) {
-          const reg = new RegExp(`(@${escapeStringRegexp(tag.tag)}.*)${escapeStringRegexp(beginning)}`, 'u');
+          const reg = new RegExp(`(@${escapeStringRegexp(tag.tag)}.*)${escapeStringRegexp(beginning)}`, 'v');
 
           text = text.replace(reg, (_$0, $1) => {
             return $1 + capitalize(beginning);
           });
         } else {
-          text = text.replace(new RegExp('((?:[.?!]|\\*|\\})\\s*)' + escapeStringRegexp(beginning), 'u'), '$1' + capitalize(beginning));
+          text = text.replace(new RegExp('((?:[.?!]|\\*|\\})\\s*)' + escapeStringRegexp(beginning), 'v'), '$1' + capitalize(beginning));
         }
       }
 
@@ -181,20 +181,20 @@ const validateDescription = (
     };
 
     if (sentences.some((sentence) => {
-      return (/^[.?!]$/u).test(sentence);
+      return (/^[.?!]$/v).test(sentence);
     })) {
       report('Sentences must be more than punctuation.', null, tag);
     }
 
     if (sentences.some((sentence) => {
-      return !(/^\s*$/u).test(sentence) && !isCapitalized(sentence) && !isTable(sentence);
+      return !(/^\s*$/v).test(sentence) && !isCapitalized(sentence) && !isTable(sentence);
     })) {
       report('Sentences should start with an uppercase character.', fix, tag);
     }
 
     const paragraphNoAbbreviations = paragraph.replace(abbreviationsRegex, '');
 
-    if (!/(?:[.?!|]|```)\s*$/u.test(paragraphNoAbbreviations)) {
+    if (!/(?:[.?!\|]|```)\s*$/v.test(paragraphNoAbbreviations)) {
       report('Sentences must end with a period.', fix, tag);
       return true;
     }
@@ -224,8 +224,8 @@ export default iterateJsdoc(({
 
   const abbreviationsRegex = abbreviations.length ?
     new RegExp('\\b' + abbreviations.map((abbreviation) => {
-      return escapeStringRegexp(abbreviation.replaceAll(/\.$/ug, '') + '.');
-    }).join('|') + '(?:$|\\s)', 'gu') :
+      return escapeStringRegexp(abbreviation.replaceAll(/\.$/gv, '') + '.');
+    }).join('|') + '(?:$|\\s)', 'gv') :
     '';
 
   let {
@@ -233,7 +233,7 @@ export default iterateJsdoc(({
   } = utils.getDescription();
 
   const indices = [
-    ...description.matchAll(/```[\s\S]*```/gu),
+    ...description.matchAll(/```[\s\S]*```/gv),
   ].map((match) => {
     const {
       index,
@@ -289,7 +289,7 @@ export default iterateJsdoc(({
   tagsWithNames.some((tag) => {
     const desc = /** @type {string} */ (
       utils.getTagDescription(tag)
-    ).replace(/^- /u, '').trimEnd();
+    ).replace(/^- /v, '').trimEnd();
 
     return validateDescription(desc, report, jsdocNode, abbreviationsRegex, sourceCode, tag, newlineBeforeCapsAssumesBadSentenceEnd);
   });

package/src/rules/requireHyphenBeforeParamDescription.js

@@ -29,7 +29,7 @@ export default iterateJsdoc(({
       return;
     }
 
-    const startsWithHyphen = (/^\s*-/u).test(desc);
+    const startsWithHyphen = (/^\s*-/v).test(desc);
     let lines = 0;
     for (const {
       tokens,
@@ -54,7 +54,7 @@ export default iterateJsdoc(({
             } of jsdocTag.source) {
               if (tokens.description) {
                 tokens.description = tokens.description.replace(
-                  /^(\s*)/u, '$1- ',
+                  /^(\s*)/v, '$1- ',
                 );
                 break;
               }
@@ -74,7 +74,7 @@ export default iterateJsdoc(({
           } of jsdocTag.source) {
             if (tokens.description) {
               tokens.description = tokens.description.replace(
-                /^\s*-\s*/u, '',
+                /^\s*-\s*/v, '',
               );
               break;
             }

package/src/rules/requireJsdoc.js

@@ -444,7 +444,7 @@ export default {
          */
         const underMinLine = (count) => {
           return count !== undefined && count >
-            (sourceCode.getText(node).match(/\n/gu)?.length ?? 0) + 1;
+            (sourceCode.getText(node).match(/\n/gv)?.length ?? 0) + 1;
         };
 
         if (underMinLine(minLineCount)) {

package/src/rules/requireReturnsCheck.js

@@ -81,7 +81,7 @@ export default iterateJsdoc(({
   const type = tag.type.trim();
 
   // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
-  if (/asserts\s/u.test(type)) {
+  if (/asserts\s/v.test(type)) {
     return;
   }
 

package/src/rules/requireTemplate.js

@@ -31,7 +31,7 @@ export default iterateJsdoc(({
       const {
         name,
       } = tag;
-      const names = name.split(/,\s*/u);
+      const names = name.split(/,\s*/v);
       if (names.length > 1) {
         report(`Missing separate @template for ${names[1]}`, null, tag);
       }
@@ -126,7 +126,7 @@ export default iterateJsdoc(({
         type,
         value,
       } = /** @type {import('jsdoc-type-pratt-parser').NameResult} */ (nde);
-      if (type === 'JsdocTypeName' && (/^[A-Z]$/u).test(value)) {
+      if (type === 'JsdocTypeName' && (/^[A-Z]$/v).test(value)) {
         usedNames.add(value);
         if (!usedNameToTag.has(value)) {
           usedNameToTag.set(value, potentialTag);