re2js 2.2.2 → 2.2.3

package/build/index.umd.js

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v2.2.2
+ * @version v2.2.3
  * @author Oleksii Vasyliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -100,7 +100,7 @@
   }
   class Codepoint {
     // codePointAt(0)
-    static CODES = new Map([['\x07', 7], ['\b', 8], ['\t', 9], ['\n', 10], ['\v', 11], ['\f', 12], ['\r', 13], [' ', 32], ['"', 34], ['$', 36], ['&', 38], ['(', 40], [')', 41], ['*', 42], ['+', 43], ['-', 45], ['.', 46], ['0', 48], ['1', 49], ['2', 50], ['3', 51], ['4', 52], ['5', 53], ['6', 54], ['7', 55], ['8', 56], ['9', 57], [':', 58], ['<', 60], ['>', 62], ['?', 63], ['A', 65], ['B', 66], ['C', 67], ['F', 70], ['P', 80], ['Q', 81], ['U', 85], ['Z', 90], ['[', 91], ['\\', 92], [']', 93], ['^', 94], ['_', 95], ['a', 97], ['b', 98], ['f', 102], ['i', 105], ['m', 109], ['n', 110], ['r', 114], ['s', 115], ['t', 116], ['v', 118], ['x', 120], ['z', 122], ['{', 123], ['|', 124], ['}', 125]]);
+    static CODES = new Map([['\x07', 7], ['\b', 8], ['\t', 9], ['\n', 10], ['\v', 11], ['\f', 12], ['\r', 13], [' ', 32], ['"', 34], ['$', 36], ['&', 38], ["'", 39], ['(', 40], [')', 41], ['*', 42], ['+', 43], ['-', 45], ['.', 46], ['0', 48], ['1', 49], ['2', 50], ['3', 51], ['4', 52], ['5', 53], ['6', 54], ['7', 55], ['8', 56], ['9', 57], [':', 58], ['<', 60], ['>', 62], ['?', 63], ['A', 65], ['B', 66], ['C', 67], ['F', 70], ['P', 80], ['Q', 81], ['U', 85], ['Z', 90], ['[', 91], ['\\', 92], [']', 93], ['^', 94], ['_', 95], ['`', 96], ['a', 97], ['b', 98], ['f', 102], ['i', 105], ['m', 109], ['n', 110], ['r', 114], ['s', 115], ['t', 116], ['v', 118], ['x', 120], ['z', 122], ['{', 123], ['|', 124], ['}', 125]]);
 
     // convert unicode codepoint to upper case codepoint
     // return same codepoint, if cannot do it (or codepoint not have upper variation)
@@ -154,10 +154,6 @@
     getStride(index) {
       return this.isStride1 ? 1 : this.data[index * this.SIZE + 2];
     }
-    get(index) {
-      const i = index * this.SIZE;
-      return [this.data[i], this.data[i + 1], this.getStride(index)];
-    }
     get length() {
       return this.data.length / this.SIZE;
     }
@@ -654,6 +650,9 @@
     static emptyInts() {
       return [];
     }
+    static isByteArray(input) {
+      return Array.isArray(input) || input instanceof Uint8Array;
+    }
 
     // Returns true iff |c| is an ASCII letter or decimal digit.
     static isalnum(c) {
@@ -955,7 +954,7 @@
      * @returns {number[]}
      */
     asBytes() {
-      return this.charSequence.toString().split('').map(s => s.codePointAt(0));
+      return Utils.stringToUtf8ByteArray(this.charSequence.toString());
     }
 
     /**
@@ -980,7 +979,7 @@
      * @returns {Utf8MatcherInput}
      */
     static utf8(input) {
-      if (Array.isArray(input)) {
+      if (Utils.isByteArray(input)) {
         return new Utf8MatcherInput(input);
       }
       return new Utf8MatcherInput(Utils.stringToUtf8ByteArray(input));
@@ -1112,10 +1111,10 @@
           if (start < this.start) {
             start = this.start;
           }
-          r1 = this.step(start) >> 3;
+          r1 = this.step(start - this.start) >> 3;
         }
       }
-      const r2 = pos < this.end ? this.step(pos) >> 3 : -1;
+      const r2 = pos < this.end ? this.step(pos - this.start) >> 3 : -1;
       return Utils.emptyOpContext(r1, r2);
     }
 
@@ -1197,14 +1196,17 @@
     index(re2, pos) {
       pos += this.start;
       const i = this.charSequence.indexOf(re2.prefix, pos);
-      return i < 0 ? i : i - pos;
+      if (i < 0 || i > this.end - re2.prefix.length) {
+        return -1;
+      }
+      return i - pos;
     }
 
     // Returns a bitmask of EMPTY_* flags.
     context(pos) {
       pos += this.start;
-      const r1 = pos > 0 && pos <= this.charSequence.length ? this.charSequence.codePointAt(pos - 1) : -1;
-      const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1;
+      const r1 = pos > this.start && pos <= this.end ? this.charSequence.codePointAt(pos - 1) : -1;
+      const r2 = pos < this.end ? this.charSequence.codePointAt(pos) : -1;
       return Utils.emptyOpContext(r1, r2);
     }
     prefixLength(re2) {
@@ -1392,7 +1394,7 @@
       this.numberOfInstructions = re2.numberOfInstructions();
       if (input instanceof MatcherInputBase) {
         this.resetMatcherInput(input);
-      } else if (Array.isArray(input)) {
+      } else if (Utils.isByteArray(input)) {
         this.resetMatcherInput(MatcherInput.utf8(input));
       } else {
         this.resetMatcherInput(MatcherInput.utf16(input));
@@ -1554,10 +1556,7 @@
       if (group === 0 || this.hasGroups) {
         return;
       }
-      let end = this.groups[1] + 1;
-      if (end > this.matcherInputLength) {
-        end = this.matcherInputLength;
-      }
+      const end = this.matcherInputLength;
       const res = this.patternInput.re2().matchMachineInput(this.matcherInput, this.groups[0], end, this.anchorFlag, 1 + this.patternGroupCount);
       const ok = res[0];
       if (!ok) {
@@ -1753,7 +1752,10 @@
               throw new RE2JSGroupException("named capture group is missing trailing '}'");
             }
             const groupName = replacement.substring(i + 1, j);
-            res += this.group(groupName);
+            const groupVal = this.group(groupName);
+            if (groupVal !== null) {
+              res += groupVal;
+            }
             last = j + 1;
             i = j;
             continue;
@@ -1799,6 +1801,22 @@
             i++;
             last = i + 1;
             continue;
+          } else if (Codepoint.CODES.get('`') === c) {
+            if (last < i) {
+              res += replacement.substring(last, i);
+            }
+            res += this.substring(0, this.start(0));
+            i++;
+            last = i + 1;
+            continue;
+          } else if (Codepoint.CODES.get("'") === c) {
+            if (last < i) {
+              res += replacement.substring(last, i);
+            }
+            res += this.substring(this.end(0), this.matcherInputLength);
+            i++;
+            last = i + 1;
+            continue;
           } else if (Codepoint.CODES.get('1') <= c && c <= Codepoint.CODES.get('9')) {
             let n = c - Codepoint.CODES.get('0');
             if (last < i) {
@@ -1841,7 +1859,10 @@
             }
             const groupName = replacement.substring(i + 1, j);
             if (Object.prototype.hasOwnProperty.call(this.namedGroups, groupName)) {
-              res += this.group(groupName);
+              const groupVal = this.group(groupName);
+              if (groupVal !== null) {
+                res += groupVal;
+              }
             } else {
               res += `$<${groupName}>`;
             }
@@ -4343,13 +4364,6 @@
     // start every program with a fail instruction, so we'll never want to point
     // at its output link.
 
-    next(l) {
-      const i = this.inst[l >> 1];
-      if ((l & 1) === 0) {
-        return i.out;
-      }
-      return i.arg;
-    }
     patch(l, val) {
       let head = l.head;
       while (head !== 0) {
@@ -5679,6 +5693,7 @@
         case Codepoint.CODES.get('6'):
         case Codepoint.CODES.get('7'):
           {
+            // Single non-zero digit is a backreference; not supported
             if (!t.more() || t.peek() < Codepoint.CODES.get('0') || t.peek() > Codepoint.CODES.get('7')) {
               break;
             }
@@ -5686,6 +5701,7 @@
         // eslint-disable-next-line no-fallthrough
         case Codepoint.CODES.get('0'):
           {
+            // Consume up to three octal digits; already have one.
             let r = c - Codepoint.CODES.get('0');
             for (let i = 1; i < 3; i++) {
               if (!t.more() || t.peek() < Codepoint.CODES.get('0') || t.peek() > Codepoint.CODES.get('7')) {
@@ -7466,7 +7482,11 @@
      */
     matchWithGroup(input, start, end, anchor, ngroup) {
       if (!(input instanceof MatcherInputBase)) {
-        input = MatcherInput.utf16(input);
+        if (Utils.isByteArray(input)) {
+          input = MatcherInput.utf8(input);
+        } else {
+          input = MatcherInput.utf16(input);
+        }
       }
       return this.matchMachineInput(input, start, end, anchor, ngroup);
     }
@@ -7972,7 +7992,7 @@
     }
     match(input) {
       if (!this.prog) this.compile();
-      const machineInput = Array.isArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
+      const machineInput = Utils.isByteArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
       let internalAnchor = RE2Flags.UNANCHORED;
       if (this.anchor === RE2Set.ANCHOR_START) {
         internalAnchor = RE2Flags.ANCHOR_START;
@@ -8029,45 +8049,50 @@
                 {
                   if (i + 2 < size) {
                     let nextCh = data[i + 2];
-                    if (TranslateRegExpString.isUpperCaseAlpha(nextCh)) {
+                    let code = nextCh.charCodeAt(0);
+                    if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+                      let val = code % 32;
                       result += '\\x';
-                      result += (nextCh.charCodeAt(0) - 64 >> 4).toString(16).toUpperCase();
-                      result += (nextCh.charCodeAt(0) - 64 & 15).toString(16).toUpperCase();
+                      result += (val >> 4).toString(16).toUpperCase();
+                      result += (val & 15).toString(16).toUpperCase();
                       i += 3;
                       changed = true;
                       continue;
                     }
                   }
-                  result += '\\c';
+                  result += 'c';
                   i += 2;
+                  changed = true;
                   continue;
                 }
               case 'u':
                 {
                   if (i + 2 < size) {
                     let nextCh = data[i + 2];
-                    if (TranslateRegExpString.isHexadecimal(nextCh)) {
-                      result += '\\x{' + nextCh;
-                      i += 3;
-                      for (let j = 0; j < 3 && i < size; ++i, ++j) {
-                        nextCh = data[i];
-                        if (!TranslateRegExpString.isHexadecimal(nextCh)) {
-                          break;
-                        }
-                        result += nextCh;
-                      }
-                      result += '}';
-                      changed = true;
-                      continue;
-                    } else if (nextCh === '{') {
+                    if (nextCh === '{') {
                       result += '\\x';
                       i += 2;
                       changed = true;
                       continue;
+                    } else if (i + 5 < size) {
+                      let isHex4 = true;
+                      for (let j = 0; j < 4; j++) {
+                        if (!TranslateRegExpString.isHexadecimal(data[i + 2 + j])) {
+                          isHex4 = false;
+                          break;
+                        }
+                      }
+                      if (isHex4) {
+                        result += '\\x{' + data.substring(i + 2, i + 6) + '}';
+                        i += 6;
+                        changed = true;
+                        continue;
+                      }
                     }
                   }
-                  result += '\\u';
+                  result += 'u';
                   i += 2;
+                  changed = true;
                   continue;
                 }
               default:
@@ -8302,7 +8327,7 @@
      * @returns {Matcher}
      */
     matcher(input) {
-      if (Array.isArray(input)) {
+      if (Utils.isByteArray(input)) {
         input = MatcherInput.utf8(input);
       }
       return new Matcher(this, input);
@@ -8318,7 +8343,7 @@
      * @returns {boolean} `true` if the pattern is found anywhere in the input, `false` otherwise.
      */
     test(input) {
-      if (Array.isArray(input)) {
+      if (Utils.isByteArray(input)) {
         // Reuse the existing UTF-8 fast-path method
         return this.re2Input.matchUTF8(input);
       }
@@ -8337,7 +8362,7 @@
      * @returns {boolean} `true` if the exact input string fully matches the pattern, `false` otherwise.
      */
     testExact(input) {
-      const machineInput = Array.isArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
+      const machineInput = Utils.isByteArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
       return this.re2Input.executeEngine(machineInput, 0, RE2Flags.ANCHOR_BOTH, 0) !== null;
     }