re2js 0.3.3 → 0.4.0

package/build/index.esm.d.ts

@@ -165,7 +165,7 @@ export class RE2JSGroupException extends RE2JSException {
  * An exception thrown by the parser if the pattern was invalid.
  */
 export class RE2JSSyntaxException extends RE2JSException {
-    constructor(error: any, ...args: any[]);
+    constructor(error: any, input?: any);
     error: any;
     input: any;
     /**
@@ -247,20 +247,20 @@ declare class Matcher {
      * @param {string|number} [group=0]
      * @returns {string}
      */
-    start(...args: any[]): string;
+    start(group?: string | number): string;
     /**
      * Returns the end of the named group of the most recent match, or -1 if the group was not
      * matched.
      * @param {string|number} [group=0]
      * @returns {string}
      */
-    end(...args: any[]): string;
+    end(group?: string | number): string;
     /**
      * Returns the named group of the most recent match, or {@code null} if the group was not matched.
      * @param {string|number} [group=0]
      * @returns {string}
      */
-    group(...args: any[]): string;
+    group(group?: string | number): string;
     /**
      * Returns the number of subgroups in this pattern.
      *
@@ -295,7 +295,7 @@ declare class Matcher {
      * @returns {boolean} if it finds a match
      * @throws IndexOutOfBoundsException if start is not a valid input position
      */
-    find(...args: any[]): boolean;
+    find(start?: string | number): boolean;
     /**
      * Helper: does match starting at start, with RE2 anchor flag.
      * @param {number} startByte
@@ -367,7 +367,7 @@ declare 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: string, ...args: any[]): string;
+    replaceAll(replacement: string, perlMode?: boolean): string;
     /**
      * Returns the input with the first match replaced by {@code replacement}, interpreted as for
      * {@code appendReplacement}.
@@ -377,7 +377,7 @@ declare 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: string, ...args: any[]): string;
+    replaceFirst(replacement: string, perlMode?: boolean): string;
     /**
      * Helper: replaceAll/replaceFirst hybrid.
      * @param {string} replacement - the replacement string

package/build/index.esm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"AA27KA;;;;;;;;;;GAUG;AACH;IACE;;OAEG;IACH,gCAA4B;IAC5B;;OAEG;IACH,sBAAkB;IAClB;;;OAGG;IACH,yBAAqB;IACrB;;OAEG;IACH,sCAAkC;IAClC;;OAEG;IACH,6BAA0B;IAE1B;;;;;;;;;;;OAWG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,mBAEJ,KAAK,CAyBjB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,SACN,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,CAKnB;IAED;;;OAGG;IACH,wBAWC;IAED;;;;OAIG;IACH,qBAHW,MAAM,SACN,MAAM,EAOhB;IAHC,qBAA2B;IAE3B,mBAAuB;IAGzB;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;IACD,WAEC;IAED;;;;;OAKG;IACH,eAHW,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,CAOnB;IAED;;;;;;;;;;;;;OAaG;IACH,aAJW,MAAM,mBAEJ,MAAM,EAAE,CAiDpB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,oBAFa,OAAO,CAUnB;CACF;AAr4JD;;GAEG;AACH;CAKC;AA/CD;IACE,0BAGC;CACF;AAsDD;;GAEG;AACH;CAKC;AAlBD;;GAEG;AACH;CAKC;AAlDD;;GAEG;AACH;IACE,wCAWC;IAFC,WAAkB;IAClB,WAAkB;IAGpB;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;CACF;AAgCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACE;;;;;;OAMG;IACH,6BAHW,MAAM,GACJ,MAAM,CAalB;IACD;;;;OAIG;IACH,qBAHW,KAAK,SACL,gBAAgB,GAAC,iBAAiB,GAAC,MAAM,EAAE,GAAC,MAAM,EAqB5D;IAdC,oBAA2B;IAG3B,uBAAsD;IAEtD,cAAgB;IAChB,iBAAkC;IAUpC;;;OAGG;IACH,WAFa,KAAK,CAIjB;IAED;;;;OAIG;IACH,SAFa,OAAO,CAenB;IAXC,wBAAoD;IAEpD,2BAAkB;IAElB,kBAAqB;IAGrB,mBAAsB;IAEtB,mBAAmB;IAIrB;;;OAGG;IACH,+BAFa,OAAO,CASnB;IAHC,kBAAyB;IAK3B;;;;;OAKG;IACH,uBAFa,MAAM,CAalB;IAED;;;;;OAKG;IACH,qBAFa,MAAM,CAalB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAiBlB;IACD;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAqBC;IAED;;;;;OAKG;IACH,WAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,aAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,sBAHa,OAAO,CAqBnB;IAED;;;;;;OAMG;IACH,iBAWC;IAED;;;;;OAKG;IACH,iBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAWC;IAED;;;;OAIG;IACH,kCA2DC;IAED;;;;OAIG;IACH,sCAiFC;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,wBALW,MAAM,mBAEJ,MAAM,CAMlB;IAED;;;;;;;;OAQG;IACH,0BALW,MAAM,mBAEJ,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,gBAaC;CACF;AA7rBD;IACE,4BAIC;IADC,WAAkB;IAEpB,mBAEC;IACD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,MAAM,EAAE,CAIpB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;CACF;AACD;IACE,4BAIC;IADC,kBAAgC;IAElC,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,MAAM,EAAE,CAIpB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;CACF;AA3FD;;GAEG;AACH;IACE,8BAAkD;IAClD,oBAEC;IAED;;;OAGG;IACH,kBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,mBAFa,OAAO,CAInB;CACF"}
+{"version":3,"file":"index.esm.d.ts","sourceRoot":"","sources":["index.esm.js"],"names":[],"mappings":"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"}

package/build/index.esm.js

@@ -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.0
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -417,6 +417,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
@@ -675,9 +677,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];
@@ -812,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}\``;
@@ -986,8 +985,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)) {
@@ -1005,8 +1003,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)) {
@@ -1023,8 +1020,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)) {
@@ -1104,8 +1100,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}`);
@@ -1188,8 +1183,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();
@@ -1373,8 +1367,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);
   }
 
@@ -1387,8 +1380,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);
   }
 
@@ -1400,9 +1392,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()) {
@@ -1998,6 +1988,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);
       }
@@ -2229,10 +2223,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
@@ -2725,8 +2716,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.
   }
@@ -3400,8 +3390,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.
@@ -4143,21 +4132,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);
@@ -4629,8 +4619,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) {
@@ -4960,9 +4949,7 @@ class RE2 {
   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;
@@ -5196,8 +5183,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) {