re2js 2.0.2 → 2.1.0

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.2
+ * @version v2.1.0
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -60,6 +60,23 @@
   /**
    * Various constants and helper for unicode codepoints.
    */
+  const ASCII_SIZE = 128;
+  const ASCII_TO_UPPER = new Int32Array(ASCII_SIZE);
+  const ASCII_TO_LOWER = new Int32Array(ASCII_SIZE);
+  for (let i = 0; i < ASCII_SIZE; i++) {
+    if (i >= 97 && i <= 122) {
+      // a-z
+      ASCII_TO_UPPER[i] = i - 32;
+    } else {
+      ASCII_TO_UPPER[i] = i;
+    }
+    if (i >= 65 && i <= 90) {
+      // A-Z
+      ASCII_TO_LOWER[i] = i + 32;
+    } else {
+      ASCII_TO_LOWER[i] = i;
+    }
+  }
   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]]);
@@ -67,6 +84,7 @@
     // convert unicode codepoint to upper case codepoint
     // return same codepoint, if cannot do it (or codepoint not have upper variation)
     static toUpperCase(codepoint) {
+      if (codepoint < ASCII_SIZE) return ASCII_TO_UPPER[codepoint];
       const s = String.fromCodePoint(codepoint).toUpperCase();
       if (s.length > 1) {
         return codepoint;
@@ -81,6 +99,7 @@
     // convert unicode codepoint to lower case codepoint
     // return same codepoint, if cannot do it (or codepoint not have lower variation)
     static toLowerCase(codepoint) {
+      if (codepoint < ASCII_SIZE) return ASCII_TO_LOWER[codepoint];
       const s = String.fromCodePoint(codepoint).toLowerCase();
       if (s.length > 1) {
         return codepoint;
@@ -203,9 +222,11 @@
       C: () => new UnicodeRangeTable(decodeRanges('AfBgDgBBOrWrWBHHBCBICCVuMuMnBBBzBBBE4B4BBGBcDBHQBXhGhGxBBB8BBBmDNB8BBByBBBQddBCCMEBgBHBsCiFiFJBBDBBXIICCBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBPMMBEB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKMMBDBbEByBPBDBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBjoIBvLBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCB-FCBHBBHBBHBBECBIIIBLBDBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIB-BGGBLBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMBxhBPBXJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBF-6DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBrCHBxDUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEvq3VBxHvw-FB', false)),
       Cc: () => new UnicodeRangeTable(decodeRanges('AfgDgB', true)),
       Cf: () => new UnicodeRangeTable(decodeRanges('tFzqBzqBBEBXhGhGyBhMhMBxCxCs5D9-B9-BBDBbEByBEBCJBw03B6H6HBBBimEQQj7IPBhjiBDBwmFHBn0rYffB+CB', false)),
+      Cn: () => new UnicodeRangeTable(decodeRanges('4bBBHDBICCVuMuMnBBBzBBBE4B4BBGBcDBHKBvI9B9BBmDmDBMB8BBByBBBQddBCCMEBgBDDBDBuHJJBDDBXXICCBBBFBBKBBDBBFHBCDBDGGBaaBEEHDBDBBXIIDGDBCCGDBDBBECBCGBFCCBFBSJBEKKEXXIDDGBBLIEBCCBNBFBBNGBIEEJBBDBBXIIDGGBKKBDDBEEBFBEDBDGGBTTBIBDHHBBBEFFBBBDCCDCBDCBECBNDBGCBEFFBCCBEBCNBWEBOEEYRRBKKEFFBFBDEEBCCBFFBLLBFBXEEYLLGBBKEEFGBDFBDFFBLLELBOEE0BEEHDBRBBbEETCBZKKCBBICBCDBHCCJFBLBBELB7BDBekBBDCCGZZCYYBGGCIILBBFfBpClBlBBCBoBlBlBQOOBjBBnGCCBDBCBB6LFFBIICFFBqBqBFBBiBFFBIICFFBQQ6BFFBkCkCBhBhBBBBbFB3CBBHBB+UCB6CGBXIBZIBVLBOEEDLB-CBBLFBLFBbFB6CGBsBEBnCJBgBNNBCBNDBCCBrBBBGKBtBDBbFBMCB-BBBiCeeBMMBEBLFBPBBgBwBBuCnFnFBGB9BCBQCB-BEBsBBBMHBsBEB3QBBHBBnBBBHBBJGCgBBB2BQQPBBHUUBEEKmDmDNBBcOOBBBiBOBiBOBtEDB7UVBMUB14BBBhB+K+KBDBuBCCBDBCBB5BGBDNBZIBI4BI-DhBBb6C6CBKB3GZBxC3C3CBoDoDBDBsB-C-C3CIBxBuzcuzcBBB4BIB9KTB5FHBvGBBDCCJUB8BCBLFB5BHBnCHBNFB1DKBfCBvCMMBCBiB4B4BBHBPBBLBBoDXBdJBHBBHBBHIBIII9BDB-DBBLFBl9KLBYDByBDBvzIBBrDlBBILBGEBbGGCGD+DPB+NBB3BGBCfBrBFB0BUUFDBGoEoEBCC-FCBHBBHBBHBBECBIIIBIBGBBNbbUDDQBBPhBB8DEBEDBuBCB5COOBBBCuBBvBhEBeCByBOBdDBlBIBfEBsBEBfmBmBBCBPpBB-EBBLFBlBDBlBDBpBHB1BKBNQQIDDMQQIDDBBB1BLB4JIBXJBJXBHrBrBKkCBHBBCtBtBDCBCBBYpCpCBGBKvBBUDDBDBiBCBcEBC-BB5BDBVBBzBDDBDBJEEeBBEDBLGBKGBhCfBoBDBNIB3BCBeBBcEBbGBFLBIvCBqC2BB0BMB0BGBvBHBLFBnBCBeHBDvGBgBrBrBEBBDPBE2BBtBHBrBVBblBBdTBYIBvCDBlBIBlCJBCBBaGBLFB2BTTBGBoBIBhDVVBJBTwBwBB8BBICCFQQMFB8BEBLFBFJJBDDBXXIDDGLLBDDBEEBCCBEBCEBIBBICBGKBLCCBCCnBLLCBBCFFLDDBGBDcB9CGGBcBpCHBLlFB3BBBnBhBBmCKBLFBOSB7BFBLFBVbBcBBQDBY4FB9BjDB0CLBJBBCBBJDDfDDBNNBHBLlCBJBBvBBBMaBpCHB0CMBqCGBL1FBjBNBLFBKuBuBPJBeCBhBBBXPPBnCBIDDtBCBCDDKHBLFBHDDmBDDHGBL1JBaGBSqBqBBBBe0CBCOBzBMB8clDBwDGGBJBlGryCBkDMB3iBJB88DEBoS41GB7Bl2BB6RGBgBLLBCByCLLBEBfBBHJBnCJBLIIWEBUvNB7BlGB8CkDBsCDB6BGBS-BBGKBDNB5-FHB3mBoBBLm3IBFIIDkJkJBNBCcBEBBCNBFHBtMjoCBsDEBOCBKGBLBBJ76DB7HFB1NrCBvBBBYIB1D7BB3HJBoBBBjGUBnC5DBVLBVLB4CIBamEB2CoCoCDBBCBBDBBFNNCIIiCFFBJJIddFGGCCBI1K1KBlJlJB-V-VBNBGQQBuiBBgBFBH0GBISSBIIDGGBDB-BgBBCvDBuBCBPBBLDBD-JBgBQB7BEBCvOBrB1GBsBDBC-OBIFFDQQmGBBRoBBtCDBLDBDwYBlCrCB+BhGBFccDCCBCCLFFCCCBEBCDBCECEDDCBBCICDCCBFFIKFCLLSEBEGGSzBBDtIBtBDBlDLBQBBQQQmBJBvF3BBeMBtBDBKGBDNBH5EB5eDBSCBOCB4DDBgDFBNDBCOBNDB5BHBLFBpBHBfBBNDBD9BB1KLBPBBOCBLEB5BGBQBBMFBKGB0EnDnDBkgBBh3pBfB7hEFB-GBBj0FNBypHOBvThtCB-QhvBBs6EEBhjEwi3VBCdBhD-DBxHvw-BB---BBB---BBB', false)),
       Co: () => new UnicodeRangeTable(decodeRanges('gg4B-nGh4hc9--BD9--B', true)),
       Cs: () => new UnicodeRangeTable(decodeRanges('gg2B--B', true)),
       L: () => new UnicodeRangeTable(decodeRanges('hCZBHZBwBLLFGGBVBCeBCpOBFLBPEBICCiEEBCBBDDBCHHCCBCCCBSBCyCBCqEBJlFBClBBDHHBnBBoCaBFDBuBqBBkBBBCiDBCQQBIIBLLBBBDRRCdBe4CBMZZBfBKBBFGGBUBFKKEYYBXBIKBGXBCFBSpBB7B1BBETTIJBQPBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNGB7BBBCCCBDBCXBCCCBIBCBBKDDBDBCWWBCBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNSSBkBBCGGDqBBCsKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPBR1CBDFBErTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBkBFFkC4CBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBzC+C+CBtBBSHB3BdBOBBLrBBbjBBqBCBLjBBDKBGqBBDCBqBDBCFBCBBEGGB+FBhC1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGB1DOORMBmDFFDJBCEEBDBHGCBCBCKBDDBGEBF1B1BB8zC8zCBjHBHDBEBBNlBBCGGD3BBIRRBVBKGBCGBCGBCGBCGBCGBCGBCGBxC2O2OBrBrBBDBGBBF1CBHCBC5CBCDBGqBBC9CBSfBxBPBhQ-tGBhCs0VBkCtBBDsIBEPBLBBVuBBReBDlCByBIBDmDBDiCBDBBCCCBGBWPBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBdRRBDBCJBLEBCoBBYCBCHBVWBEEEBwBBCEEBDDBDBDCCZCBDKBICBNFBDFBDFBKGBCGBCqBBCNBHyDBej9KBNWBFwBBloItLBDpDBnBGBNEBGCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBlBZBHZBM4CBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBxB9EBTjBBFjBBFnBBJzBBNKBCOBCGBCBBCKBCOBCGBCBBEzBBN2JBKVBLHBZFBCpBBCIBmCFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4ByBBOyBBOjBBnBbBKWB7HpBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB1D-BBgBHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBBRDBgBUBGSBxNsBB0G-BBhEqCBGjCjCBLBhCBBCddB2-FBJ1mBBqBJBo3IDBCGBCBBCiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBn7F0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BeBHFBmI9BBzEsBBLGBRiKiKBcBTrBBlPbBlHdBDwPwPBFBCDBCBBCOBCkGB8BjCBI1lB1lBBCBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB', false)),
+      LC: () => new UnicodeRangeTable(decodeRanges('hCZBHZB7BLLBVBCeBCiGBCDBFvGBCaBhGDBDBBECBCHHCCBCCCBSBCyCBCqEBJlFBClBBKoBB44ClBBCGGDqBBDCBhV1CBDFBjkCKBGqBBDCBhCrBBgCMBChBBmD1IBDFBDlBBDFBDHBCGCBdBD0BBCGBCEEBBBCGBEDBDFBFMBGCBCGBmIFFDJBCEEBDBHGCBCBCFBFDDBCBGEBF1B1BB8zC8zCB6DBDmDBHDBEBBNlBBCGGzoetBBTbBnEtCBCWBEDBC9BBDBBCCCBGBZBBE2Z2ZBpBBGIBIvCBh6TGBNEBqgBZBHZBmlBvCBhDjBBFjBB1DKBCOBCGBCBBCKBCOBCGBCBBk2ByBBOyBB+CVBLVB74C-BBhrV-BBhsZ0CBCmCBCBBDDDBDDBCBCLBCCCBFBCgCBCDBDHBCGBCbBCDBCEBCEEBFBCzKBDYBCYBCeBCYBCeBCYBCeBCYBCeBCYBCHB15BJBCTBHFB2uCjCB', false)),
       Ll: () => new UnicodeRangeTable(decodeRanges('hDZB7BqBqBBWBCHBC2BCBQCBuBCDECBBBDCCDEEBFFDEEBBBDDDCCCDCCBCCDEECDDBDDBBBHGDCOCBSCBDDCEEC4BCBFBDDDBCCFICBjCBCaBiGCCEEEBBBTccBhBBCBBECBCWCBDBCGDB0B0BBuBBCgBCK0BCDMCBgDCxBoBBo6CqBBDCB5XFBjkCIBC2D2DBqBBgCMBChBBnD0ECBHBCgDCBHBJFBLHBJHBJFBLHBJHBJNBDHBJHBJHBJEBCBBHEEBBBCBBJDBDBBJHBLCBCBBzIEEBEEcKFDBBJDBF2B2Bs1CvBBCEEBGCFCCBCCBEBGiDCBIICFFNlBBCGG0oesBCUaCoEMCBBBC+BCBGBCCCDICFCCDCCBBBCSCGGGCMCFCCDEECICbEE2ZqBBGIBIvCBh6TGBNEBqhBZBumBnBBpEjBB8EKBCOBCGBCBBk4ByBB+DVB75CfBhsVfB7sZZBbGBCRBbZBbDBCCCBFBCKBbZBbZBbZBbZBbZBbZBbZBbZBbbBdYBCFBbYBCFBbYBCFBbYBCFBbYBCFBC15B15BBIBCTBHFB4vChBB', false)),
       Lm: () => new UnicodeRangeTable(decodeRanges('wVRBFLBPEBICCmEGG-OnHnHlFBBuIBBFgBgBKEEhFoFoF1mBgEgE2R72B72BsDkTkTxOFBvF+BBOjBjBBjBByVOORMBg-CBByHgGgG2OsBsBBDBGiDiDB+C+CBBB34bjnBjnBBEBvIzDzDdBB6DIBxCYYqDCBEBB2OXXqEtDtDWBBoDDBKngVngVuBBBh-BFBCpBBCIB0sBhBhBxuXDB9PCBpBBBnRMBhCBBCtgQtgQBCBCGBCBByhM9BBqGGBudgjBgjB', false)),
       Lo: () => new UnicodeRangeTable(decodeRanges('qFQQhIFFBCBxG8Z8ZBZBFDBuBfBCJBkBBBCiDBCZZBLLBBBDRRCdBe4CBMZZBfBWVBrBYBIKBGXBCFBSoBB8B1BBETTIJBROBFHBDBBDVBCGBCEEBCBERROBBCCBPBBLJJBEBFBBDVBCGBCBBCBBCBBgBDBCUUBBBRIBCCBCVBCGBCBBCEBETTQBBYMMBGBDBBDVBCGBCBBCEBEffBCCBBBQSSCFBECBCDBEBBCCCBEEBEEBBBELBX1B1BBGBCCBCWBCPBEbbBBBDDDBffFHBCCBCWBCJBCEBEgBgBBCCBQQBSSBHBCCBCoBBDRRGCBJCBZFBGRBEXBCIBCDDBFB7BvBBCBBNFB8BBBCCCBDBCXBCCCBIBCBBKDDBDBYDBhBgCgCBGBCjBBcEB0DqBBVRRBEBFDBEEEBIIBBBFMBNyDyDBnKBCDBDGBCCCBCBDoBBCDBDgBBCDBDGBCCCBCBDOBC4BBCDBDiCBmBPByDrTBDQBCZBGqCBHHBIRBOSBPRBPMBCCBQzBBpBkCkCBhBBC0BBIEBDhBBCGGBkCBLeByBdBDEBMrBBFZB3BWBK0BBxFuBBSHB3BdBOBBLrBBbjBBqBCBLdByDDBCFBCBBE7hB7hBBCB4-C3BBZWBKGBCGBCGBCGBCGBCGBCGBCGBoR2B2BF1CBJCCB4CBFGGBpBBC9CBSfBxBPBhQ-tGBhC0wUBC2jBBkCnBBJrIBFPBLBBjCyByBBkCBqFoDoDEGBCCBCDBCWBezBBPxBB-BFBECCBMMBaBLWBacBIuBBuBEBDIBLEBCoBBYCBCHBVPBCFBEEEBwBBCEEBDDBDBDCCZBBEKBIPPBEBDFBDFBKGBCGByEiBBej9KBNWBFwBBloItLBDpDBkCCCBIBCMBCEBCCCBCCBCCBqDBiBqLBT-BBD1BBpBLB1DEBCmEBqDJBCsBBDeBEFBDFBDFBDCBkBLBCZBCSBCBBCOBDNBjB6DBmMcBEwBBwBfBOTBCHBHlBBLdBDjBBFHBhEtCBjDnBBJzBB9CzBBN2JBKVBLHB5EFBDCCBqBBCBBEDDBVBLWBKeBiCSBCBBLVBLZBnC3BBHBBhCQQBCBCCBCcBrBcBEcBkBHBCbBc1BBLVBLSBORBvDoCB4FjBBnBDBCxJxJBoBBHBBRCB8BcBLJJBUBrBRBvBUBcWBN0BB6BBBDOOBrBBhBYBbjBBeDDJiBBENNBuBBPDBWCCkBRBCYBUBBgCGBCCCBCBCOBCJBIuBBnBHBDBBDVBCGBCBBCEBETTNEBfJBCDDClBBCaaCtBtBBzBBTDBVCBfvBBVBBC5F5FBtBBqBDBlBvBBV8B8BBpBBOoCoCBZBmBGB6FrBB0GHBDDDBGBCBBCXBQCC-CHBDmBBRCCdLLBmBBIWWMtBBUTTBnCBoGgBBgBIBCkBBSyByBBcBxDGBCBBClBBWaaBEBCBBCfBPoKoKBRBQCCBLBChBB9DwCwCB4cBnHjGBtyCgDBQvhBBSFBa68DBGmSB61GdBj3B4RBIeBSuCBSdBTvBB0BUBGSB0NnBB2MqCBGwFwFB2-FBJ1mBBqBJB43IiJBQeeBBBDPPBCBJrMBloCqDBGMBEIBIJBxzI2P2PBrBBiBiKiKBcBTrBBlPaBmHdBDwPwPBFBCDBCBBCOBCkGB8pBDBCaBCBBCDDCJBCDBCCCHFFCECBBBCBBCDDCICBCCDDBCGBCDBCDBCCCBIBCQBGCBCEBCQBlqE-2pBBhB5hEBH9GBDh0FBPwpHBQtTBjtC9QBjvBq6EBG-iEB', false)),
@@ -414,8 +435,11 @@
       Zanabazar_Square: () => new UnicodeRangeTable(decodeRanges('gwmCnC', true))
     });
     static FOLD_CATEGORIES = new LazyMap({
-      L: () => new UnicodeRangeTable(decodeRanges('laA', true)),
-      Ll: () => new UnicodeRangeTable(decodeRanges('hCZBmDWBCGBiBuBCEECDOCDuBCBECEBBCCCBCCBBBDDBCBBCCBEBBCBBCECBCCDCCBCCBBBCCCBEEIBBCBBCBBCOCDQCDBBCCCBBBC4BCIBBCBBDCCBCBCGC3HrBrBCEEJHHCCBCCCBCCBPBCIBkBJJCUCGDDCBBDyBBxBgBCK2BCBMCD+CCDlBBq6ClBBCGGzW1CB0kCHHBpBBDCBhK0ECKgDCKHBJFBLHBJHBJFBMGCJHBZHBJHBJHBJEBMEBMDBNEBMEBqJEEBHHxC9zC9zCBuBBxBCCBBBDGCBCBCDDJCBCgDCJCCFuqeuqeCqBCUaCoEMCE8BCLECBICFCCDCCEUCBDBCEBCOCBCBCCCBEEGGCZs5Vs5VBYBmmBnBBpEjBB9EKBCOBCGBCBBr3ByBB+EVB75CfBhsVfBh1ehBB', false)),
+      C: () => new UnicodeRangeTable(decodeRanges('z+pBCC', false)),
+      Cn: () => new UnicodeRangeTable(decodeRanges('z+pBCC', false)),
+      L: () => new UnicodeRangeTable(decodeRanges('latkpBtkpBCAB', false)),
+      LC: () => new UnicodeRangeTable(decodeRanges('latkpBtkpBCAB', false)),
+      Ll: () => new UnicodeRangeTable(decodeRanges('hCZBmDWBCGBiBuBCEECDOCDuBCBECEBBCCCBCCBBBDDBCBBCCBEBBCBBCECBCCDCCBCCBBBCCCBEEIBBCBBCBBCOCDQCDBBCCCBBBC4BCIBBCBBDCCBCBCGC3HrBrBCEEJHHCCBCCCBCCBPBCIBkBJJCUCGDDCBBDyBBxBgBCK2BCBMCD+CCDlBBq6ClBBCGGzW1CB0kCHHBpBBDCBhK0ECKgDCKHBJFBLHBJHBJFBMGCJHBZHBJHBJHBJEBMEBMDBNEBMEBqJEEBHHxC9zC9zCBuBBxBCCBBBDGCBCBCDDJCBCgDCJCCFuqeuqeCqBCUaCoEMCE8BCLECBICFCCDCCEUCBDBCEBCOCBCBCCCBEECKCZs5Vs5VBYBmmBnBBpEjBB9EKBCOBCGBCBBr3ByBB+EVB75CfBhsVfBh1ehBB', false)),
       Lt: () => new UnicodeRangeTable(decodeRanges('kOCCBCCBCClBCCtsHHBJHBJHBMQQwBAB', false)),
       Lu: () => new UnicodeRangeTable(decodeRanges('hDZB7BqBqBBWBCHBCuBCEECDOCDsBCDECBBBDCCDEEGDDECBDDDCCCDFFDEECDDECCGBBCBBCBBCOCBSCDBBCEECkBCEQCJDDBCCFICBEBCBBCCCBEEBCCBCBCEBDCCBDDIDDCBBEFBGLLBnFnFsBCCEEEBBBvBDBCdBCBBECBCWCBDBCGD1BvBBCgBCK0BCDMCBgDCyBlBBq6CqBBDCB5XFBjkCIBCvHvHERRzD0ECGGGC8CCBHBJFBLHBJHBJFBMGCJHBJNBzBBBNSSBPPBEEpL2B2Bs1CvBBCEEBGCHDDLiDCJCCFNNBkBBCGG0oesBCUaCoEMCE8BCLCCDICFFFCBBDSCMOCFCCDEEGECb9a9advCBi8UZBumBnBBpEjBB8EKBCOBCGBCBBk4ByBB+DVB75CfBhsVfBj1ehBB', false)),
       M: () => new UnicodeRangeTable(decodeRanges('5cgBgBlgHAB', false)),
@@ -424,7 +448,9 @@
     static FOLD_SCRIPT = new LazyMap({
       Common: () => new UnicodeRangeTable(decodeRanges('8cgBgB', false)),
       Greek: () => new UnicodeRangeTable(decodeRanges('1FwUwU', false)),
-      Inherited: () => new UnicodeRangeTable(decodeRanges('5cgBgBlgHAB', false))
+      Inherited: () => new UnicodeRangeTable(decodeRanges('5cgBgBlgHAB', false)),
+      Latin: () => new UnicodeRangeTable(decodeRanges('y+pBCC', false)),
+      Unknown: () => new UnicodeRangeTable(decodeRanges('z+pBCC', false))
     });
   }
 
@@ -678,7 +704,7 @@
 
     // Returns the array of runes in the specified Java UTF-16 string.
     static stringToRunes(str) {
-      return String(str).split('').map(s => s.codePointAt(0));
+      return Array.from(String(str)).map(s => s.codePointAt(0));
     }
 
     // Returns the Java UTF-16 string containing the single rune |r|.
@@ -949,6 +975,14 @@
     endPos() {
       return this.end;
     }
+    hasString() {
+      return false;
+    }
+
+    // Helper for the exact-literal fast-path execution router
+    prefixLength() {
+      return 0;
+    }
   }
 
   // An implementation of MachineInput for UTF-8 byte arrays.
@@ -960,6 +994,14 @@
       this.start = start;
       this.end = end;
     }
+    hasString(prefilter, pos) {
+      const target = prefilter.bytes;
+      if (target.length === 0) return true;
+
+      // Reuse the high-speed indexOf method already implemented below
+      const idx = this.indexOf(this.bytes, target, this.start + pos);
+      return idx !== -1 && idx <= this.end - target.length;
+    }
 
     // Returns the rune at the specified index; the units are
     // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
@@ -1036,10 +1078,10 @@
     indexOf(source, target, fromIndex = 0) {
       let targetLength = target.length;
       if (targetLength === 0) {
-        return -1;
+        return fromIndex <= this.end ? fromIndex : -1;
       }
-      let sourceLength = source.length;
-      for (let i = fromIndex; i <= sourceLength - targetLength; i++) {
+      let limit = this.end - targetLength;
+      for (let i = fromIndex; i <= limit; i++) {
         for (let j = 0; j < targetLength; j++) {
           if (source[i + j] !== target[j]) {
             break;
@@ -1050,6 +1092,9 @@
       }
       return -1;
     }
+    prefixLength(re2) {
+      return re2.prefixUTF8.length;
+    }
   }
 
   // |pos| and |width| are in JS "char" units.
@@ -1060,6 +1105,10 @@
       this.start = start;
       this.end = end;
     }
+    hasString(prefilter, pos) {
+      const idx = this.charSequence.indexOf(prefilter.str, this.start + pos);
+      return idx !== -1 && idx <= this.end - prefilter.str.length;
+    }
 
     // Returns the rune at the specified index; the units are
     // unspecified, but could be UTF-8 byte, UTF-16 char, or rune
@@ -1105,6 +1154,9 @@
       const r2 = pos < this.charSequence.length ? this.charSequence.codePointAt(pos) : -1;
       return Utils.emptyOpContext(r1, r2);
     }
+    prefixLength(re2) {
+      return re2.prefix.length;
+    }
   }
   class MachineInput {
     static fromUTF8(bytes, start = 0, end = bytes.length) {
@@ -1195,6 +1247,17 @@
     }
   }
 
