re2js 0.3.3 → 0.4.1

package/README.md

@@ -24,11 +24,14 @@ There are certain features of PCRE or Perl regular expressions that cannot be im
 To install RE2JS:
 
 ```bash
+# npm
 npm install re2js
-# or
+# yarn
 yarn add re2js
-# or
+# pnpm
 pnpm add re2js
+# bun
+bun add re2js
 ```
 
 ## Usage
@@ -205,6 +208,7 @@ You can access the named groups in a pattern using the `namedGroups()` function
 import { RE2JS } from 're2js'
 
 RE2JS.compile('(?P<foo>\\d{2})').namedGroups() // { foo: 1 }
+RE2JS.compile('(?<bar>\\d{2})').namedGroups() // { bar: 1 }
 RE2JS.compile('\\d{2}').namedGroups() // {}
 RE2JS.compile('(?P<foo>.*)(?P<bar>.*)').namedGroups() // { foo: 1, bar: 2 }
 ```
@@ -234,6 +238,7 @@ The `group()` method retrieves the content matched by a specific name of capturi
 ```js
 import { RE2JS } from 're2js'
 
+// example with `(?P<name>expr)`
 const p = RE2JS.compile(
   '(?P<baz>f(?P<foo>b*a(?P<another>r+)){0,10})(?P<bag>bag)?(?P<nomatch>zzz)?'
 )
@@ -245,6 +250,16 @@ if (matchString.matches()) {
   matchString.group('bag') // 'bag'
   matchString.group('nomatch') // null
 }
+
+// example with `(?<name>expr)`
+const m = RE2JS.compile(
+  '(?<baz>f(?<foo>b*a))'
+)
+const mString = m.matcher('fbba')
+if (mString.matches()) {
+  mString.group('baz') // 'fbba'
+  mString.group('foo') // 'bba'
+}
 ```
 
 ### Replacing Matches

package/build/index.cjs.cjs

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v0.3.3
+ * @version v0.4.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -419,6 +419,8 @@ class Unicode {
   // equalsIgnoreCase performs case-insensitive equality comparison
   // on the given runes |r1| and |r2|, with special consideration
   // for the likely scenario where both runes are ASCII characters.
+  // If non-ASCII, Unicode case folding will be performed on |r1|
+  // to compare it to |r2|.
   // -1 is interpreted as the end-of-file mark.
   static equalsIgnoreCase(r1, r2) {
     // Runes already match, or one of them is EOF
@@ -677,9 +679,7 @@ class Utils {
 // example
 // Encoding[(Encoding['UTF_16'] = 0)] = 'UTF_16'
 // Encoding[(Encoding['UTF_8'] = 1)] = 'UTF_8'
-const createEnum = function () {
-  let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  let initNum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+const createEnum = (values = [], initNum = 0) => {
   const enumObject = {};
   for (let i = 0; i < values.length; i++) {
     const val = values[i];
@@ -716,8 +716,7 @@ class MatcherInputBase {
   }
 }
 class Utf8MatcherInput extends MatcherInputBase {
-  constructor() {
-    let bytes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  constructor(bytes = null) {
     super();
     this.bytes = bytes;
   }
@@ -749,8 +748,7 @@ class Utf8MatcherInput extends MatcherInputBase {
   }
 }
 class Utf16MatcherInput extends MatcherInputBase {
-  constructor() {
-    let charSequence = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  constructor(charSequence = null) {
     super();
     this.charSequence = charSequence;
   }
@@ -814,8 +812,7 @@ class RE2JSException extends Error {
  * An exception thrown by the parser if the pattern was invalid.
  */
 class RE2JSSyntaxException extends RE2JSException {
-  constructor(error) {
-    let input = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  constructor(error, input = null) {
     let message = `error parsing regexp: ${error}`;
     if (input) {
       message += `: \`${input}\``;
