re2js 2.0.0 → 2.0.1

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.0.0
+ * @version v2.0.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -365,6 +365,11 @@
     // Checked during test.
     static MIN_FOLD = 0x0041;
     static MAX_FOLD = 0x1e943;
+    static MIN_HIGH_SURROGATE = 0xd800;
+    static MAX_HIGH_SURROGATE = 0xdbff;
+    static MIN_LOW_SURROGATE = 0xdc00;
+    static MAX_LOW_SURROGATE = 0xdfff;
+    static MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
 
     // is32 uses binary search to test whether rune is in the specified
     // slice of 32-bit ranges.
@@ -671,9 +676,9 @@
           } else if (c < 2048) {
             out[p++] = c >> 6 | 192;
             out[p++] = c & 63 | 128;
-          } else if ((c & 0xfc00) === 0xd800 && i + 1 < str.length && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+          } else if ((c & 0xfc00) === Unicode.MIN_HIGH_SURROGATE && i + 1 < str.length && (str.charCodeAt(i + 1) & 0xfc00) === Unicode.MIN_LOW_SURROGATE) {
             // Surrogate Pair
-            c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
+            c = Unicode.MIN_SUPPLEMENTARY_CODE_POINT + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
             out[p++] = c >> 18 | 240;
             out[p++] = c >> 12 & 63 | 128;
             out[p++] = c >> 6 & 63 | 128;
@@ -707,9 +712,9 @@
             let c2 = bytes[pos++];
             let c3 = bytes[pos++];
             let c4 = bytes[pos++];
-            let u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 0x10000;
-            out[c++] = String.fromCharCode(0xd800 + (u >> 10));
-            out[c++] = String.fromCharCode(0xdc00 + (u & 1023));
+            let u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - Unicode.MIN_SUPPLEMENTARY_CODE_POINT;
+            out[c++] = String.fromCharCode(Unicode.MIN_HIGH_SURROGATE + (u >> 10));
+            out[c++] = String.fromCharCode(Unicode.MIN_LOW_SURROGATE + (u & 1023));
           } else {
             let c2 = bytes[pos++];
             let c3 = bytes[pos++];
@@ -883,38 +888,34 @@
     // the lower 3 bits, and the rune (Unicode code point) in the high
     // bits.  Never negative, except for EOF which is represented as -1
     // << 3 | 0.
-    step(i) {
-      i += this.start;
-      if (i >= this.end) {
+    step(pos) {
+      pos += this.start;
+      if (pos >= this.end) {
         return MachineInputBase.EOF();
       }
-      let x = this.bytes[i++] & 255;
-      if ((x & 128) === 0) {
-        return x << 3 | 1;
-      } else if ((x & 224) === 192) {
-        x = x & 31;
-        if (i >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 2;
-      } else if ((x & 240) === 224) {
-        x = x & 15;
-        if (i + 1 >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 3;
+
+      // Read UTF-8 bytes to extract the Rune and its width
+      const c = this.bytes[pos] & 0xff;
+      if (c < 0x80) {
+        return c << 3 | 1;
+      } else if (c >= 0xc2 && c <= 0xdf && pos + 1 < this.end) {
+        const c1 = this.bytes[pos + 1] & 0xff;
+        const rune = (c & 0x1f) << 6 | c1 & 0x3f;
+        return rune << 3 | 2;
+      } else if (c >= 0xe0 && c <= 0xef && pos + 2 < this.end) {
+        const c1 = this.bytes[pos + 1] & 0xff;
+        const c2 = this.bytes[pos + 2] & 0xff;
+        const rune = (c & 0x0f) << 12 | (c1 & 0x3f) << 6 | c2 & 0x3f;
+        return rune << 3 | 3;
+      } else if (c >= 0xf0 && c <= 0xf4 && pos + 3 < this.end) {
+        const c1 = this.bytes[pos + 1] & 0xff;
+        const c2 = this.bytes[pos + 2] & 0xff;
+        const c3 = this.bytes[pos + 3] & 0xff;
+        const rune = (c & 0x07) << 18 | (c1 & 0x3f) << 12 | (c2 & 0x3f) << 6 | c3 & 0x3f;
+        return rune << 3 | 4;
       } else {
-        x = x & 7;
-        if (i + 2 >= this.end) {
-          return MachineInputBase.EOF();
-        }
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        x = x << 6 | this.bytes[i++] & 63;
-        return x << 3 | 4;
+        // Invalid sequence fallback
+        return c << 3 | 1;
       }
     }
 
@@ -989,12 +990,25 @@
     // << 3 | 0.
     step(pos) {
       pos += this.start;
-      if (pos < this.end) {
-        const rune = this.charSequence.codePointAt(pos);
-        return rune << 3 | Utils.charCount(rune);
-      } else {
+      if (pos >= this.end) {
         return MachineInputBase.EOF();
       }
+      const c1 = this.charSequence.charCodeAt(pos);
+
+      // Fast path: standard BMP character (not a high surrogate)
+      if (c1 < Unicode.MIN_HIGH_SURROGATE || c1 > Unicode.MAX_HIGH_SURROGATE || pos + 1 >= this.end) {
+        return c1 << 3 | 1;
+      }
+
+      // Slow path: Calculate surrogate pair manually
+      const c2 = this.charSequence.charCodeAt(pos + 1);
+      if (c2 >= Unicode.MIN_LOW_SURROGATE && c2 <= Unicode.MAX_LOW_SURROGATE) {
+        const rune = (c1 - Unicode.MIN_HIGH_SURROGATE) * 0x400 + (c2 - Unicode.MIN_LOW_SURROGATE) + Unicode.MIN_SUPPLEMENTARY_CODE_POINT;
+        return rune << 3 | 2;
+      }
+
+      // Invalid surrogate pair fallback
+      return c1 << 3 | 1;
     }
 
     // Returns the index relative to |pos| at which |re2.prefix| is found
@@ -1742,7 +1756,7 @@
       let lo = 0;
       let hi = this.runes.length / 2 | 0;
       while (lo < hi) {
-        const m = lo + ((hi - lo) / 2 | 0);
+        const m = lo + hi >> 1; // native cpu instruction for "lo + (((hi - lo) / 2) | 0)"
         const c = this.runes[2 * m];
         if (c <= r) {
           if (r <= this.runes[2 * m + 1]) {
@@ -1803,10 +1817,10 @@
   // A queue is a 'sparse array' holding pending threads of execution.  See:
   // research.swtch.com/2008/03/using-uninitialized-memory-for-fun-and.html
   class Queue {
-    constructor() {
-      this.sparse = []; // may contain stale but in-bounds values.
-      this.densePcs = []; // may contain stale pc in slots >= size
-      this.denseThreads = []; // may contain stale Thread in slots >= size
+    constructor(numInst) {
+      this.sparse = new Int32Array(numInst); // may contain stale but in-bounds values.
+      this.densePcs = new Int32Array(numInst); // may contain stale pc in slots >= size
+      this.denseThreads = new Array(numInst); // may contain stale Thread in slots >= size
       this.size = 0;
     }
     contains(pc) {
@@ -2307,7 +2321,7 @@
         if (width === 0) {
           break;
         }
-        currentState = this.step(currentState, rune, anchor);
+        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_ASCII && currentState.nextAscii[rune] || this.step(currentState, rune, anchor);
 
         // If we hit an unrecoverable DFA error or bailout, signal fallback
         if (currentState === null) return null;