+  /**
+   * An exception thrown for internal engine errors, such as corrupted bytecodes.
+   */
+  class RE2JSInternalException extends RE2JSException {
+    /** @param {string} message */
+    constructor(message) {
+      super(message);
+      this.name = 'RE2JSInternalException';
+    }
+  }
+
   /**
    * A stateful iterator that interprets a regex {@code RE2JS} on a specific input.
    *
@@ -1397,6 +1460,23 @@
       }
       return this.substring(start, end);
     }
+
+    /**
+     * Returns a dictionary map of all named capturing groups and their matched values.
+     * If a group was not matched, its value will be `null`.
+     * @returns {Record<string, string|null>}
+     */
+    getNamedGroups() {
+      if (!this.hasMatch) {
+        throw new RE2JSGroupException('perhaps no match attempted');
+      }
+      const result = {};
+      for (const name of Object.keys(this.namedGroups)) {
+        result[name] = this.group(name);
+      }
+      return result;
+    }
+
     /**
      * Returns the number of subgroups in this pattern.
      *
@@ -1821,16 +1901,20 @@
         }
         return r === r0;
       }
-      // Peek at the first few pairs.
-      // Should handle ASCII well.
-      for (let j = 0; j < this.runes.length && j <= 8; j += 2) {
-        if (r < this.runes[j]) {
-          return false;
-        }
-        if (r <= this.runes[j + 1]) {
-          return true;
+      const len = this.runes.length;
+      // If the array is exactly 2, 4, 6, or 8 items, DO NOT fall through to binary search
+      if (len === 2 || len === 4 || len === 6 || len === 8) {
+        for (let j = 0; j < len; j += 2) {
+          if (r < this.runes[j]) {
+            return false;
+          }
+          if (r <= this.runes[j + 1]) {
+            return true;
+          }
         }
+        return false; // Stop here
       }
+
       // Otherwise binary search.
       let lo = 0;
       let hi = this.runes.length / 2 | 0;
@@ -1848,6 +1932,40 @@
       }
       return false;
     }
+
+    // matchRunePos checks whether the instruction matches (and consumes) r.
+    // If so, it returns the index of the matching rune pair.
+    // If not, it returns -1.
+    matchRunePos(r) {
+      if (this.runes.length === 1) {
+        const r0 = this.runes[0];
+        if ((this.arg & RE2Flags.FOLD_CASE) !== 0) {
+          return Unicode.equalsIgnoreCase(r0, r) ? 0 : -1;
+        }
+        return r === r0 ? 0 : -1;
+      }
+      const len = this.runes.length;
+      if (len === 2 || len === 4 || len === 6 || len === 8) {
+        for (let j = 0; j < len; j += 2) {
+          if (r < this.runes[j]) return -1;
+          if (r <= this.runes[j + 1]) return Math.floor(j / 2);
+        }
+        return -1;
+      }
+      let lo = 0;
+      let hi = Math.floor(len / 2);
+      while (lo < hi) {
+        const m = lo + hi >> 1;
+        const c = this.runes[2 * m];
+        if (c <= r) {
+          if (r <= this.runes[2 * m + 1]) return m;
+          lo = m + 1;
+        } else {
+          hi = m;
+        }
+      }
+      return -1;
+    }
     /**
      *
      * @returns {string}
@@ -1863,7 +1981,7 @@
         case Inst.EMPTY_WIDTH:
           return `empty ${this.arg} -> ${this.out}`;
         case Inst.MATCH:
-          return 'match';
+          return `match${this.arg !== 0 ? ` ${this.arg}` : ''}`;
         case Inst.FAIL:
           return 'fail';
         case Inst.NOP:
@@ -1889,7 +2007,7 @@
   class Thread {
     constructor() {
       this.inst = null;
-      this.cap = [];
+      this.cap = null; // Initialized to Int32Array later
     }
   }
 
@@ -1917,9 +2035,11 @@
       return j;
     }
     clear() {
-      this.sparse = [];
-      this.densePcs = [];
-      this.denseThreads = [];
+      // Prevent memory leaks by nulling out used object references
+      for (let i = 0; i < this.size; i++) {
+        this.denseThreads[i] = null;
+      }
+      // The sparse set logic safely ignores stale integers in Typed Arrays.
       this.size = 0;
     }
     toString() {
@@ -1948,7 +2068,8 @@
       m.pool = [];
       m.poolSize = 0;
       m.matched = false;
-      m.matchcap = Array(m.prog.numCap < 2 ? 2 : m.prog.numCap).fill(0);
+      // Use Int32Array instead of standard JS array
+      m.matchcap = new Int32Array(m.prog.numCap < 2 ? 2 : m.prog.numCap);
       m.ncap = 0;
       return m;
     }
@@ -1962,27 +2083,30 @@
       if (ncap > this.matchcap.length) {
         this.initNewCap(ncap);
       } else {
-        this.resetCap(ncap);
+        this.resetCap();
       }
     }
-    resetCap(ncap) {
+
+    // Wipes existing typed array memory without reallocating
+    resetCap() {
       for (let i = 0; i < this.poolSize; i++) {
         const t = this.pool[i];
-        t.cap = Array(ncap).fill(0);
+        t.cap.fill(0);
       }
     }
     initNewCap(ncap) {
       for (let i = 0; i < this.poolSize; i++) {
         const t = this.pool[i];
-        t.cap = Array(ncap).fill(0);
+        t.cap = new Int32Array(ncap);
       }
-      this.matchcap = Array(ncap).fill(0);
+      this.matchcap = new Int32Array(ncap);
     }
     submatches() {
       if (this.ncap === 0) {
         return Utils.emptyInts();
       }
-      return this.matchcap.slice(0, this.ncap);
+      // Use subarray() to create a zero-allocation view before converting
+      return Array.from(this.matchcap.subarray(0, this.ncap));
     }
 
     // alloc() allocates a new thread with the given instruction.
@@ -1994,6 +2118,7 @@
         t = this.pool[this.poolSize];
       } else {
         t = new Thread();
+        t.cap = new Int32Array(this.matchcap.length);
       }
       t.inst = inst;
       return t;
@@ -2023,7 +2148,7 @@
         return false;
       }
       this.matched = false;
-      this.matchcap = Array(this.prog.numCap).fill(-1);
+      this.matchcap.fill(-1);
       let runq = this.q0;
       let nextq = this.q1;
       let r = input.step(pos);
@@ -2094,6 +2219,85 @@
       this.freeQueue(nextq);
       return this.matched;
     }
+    matchSet(input, pos, anchor) {
+      const startCond = this.re2.cond;
+      if (startCond === Utils.EMPTY_ALL) return [];
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return [];
+      }
+      let runq = this.q0;
+      let nextq = this.q1;
+      let r = input.step(pos);
+      let rune = r >> 3;
+      let width = r & 7;
+      let rune1 = -1;
+      let width1 = 0;
+      if (r !== MachineInputBase.EOF()) {
+        r = input.step(pos + width);
+        rune1 = r >> 3;
+        width1 = r & 7;
+      }
+      let flag = pos === 0 ? Utils.emptyOpContext(-1, rune) : input.context(pos);
+      const matches = new Set();
+      while (true) {
+        if (runq.isEmpty()) {
+          if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) break;
+        }
+        if (pos === 0 || anchor === RE2Flags.UNANCHORED) {
+          this.add(runq, this.prog.start, pos, this.matchcap, flag, null);
+        }
+        const nextPos = pos + width;
+        flag = input.context(nextPos);
+        for (let j = 0; j < runq.size; j++) {
+          let t = runq.denseThreads[j];
+          if (t === null) continue;
+          const i = t.inst;
+          let add = false;
+          switch (i.op) {
+            case Inst.MATCH:
+              if (anchor === RE2Flags.ANCHOR_BOTH && pos !== input.endPos()) break;
+              matches.add(i.arg); // Record the matched Set ID
+              break;
+            case Inst.RUNE:
+              add = i.matchRune(rune);
+              break;
+            case Inst.RUNE1:
+              add = rune === i.runes[0];
+              break;
+            case Inst.RUNE_ANY:
+              add = true;
+              break;
+            case Inst.RUNE_ANY_NOT_NL:
+              add = rune !== Codepoint.CODES.get('\n');
+              break;
+            default:
+              throw new RE2JSInternalException('bad inst');
+          }
+          if (add) {
+            t = this.add(nextq, i.out, nextPos, t.cap, flag, t);
+          }
+          if (t !== null) {
+            this.freeThread(t);
+            runq.denseThreads[j] = null;
+          }
+        }
+        runq.clear();
+        if (width === 0) break;
+        pos += width;
+        rune = rune1;
+        width = width1;
+        if (rune !== -1) {
+          r = input.step(pos + width);
+          rune1 = r >> 3;
+          width1 = r & 7;
+        }
+        const tmpq = runq;
+        runq = nextq;
+        nextq = tmpq;
+      }
+      this.freeQueue(nextq);
+      return Array.from(matches).sort((a, b) => a - b);
+    }
     step(runq, nextq, pos, nextPos, c, nextCond, anchor, atEnd) {
       const longest = this.re2.longest;
       for (let j = 0; j < runq.size; j++) {
@@ -2114,7 +2318,9 @@
             }
             if (this.ncap > 0 && (!longest || !this.matched || this.matchcap[1] < pos)) {
               t.cap[1] = pos;
-              this.matchcap = t.cap.slice(0, this.ncap);
+              // Using subarray creates a fast view, avoiding a full array copy
+              // until the submatches are finalized at the very end.
+              this.matchcap.set(t.cap.subarray(0, this.ncap));
             }
             if (!longest) {
               this.freeQueue(runq, j + 1);
@@ -2134,7 +2340,7 @@
             add = c !== Codepoint.CODES.get('\n');
             break;
           default:
-            throw new Error('bad inst');
+            throw new RE2JSInternalException('bad inst');
         }
         if (add) {
           t = this.add(nextq, i.out, nextPos, t.cap, nextCond, t);
@@ -2192,6 +2398,7 @@
             t.inst = inst;
           }
           if (this.ncap > 0 && t.cap !== cap) {
+            // Direct assignment utilizing Typed Array performance
             for (let c = 0; c < this.ncap; c++) {
               t.cap[c] = cap[c];
             }
@@ -2226,20 +2433,23 @@
     return true;
   };
   class DFAState {
-    constructor(nfaStates, isMatch) {
+    constructor(nfaStates, isMatch, matchIDs = []) {
       this.nfaStates = nfaStates; // Int32Array of Instruction PCs
       this.isMatch = isMatch; // Boolean
+      this.matchIDs = matchIDs; // Array of integers indicating which Set patterns matched
       this.nextAscii = new Array(Unicode.MAX_ASCII + 1).fill(null); // Flat array for blisteringly fast ASCII lookups
       this.nextMap = new Map(); // Cache of Char -> DFAState
     }
   }
   class DFA {
+    static MAX_CACHE_CLEARS = 5;
     constructor(prog) {
       this.prog = prog;
       this.stateCache = new Map(); // hash(number) -> DFAState[]
       this.stateCount = 0; // Tracks total states for memory limits
       this.startState = null;
       this.stateLimit = 10000; // Prevent memory explosion (ReDoS protection)
+      this.cacheClears = 0; // Track thrashing
       this.failed = false; // mark if DFA cannot work with provided prog
     }
 
@@ -2248,6 +2458,7 @@
       const closure = new Set();
       const stack = [...pcs];
       let isMatch = false;
+      const matchIDs = [];
       while (stack.length > 0) {
         const pc = stack.pop();
         if (closure.has(pc)) continue;
@@ -2256,6 +2467,7 @@
         switch (inst.op) {
           case Inst.MATCH:
             isMatch = true;
+            if (!matchIDs.includes(inst.arg)) matchIDs.push(inst.arg);
             break;
           case Inst.ALT:
           case Inst.ALT_MATCH:
@@ -2273,9 +2485,11 @@
         }
       }
       const sortedPCs = Int32Array.from(closure).sort();
+      matchIDs.sort((a, b) => a - b);
       return {
         pcs: sortedPCs,
-        isMatch
+        isMatch,
+        matchIDs
       };
     }
 
@@ -2301,6 +2515,8 @@
         bucket = [];
         this.stateCache.set(hash, bucket);
       }
+
+      // DFA already failed once - exit
       if (this.failed) return null;
 
       // Safety: prevent memory exhaustion from state explosion
@@ -2309,12 +2525,18 @@
         this.stateCache.clear();
         this.stateCount = 0;
         this.startState = null;
-        this.failed = true;
+        this.cacheClears++;
+
+        // If this regex causes continuous cache thrashing, permanently fall back to NFA
+        // to avoid spending CPU cycles constantly rebuilding the DFA tree.
+        if (this.cacheClears >= DFA.MAX_CACHE_CLEARS) {
+          this.failed = true;
+        }
         return null;
       }
 
       // State not found, create it and add to bucket
-      const state = new DFAState(sortedPCs, closureResult.isMatch);
+      const state = new DFAState(sortedPCs, closureResult.isMatch, closureResult.matchIDs);
       bucket.push(state);
       this.stateCount++;
       return state;
@@ -2334,76 +2556,808 @@
           return state.nextMap.get(key);
         }
       }
-      const nextPCs = [];
-      for (let i = 0; i < state.nfaStates.length; i++) {
-        const pc = state.nfaStates[i];
-        const inst = this.prog.getInst(pc);
-        if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) {
-          nextPCs.push(inst.out);
+      const nextPCs = [];
+      for (let i = 0; i < state.nfaStates.length; i++) {
+        const pc = state.nfaStates[i];
+        const inst = this.prog.getInst(pc);
+        if (Inst.isRuneOp(inst.op) && inst.matchRune(charCode)) {
+          nextPCs.push(inst.out);
+        }
+      }
+      if (anchor === RE2Flags.UNANCHORED) {
+        nextPCs.push(this.prog.start);
+      }
+      const nextState = this.getState(nextPCs);
+
+      // Cache the result
+      if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) {
+        state.nextAscii[charCode] = nextState;
+      } else {
+        const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
+        state.nextMap.set(key, nextState);
+      }
+      return nextState;
+    }
+
+    // The hot loop: Execute the Lazy DFA
+    match(input, pos, anchor) {
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return false;
+      }
+      if (!this.startState) {
+        this.startState = this.getState([this.prog.start]);
+        if (!this.startState) return null; // Fallback to NFA
+      }
+      let endPos = input.endPos();
+      let currentState = this.startState;
+      if (currentState.isMatch) {
+        if (anchor === RE2Flags.ANCHOR_BOTH) {
+          if (pos === endPos) return true;
+        } else {
+          return true;
+        }
+      }
+      let i = pos;
+      while (i < endPos) {
+        const r = input.step(i);
+        const rune = r >> 3;
+        const width = r & 7;
+
+        // prevent infinite loop on EOF
+        if (width === 0) {
+          break;
+        }
+        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;
+        if (currentState.isMatch) {
+          if (anchor === RE2Flags.ANCHOR_BOTH) {
+            if (i + width === endPos) return true;
+          } else {
+            return true;
+          }
+        }
+
+        // If we hit a dead end, and anchored, fail early
+        if (currentState.nfaStates.length === 0) {
+          if (anchor !== RE2Flags.UNANCHORED) return false;
+        }
+        i += width;
+      }
+      return false;
+    }
+
+    // The hot loop for evaluating Multi-Pattern Sets
+    matchSet(input, pos, anchor) {
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return [];
+      }
+      if (!this.startState) {
+        this.startState = this.getState([this.prog.start]);
+        if (!this.startState) return null; // Fallback to NFA
+      }
+      let endPos = input.endPos();
+      let currentState = this.startState;
+      const matches = new Set();
+      const checkMatch = (state, currentPos) => {
+        if (state.isMatch) {
+          if (anchor === RE2Flags.ANCHOR_BOTH) {
+            if (currentPos === endPos) {
+              state.matchIDs.forEach(id => matches.add(id));
+            }
+          } else {
+            state.matchIDs.forEach(id => matches.add(id));
+          }
+        }
+      };
+      checkMatch(currentState, pos);
+      let i = pos;
+      while (i < endPos) {
+        const r = input.step(i);
+        const rune = r >> 3;
+        const width = r & 7;
+        if (width === 0) break;
+        currentState = anchor === RE2Flags.UNANCHORED && rune <= Unicode.MAX_ASCII && currentState.nextAscii[rune] || this.step(currentState, rune, anchor);
+        if (currentState === null) return null; // Bailout to NFA
+
+        i += width;
+        checkMatch(currentState, i);
+        if (currentState.nfaStates.length === 0) {
+          if (anchor !== RE2Flags.UNANCHORED) break;
+        }
+      }
+      return Array.from(matches).sort((a, b) => a - b);
+    }
+  }
+
+  const VISITED_BITS = 32;
+  const MAX_BACKTRACK_PROG = 500;
+  const INITIAL_JOB_CAPACITY = 256; // Starting size for the job stack arrays
+  const MAX_BACKTRACK_VECTOR = 256 * 1024; // 32 KB limit for the visited bit-mask
+
+  class BitState {
+    constructor() {
+      this.end = 0;
+      this.cap = new Int32Array(0);
+      this.matchcap = new Int32Array(0);
+      this.ncap = 0;
+
+      // Parallel arrays acting as the backtrack job stack
+      this.jobPc = new Int32Array(INITIAL_JOB_CAPACITY);
+      this.jobArg = new Uint8Array(INITIAL_JOB_CAPACITY);
+      this.jobPos = new Int32Array(INITIAL_JOB_CAPACITY);
+      this.jobLen = 0;
+      this.visited = new Uint32Array(0);
+    }
+    reset(prog, end, ncap) {
+      this.end = end;
+      this.jobLen = 0;
+      this.ncap = ncap;
+
+      // Bitwise shift (>>> 5) instead of Math.floor( / 32)
+      const visitedSize = prog.numInst() * (end + 1) + VISITED_BITS - 1 >>> 5;
+      if (this.visited.length < visitedSize) {
+        this.visited = new Uint32Array(Math.floor(MAX_BACKTRACK_VECTOR / VISITED_BITS));
+      } else {
+        this.visited.fill(0, 0, visitedSize);
+      }
+      if (this.cap.length < ncap) {
+        // Must explicitly fill with -1 as Int32Array defaults to 0
+        this.cap = new Int32Array(ncap).fill(-1);
+      } else {
+        this.cap.fill(-1, 0, ncap);
+      }
+      if (this.matchcap.length < ncap) {
+        this.matchcap = new Int32Array(ncap).fill(-1);
+      } else {
+        this.matchcap.fill(-1, 0, ncap);
+      }
+    }
+    shouldVisit(pc, pos) {
+      const n = pc * (this.end + 1) + pos;
+      const idx = n >>> 5; // Equivalent to Math.floor(n / 32)
+      const mask = 1 << (n & 31); // Equivalent to n % 32
+
+      if ((this.visited[idx] & mask) !== 0) {
+        return false;
+      }
+      this.visited[idx] |= mask;
+      return true;
+    }
+    push(re2, pc, pos, arg) {
+      if (re2.prog.getInst(pc).op !== Inst.FAIL && (arg || this.shouldVisit(pc, pos))) {
+        if (this.jobLen >= this.jobPc.length) {
+          const newSize = this.jobPc.length * 2;
+          const newPc = new Int32Array(newSize);
+          newPc.set(this.jobPc);
+          this.jobPc = newPc;
+          const newArg = new Uint8Array(newSize);
+          newArg.set(this.jobArg);
+          this.jobArg = newArg;
+          const newPos = new Int32Array(newSize);
+          newPos.set(this.jobPos);
+          this.jobPos = newPos;
+        }
+        this.jobPc[this.jobLen] = pc;
+        this.jobArg[this.jobLen] = arg ? 1 : 0;
+        this.jobPos[this.jobLen] = pos;
+        this.jobLen++;
+      }
+    }
+    tryBacktrack(re2, input, pc, pos, anchor) {
+      const longest = re2.longest;
+      this.push(re2, pc, pos, false);
+      while (this.jobLen > 0) {
+        this.jobLen--;
+        let currentPc = this.jobPc[this.jobLen];
+        let arg = this.jobArg[this.jobLen] === 1;
+        let currentPos = this.jobPos[this.jobLen];
+        let skipShouldVisit = true;
+        while (true) {
+          if (!skipShouldVisit) {
+            if (!this.shouldVisit(currentPc, currentPos)) {
+              break;
+            }
+          }
+          skipShouldVisit = false;
+          const inst = re2.prog.getInst(currentPc);
+          switch (inst.op) {
+            case Inst.FAIL:
+              {
+                throw new RE2JSInternalException('unexpected InstFail');
+              }
+            case Inst.ALT:
+              {
+                if (arg) {
+                  arg = false;
+                  currentPc = inst.arg;
+                  continue;
+                } else {
+                  this.push(re2, currentPc, currentPos, true);
+                  currentPc = inst.out;
+                  continue;
+                }
+              }
+            case Inst.ALT_MATCH:
+              {
+                const outInst = re2.prog.getInst(inst.out);
+                if (Inst.isRuneOp(outInst.op)) {
+                  this.push(re2, inst.arg, currentPos, false);
+                  currentPc = inst.out;
+                  continue;
+                }
+                this.push(re2, inst.out, this.end, false);
+                currentPc = inst.arg;
+                continue;
+              }
+            case Inst.RUNE:
+              {
+                const r = input.step(currentPos);
+                if (r === MachineInputBase.EOF()) break;
+                if (!inst.matchRune(r >> 3)) break;
+                currentPos += r & 7;
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.RUNE1:
+              {
+                const r = input.step(currentPos);
+                if (r === MachineInputBase.EOF()) break;
+                if (r >> 3 !== inst.runes[0]) break;
+                currentPos += r & 7;
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.RUNE_ANY_NOT_NL:
+              {
+                const r = input.step(currentPos);
+                if (r === MachineInputBase.EOF()) break;
+                if (r >> 3 === 10) break;
+                currentPos += r & 7;
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.RUNE_ANY:
+              {
+                const r = input.step(currentPos);
+                if (r === MachineInputBase.EOF()) break;
+                currentPos += r & 7;
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.CAPTURE:
+              {
+                if (arg) {
+                  this.cap[inst.arg] = currentPos;
+                  break;
+                } else {
+                  if (inst.arg < this.ncap) {
+                    this.push(re2, currentPc, this.cap[inst.arg], true);
+                    this.cap[inst.arg] = currentPos;
+                  }
+                  currentPc = inst.out;
+                  continue;
+                }
+              }
+            case Inst.EMPTY_WIDTH:
+              {
+                const flag = input.context(currentPos);
+                if ((inst.arg & ~flag) !== 0) break;
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.NOP:
+              {
+                currentPc = inst.out;
+                continue;
+              }
+            case Inst.MATCH:
+              {
+                if (anchor === RE2Flags.ANCHOR_BOTH && currentPos !== this.end) {
+                  break;
+                }
+                if (this.ncap === 0) return true;
+                if (this.ncap > 1) {
+                  this.cap[1] = currentPos;
+                }
+                const old = this.matchcap[1];
+                if (old === -1 || longest && currentPos > 0 && currentPos > old) {
+                  this.matchcap.set(this.cap);
+                }
+                if (!longest) return true;
+                if (currentPos === this.end) return true;
+                break;
+              }
+            default:
+              {
+                throw new RE2JSInternalException('bad inst');
+              }
+          }
+          break;
+        }
+      }
+      return longest && this.matchcap.length > 1 && this.matchcap[1] >= 0;
+    }
+  }
+  const bitStatePool = [];
+  class Backtracker {
+    static shouldBacktrack(prog) {
+      return prog.numInst() <= MAX_BACKTRACK_PROG;
+    }
+    static maxBitStateLen(prog) {
+      if (!Backtracker.shouldBacktrack(prog)) {
+        return 0;
+      }
+      return Math.floor(MAX_BACKTRACK_VECTOR / prog.numInst());
+    }
+    static execute(re2, input, pos, anchor, ncap) {
+      const startCond = re2.cond;
+      if (startCond === Utils.EMPTY_ALL) {
+        return null;
+      }
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return null;
+      }
+      if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 && pos !== 0) {
+        return null;
+      }
+      const b = bitStatePool.length > 0 ? bitStatePool.pop() : new BitState();
+      const end = input.endPos();
+      b.reset(re2.prog, end, ncap);
+      let matched = false;
+      if ((startCond & Utils.EMPTY_BEGIN_TEXT) !== 0 || anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) {
+        if (b.ncap > 0) {
+          b.cap[0] = pos;
+        }
+        if (b.tryBacktrack(re2, input, re2.prog.start, pos, anchor)) {
+          matched = true;
+        }
+      } else {
+        let width = -1;
+        for (; pos <= end && width !== 0; pos += width) {
+          if (re2.prefix.length > 0) {
+            const advance = input.index(re2, pos);
+            if (advance < 0) {
+              break;
+            }
+            pos += advance;
+          }
+          if (b.ncap > 0) {
+            b.cap[0] = pos;
+          }
+          if (b.tryBacktrack(re2, input, re2.prog.start, pos, anchor)) {
+            matched = true;
+            break;
+          }
+          const r = input.step(pos);
+          width = r === MachineInputBase.EOF() ? 0 : r & 7;
+        }
+      }
+      if (!matched) {
+        bitStatePool.push(b);
+        return null;
+      }
+
+      // Must slice so we don't accidentally leak trailing arrays from previously recycled typed arrays
+      const result = ncap === 0 ? [] : Array.from(b.matchcap.subarray(0, ncap));
+      bitStatePool.push(b);
+      return result;
+    }
+  }
+
+  class QueueOnePass {
+    constructor(size) {
+      this.sparse = new Uint32Array(size);
+      this.dense = new Uint32Array(size);
+      this.size = 0;
+      this.nextIndex = 0;
+    }
+    empty() {
+      return this.nextIndex >= this.size;
+    }
+    next() {
+      return this.dense[this.nextIndex++];
+    }
+    clear() {
+      this.size = 0;
+      this.nextIndex = 0;
+    }
+    contains(u) {
+      return u < this.sparse.length && this.sparse[u] < this.size && this.dense[this.sparse[u]] === u;
+    }
+    insert(u) {
+      if (!this.contains(u)) this.insertNew(u);
+    }
+    insertNew(u) {
+      if (u >= this.sparse.length) return;
+      this.sparse[u] = this.size;
+      this.dense[this.size] = u;
+      this.size++;
+    }
+  }
+  const mergeRuneSets = (leftRunes, rightRunes, leftPC, rightPC) => {
+    const leftLen = leftRunes.length;
+    const rightLen = rightRunes.length;
+    let lx = 0,
+      rx = 0;
+    const merged = [];
+    const next = [];
+    let ok = true;
+    let ix = -1;
+    const extend = isLeft => {
+      const newArray = isLeft ? leftRunes : rightRunes;
+      const low = isLeft ? lx : rx;
+      const pc = isLeft ? leftPC : rightPC;
+      if (ix > 0 && newArray[low] <= merged[ix]) return false;
+      merged.push(newArray[low], newArray[low + 1]);
+      if (isLeft) lx += 2;else rx += 2;
+      ix += 2;
+      next.push(pc);
+      return true;
+    };
+    while (lx < leftLen || rx < rightLen) {
+      if (rx >= rightLen) {
+        ok = extend(true);
+      } else if (lx >= leftLen) {
+        ok = extend(false);
+      } else if (rightRunes[rx] < leftRunes[lx]) {
+        ok = extend(false);
+      } else {
+        ok = extend(true);
+      }
+      if (!ok) return null;
+    }
+    return {
+      merged,
+      next
+    };
+  };
+  class OnePassProg {
+    constructor(prog) {
+      this.start = prog.start;
+      this.numCap = prog.numCap;
+      this.inst = new Array(prog.inst.length);
+      for (let i = 0; i < prog.inst.length; i++) {
+        const orig = prog.inst[i];
+        const inst = new Inst(orig.op);
+        inst.out = orig.out;
+        inst.arg = orig.arg;
+        inst.runes = orig.runes ? orig.runes.slice() : [];
+        inst.next = null;
+        this.inst[i] = inst;
+      }
+    }
+  }
+  const onePassCopy = prog => {
+    const p = new OnePassProg(prog);
+
+    // Rewrites one or more common Prog constructs that enable some otherwise
+    // non-onepass Progs to be onepass.
+    for (let pc = 0; pc < p.inst.length; pc++) {
+      const inst = p.inst[pc];
+      if (inst.op !== Inst.ALT && inst.op !== Inst.ALT_MATCH) continue;
+      let pAOther = 'out';
+      let pAAlt = 'arg';
+      let instAlt = p.inst[inst[pAAlt]];
+      if (instAlt.op !== Inst.ALT && instAlt.op !== Inst.ALT_MATCH) {
+        pAOther = 'arg';
+        pAAlt = 'out';
+        instAlt = p.inst[inst[pAAlt]];
+        if (instAlt.op !== Inst.ALT && instAlt.op !== Inst.ALT_MATCH) continue;
+      }
+      const instOther = p.inst[inst[pAOther]];
+      if (instOther.op === Inst.ALT || instOther.op === Inst.ALT_MATCH) continue;
+      let pBAlt = 'out';
+      let pBOther = 'arg';
+      let patch = false;
+      if (instAlt.out === pc) {
+        patch = true;
+      } else if (instAlt.arg === pc) {
+        patch = true;
+        pBAlt = 'arg';
+        pBOther = 'out';
+      }
+      if (patch) instAlt[pBAlt] = inst[pAOther];
+      if (inst[pAOther] === instAlt[pBAlt]) inst[pAAlt] = instAlt[pBOther];
+    }
+    return p;
+  };
+  const makeOnePass = p => {
+    if (p.inst.length >= 1000) return null;
+    const instQueue = new QueueOnePass(p.inst.length);
+    const visitQueue = new QueueOnePass(p.inst.length);
+    const onePassRunes = new Array(p.inst.length);
+    const m = new Array(p.inst.length).fill(false);
+    const check = pc => {
+      let ok = true;
+      const inst = p.inst[pc];
+      if (visitQueue.contains(pc)) return true;
+      visitQueue.insert(pc);
+      switch (inst.op) {
+        case Inst.ALT:
+        case Inst.ALT_MATCH:
+          {
+            ok = check(inst.out) && check(inst.arg);
+            let matchOut = m[inst.out];
+            let matchArg = m[inst.arg];
+            if (matchOut && matchArg) return false;
+            if (matchArg) {
+              const tempOut = inst.out;
+              inst.out = inst.arg;
+              inst.arg = tempOut;
+              const tempMatch = matchOut;
+              matchOut = matchArg;
+              matchArg = tempMatch;
+            }
+            if (matchOut) {
+              m[pc] = true;
+              inst.op = Inst.ALT_MATCH;
+            }
+            const leftRunes = onePassRunes[inst.out] || [];
+            const rightRunes = onePassRunes[inst.arg] || [];
+            const mergeRes = mergeRuneSets(leftRunes, rightRunes, inst.out, inst.arg);
+            if (!mergeRes) return false;
+            onePassRunes[pc] = mergeRes.merged;
+            inst.next = new Uint32Array(mergeRes.next);
+            break;
+          }
+        case Inst.CAPTURE:
+        case Inst.EMPTY_WIDTH:
+        case Inst.NOP:
+          {
+            ok = check(inst.out);
+            m[pc] = m[inst.out];
+            onePassRunes[pc] = onePassRunes[inst.out] ? onePassRunes[inst.out].slice() : [];
+            inst.next = new Uint32Array(Math.floor(onePassRunes[pc].length / 2) + 1).fill(inst.out);
+            break;
+          }
+        case Inst.MATCH:
+        case Inst.FAIL:
+          {
+            m[pc] = inst.op === Inst.MATCH;
+            break;
+          }
+        case Inst.RUNE:
+          {
+            m[pc] = false;
+            if (inst.next && inst.next.length > 0) break;
+            instQueue.insert(inst.out);
+            if (!inst.runes || inst.runes.length === 0) {
+              onePassRunes[pc] = [];
+              inst.next = new Uint32Array([inst.out]);
+              break;
+            }
+            let runes = [];
+            if (inst.runes.length === 1 && (inst.arg & RE2Flags.FOLD_CASE) !== 0) {
+              const r0 = inst.runes[0];
+              runes.push(r0, r0);
+              for (let r1 = Unicode.simpleFold(r0); r1 !== r0; r1 = Unicode.simpleFold(r1)) {
+                runes.push(r1, r1);
+              }
+              runes.sort((a, b) => a - b);
+            } else {
+              runes.push(...inst.runes);
+            }
+            onePassRunes[pc] = runes;
+            inst.next = new Uint32Array(Math.floor(runes.length / 2) + 1).fill(inst.out);
+            inst.op = Inst.RUNE;
+            break;
+          }
+        case Inst.RUNE1:
+          {
+            m[pc] = false;
+            if (inst.next && inst.next.length > 0) break;
+            instQueue.insert(inst.out);
+            let runes = [];
+            if ((inst.arg & RE2Flags.FOLD_CASE) !== 0) {
+              const r0 = inst.runes[0];
+              runes.push(r0, r0);
+              for (let r1 = Unicode.simpleFold(r0); r1 !== r0; r1 = Unicode.simpleFold(r1)) {
+                runes.push(r1, r1);
+              }
+              runes.sort((a, b) => a - b);
+            } else {
+              runes.push(inst.runes[0], inst.runes[0]);
+            }
+            onePassRunes[pc] = runes;
+            inst.next = new Uint32Array(Math.floor(runes.length / 2) + 1).fill(inst.out);
+            inst.op = Inst.RUNE;
+            break;
+          }
+        case Inst.RUNE_ANY:
+          {
+            m[pc] = false;
+            if (inst.next && inst.next.length > 0) break;
+            instQueue.insert(inst.out);
+            onePassRunes[pc] = [0, Unicode.MAX_RUNE];
+            inst.next = new Uint32Array([inst.out]);
+            break;
+          }
+        case Inst.RUNE_ANY_NOT_NL:
+          {
+            m[pc] = false;
+            if (inst.next && inst.next.length > 0) break;
+            instQueue.insert(inst.out);
+            onePassRunes[pc] = [0, 9, 11, Unicode.MAX_RUNE]; // \n is 10
+            inst.next = new Uint32Array(Math.floor(onePassRunes[pc].length / 2) + 1).fill(inst.out);
+            break;
+          }
+      }
+      return ok;
+    };
+    instQueue.clear();
+    instQueue.insert(p.start);
+    while (!instQueue.empty()) {
+      visitQueue.clear();
+      const pc = instQueue.next();
+      if (!check(pc)) return null;
+    }
+    for (let i = 0; i < p.inst.length; i++) {
+      if (onePassRunes[i]) p.inst[i].runes = onePassRunes[i];
+    }
+    return p;
+  };
+  const cleanupOnePass = (p, original) => {
+    for (let ix = 0; ix < original.inst.length; ix++) {
+      const instOriginal = original.inst[ix];
+      switch (instOriginal.op) {
+        case Inst.ALT:
+        case Inst.ALT_MATCH:
+        case Inst.RUNE:
+          break;
+        case Inst.CAPTURE:
+        case Inst.EMPTY_WIDTH:
+        case Inst.NOP:
+        case Inst.MATCH:
+        case Inst.FAIL:
+          p.inst[ix].next = null;
+          break;
+        case Inst.RUNE1:
+        case Inst.RUNE_ANY:
+        case Inst.RUNE_ANY_NOT_NL:
+          p.inst[ix].next = null;
+          p.inst[ix].op = instOriginal.op;
+          p.inst[ix].runes = instOriginal.runes ? instOriginal.runes.slice() : [];
+          break;
+      }
+    }
+  };
+  class OnePass {
+    static compile(prog) {
+      if (prog.start === 0) return null;
+      const startInst = prog.inst[prog.start];
+      // onepass regexps must be strictly anchored
+      if (startInst.op !== Inst.EMPTY_WIDTH || (startInst.arg & Utils.EMPTY_BEGIN_TEXT) === 0) {
+        return null;
+      }
+      let hasAlt = false;
+      for (let i = 0; i < prog.inst.length; i++) {
+        if (prog.inst[i].op === Inst.ALT || prog.inst[i].op === Inst.ALT_MATCH) {
+          hasAlt = true;
+          break;
         }
       }
-      if (anchor === RE2Flags.UNANCHORED) {
-        nextPCs.push(this.prog.start);
+      for (let i = 0; i < prog.inst.length; i++) {
+        const inst = prog.inst[i];
+        const opOut = prog.inst[inst.out].op;
+        switch (inst.op) {
+          case Inst.ALT:
+          case Inst.ALT_MATCH:
+            if (opOut === Inst.MATCH || prog.inst[inst.arg].op === Inst.MATCH) {
+              return null;
+            }
+            break;
+          case Inst.EMPTY_WIDTH:
+            if (opOut === Inst.MATCH) {
+              if ((inst.arg & Utils.EMPTY_END_TEXT) === Utils.EMPTY_END_TEXT) {
+                continue;
+              }
+              return null;
+            }
+            break;
+          default:
+            if (opOut === Inst.MATCH && hasAlt) {
+              return null;
+            }
+            break;
+        }
       }
-      const nextState = this.getState(nextPCs);
-
-      // Cache the result
-      if (anchor === RE2Flags.UNANCHORED && charCode <= Unicode.MAX_ASCII) {
-        state.nextAscii[charCode] = nextState;
-      } else {
-        const key = charCode + (anchor === RE2Flags.UNANCHORED ? 0 : Unicode.MAX_RUNE + 1);
-        state.nextMap.set(key, nextState);
+      let p = onePassCopy(prog);
+      p = makeOnePass(p);
+      if (p !== null) {
+        cleanupOnePass(p, prog);
       }
-      return nextState;
+      return p;
     }
-
-    // The hot loop: Execute the Lazy DFA
-    match(input, pos, anchor) {
-      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
-        return false;
-      }
-      if (!this.startState) {
-        this.startState = this.getState([this.prog.start]);
-        if (!this.startState) return null; // Fallback to NFA
-      }
-      let endPos = input.endPos();
-      let currentState = this.startState;
-      if (currentState.isMatch) {
-        if (anchor === RE2Flags.ANCHOR_BOTH) {
-          if (pos === endPos) return true;
-        } else {
-          return true;
+    static next(inst, r) {
+      const nextIdx = inst.matchRunePos(r);
+      if (nextIdx >= 0) return inst.next[nextIdx];
+      if (inst.op === Inst.ALT_MATCH) return inst.out;
+      return 0; // fail
+    }
+    static execute(re2, input, pos, anchor, ncap) {
+      const onepass = re2.onepass;
+      if (!onepass) return null;
+      const matchcap = new Int32Array(ncap).fill(-1);
+      let matched = false;
+      let r = input.step(pos);
+      let rune = r >> 3;
+      let width = r & 7;
+      let r1 = MachineInputBase.EOF();
+      let rune1 = -1;
+      let width1 = 0;
+      if (r !== MachineInputBase.EOF()) {
+        r1 = input.step(pos + width);
+        if (r1 !== MachineInputBase.EOF()) {
+          rune1 = r1 >> 3;
+          width1 = r1 & 7;
         }
       }
-      let i = pos;
-      while (i < endPos) {
-        const r = input.step(i);
-        const rune = r >> 3;
-        const width = r & 7;
-
-        // prevent infinite loop on EOF
-        if (width === 0) {
-          break;
+      let flag = pos === 0 ? Utils.emptyOpContext(-1, rune) : input.context(pos);
+      let pc = onepass.start;
+      let inst;
+      while (true) {
+        inst = onepass.inst[pc];
+        pc = inst.out;
+        switch (inst.op) {
+          case Inst.MATCH:
+            {
+              matched = true;
+              if (matchcap.length > 0) {
+                matchcap[0] = 0;
+                matchcap[1] = pos;
+              }
+              return ncap === 0 ? [] : Array.from(matchcap);
+            }
+          case Inst.RUNE:
+            if (!inst.matchRune(rune)) return null;
+            break;
+          case Inst.RUNE1:
+            if (rune !== inst.runes[0]) return null;
+            break;
+          case Inst.RUNE_ANY:
+            break;
+          case Inst.RUNE_ANY_NOT_NL:
+            if (rune === 10) return null;
+            break;
+          case Inst.ALT:
+          case Inst.ALT_MATCH:
+            pc = OnePass.next(inst, rune);
+            continue;
+          case Inst.FAIL:
+            return null;
+          case Inst.NOP:
+            continue;
+          case Inst.EMPTY_WIDTH:
+            if ((inst.arg & ~flag) !== 0) return null;
+            continue;
+          case Inst.CAPTURE:
+            if (inst.arg < matchcap.length) {
+              matchcap[inst.arg] = pos;
+            }
+            continue;
+          default:
+            throw new RE2JSInternalException('bad inst');
         }
-        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;
-        if (currentState.isMatch) {
-          if (anchor === RE2Flags.ANCHOR_BOTH) {
-            if (i + width === endPos) return true;
+        if (width === 0) break;
+        flag = Utils.emptyOpContext(rune, rune1);
+        pos += width;
+        rune = rune1;
+        width = width1;
+        if (rune !== -1) {
+          r1 = input.step(pos + width);
+          if (r1 !== MachineInputBase.EOF()) {
+            rune1 = r1 >> 3;
+            width1 = r1 & 7;
           } else {
-            return true;
+            rune1 = -1;
+            width1 = 0;
           }
         }
-
-        // If we hit a dead end, and anchored, fail early
-        if (currentState.nfaStates.length === 0) {
-          if (anchor !== RE2Flags.UNANCHORED) return false;
-        }
-        i += width;
       }
-      return false;
+      if (!matched) return null;
+      return ncap === 0 ? [] : Array.from(matchcap);
     }
   }
 
@@ -2488,7 +3442,7 @@
       this.max = 0; // max for REPEAT
       this.cap = 0; // capturing index, for CAPTURE
       this.name = null; // capturing name, for CAPTURE
-      this.namedGroups = {}; // map of group name -> capturing index
+      this.namedGroups = Object.create(null); // map of group name -> capturing index
     }
     reinit() {
       this.flags = 0;
@@ -2498,7 +3452,7 @@
       this.min = 0;
       this.max = 0;
       this.name = null;
-      this.namedGroups = {};
+      this.namedGroups = Object.create(null);
     }
     toString() {
       return this.appendTo();
@@ -2758,6 +3712,188 @@
     }
   }
 
+  class Prefilter {
+    static Type = {
+      NONE: 0,
+      EXACT: 1,
+      AND: 2,
+      OR: 3
+    };
+    constructor(type) {
+      this.type = type;
+      this.subs = [];
+      this.str = '';
+      this.bytes = null;
+    }
+    eval(input, pos) {
+      switch (this.type) {
+        case Prefilter.Type.NONE:
+          return true;
+        case Prefilter.Type.EXACT:
+          return input.hasString(this, pos);
+        case Prefilter.Type.AND:
+          for (let i = 0; i < this.subs.length; i++) {
+            if (!this.subs[i].eval(input, pos)) return false;
+          }
+          return true;
+        case Prefilter.Type.OR:
+          for (let i = 0; i < this.subs.length; i++) {
+            if (this.subs[i].eval(input, pos)) return true;
+          }
+          return false;
+        default:
+          return true;
+      }
+    }
+  }
+  class PrefilterTree {
+    static build(re) {
+      const pf = PrefilterTree.fromRegexp(re);
+      return PrefilterTree.simplify(pf);
+    }
+    static fromRegexp(re) {
+      if (!re) return new Prefilter(Prefilter.Type.NONE);
+      switch (re.op) {
+        case Regexp.Op.NO_MATCH:
+        case Regexp.Op.EMPTY_MATCH:
+        case Regexp.Op.BEGIN_LINE:
+        case Regexp.Op.END_LINE:
+        case Regexp.Op.BEGIN_TEXT:
+        case Regexp.Op.END_TEXT:
+        case Regexp.Op.WORD_BOUNDARY:
+        case Regexp.Op.NO_WORD_BOUNDARY:
+        case Regexp.Op.CHAR_CLASS:
+        case Regexp.Op.ANY_CHAR_NOT_NL:
+        case Regexp.Op.ANY_CHAR:
+          {
+            return new Prefilter(Prefilter.Type.NONE);
+          }
+        case Regexp.Op.LITERAL:
+          {
+            if (re.runes.length === 0 || (re.flags & RE2Flags.FOLD_CASE) !== 0) {
+              // Skip case-folded literals for simplicity
+              return new Prefilter(Prefilter.Type.NONE);
+            }
+            const pf = new Prefilter(Prefilter.Type.EXACT);
+            let str = '';
+            for (let i = 0; i < re.runes.length; i++) {
+              str += String.fromCodePoint(re.runes[i]);
+            }
+            pf.str = str;
+            pf.bytes = Utils.stringToUtf8ByteArray(pf.str);
+            return pf;
+          }
+        case Regexp.Op.CAPTURE:
+        case Regexp.Op.PLUS:
+          {
+            return PrefilterTree.fromRegexp(re.subs[0]);
+          }
+        case Regexp.Op.REPEAT:
+          {
+            if (re.min >= 1) {
+              return PrefilterTree.fromRegexp(re.subs[0]);
+            }
+            return new Prefilter(Prefilter.Type.NONE);
+          }
+        case Regexp.Op.CONCAT:
+          {
+            const pf = new Prefilter(Prefilter.Type.AND);
+            for (const sub of re.subs) {
+              pf.subs.push(PrefilterTree.fromRegexp(sub));
+            }
+            return pf;
+          }
+        case Regexp.Op.ALTERNATE:
+          {
+            const pf = new Prefilter(Prefilter.Type.OR);
+            for (const sub of re.subs) {
+              pf.subs.push(PrefilterTree.fromRegexp(sub));
+            }
+            return pf;
+          }
+        default:
+          return new Prefilter(Prefilter.Type.NONE);
+      }
+    }
+    static simplify(pf) {
+      if (pf.type === Prefilter.Type.EXACT || pf.type === Prefilter.Type.NONE) {
+        return pf;
+      }
+      if (pf.type === Prefilter.Type.AND) {
+        const newSubs = [];
+        for (const sub of pf.subs) {
+          const s = PrefilterTree.simplify(sub);
+          if (s.type !== Prefilter.Type.NONE) {
+            if (s.type === Prefilter.Type.AND) {
+              newSubs.push(...s.subs);
+            } else {
+              newSubs.push(s);
+            }
+          }
+        }
+        if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE);
+        if (newSubs.length === 1) return newSubs[0];
+        pf.subs = newSubs;
+        return pf;
+      }
+      if (pf.type === Prefilter.Type.OR) {
+        const newSubs = [];
+        for (const sub of pf.subs) {
+          const s = PrefilterTree.simplify(sub);
+          if (s.type === Prefilter.Type.NONE) {
+            // If any branch of an OR has no requirements, the whole OR has no requirements
+            return new Prefilter(Prefilter.Type.NONE);
+          }
+          if (s.type === Prefilter.Type.OR) {
+            newSubs.push(...s.subs);
+          } else {
+            newSubs.push(s);
+          }
+        }
+        if (newSubs.length === 0) return new Prefilter(Prefilter.Type.NONE);
+        if (newSubs.length === 1) return newSubs[0];
+
+        // De-duplicate EXACT branches
+        const seen = new Set();
+        const uniqueSubs = [];
+        for (const sub of newSubs) {
+          if (sub.type === Prefilter.Type.EXACT) {
+            if (!seen.has(sub.str)) {
+              seen.add(sub.str);
+              uniqueSubs.push(sub);
+            }
+          } else {
+            uniqueSubs.push(sub);
+          }
+        }
+        pf.subs = uniqueSubs;
+        return pf;
+      }
+      return pf;
+    }
+  }
+
+  /**
+   * A list of instruction pointers waiting to be patched.
+   * Tracks both `head` and `tail` to allow O(1) appending during compilation.
+   * * Values are encoded integers, not standard memory pointers:
+   * - Program instruction index: `l >> 1`
+   * - Patch `.out` field if: `(l & 1) === 0`
+   * - Patch `.arg` field if: `(l & 1) === 1`
+   * - `0` denotes an empty list.
+   * * @see https://swtch.com/~rsc/regexp/regexp1.html
+   */
+  class PatchList {
+    /**
+     * @param {number} head - Encoded pointer to the start of the patch list.
+     * @param {number} tail - Encoded pointer to the end of the patch list.
+     */
+    constructor(head = 0, tail = 0) {
+      this.head = head;
+      this.tail = tail;
+    }
+  }
+
   /**
    * A Prog is a compiled regular expression program.
    */