@@ -875,7 +872,6 @@ class RE2JSFlagsException extends RE2JSException {
 /**
  * A stateful iterator that interprets a regex {@code RE2JS} on a specific input.
  *
- * <p>
  * Conceptually, a Matcher consists of four parts:
  * <ol>
  * <li>A compiled regular expression {@code RE2JS}, set at construction and fixed for the lifetime
@@ -988,8 +984,7 @@ class Matcher {
    * @param {string|number} [group=0]
    * @returns {string}
    */
-  start() {
-    let group = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  start(group = 0) {
     if (typeof group === 'string') {
       const groupInt = this.namedGroups[group];
       if (!Number.isFinite(groupInt)) {
@@ -1007,8 +1002,7 @@ class Matcher {
    * @param {string|number} [group=0]
    * @returns {string}
    */
-  end() {
-    let group = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  end(group = 0) {
     if (typeof group === 'string') {
       const groupInt = this.namedGroups[group];
       if (!Number.isFinite(groupInt)) {
@@ -1025,8 +1019,7 @@ class Matcher {
    * @param {string|number} [group=0]
    * @returns {string}
    */
-  group() {
-    let group = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  group(group = 0) {
     if (typeof group === 'string') {
       const groupInt = this.namedGroups[group];
       if (!Number.isFinite(groupInt)) {
@@ -1106,8 +1099,7 @@ class Matcher {
    * @returns {boolean} if it finds a match
    * @throws IndexOutOfBoundsException if start is not a valid input position
    */
-  find() {
-    let start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  find(start = null) {
     if (start !== null) {
       if (start < 0 || start > this.matcherInputLength) {
         throw new RE2JSGroupException(`start index out of bounds: ${start}`);
@@ -1173,12 +1165,10 @@ class Matcher {
    * the form {@code $n}, where {@code n} is the group number in decimal. It advances the append
    * position to where the most recent match ended.
    *
-   * <p>
    * To embed a literal {@code $}, use \$ (actually {@code "\\$"} with string escapes). The escape
    * is only necessary when {@code $} is followed by a digit, but it is always allowed. Only
    * {@code $} and {@code \} need escaping, but any character can be escaped.
    *
-   * <p>
    * The group number {@code n} in {@code $n} is always at least one digit and expands to use more
    * digits as long as the resulting number is a valid group number for this pattern. To cut it off
    * earlier, escape the first digit that should not be used.
@@ -1190,8 +1180,7 @@ class Matcher {
    * @throws IndexOutOfBoundsException if replacement refers to an invalid group
    * @private
    */
-  appendReplacement(replacement) {
-    let perlMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  appendReplacement(replacement, perlMode = false) {
     let res = '';
     const s = this.start();
     const e = this.end();
@@ -1375,8 +1364,7 @@ class Matcher {
    * @returns {string} the input string with the matches replaced
    * @throws IndexOutOfBoundsException if replacement refers to an invalid group and perlMode is false
    */
-  replaceAll(replacement) {
-    let perlMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  replaceAll(replacement, perlMode = false) {
     return this.replace(replacement, true, perlMode);
   }
 
@@ -1389,8 +1377,7 @@ class Matcher {
    * @returns {string} the input string with the first match replaced
    * @throws IndexOutOfBoundsException if replacement refers to an invalid group and perlMode is false
    */
-  replaceFirst(replacement) {
-    let perlMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  replaceFirst(replacement, perlMode = false) {
     return this.replace(replacement, false, perlMode);
   }
 
@@ -1402,9 +1389,7 @@ class Matcher {
    * @returns {string}
    * @private
    */
-  replace(replacement) {
-    let all = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    let perlMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  replace(replacement, all = true, perlMode = false) {
     let res = '';
     this.reset();
     while (this.find()) {
@@ -1441,9 +1426,7 @@ class MachineInputBase {
 // An implementation of MachineInput for UTF-8 byte arrays.
 // |pos| and |width| are byte indices.
 class MachineUTF8Input extends MachineInputBase {
-  constructor(bytes) {
-    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : bytes.length;
+  constructor(bytes, start = 0, end = bytes.length) {
     super();
     this.bytes = bytes;
     this.start = start;
@@ -1526,8 +1509,7 @@ class MachineUTF8Input extends MachineInputBase {
 
   // Returns the index of the first occurrence of array |target| within
   // array |source| after |fromIndex|, or -1 if not found.
-  indexOf(source, target) {
-    let fromIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  indexOf(source, target, fromIndex = 0) {
     let targetLength = target.length;
     if (targetLength === 0) {
       return -1;
@@ -1548,9 +1530,7 @@ class MachineUTF8Input extends MachineInputBase {
 
 // |pos| and |width| are in JS "char" units.
 class MachineUTF16Input extends MachineInputBase {
-  constructor(charSequence) {
-    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : charSequence.length;
+  constructor(charSequence, start = 0, end = charSequence.length) {
     super();
     this.charSequence = charSequence;
     this.start = start;
@@ -1590,14 +1570,10 @@ class MachineUTF16Input extends MachineInputBase {
   }
 }
 class MachineInput {
-  static fromUTF8(bytes) {
-    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : bytes.length;
+  static fromUTF8(bytes, start = 0, end = bytes.length) {
     return new MachineUTF8Input(bytes, start, end);
   }
-  static fromUTF16(charSequence) {
-    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : charSequence.length;
+  static fromUTF16(charSequence, start = 0, end = charSequence.length) {
     return new MachineUTF16Input(charSequence, start, end);
   }
 }
@@ -1685,7 +1661,6 @@ class Regexp {
     this.name = null; // capturing name, for CAPTURE
     this.namedGroups = {}; // map of group name -> capturing index
   }
-
   reinit() {
     this.flags = 0;
     this.subs = Regexp.emptySubs();
@@ -2000,6 +1975,10 @@ class Inst {
     // class.
     if (this.runes.length === 1) {
       const r0 = this.runes[0];
+      // If this pattern is case-insensitive, apply Unicode case folding to compare the two runes.
+      // Note that this may result in a case-folding loop when executed,
+      // so attempt to reduce the chance of that occurring
+      // by performing case folding on |r0| from the pattern rather than |r| from the input.
       if ((this.arg & RE2Flags.FOLD_CASE) !== 0) {
         return Unicode.equalsIgnoreCase(r0, r);
       }
@@ -2231,10 +2210,7 @@ class Prog {
  * @class
  */
 class Frag {
-  constructor() {
-    let i = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let out = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let nullable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  constructor(i = 0, out = 0, nullable = false) {
     this.i = i; // an instruction address (pc).
     this.out = out; // a patch list; see explanation in Prog.js
     this.nullable = nullable; // whether the fragment can match the empty string
@@ -2727,8 +2703,7 @@ class CharClass {
       CharClass.qsortIntPair(array, i, right);
     }
   }
-  constructor() {
-    let r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Utils.emptyInts();
+  constructor(r = Utils.emptyInts()) {
     this.r = r; // inclusive ranges, pairs of [lo,hi].  r.length is even.
     this.len = r.length; // prefix of |r| that is defined.  Even.
   }
@@ -3402,8 +3377,7 @@ class Parser {
   static concatRunes(x, y) {
     return [...x, ...y];
   }
-  constructor(wholeRegexp) {
-    let flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  constructor(wholeRegexp, flags = 0) {
     this.wholeRegexp = wholeRegexp;
     // Flags control the behavior of the parser and record information about
     // regexp context.
@@ -4116,7 +4090,6 @@ class Parser {
     if (this.swapVerticalBar()) {
       this.pop(); // pop vertical bar
     }
-
     this.alternate();
     const n = this.stack.length;
     if (n !== 1) {
@@ -4145,21 +4118,22 @@ class Parser {
     // support all three as well.  EcmaScript 4 uses only the Python form.
     //
     // In both the open source world (via Code Search) and the
-    // Google source tree, (?P<expr>name) is the dominant form,
-    // so that's the one we implement.  One is enough.
+    // Google source tree, (?P<name>expr) and (?<name>expr) are the
+    // dominant forms of named captures and both are supported.
     const s = t.rest();
-    if (s.startsWith('(?P<')) {
+    if (s.startsWith('(?P<') || s.startsWith('(?<')) {
       // Pull out name.
+      const begin = s.charAt(2) === 'P' ? 4 : 3;
       const end = s.indexOf('>');
       if (end < 0) {
         throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s);
       }
-      const name = s.substring(4, end); // "name"
+      const name = s.substring(begin, end); // "name"
       t.skipString(name);
-      t.skip(5); // "(?P<>"
+      t.skip(begin + 1); // "(?P<>" or "(?<>"
       if (!Parser.isValidCaptureName(name)) {
         // "(?P<name>"
-        throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s.substring(0, end));
+        throw new RE2JSSyntaxException(Parser.ERR_INVALID_NAMED_CAPTURE, s.substring(0, end + 1)); // "(?P<name>" or "(?<name>"
       }
       // Like ordinary capture, but named.
       const re = this.op(Regexp.Op.LEFT_PAREN);
@@ -4289,7 +4263,6 @@ class Parser {
     if (this.swapVerticalBar()) {
       this.pop(); // pop vertical bar
     }
-
     this.alternate();
     const n = this.stack.length;
     if (n < 2) {
@@ -4631,8 +4604,7 @@ class Machine {
   }
 
   // Frees all threads on the thread queue, returning them to the free pool.
-  freeQueue(queue) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  freeQueue(queue, from = 0) {
     const numberOfThread = queue.size - from;
     const requiredPoolLength = this.poolSize + numberOfThread;
     if (this.pool.length < requiredPoolLength) {
@@ -4876,10 +4848,8 @@ class AtomicReference {
  * An RE2 class instance is a compiled representation of an RE2 regular expression, independent of
  * the public Java-like Pattern/Matcher API.
  *
- * <p>
  * This class also contains various implementation helpers for RE2 regular expressions.
  *
- * <p>
  * Use the {@link #quoteMeta(String)} utility function to quote all regular expression
  * metacharacters in an arbitrary string.
  *
@@ -4901,7 +4871,6 @@ class RE2 {
    * Parses a regular expression and returns, if successful, an {@code RE2} instance that can be
    * used to match against text.
    *
-   * <p>
    * When matching against text, the regexp returns a match that begins as early as possible in the
    * input (leftmost), and among those it chooses the one that a backtracking search would have
    * found first. This so-called leftmost-first matching is the same semantics that Perl, Python,
@@ -4916,13 +4885,11 @@ class RE2 {
    * {@code compilePOSIX} is like {@link #compile} but restricts the regular expression to POSIX ERE
    * (egrep) syntax and changes the match semantics to leftmost-longest.
    *
-   * <p>
    * That is, when matching against text, the regexp returns a match that begins as early as
    * possible in the input (leftmost), and among those it chooses a match that is as long as
    * possible. This so-called leftmost-longest matching is the same semantics that early regular
    * expression implementations used and that POSIX specifies.
    *
-   * <p>
    * However, there can be multiple leftmost-longest matches, with different submatch choices, and
    * here this package diverges from POSIX. Among the possible leftmost-longest matches, this
    * package chooses the one that a backtracking search would have found first, while POSIX
@@ -4955,16 +4922,13 @@ class RE2 {
   /**
    * Returns true iff textual regular expression {@code pattern} matches string {@code s}.
    *
-   * <p>
    * More complicated queries need to use {@link #compile} and the full {@code RE2} interface.
    */
   // This is visible for testing.
   static match(pattern, s) {
     return RE2.compile(pattern).match(s);
   }
-  constructor(expr, prog) {
-    let numSubexp = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let longest = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  constructor(expr, prog, numSubexp = 0, longest = 0) {
     this.expr = expr; // as passed to Compile
     this.prog = prog; // compiled program
     this.numSubexp = numSubexp;
@@ -5198,8 +5162,7 @@ class RE2 {
   }
 
   // Find matches in input.
-  allMatches(input, n) {
-    let deliverFun = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : v => v;
+  allMatches(input, n, deliverFun = v => v) {
     let result = [];
     const end = input.endPos();
     if (n < 0) {
@@ -5276,7 +5239,6 @@ class RE2 {
    * Returns an array holding the text of the leftmost match in {@code b} of this regular
    * expression.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5292,7 +5254,6 @@ class RE2 {
    * Returns a two-element array of integers defining the location of the leftmost match in
    * {@code b} of this regular expression. The match itself is at {@code b[loc[0]...loc[1]]}.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5308,7 +5269,6 @@ class RE2 {
    * Returns a string holding the text of the leftmost match in {@code s} of this regular
    * expression.
    *
-   * <p>
    * If there is no match, the return value is an empty string, but it will also be empty if the
    * regular expression successfully matches an empty string. Use {@link #findIndex} or
    * {@link #findSubmatch} if it is necessary to distinguish these cases.
@@ -5327,7 +5287,6 @@ class RE2 {
    * {@code s} of this regular expression. The match itself is at
    * {@code s.substring(loc[0], loc[1])}.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5340,7 +5299,6 @@ class RE2 {
    * {@code b} and the matches, if any, of its subexpressions, as defined by the <a
    * href='#submatch'>Submatch</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5363,7 +5321,6 @@ class RE2 {
    * expression in {@code b} and the matches, if any, of its subexpressions, as defined by the the
    * <a href='#submatch'>Submatch</a> and <a href='#index'>Index</a> descriptions above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5376,7 +5333,6 @@ class RE2 {
    * {@code s} and the matches, if any, of its subexpressions, as defined by the <a
    * href='#submatch'>Submatch</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5399,7 +5355,6 @@ class RE2 {
    * expression in {@code s} and the matches, if any, of its subexpressions, as defined by the <a
    * href='#submatch'>Submatch</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5412,7 +5367,6 @@ class RE2 {
    * list of up to {@code n} successive matches of the expression, as defined by the <a
    * href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    *
    * TODO(adonovan): think about defining a byte slice view class, like a read-only Go slice backed
@@ -5432,7 +5386,6 @@ class RE2 {
    * returns a list of up to {@code n} successive matches of the expression, as defined by the <a
    * href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5449,7 +5402,6 @@ class RE2 {
    * to {@code n} successive matches of the expression, as defined by the <a href='#all'>All</a>
    * description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5466,7 +5418,6 @@ class RE2 {
    * list of up to {@code n} successive matches of the expression, as defined by the <a
    * href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5483,7 +5434,6 @@ class RE2 {
    * it returns a list of up to {@code n} successive matches of the expression, as defined by the <a
    * href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5508,7 +5458,6 @@ class RE2 {
    * {@link #findUTF8SubmatchIndex}; it returns a list of up to {@code n} successive matches of the
    * expression, as defined by the <a href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5525,7 +5474,6 @@ class RE2 {
    * returns a list of up to {@code n} successive matches of the expression, as defined by the <a
    * href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5550,7 +5498,6 @@ class RE2 {
    * {@link #findSubmatchIndex}; it returns a list of up to {@code n} successive matches of the
    * expression, as defined by the <a href='#all'>All</a> description above.
    *
-   * <p>
    * A return value of null indicates no match.
    */
   // This is visible for testing.
@@ -5566,7 +5513,6 @@ class RE2 {
 /**
  * A compiled representation of an RE2 regular expression
  *
- * <p>
  * The matching functions take {@code String} arguments instead of the more general Java
  * {@code CharSequence} since the latter doesn't provide UTF-16 decoding.
  *
@@ -5600,10 +5546,9 @@ class RE2JS {
   /**
    * Returns a literal pattern string for the specified string.
    *
-   * <p>
    * This method produces a string that can be used to create a <code>RE2JS</code> that would
    * match the string <code>s</code> as if it were a literal pattern.
-   * </p>
+   *
    * Metacharacters or escape sequences in the input sequence will be given no special meaning.
    *
    * @param {string} str The string to be literalized
@@ -5619,8 +5564,7 @@ class RE2JS {
    * @param {number} [flags=0]
    * @returns {RE2JS}
    */
-  static compile(regex) {
-    let flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  static compile(regex, flags = 0) {
     let fregex = regex;
     if ((flags & RE2JS.CASE_INSENSITIVE) !== 0) {
       fregex = `(?i)${fregex}`;
@@ -5739,7 +5683,6 @@ class RE2JS {
    * Splits input around instances of the regular expression. It returns an array giving the strings
    * that occur before, between, and after instances of the regular expression.
    *
-   * <p>
    * If {@code limit <= 0}, there is no limit on the size of the returned array. If
    * {@code limit == 0}, empty strings that would occur at the end of the array are omitted. If
    * {@code limit > 0}, at most limit strings are returned. The final string contains the remainder
@@ -5749,8 +5692,7 @@ class RE2JS {
    * @param {number} [limit=0] the limit
    * @returns {string[]} the split strings
    */
-  split(input) {
-    let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  split(input, limit = 0) {
     const m = this.matcher(input);
     const result = [];
     let emptiesSkipped = 0;