refactor: replace startsWith with strict equality

eslint.config.mjs

@@ -4,6 +4,7 @@ import { fixupConfigRules } from "@eslint/compat"
 import { FlatCompat } from "@eslint/eslintrc"
 import js from "@eslint/js"
 import myPlugin from "@ota-meshi/eslint-plugin"
+import pere from "eslint-plugin-pere"
 import regexp from "eslint-plugin-regexp"
 import unicorn from "eslint-plugin-unicorn"
 import tseslint from "typescript-eslint"
@@ -169,6 +170,12 @@ export default [
             "no-implicit-globals": "off",
             "@typescript-eslint/naming-convention": "off",
             "@typescript-eslint/no-shadow": "error",
+            "@typescript-eslint/prefer-string-starts-ends-with": [
+                "error",
+                {
+                    allowSingleElementEquality: "always",
+                },
+            ],
         },
     },
     {
@@ -253,4 +260,11 @@ export default [
             "unicorn/prefer-string-raw": "error",
         },
     },
+    {
+        files: ["**/*.{ts,mts}"],
+        plugins: { pere },
+        rules: {
+            "pere/no-startswith-one-char": "error",
+        },
+    },
 ]

lib/rules/match-any.ts

@@ -112,7 +112,7 @@ export default createRule("match-any", {
 
             if (
                 regexpNode.type === "CharacterClass" &&
-                preference.startsWith("[") &&
+                preference[0] === "[" &&
                 preference.endsWith("]")
             ) {
                 // We know that the first and last character are the same,

lib/rules/no-control-character.ts

@@ -53,7 +53,7 @@ export default createRule("no-control-character", {
             function isAllowedEscapeRaw(raw: string): boolean {
                 return (
                     ALLOWED_CONTROL_CHARS.test(raw) ||
-                    (raw.startsWith("\\") &&
+                    (raw[0] === "\\" &&
                         ALLOWED_CONTROL_CHARS.test(raw.slice(1)))
                 )
             }
@@ -78,7 +78,7 @@ export default createRule("no-control-character", {
 
                 return (
                     isBadEscapeRaw(char.raw, char.value) ||
-                    (char.raw.startsWith("\\") &&
+                    (char.raw[0] === "\\" &&
                         isBadEscapeRaw(char.raw.slice(1), char.value))
                 )
             }

lib/rules/no-useless-escape.ts

@@ -121,7 +121,7 @@ export default createRule("no-useless-escape", {
                 onExpressionCharacterClassLeave: () =>
                     characterClassStack.shift(),
                 onCharacterEnter(cNode) {
-                    if (cNode.raw.startsWith("\\")) {
+                    if (cNode.raw[0] === "\\") {
                         // escapes
                         const char = cNode.raw.slice(1)
                         const escapedChar = String.fromCodePoint(cNode.value)

lib/rules/no-useless-range.ts

@@ -67,7 +67,7 @@ export default createRule("no-useless-range", {
                                 }
                             }
 
-                            if (rawAfter.startsWith("-")) {
+                            if (rawAfter[0] === "-") {
                                 // the next "-" might be interpreted as a range
                                 // operator now, so we have to escape it
                                 // e.g. /[a-a-z]/ -> /[a\-z]/

lib/rules/prefer-character-class.ts

@@ -122,7 +122,7 @@ function elementsToCharacterClass(elements: CharElementArray): string {
         }
     })
 
-    if (parts.length > 0 && parts[0].startsWith("^")) {
+    if (parts.length > 0 && parts[0][0] === "^") {
         parts[0] = `\\${parts[0]}`
     }
 

lib/rules/sort-character-class-elements.ts

@@ -283,7 +283,7 @@ export default createRule("sort-character-class-elements", {
  */
 function escapeRaw(node: CharacterClassElement, target: CharacterClassElement) {
     let raw = node.raw
-    if (raw.startsWith("-")) {
+    if (raw[0] === "-") {
         const parent = target.parent as CharacterClass
         const elements: (
             | UnicodeSetsCharacterClassElement
@@ -296,7 +296,7 @@ function escapeRaw(node: CharacterClassElement, target: CharacterClassElement) {
         ) {
             raw = `\\${raw}`
         }
-    } else if (raw.startsWith("^")) {
+    } else if (raw[0] === "^") {
         const parent = target.parent as CharacterClass
         const elements: (
             | UnicodeSetsCharacterClassElement
@@ -306,7 +306,7 @@ function escapeRaw(node: CharacterClassElement, target: CharacterClassElement) {
             raw = `\\${raw}`
         }
     }
-    if (target.raw.startsWith("-")) {
+    if (target.raw[0] === "-") {
         if (node.type === "Character" || node.type === "CharacterSet") {
             raw = `${raw}\\`
         }

lib/rules/strict.ts

@@ -185,7 +185,7 @@
                         return
                     }
 
-                    if (cNode.raw.startsWith("\\")) {
+                    if (cNode.raw[0] === "\\") {
                         const identity = cNode.raw.slice(1)
                         const syntaxChars = insideCharClass
                             ? CHARACTER_CLASS_SYNTAX_CHARACTERS
@@ -256,7 +256,7 @@
                         // There is a bug in regexpp that causes it throw a
                         // syntax error for all non-Unicode regexes with named
                         // backreferences.
                         // TODO: Remove this workaround when the bug is fixed.
                         return
                     }
 

lib/utils/index.ts

@@ -935,7 +935,7 @@ export function mightCreateNewElement(before: string, after: string): boolean {
     if (
         (/(?:^|[^\\])(?:\\{2})*\\[1-9]\d*$/u.test(before) &&
             /^\d/u.test(after)) ||
-        (/(?:^|[^\\])(?:\\{2})*\\k$/u.test(before) && after.startsWith("<")) ||
+        (/(?:^|[^\\])(?:\\{2})*\\k$/u.test(before) && after[0] === "<") ||
         /(?:^|[^\\])(?:\\{2})*\\k<[^<>]*$/u.test(before)
     ) {
         return true
@@ -959,8 +959,7 @@ export function mightCreateNewElement(before: string, after: string): boolean {
             /^[\d,}]/u.test(after)) ||
         (/(?:^|[^\\])(?:\\{2})*\{\d+,$/u.test(before) &&
             /^(?:\d+(?:\}|$)|\})/u.test(after)) ||
-        (/(?:^|[^\\])(?:\\{2})*\{\d+,\d*$/u.test(before) &&
-            after.startsWith("}"))
+        (/(?:^|[^\\])(?:\\{2})*\{\d+,\d*$/u.test(before) && after[0] === "}")
     ) {
         return true
     }
@@ -1014,13 +1013,13 @@ export function fixRemoveCharacterClassElement(
         if (
             // ... the text character is a dash
             // e.g. [a\w-b] -> [a\-b], [\w-b] -> [-b], [\s\w-b] -> [\s-b]
-            (textAfter.startsWith("-") &&
+            (textAfter[0] === "-" &&
                 elementBefore &&
                 elementBefore.type === "Character") ||
             // ... the next character is a caret and the caret will then be the
             // first character in the character class
             // e.g. [a^b] -> [\^b], [ba^] -> [b^]
-            (textAfter.startsWith("^") && !cc.negate && !elementBefore)
+            (textAfter[0] === "^" && !cc.negate && !elementBefore)
         ) {
             return "\\"
         }

lib/utils/regex-syntax.ts

@@ -68,7 +68,7 @@ export enum EscapeSequenceKind {
  * Returns which escape sequence kind was used for the given raw of a character literal.
  */
 export function getEscapeSequenceKind(raw: string): EscapeSequenceKind | null {
-    if (!raw.startsWith("\\")) {
+    if (raw[0] !== "\\") {
         return null
     }
     if (isOctalEscape(raw)) {

lib/utils/type-tracker/jsdoc.ts

@@ -174,7 +174,7 @@ function findJSDocComment(node: ES.Node, sourceCode: SourceCode) {
     if (
         tokenBefore &&
         tokenBefore.type === "Block" &&
-        tokenBefore.value.startsWith("*")
+        tokenBefore.value[0] === "*"
     ) {
         return tokenBefore
     }

package.json

@@ -95,6 +95,7 @@
         "eslint-plugin-jsonc": "^2.16.0",
         "eslint-plugin-markdown": "^5.0.0",
         "eslint-plugin-n": "^17.9.0",
+        "eslint-plugin-pere": "^0.0.1",
         "eslint-plugin-prettier": "^5.1.3",
         "eslint-plugin-regexp": "~2.10.0",
         "eslint-plugin-unicorn": "^61.0.0",

tools/update-unicode-alias.ts

@@ -108,7 +108,7 @@ async function* getUnicodePropertyAliases(): AsyncIterable<UnicodePropertyAlias>
         if (!line) {
             continue
         }
-        if (line.startsWith("#")) {
+        if (line[0] === "#") {
             if (
                 /^#\s*=+$/u.test(dbLines[index - 1]) &&
                 /^#\s*=+$/u.test(dbLines[index + 1])
@@ -137,7 +137,7 @@ async function* getUnicodePropertyValueAliases(): AsyncIterable<UnicodePropertyV
     logger.log("Fetching data... (%s)", DB_URL)
     const dbContent = await fetch(DB_URL).then((res) => res.text())
     for (const line of dbContent.split("\n")) {
-        if (!line || line.startsWith("#")) {
+        if (!line || line[0] === "#") {
             continue
         }
         const [propertyAlias, short, long, ...other] = line