@@ -2859,39 +3995,30 @@
       return i.arg;
     }
     patch(l, val) {
-      while (l !== 0) {
-        const i = this.inst[l >> 1];
-        if ((l & 1) === 0) {
-          l = i.out;
+      let head = l.head;
+      while (head !== 0) {
+        const i = this.inst[head >> 1];
+        if ((head & 1) === 0) {
+          head = i.out;
           i.out = val;
         } else {
-          l = i.arg;
+          head = i.arg;
           i.arg = val;
         }
       }
     }
     append(l1, l2) {
-      if (l1 === 0) {
-        return l2;
-      }
-      if (l2 === 0) {
-        return l1;
-      }
-      let last = l1;
-      for (;;) {
-        const next = this.next(last);
-        if (next === 0) {
-          break;
-        }
-        last = next;
-      }
-      const i = this.inst[last >> 1];
-      if ((last & 1) === 0) {
-        i.out = l2;
+      if (l1.head === 0) return l2;
+      if (l2.head === 0) return l1;
+
+      // We know exactly where the tail is
+      const i = this.inst[l1.tail >> 1];
+      if ((l1.tail & 1) === 0) {
+        i.out = l2.head;
       } else {
-        i.arg = l2;
+        i.arg = l2.head;
       }
-      return l1;
+      return new PatchList(l1.head, l2.tail);
     }
     /**
      *
@@ -2920,7 +4047,7 @@
    * @class
    */
   class Frag {
-    constructor(i = 0, out = 0, nullable = false) {
+    constructor(i = 0, out = new PatchList(), 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
@@ -2945,6 +4072,33 @@
       c.prog.start = f.i;
       return c.prog;
     }
+    static compileSet(regexps) {
+      const c = new Compiler();
+      if (regexps.length === 0) {
+        c.prog.start = c.newInst(Inst.FAIL).i;
+        return c.prog;
+      }
+      let starts = [];
+      for (let i = 0; i < regexps.length; i++) {
+        const f = c.compile(regexps[i]);
+        const m = c.newInst(Inst.MATCH);
+        c.prog.getInst(m.i).arg = i; // Store the regex index
+        c.prog.patch(f.out, m.i);
+        starts.push(f.i);
+      }
+
+      // Link starts together via ALT
+      let start = starts[0];
+      for (let i = 1; i < starts.length; i++) {
+        const f = c.newInst(Inst.ALT);
+        const inst = c.prog.getInst(f.i);
+        inst.out = start;
+        inst.arg = starts[i];
+        start = f.i;
+      }
+      c.prog.start = start;
+      return c.prog;
+    }
     constructor() {
       this.prog = new Prog();
       this.newInst(Inst.FAIL);
@@ -2957,7 +4111,7 @@
     // Returns a no-op fragment.  Sometimes unavoidable.
     nop() {
       const f = this.newInst(Inst.NOP);
-      f.out = f.i << 1;
+      f.out = new PatchList(f.i << 1, f.i << 1);
       return f;
     }
     fail() {
@@ -2968,7 +4122,7 @@
     // Given a fragment a, returns a fragment with capturing parens around a.
     cap(arg) {
       const f = this.newInst(Inst.CAPTURE);
-      f.out = f.i << 1;
+      f.out = new PatchList(f.i << 1, f.i << 1);
       this.prog.getInst(f.i).arg = arg;
       if (this.prog.numCap < arg + 1) {
         this.prog.numCap = arg + 1;
@@ -3016,10 +4170,10 @@
       const i = this.prog.getInst(f.i);
       if (nongreedy) {
         i.arg = f1.i;
-        f.out = f.i << 1;
+        f.out = new PatchList(f.i << 1, f.i << 1);
       } else {
         i.out = f1.i;
-        f.out = f.i << 1 | 1;
+        f.out = new PatchList(f.i << 1 | 1, f.i << 1 | 1);
       }
       this.prog.patch(f1.out, f.i);
       return f;
@@ -3031,10 +4185,10 @@
       const i = this.prog.getInst(f.i);
       if (nongreedy) {
         i.arg = f1.i;
-        f.out = f.i << 1;
+        f.out = new PatchList(f.i << 1, f.i << 1);
       } else {
         i.out = f1.i;
-        f.out = f.i << 1 | 1;
+        f.out = new PatchList(f.i << 1 | 1, f.i << 1 | 1);
       }
       f.out = this.prog.append(f.out, f1.out);
       return f;
@@ -3057,7 +4211,7 @@
     empty(op) {
       const f = this.newInst(Inst.EMPTY_WIDTH);
       this.prog.getInst(f.i).arg = op;
-      f.out = f.i << 1;
+      f.out = new PatchList(f.i << 1, f.i << 1);
       return f;
     }
 
@@ -3072,7 +4226,7 @@
         flags &= -2;
       }
       i.arg = flags;
-      f.out = f.i << 1;
+      f.out = new PatchList(f.i << 1, f.i << 1);
       if ((flags & RE2Flags.FOLD_CASE) === 0 && runes.length === 1 || runes.length === 2 && runes[0] === runes[1]) {
         i.op = Inst.RUNE1;
       } else if (runes.length === 2 && runes[0] === 0 && runes[1] === Unicode.MAX_RUNE) {
@@ -3177,23 +4331,92 @@
       }
       switch (re.op) {
         case Regexp.Op.CAPTURE:
+          {
+            const sub = Simplify.simplify(re.subs[0]);
+            if (sub !== re.subs[0]) {
+              const nre = Regexp.fromRegexp(re);
+              nre.runes = [];
+              nre.subs = [sub];
+              return nre;
+            }
+            return re;
+          }
         case Regexp.Op.CONCAT:
         case Regexp.Op.ALTERNATE:
           {
-            let nre = re;
+            const newSubs = [];
+            let changed = false;
             for (let i = 0; i < re.subs.length; i++) {
               const sub = re.subs[i];
               const nsub = Simplify.simplify(sub);
-              if (nre === re && nsub !== sub) {
-                nre = Regexp.fromRegexp(re);
-                nre.runes = [];
-                nre.subs = re.subs.slice(0, re.subs.length);
+              if (nsub !== sub) {
+                changed = true;
+              }
+              if (re.op === Regexp.Op.CONCAT) {
+                // If any part of a CONCAT is mathematically impossible,
+                // the entire CONCAT sequence becomes impossible.
+                if (nsub.op === Regexp.Op.NO_MATCH) {
+                  return new Regexp(Regexp.Op.NO_MATCH);
+                }
+                // Drop empty 0-width match nodes entirely from sequences
+                if (nsub.op === Regexp.Op.EMPTY_MATCH) {
+                  changed = true;
+                  continue;
+                }
+                // Flatten nested concatenations
+                if (nsub.op === Regexp.Op.CONCAT) {
+                  changed = true;
+                  newSubs.push(...nsub.subs);
+                  continue;
+                }
+              } else if (re.op === Regexp.Op.ALTERNATE) {
+                // Drop impossible branches from alternations
+                if (nsub.op === Regexp.Op.NO_MATCH) {
+                  changed = true;
+                  continue;
+                }
+                // Flatten nested alternations
+                if (nsub.op === Regexp.Op.ALTERNATE) {
+                  changed = true;
+                  newSubs.push(...nsub.subs);
+                  continue;
+                }
               }
-              if (nre !== re) {
-                nre.subs[i] = nsub;
+              newSubs.push(nsub);
+            }
+            if (changed) {
+              // If we filtered out all nodes, return the mathematically correct fallback
+              if (newSubs.length === 0) {
+                return new Regexp(re.op === Regexp.Op.CONCAT ? Regexp.Op.EMPTY_MATCH : Regexp.Op.NO_MATCH);
+              }
+              // If only 1 node remains, we don't need a CONCAT/ALT container at all
+              if (newSubs.length === 1) {
+                return newSubs[0];
               }
+              const nre = Regexp.fromRegexp(re);
+              nre.runes = [];
+              nre.subs = newSubs;
+              return nre;
+            }
+            return re;
+          }
+        case Regexp.Op.CHAR_CLASS:
+          {
+            if (re.runes === null) return re;
+
+            // Empty character classes match nothing.
+            if (re.runes.length === 0) {
+              return new Regexp(Regexp.Op.NO_MATCH);
             }
-            return nre;
+            // Full character classes match everything.
+            if (re.runes.length === 2 && re.runes[0] === 0 && re.runes[1] === Unicode.MAX_RUNE) {
+              return new Regexp(Regexp.Op.ANY_CHAR);
+            }
+            // Standard catch-all except newline
+            if (re.runes.length === 4 && re.runes[0] === 0 && re.runes[1] === Codepoint.CODES.get('\n') - 1 && re.runes[2] === Codepoint.CODES.get('\n') + 1 && re.runes[3] === Unicode.MAX_RUNE) {
+              return new Regexp(Regexp.Op.ANY_CHAR_NOT_NL);
+            }
+            return re;
           }
         case Regexp.Op.STAR:
         case Regexp.Op.PLUS:
@@ -3230,7 +4453,9 @@
               }
               subs.push(Simplify.simplify1(Regexp.Op.PLUS, re.flags, sub, null));
               nre.subs = subs.slice(0);
-              return nre;
+
+              // Ensure newly created CONCAT is properly flattened
+              return Simplify.simplify(nre);
             }
             // Special case x{0} handled above.
 
@@ -3268,7 +4493,8 @@
             if (prefixSubs !== null) {
               const prefix = new Regexp(Regexp.Op.CONCAT);
               prefix.subs = prefixSubs.slice(0);
-              return prefix;
+              // Ensure newly created CONCAT is properly flattened
+              return Simplify.simplify(prefix);
             }
 
             // Some degenerate case like min > max or min < max < 0.
@@ -3301,6 +4527,13 @@
         return sub;
       }
 
+      // Handle impossible targets gracefully.
+      // e.g. Trying to match "NO_MATCH" 0 or 1 times (QUEST/STAR) evaluates to EMPTY_MATCH.
+      if (sub.op === Regexp.Op.NO_MATCH) {
+        if (op === Regexp.Op.PLUS) return sub; // 1+ times is impossible
+        return new Regexp(Regexp.Op.EMPTY_MATCH);
+      }
+
       // The operators are idempotent if the flags match.
       if (op === sub.op && (flags & RE2Flags.NON_GREEDY) === (sub.flags & RE2Flags.NON_GREEDY)) {
         return sub;
@@ -3308,10 +4541,10 @@
       if (re !== null && re.op === op && (re.flags & RE2Flags.NON_GREEDY) === (flags & RE2Flags.NON_GREEDY) && sub === re.subs[0]) {
         return re;
       }
-      re = new Regexp(op);
-      re.flags = flags;
-      re.subs = [sub];
-      return re;
+      const nre = new Regexp(op);
+      nre.flags = flags;
+      nre.subs = [sub];
+      return nre;
     }
   }
 
@@ -3657,16 +4890,6 @@
     }
   }
 
-  class Pair {
-    static of(first, second) {
-      return new Pair(first, second);
-    }
-    constructor(first, second) {
-      this.first = first;
-      this.second = second;
-    }
-  }
-
   // StringIterator: a stream of runes with an opaque cursor, permitting
   // rewinding.  The units of the cursor are not specified beyond the
   // fact that ASCII characters are single width.  (Cursor positions
@@ -3813,18 +5036,59 @@
     // stride).
     static ANY_TABLE = new UnicodeRangeTable(new Uint32Array([0, Unicode.MAX_RUNE, 1]));
 
+    // Ascii tables
+    static ASCII_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1]));
+    static ASCII_FOLD_TABLE = new UnicodeRangeTable(new Uint32Array([0, 0x7f, 1, 0x017f, 0x017f, 1,
+    // Old English long s (ſ), folds to S/s.
+    0x212a, 0x212a, 1 // Kelvin K, folds to K/k.
+    ]));
+
     // unicodeTable() returns the Unicode RangeTable identified by name
     // and the table of additional fold-equivalent code points.
     // Returns null if |name| does not identify a Unicode character range.
     static unicodeTable(name) {
       if (name === 'Any') {
-        return Pair.of(Parser.ANY_TABLE, Parser.ANY_TABLE);
+        return {
+          tab: Parser.ANY_TABLE,
+          fold: Parser.ANY_TABLE,
+          sign: 1
+        };
+      }
+      if (name === 'Ascii') {
+        return {
+          tab: Parser.ASCII_TABLE,
+          fold: Parser.ASCII_FOLD_TABLE,
+          sign: 1
+        };
+      }
+      if (name === 'Assigned') {
+        // Assigned is the mathematical inversion of Cn (Unassigned)
+        return {
+          tab: UnicodeTables.CATEGORIES.get('Cn'),
+          fold: UnicodeTables.CATEGORIES.get('Cn'),
+          sign: -1
+        };
+      }
+      if (name === 'Lc') {
+        return {
+          tab: UnicodeTables.CATEGORIES.get('LC'),
+          fold: UnicodeTables.FOLD_CATEGORIES.get('LC'),
+          sign: 1
+        };
       }
       if (UnicodeTables.CATEGORIES.has(name)) {
-        return Pair.of(UnicodeTables.CATEGORIES.get(name), UnicodeTables.FOLD_CATEGORIES.get(name));
+        return {
+          tab: UnicodeTables.CATEGORIES.get(name),
+          fold: UnicodeTables.FOLD_CATEGORIES.get(name),
+          sign: 1
+        };
       }
       if (UnicodeTables.SCRIPTS.has(name)) {
-        return Pair.of(UnicodeTables.SCRIPTS.get(name), UnicodeTables.FOLD_SCRIPT.get(name));
+        return {
+          tab: UnicodeTables.SCRIPTS.get(name),
+          fold: UnicodeTables.FOLD_SCRIPT.get(name),
+          sign: 1
+        };
       }
       return null;
     }
@@ -4133,7 +5397,7 @@
       this.flags = flags;
       // number of capturing groups seen
       this.numCap = 0;
-      this.namedGroups = {};
+      this.namedGroups = Object.create(null);
       // Stack of parsed expressions.
       this.stack = [];
       this.free = null;
@@ -4977,9 +6241,11 @@
                         const i = lit.indexOf('\\E');
                         if (i >= 0) {
                           lit = lit.substring(0, i);
+                          t.skipString(lit);
+                          t.skipString('\\E');
+                        } else {
+                          t.skipString(lit);
                         }
-                        t.skipString(lit);
-                        t.skipString('\\E');
                         let j = 0;
                         while (j < lit.length) {
                           const codepoint = lit.codePointAt(j);
@@ -4995,6 +6261,9 @@
                       t.rewindTo(savedPos);
                       break;
                   }
+                } else {
+                  // Unconditionally rewind if PERL_X is off, or if string ended abruptly
+                  t.rewindTo(savedPos);
                 }
                 const re = this.newRegexp(Regexp.Op.CHAR_CLASS);
                 re.flags = this.flags;
@@ -5320,8 +6589,11 @@
       if (pair === null) {
         throw new RE2JSSyntaxException(Parser.ERR_INVALID_CHAR_RANGE, t.from(startPos));
       }
-      const tab = pair.first;
-      const fold = pair.second; // fold-equivalent table
+      if (pair.sign < 0) {
+        sign = 0 - sign;
+      }
+      const tab = pair.tab;
+      const fold = pair.fold; // fold-equivalent table
       // Variation of CharClass.appendGroup() for tables.
       if ((this.flags & RE2Flags.FOLD_CASE) === 0 || fold === null) {
         cc.appendTableWithSign(tab, sign);
@@ -5465,6 +6737,7 @@
       res.prefixUTF8 = re2.prefixUTF8;
       res.prefixComplete = re2.prefixComplete;
       res.prefixRune = re2.prefixRune;
+      res.prefilter = re2.prefilter;
       return res;
     }
 
@@ -5507,8 +6780,10 @@
       let re = Parser.parse(expr, mode);
       const maxCap = re.maxCap();
       re = Simplify.simplify(re);
+      const prefilter = PrefilterTree.build(re);
       const prog = Compiler.compileRegexp(re);
       const re2 = new RE2(expr, prog, maxCap, longest);
+      re2.prefilter = prefilter.type === Prefilter.Type.NONE ? null : prefilter;
       const [prefixCompl, prefixStr] = prog.prefix();
       re2.prefixComplete = prefixCompl;
       re2.prefix = prefixStr;
@@ -5540,12 +6815,78 @@
       this.prefixComplete = false; // true if prefix is the entire regexp
       this.prefixRune = 0; // first rune in prefix
       this.pooled = new AtomicReference(); // Cache of machines for running regexp. Forms a Treiber stack.
-      this.dfa = new DFA(prog); // Initialize the Lazy DFA
+      this.dfa = new DFA(this.prog); // initialize Lazy DFA
+      this.onepass = OnePass.compile(this.prog); // compile OnePass
+      this.prefilter = null;
+    }
+    matchPrefixComplete(input, pos, anchor, ncap) {
+      // If strictly anchored, execution must start at 0
+      if ((anchor === RE2Flags.ANCHOR_START || anchor === RE2Flags.ANCHOR_BOTH) && pos !== 0) {
+        return null;
+      }
+      let matchStart = -1;
+      let matchEnd = -1;
+      const pLen = input.prefixLength(this);
+      if (anchor === RE2Flags.UNANCHORED) {
+        const idx = input.index(this, pos);
+        if (idx < 0) return null;
+        matchStart = pos + idx;
+        matchEnd = matchStart + pLen;
+      } else if (anchor === RE2Flags.ANCHOR_BOTH) {
+        if (input.endPos() !== pLen) return null;
+        const idx = input.index(this, 0);
+        if (idx !== 0) return null;
+        matchStart = 0;
+        matchEnd = pLen;
+      } else if (anchor === RE2Flags.ANCHOR_START) {
+        const idx = input.index(this, 0);
+        if (idx !== 0) return null;
+        matchStart = 0;
+        matchEnd = pLen;
+      }
+      if (matchStart < 0) return null;
+
+      // If captures are requested (e.g. findSubmatch instead of test), populate bounds
+      if (ncap > 0) {
+        const matchcap = new Int32Array(ncap).fill(-1);
+        matchcap[0] = matchStart;
+        matchcap[1] = matchEnd;
+        return Array.from(matchcap);
+      }
+      return []; // Matched successfully, but no capture data requested
     }
     executeEngine(input, pos, anchor, ncap) {
+      // LITERAL FAST PATH
+      // If the entire regex is just a literal string (and no nested capture boundaries are requested),
+      // bypass all state machines and execute via V8's blistering fast native indexOf
+      if (this.prefixComplete && (ncap === 0 || this.numSubexp === 0)) {
+        return this.matchPrefixComplete(input, pos, anchor, ncap);
+      }
+
+      // PREFILTER FAST PATH
+      // If the unanchored query requires specific literal strings (e.g. "a.*b"),
+      // verify those strings exist using high-speed JS string searches before waking up the state engines.
+      if (this.prefilter !== null && anchor === RE2Flags.UNANCHORED) {
+        if (!this.prefilter.eval(input, pos)) {
+          return null;
+        }
+      }
+
+      // FAST PATH: OnePass DFA engine.
+      // If compiled successfully, it perfectly supports capture groups
+      // and is blisteringly fast since it skips thread queues completely.
+      if (this.onepass !== null) {
+        return OnePass.execute(this, input, pos, anchor, ncap);
+      }
+
       // If the user wants capturing groups (ncap > 0), the DFA mathematically CANNOT do it.
       // We must use the NFA.
       if (ncap > 0) {
+        // Backtracker bit-state execution bounds check
+        if (input.endPos() <= Backtracker.maxBitStateLen(this.prog)) {
+          return Backtracker.execute(this, input, pos, anchor, ncap);
+        }
+        // NFA execution
         return this.doExecuteNFA(input, pos, anchor, ncap);
       }
       const dfaResult = this.dfa.match(input, pos, anchor);
@@ -5554,6 +6895,11 @@
         return dfaResult ? [] : null; // Return empty array to signify "matched but no captures"
       }
 
