Use native RegExp Match indices

cucumber-expressions/CHANGELOG.md

@@ -20,6 +20,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Fixed
 
+* Use native RegExp Match indices (currently relying on a polyfill)
+  ([#1652](https://github.com/cucumber/common/pull/1652)
+   [aslakhellesoy])
+
 ## [12.1.1] - 2021-04-06
 
 ### Fixed

cucumber-expressions/javascript/package.json

@@ -34,7 +34,7 @@
     "typescript": "4.3.5"
   },
   "dependencies": {
-    "becke-ch--regex--s0-0-v1--base--pl--lib": "1.4.0"
+    "regexp-match-indices": "1.0.2"
   },
   "directories": {
     "test": "test"

cucumber-expressions/javascript/src/Group.ts

@@ -1,8 +1,8 @@
 export default class Group {
   constructor(
     public readonly value: string | undefined,
-    public readonly start: number,
-    public readonly end: number,
+    public readonly start: number | undefined,
+    public readonly end: number | undefined,
     public readonly children: readonly Group[]
   ) {}
 

cucumber-expressions/javascript/src/GroupBuilder.ts

@@ -1,5 +1,5 @@
 import Group from './Group'
-import RegexExecArray from './RegexExecArray'
+import { RegExpExecArray } from 'regexp-match-indices'
 
 export default class GroupBuilder {
   public source: string
@@ -10,15 +10,14 @@ export default class GroupBuilder {
     this.groupBuilders.push(groupBuilder)
   }
 
-  public build(match: RegexExecArray, nextGroupIndex: () => number): Group {
+  public build(match: RegExpExecArray, nextGroupIndex: () => number): Group {
     const groupIndex = nextGroupIndex()
     const children = this.groupBuilders.map((gb) => gb.build(match, nextGroupIndex))
-    return new Group(
-      match[groupIndex] || undefined,
-      match.index[groupIndex],
-      match.index[groupIndex] + (match[groupIndex] || '').length,
-      children
-    )
+    const value = match[groupIndex] || undefined
+    const index = match.indices[groupIndex]
+    const start = index ? index[0] : undefined
+    const end = index ? index[1] : undefined
+    return new Group(value, start, end, children)
   }
 
   public setNonCapturing() {

cucumber-expressions/javascript/src/TreeRegexp.ts

@@ -1,18 +1,18 @@
 import GroupBuilder from './GroupBuilder'
-// @ts-ignore
-import Regex from 'becke-ch--regex--s0-0-v1--base--pl--lib'
-import RegexExecArray from './RegexExecArray'
 import Group from './Group'
+import execWithIndices from 'regexp-match-indices'
 
 export default class TreeRegexp {
-  public regexp: RegExp
-  private regex: any
-  public groupBuilder: GroupBuilder
+  public readonly regexp: RegExp
+  public readonly groupBuilder: GroupBuilder
 
   constructor(regexp: RegExp | string) {
-    this.regexp = 'string' === typeof regexp ? new RegExp(regexp) : regexp
-    this.regex = new Regex(this.regexp.source, this.regexp.flags)
-    this.groupBuilder = TreeRegexp.createGroupBuilder(this.regex)
+    if (regexp instanceof RegExp) {
+      this.regexp = regexp
+    } else {
+      this.regexp = new RegExp(regexp)
+    }
+    this.groupBuilder = TreeRegexp.createGroupBuilder(this.regexp)
   }
 
   private static createGroupBuilder(regexp: RegExp) {
@@ -53,22 +53,22 @@ export default class TreeRegexp {
 
   private static isNonCapturing(source: string, i: number): boolean {
     // Regex is valid. Bounds check not required.
-    if (source[i + 1] != '?') {
+    if (source[i + 1] !== '?') {
       // (X)
       return false
     }
-    if (source[i + 2] != '<') {
+    if (source[i + 2] !== '<') {
       // (?:X)
       // (?=X)
       // (?!X)
       return true
     }
     // (?<=X) or (?<!X) else (?<name>X)
-    return source[i + 3] == '=' || source[i + 3] == '!'
+    return source[i + 3] === '=' || source[i + 3] === '!'
   }
 
   public match(s: string): Group | null {
-    const match: RegexExecArray = this.regex.exec(s)
+    const match = execWithIndices(this.regexp, s)
     if (!match) {
       return null
     }

cucumber-expressions/javascript/test/TreeRegexpTest.ts

@@ -120,7 +120,7 @@ describe('TreeRegexp', () => {
     assert.strictEqual(group.children.length, 1)
   })
 
-  it('works with flags', () => {
+  it('works with case insensitive flag', () => {
     const tr = new TreeRegexp(/HELLO/i)
     const group = tr.match('hello')
     assert.strictEqual(group.value, 'hello')