feat(parser): allow start/end anchor everywhere

Also expose `UnsupportedSyntaxError`.

Author: gruhn

.github/workflows/deploy-docs.yml

@@ -35,10 +35,8 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: "lts/*"
-      - name: Install dependencies
-        run: npm clean-install
-      - name: Generate Docs
-        run: make docs
+      - name: Install & Build
+        run: make
       - name: Setup Pages
         uses: actions/configure-pages@v5
       - name: Upload artifact

.github/workflows/release.yml

@@ -25,12 +25,10 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: "lts/*"
-      - name: Install dependencies
-        run: npm clean-install
+      - name: Install & Build
+        run: make
       - name: Test
         run: npm test
-      - name: Build
-        run: make dist
       - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
         run: npm audit signatures
       - name: Release

benchmark/parser-bench.ts

@@ -1,6 +1,5 @@
 import fs from 'fs'
-import { parseRegexString } from '../dist/regex-parser.js'
-import { RB } from '../dist/index.js'
+import { parseRegExp } from '../dist/regex-parser.js'
 
 export function* readDataset() {
   const jsonStr = fs.readFileSync('./benchmark/regex-dataset.json', 'utf-8')
@@ -17,29 +16,37 @@ export function* readDataset() {
   }
 }
 
-let hasError = 0
-let noError = 0
-let totalParseTime = 0
+const dataset = [...readDataset()]
 
-for (const { regex, flags } of readDataset()) {
+let parseErrorCount = 0
+
+for (const { regex, flags } of dataset) {
   try {
     // parseRegexString(regex)
     const regexp = new RegExp(regex, flags)
     console.log('====', regexp, '====')
 
-    const timeStart = performance.now()
-    const parsed = RB(regexp)
-    const timeEnd = performance.now()
+    performance.mark('parse-start')
+    const parsed = parseRegExp(regexp)
+    performance.mark('parse-end')
+    performance.measure('parse-duration', 'parse-start', 'parse-end')
 
-    console.log(`time: ${Math.round(timeEnd - timeStart)}ms`)
-    totalParseTime += timeEnd - timeStart
-    noError++
   } catch (e) {
-    // console.error(new RegExp(regex, flags))
-    hasError++
+    console.error(new RegExp(regex, flags))
+    parseErrorCount++
   }
 }
 
-console.log('error ratio:', hasError, '/', hasError + noError)
+const totalParseTime = performance.getEntriesByName('parse-duration')
+  .map(entry => entry.duration)
+  .reduce((acc,d) => acc + d, 0)
+
+const maxParseTime = performance.getEntriesByName('parse-duration')
+  .map(entry => entry.duration)
+  .reduce((acc,d) => Math.max(acc, d), -Infinity)
+
+console.log('error ratio:', parseErrorCount, '/', dataset.length)
 console.log('total parse time:', Math.round(totalParseTime), 'ms')
+console.log('avg parse time:', Math.round(totalParseTime / (dataset.length - parseErrorCount)), 'ms')
+console.log('max parse time:', Math.round(maxParseTime), 'ms')
 

benchmark/toStdRegex_output_length.ts

@@ -1,23 +1,23 @@
 import fc from 'fast-check'
-import * as RE from '../dist/regex.js'
-import { ParseError } from '../dist/parser.js'
-import { UnsupportedSyntaxError, parseRegExp } from '../dist/regex-parser.js'
-import { toStdRegex } from '../dist/dfa.js'
-import randomRegexDataset from './regex_random_unique_no-nested-star_1000.js'
-import handwrittenRegexDataset from './regex_handwritten.js'
+import * as RE from '../src/regex'
+import { UnsupportedSyntaxError, ParseError } from '../src/index'
+import { parseRegExp } from '../src/regex-parser'
+import { toStdRegex } from '../src/dfa.js'
+import randomRegexDataset from './regex_random_unique_no-nested-star_1000'
+import handwrittenRegexDataset from './regex_handwritten'
 
 const fullRegexDataset = [
   ...randomRegexDataset,
   ...handwrittenRegexDataset,
 ]
 
-const mults = []
+const mults: number[] = []
 
-function run(inputRegExp, index) {
+function run(inputRegExp: RegExp, index: number) {
   console.log('#' + index, inputRegExp)
   const startTime = performance.now()
 
-  const inputRegex = parseRegExp(inputRegExp)
+  const inputRegex = RE.fromRegExpAST(parseRegExp(inputRegExp))
   const outputRegex = toStdRegex(inputRegex)
   const outputRegExp = RE.toRegExp(outputRegex)
 
@@ -28,7 +28,7 @@ function run(inputRegExp, index) {
 
   console.log(`
     regex input length  : ${inp}
-    regex ouptut length : ${out}
+    regex output length : ${out}
     multiplier          : ${mult}
   `) 
 }

equiv-checker.html

@@ -295,13 +295,14 @@ <h1>RegExp Equivalence Checker</h1>
     <div class="info">
       <h4>How to use:</h4>
       Enter two JavaScript regular expressions (without the surrounding slashes) and click "Check Equivalence".
-      The tool will determine the relationship between the two expressions: equivalent, subset, superset, or neither.
+      The tool determines whether the two expression match exactly the same strings.
+      Otherwise, example strings are shown that match either expression but not both.
 
       <h4>Examples:</h4>
       <ul>
-        <li><code>a*</code> and <code>a+</code> are not equivalent</li>
-        <li><code>a|b</code> and <code>b|a</code> are equivalent</li>
-        <li><code>(ab)+</code> and <code>ab(ab)*</code> are equivalent</li>
+        <li><code>a|aa</code> and <code>a{1,2}</code> are equivalent</li>
+        <li><code>a+</code> matches a subset of <code>a*</code></li>
+        <li><code>^a{0,4}$</code> and <code>^a{2,6}$</code> match some common strings</li>
       </ul>
 
       <h4>Supported syntax:</h4>

flake.nix

@@ -16,6 +16,7 @@
           buildInputs = with pkgs; [
             nodejs_23
             nodePackages.typescript-language-server
+            ripgrep
           ];
         };
       }

package.json

@@ -7,7 +7,7 @@
   "version": "0.0.0-development",
   "type": "module",
   "scripts": {
-    "test": "node --test --import=tsx test/*.spec.ts",
+    "test": "node --test --import=tsx",
     "build": "make",
     "serve": "http-server -p 8080",
     "bench": "0x --output-dir prof"