re2js 2.0.2 → 2.1.1

package/build/index.esm.js

@@ -2,7 +2,7 @@
  * re2js
  * RE2JS is the JavaScript port of RE2, a regular expression engine that provides linear time matching
  *
- * @version v2.0.2
+ * @version v2.1.1
  * @author Alexey Vasiliev
  * @homepage https://github.com/le0pard/re2js#readme
  * @repository github:le0pard/re2js
@@ -54,6 +54,23 @@ class RE2Flags {
 /**
  * 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]]);
@@ -61,6 +78,7 @@ class Codepoint {
   // 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;
@@ -75,6 +93,7 @@ class Codepoint {
   // 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;
@@ -197,9 +216,11 @@ class UnicodeTables {
     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)),
@@ -408,8 +429,11 @@ class UnicodeTables {
     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)),
@@ -418,7 +442,9 @@ class UnicodeTables {
   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))
   });
 }
 
@@ -672,7 +698,7 @@ class Utils {
 
   // 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|.
@@ -943,6 +969,14 @@ class MachineInputBase {
   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.
@@ -954,6 +988,14 @@ class MachineUTF8Input extends MachineInputBase {
     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
@@ -1030,10 +1072,10 @@ class MachineUTF8Input extends MachineInputBase {
   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;
@@ -1044,6 +1086,9 @@ class MachineUTF8Input extends MachineInputBase {
     }
     return -1;
   }
+  prefixLength(re2) {
+    return re2.prefixUTF8.length;
+  }
 }
 
 // |pos| and |width| are in JS "char" units.
@@ -1054,6 +1099,10 @@ class MachineUTF16Input extends MachineInputBase {
     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
@@ -1099,6 +1148,9 @@ class MachineUTF16Input extends MachineInputBase {
     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) {
@@ -1189,6 +1241,17 @@ class RE2JSFlagsException extends RE2JSException {
   }
 }
 
+/**
+ * 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.
  *
@@ -1391,6 +1454,23 @@ class Matcher {
     }
     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 = Object.create(null);
+    for (const name of Object.keys(this.namedGroups)) {
+      result[name] = this.group(name);
+    }
+    return result;
+  }
+
   /**
    * Returns the number of subgroups in this pattern.
    *
@@ -1815,16 +1895,20 @@ class Inst {
       }
       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;
@@ -1842,6 +1926,40 @@ class Inst {
     }
     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}
@@ -1857,7 +1975,7 @@ class Inst {
       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:
@@ -1883,7 +2001,7 @@ class Inst {
 class Thread {
   constructor() {
     this.inst = null;
-    this.cap = [];
+    this.cap = null; // Initialized to Int32Array later
   }
 }
 
@@ -1911,9 +2029,11 @@ class Queue {
     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() {
@@ -1942,7 +2062,8 @@ class Machine {
     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;
   }
@@ -1956,27 +2077,30 @@ class Machine {
     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.
@@ -1988,6 +2112,7 @@ class Machine {
       t = this.pool[this.poolSize];
     } else {
       t = new Thread();
+      t.cap = new Int32Array(this.matchcap.length);
     }
     t.inst = inst;
     return t;
@@ -2017,7 +2142,7 @@ class Machine {
       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);
@@ -2088,6 +2213,85 @@ class Machine {
     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++) {
@@ -2108,7 +2312,9 @@ class Machine {
           }
           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);
@@ -2128,7 +2334,7 @@ class Machine {
           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);
@@ -2186,6 +2392,7 @@ class Machine {
           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];
           }
@@ -2220,20 +2427,23 @@ const arraysEqual = (a, b) => {
   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
   }
 
@@ -2242,6 +2452,7 @@ class DFA {
     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;
@@ -2250,6 +2461,7 @@ class DFA {
       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:
@@ -2267,9 +2479,11 @@ class DFA {
       }
     }
     const sortedPCs = Int32Array.from(closure).sort();
+    matchIDs.sort((a, b) => a - b);
     return {
       pcs: sortedPCs,
-      isMatch
+      isMatch,
+      matchIDs
     };
   }
 
@@ -2295,6 +2509,8 @@ class DFA {
       bucket = [];
       this.stateCache.set(hash, bucket);
     }
+
+    // DFA already failed once - exit
     if (this.failed) return null;
 
     // Safety: prevent memory exhaustion from state explosion
@@ -2303,12 +2519,18 @@ class DFA {
       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;
@@ -2328,76 +2550,808 @@ class DFA {
         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);
   }
 }
 
@@ -2482,7 +3436,7 @@ class Regexp {
     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;
@@ -2492,7 +3446,7 @@ class Regexp {
     this.min = 0;
     this.max = 0;
     this.name = null;
-    this.namedGroups = {};
+    this.namedGroups = Object.create(null);
   }
   toString() {
     return this.appendTo();
@@ -2752,6 +3706,188 @@ class Regexp {
   }
 }
 
+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.
  */
@@ -2853,39 +3989,30 @@ class Prog {
     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);
   }
   /**
    *
@@ -2914,7 +4041,7 @@ class Prog {
  * @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
@@ -2939,6 +4066,33 @@ class Compiler {
     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);
@@ -2951,7 +4105,7 @@ class Compiler {
   // 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() {
@@ -2962,7 +4116,7 @@ class Compiler {
   // 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;
@@ -3010,10 +4164,10 @@ class Compiler {
     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;
@@ -3025,10 +4179,10 @@ class Compiler {
     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;
@@ -3051,7 +4205,7 @@ class Compiler {
   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;
   }
 
@@ -3066,7 +4220,7 @@ class Compiler {
       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) {
@@ -3171,23 +4325,92 @@ class Simplify {
     }
     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:
@@ -3224,7 +4447,9 @@ class Simplify {
             }
             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.
 
@@ -3262,7 +4487,8 @@ class Simplify {
           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.
@@ -3295,6 +4521,13 @@ class Simplify {
       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;
@@ -3302,10 +4535,10 @@ class Simplify {
     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;
   }
 }
 
@@ -3651,16 +4884,6 @@ class CharClass {
   }
 }
 
-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
@@ -3807,18 +5030,59 @@ class Parser {
   // 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;
   }
@@ -4127,7 +5391,7 @@ class Parser {
     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;
@@ -4971,9 +6235,11 @@ class Parser {
                       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);
@@ -4989,6 +6255,9 @@ class Parser {
                     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;
@@ -5314,8 +6583,11 @@ class Parser {
     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);
@@ -5459,6 +6731,7 @@ class RE2 {
     res.prefixUTF8 = re2.prefixUTF8;
     res.prefixComplete = re2.prefixComplete;
     res.prefixRune = re2.prefixRune;
+    res.prefilter = re2.prefilter;
     return res;
   }
 
@@ -5501,8 +6774,10 @@ class RE2 {
     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;
@@ -5534,12 +6809,78 @@ class RE2 {
     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);
@@ -5548,6 +6889,11 @@ class RE2 {
       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);
   }
@@ -6128,6 +7474,50 @@ class RE2 {
   }
 }
 
+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
  */
@@ -6210,7 +7600,8 @@ class TranslateRegExpString {
             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;
@@ -6230,7 +7621,8 @@ class TranslateRegExpString {
           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;
     }
@@ -6587,5 +7979,5 @@ class RE2JS {
   }
 }
 
-export { Matcher, RE2JS, RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSSyntaxException };
+export { Matcher, RE2JS, RE2JSCompileException, RE2JSException, RE2JSFlagsException, RE2JSGroupException, RE2JSInternalException, RE2JSSyntaxException, RE2Set };
 //# sourceMappingURL=index.esm.js.map