+      // Backtracker bit-state execution bounds check
+      if (input.endPos() <= Backtracker.maxBitStateLen(this.prog)) {
+        return Backtracker.execute(this, input, pos, anchor, ncap);
+      }
+
       // Fallback to NFA
       return this.doExecuteNFA(input, pos, anchor, ncap);
     }
@@ -6134,6 +7480,50 @@
     }
   }
 
+  class RE2Set {
+    constructor(anchor = RE2Flags.UNANCHORED, flags = RE2Flags.PERL) {
+      this.anchor = anchor;
+      this.flags = flags;
+      this.regexps = [];
+      this.prog = null;
+      this.dfa = null;
+      this.dummyRe2 = null;
+    }
+    add(pattern) {
+      if (this.prog) {
+        throw new RE2JSCompileException('Cannot add patterns after compile');
+      }
+      const re = Parser.parse(pattern, this.flags);
+      this.regexps.push(Simplify.simplify(re));
+      return this.regexps.length - 1;
+    }
+    compile() {
+      if (this.prog) return;
+      this.prog = Compiler.compileSet(this.regexps);
+      this.dfa = new DFA(this.prog);
+      this.dummyRe2 = {
+        prog: this.prog,
+        cond: this.prog.startCond(),
+        prefix: '',
+        prefixRune: 0,
+        longest: false
+      };
+    }
+    match(input) {
+      if (!this.prog) this.compile();
+      const machineInput = Array.isArray(input) ? MachineInput.fromUTF8(input) : MachineInput.fromUTF16(input);
+
+      // Fast path: Try the blistering fast DFA
+      const dfaResult = this.dfa.matchSet(machineInput, 0, this.anchor);
+      if (dfaResult !== null) return dfaResult;
+
+      // Safe Fallback: Handle boundaries (\b) or massive state explosions via NFA
+      const machine = Machine.fromRE2(this.dummyRe2);
+      machine.init(0);
+      return machine.matchSet(machineInput, 0, this.anchor);
+    }
+  }
+
   /**
    * Transform JS regex string to RE2 regex string
    */
@@ -6216,7 +7606,8 @@
               default:
                 {
                   result += '\\';
-                  let symSize = Utils.charCount(ch.codePointAt(0));
+                  let cp = data.codePointAt(i + 1);
+                  let symSize = Utils.charCount(cp);
                   result += data.substring(i + 1, i + 1 + symSize);
                   i += symSize + 1;
                   continue;
@@ -6236,7 +7627,8 @@
             continue;
           }
         }
-        let symSize = Utils.charCount(ch.codePointAt(0));
+        let cp = data.codePointAt(i);
+        let symSize = Utils.charCount(cp);
         result += data.substring(i, i + symSize);
         i += symSize;
       }
@@ -6599,7 +7991,9 @@
   exports.RE2JSException = RE2JSException;
   exports.RE2JSFlagsException = RE2JSFlagsException;
   exports.RE2JSGroupException = RE2JSGroupException;
+  exports.RE2JSInternalException = RE2JSInternalException;
   exports.RE2JSSyntaxException = RE2JSSyntaxException;
+  exports.RE2Set = RE2Set;
 
 }));
 //# sourceMappingURL=index.umd.js.map