admtracksteel/camila
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c4c8e6ffcf4944e1c5db39bcc3b2c1564bc078cb
camila/node_modules/meriyah/dist/meriyah.mjs
T

9200 lines
317 KiB
JavaScript
Raw Blame History

const unicodeLookup = ((compressed, lookup) => {
const result = new Uint32Array(69632);
let index = 0;
let subIndex = 0;
while (index < 2571) {
const inst = compressed[index++];
if (inst < 0) {
subIndex -= inst;
}
else {
let code = compressed[index++];
if (inst & 2)
code = lookup[code];
if (inst & 1) {
result.fill(code, subIndex, subIndex += compressed[index++]);
}
else {
result[subIndex++] = code;
}
}
}
return result;
})([-1, 2, 26, 2, 27, 2, 5, -1, 0, 77595648, 3, 44, 2, 3, 0, 14, 2, 63, 2, 64, 3, 0, 3, 0, 3168796671, 0, 4294956992, 2, 1, 2, 0, 2, 41, 3, 0, 4, 0, 4294966523, 3, 0, 4, 2, 16, 2, 65, 2, 0, 0, 4294836735, 0, 3221225471, 0, 4294901942, 2, 66, 0, 134152192, 3, 0, 2, 0, 4294951935, 3, 0, 2, 0, 2683305983, 0, 2684354047, 2, 18, 2, 0, 0, 4294961151, 3, 0, 2, 2, 19, 2, 0, 0, 608174079, 2, 0, 2, 60, 2, 7, 2, 6, 0, 4286611199, 3, 0, 2, 2, 1, 3, 0, 3, 0, 4294901711, 2, 40, 0, 4089839103, 0, 2961209759, 0, 1342439375, 0, 4294543342, 0, 3547201023, 0, 1577204103, 0, 4194240, 0, 4294688750, 2, 2, 0, 80831, 0, 4261478351, 0, 4294549486, 2, 2, 0, 2967484831, 0, 196559, 0, 3594373100, 0, 3288319768, 0, 8469959, 0, 65472, 2, 3, 0, 4093640191, 0, 660618719, 0, 65487, 0, 4294828015, 0, 4092591615, 0, 1616920031, 0, 982991, 2, 3, 2, 0, 0, 2163244511, 0, 4227923919, 0, 4236247022, 2, 71, 0, 4284449919, 0, 851904, 2, 4, 2, 12, 0, 67076095, -1, 2, 72, 0, 1073741743, 0, 4093607775, -1, 0, 50331649, 0, 3265266687, 2, 33, 0, 4294844415, 0, 4278190047, 2, 20, 2, 137, -1, 3, 0, 2, 2, 23, 2, 0, 2, 10, 2, 0, 2, 15, 2, 22, 3, 0, 10, 2, 74, 2, 0, 2, 75, 2, 76, 2, 77, 2, 0, 2, 78, 2, 0, 2, 11, 0, 261632, 2, 25, 3, 0, 2, 2, 13, 2, 4, 3, 0, 18, 2, 79, 2, 5, 3, 0, 2, 2, 80, 0, 2151677951, 2, 29, 2, 9, 0, 909311, 3, 0, 2, 0, 814743551, 2, 49, 0, 67090432, 3, 0, 2, 2, 42, 2, 0, 2, 6, 2, 0, 2, 30, 2, 8, 0, 268374015, 2, 110, 2, 51, 2, 0, 2, 81, 0, 134153215, -1, 2, 7, 2, 0, 2, 8, 0, 2684354559, 0, 67044351, 0, 3221160064, 2, 17, -1, 3, 0, 2, 2, 53, 0, 1046528, 3, 0, 3, 2, 9, 2, 0, 2, 54, 0, 4294960127, 2, 10, 2, 6, 2, 11, 0, 4294377472, 2, 12, 3, 0, 16, 2, 13, 2, 0, 2, 82, 2, 10, 2, 0, 2, 83, 2, 84, 2, 85, 0, 12288, 2, 55, 0, 1048577, 2, 86, 2, 14, -1, 2, 14, 0, 131042, 2, 87, 2, 88, 2, 89, 2, 0, 2, 34, -83, 3, 0, 7, 0, 1046559, 2, 0, 2, 15, 2, 0, 0, 2147516671, 2, 21, 3, 90, 2, 2, 0, -16, 2, 91, 0, 524222462, 2, 4, 2, 0, 0, 4269801471, 2, 4, 3, 0, 2, 2, 28, 2, 16, 3, 0, 2, 2, 17, 2, 0, -1, 2, 18, -16, 3, 0, 206, -2, 3, 0, 692, 2, 73, -1, 2, 18, 2, 10, 3, 0, 8, 2, 93, 2, 133, 2, 0, 0, 3220242431, 3, 0, 3, 2, 19, 2, 94, 2, 95, 3, 0, 2, 2, 96, 2, 0, 2, 97, 2, 46, 2, 0, 0, 4351, 2, 0, 2, 9, 3, 0, 2, 0, 67043391, 0, 3909091327, 2, 0, 2, 24, 2, 9, 2, 20, 3, 0, 2, 0, 67076097, 2, 8, 2, 0, 2, 21, 0, 67059711, 0, 4236247039, 3, 0, 2, 0, 939524103, 0, 8191999, 2, 101, 2, 102, 2, 22, 2, 23, 3, 0, 3, 0, 67057663, 3, 0, 349, 2, 103, 2, 104, 2, 7, -264, 3, 0, 11, 2, 24, 3, 0, 2, 2, 32, -1, 0, 3774349439, 2, 105, 2, 106, 3, 0, 2, 2, 19, 2, 107, 3, 0, 10, 2, 10, 2, 18, 2, 0, 2, 47, 2, 0, 2, 31, 2, 108, 2, 25, 0, 1638399, 0, 57344, 2, 109, 3, 0, 3, 2, 20, 2, 26, 2, 27, 2, 5, 2, 28, 2, 0, 2, 8, 2, 111, -1, 2, 112, 2, 113, 2, 114, -1, 3, 0, 3, 2, 12, -2, 2, 0, 2, 29, -3, 0, 536870912, -4, 2, 20, 2, 0, 2, 36, 0, 1, 2, 0, 2, 67, 2, 6, 2, 12, 2, 10, 2, 0, 2, 115, -1, 3, 0, 4, 2, 10, 2, 23, 2, 116, 2, 7, 2, 0, 2, 117, 2, 0, 2, 118, 2, 119, 2, 120, 2, 0, 2, 9, 3, 0, 9, 2, 21, 2, 30, 2, 31, 2, 121, 2, 122, -2, 2, 123, 2, 124, 2, 30, 2, 21, 2, 8, -2, 2, 125, 2, 30, 2, 32, -2, 2, 0, 2, 39, -2, 0, 4277137519, 0, 2269118463, -1, 3, 20, 2, -1, 2, 33, 2, 38, 2, 0, 3, 30, 2, 2, 35, 2, 19, -3, 3, 0, 2, 2, 34, -1, 2, 0, 2, 35, 2, 0, 2, 35, 2, 0, 2, 48, 2, 0, 0, 4294950463, 2, 37, -7, 2, 0, 0, 203775, 2, 57, 0, 4026531840, 2, 20, 2, 43, 2, 36, 2, 18, 2, 37, 2, 18, 2, 126, 2, 21, 3, 0, 2, 2, 38, 0, 2151677888, 2, 0, 2, 12, 0, 4294901764, 2, 144, 2, 0, 2, 58, 2, 56, 0, 5242879, 3, 0, 2, 0, 402644511, -1, 2, 128, 2, 39, 0, 3, -1, 2, 129, 2, 130, 2, 0, 0, 67045375, 2, 40, 0, 4226678271, 0, 3766565279, 0, 2039759, 2, 132, 2, 41, 0, 1046437, 0, 6, 3, 0, 2, 0, 3288270847, 0, 3, 3, 0, 2, 0, 67043519, -5, 2, 0, 0, 4282384383, 0, 1056964609, -1, 3, 0, 2, 0, 67043345, -1, 2, 0, 2, 42, 2, 23, 2, 50, 2, 11, 2, 61, 2, 38, -5, 2, 0, 2, 12, -3, 3, 0, 2, 0, 2147484671, 2, 134, 0, 4190109695, 2, 52, -2, 2, 135, 0, 4244635647, 0, 27, 2, 0, 2, 8, 2, 43, 2, 0, 2, 68, 2, 18, 2, 0, 2, 42, -6, 2, 0, 2, 45, 2, 59, 2, 44, 2, 45, 2, 46, 2, 47, 0, 8388351, -2, 2, 136, 0, 3028287487, 2, 48, 2, 138, 0, 33259519, 2, 49, -9, 2, 21, 0, 4294836223, 0, 3355443199, 0, 134152199, -2, 2, 69, -2, 3, 0, 28, 2, 32, -3, 3, 0, 3, 2, 17, 3, 0, 6, 2, 50, -81, 2, 18, 3, 0, 2, 2, 36, 3, 0, 33, 2, 25, 2, 30, 3, 0, 124, 2, 12, 3, 0, 18, 2, 38, -213, 2, 0, 2, 32, -54, 3, 0, 17, 2, 42, 2, 8, 2, 23, 2, 0, 2, 8, 2, 23, 2, 51, 2, 0, 2, 21, 2, 52, 2, 139, 2, 25, -13, 2, 0, 2, 53, -6, 3, 0, 2, -4, 3, 0, 2, 0, 4294936575, 2, 0, 0, 4294934783, -2, 0, 196635, 3, 0, 191, 2, 54, 3, 0, 38, 2, 30, 2, 55, 2, 34, -278, 2, 140, 3, 0, 9, 2, 141, 2, 142, 2, 56, 3, 0, 11, 2, 7, -72, 3, 0, 3, 2, 143, 0, 1677656575, -130, 2, 26, -16, 2, 0, 2, 24, 2, 38, -16, 0, 4161266656, 0, 4071, 0, 15360, -4, 2, 57, -13, 3, 0, 2, 2, 58, 2, 0, 2, 145, 2, 146, 2, 62, 2, 0, 2, 147, 2, 148, 2, 149, 3, 0, 10, 2, 150, 2, 151, 2, 22, 3, 58, 2, 3, 152, 2, 3, 59, 2, 0, 4294954999, 2, 0, -16, 2, 0, 2, 92, 2, 0, 0, 2105343, 0, 4160749584, 0, 65534, -34, 2, 8, 2, 154, -6, 0, 4194303871, 0, 4294903771, 2, 0, 2, 60, 2, 100, -3, 2, 0, 0, 1073684479, 0, 17407, -9, 2, 18, 2, 17, 2, 0, 2, 32, -14, 2, 18, 2, 32, -6, 2, 18, 2, 12, -15, 2, 155, 3, 0, 6, 0, 8323103, -1, 3, 0, 2, 2, 61, -37, 2, 62, 2, 156, 2, 157, 2, 158, 2, 159, 2, 160, -105, 2, 26, -32, 3, 0, 1335, -1, 3, 0, 129, 2, 32, 3, 0, 6, 2, 10, 3, 0, 180, 2, 161, 3, 0, 233, 2, 162, 3, 0, 18, 2, 10, -77, 3, 0, 16, 2, 10, -47, 3, 0, 154, 2, 6, 3, 0, 130, 2, 25, -22250, 3, 0, 7, 2, 25, -6130, 3, 5, 2, -1, 0, 69207040, 3, 44, 2, 3, 0, 14, 2, 63, 2, 64, -3, 0, 3168731136, 0, 4294956864, 2, 1, 2, 0, 2, 41, 3, 0, 4, 0, 4294966275, 3, 0, 4, 2, 16, 2, 65, 2, 0, 2, 34, -1, 2, 18, 2, 66, -1, 2, 0, 0, 2047, 0, 4294885376, 3, 0, 2, 0, 3145727, 0, 2617294944, 0, 4294770688, 2, 25, 2, 67, 3, 0, 2, 0, 131135, 2, 98, 0, 70256639, 0, 71303167, 0, 272, 2, 42, 2, 6, 0, 32511, 2, 0, 2, 49, -1, 2, 99, 2, 68, 0, 4278255616, 0, 4294836227, 0, 4294549473, 0, 600178175, 0, 2952806400, 0, 268632067, 0, 4294543328, 0, 57540095, 0, 1577058304, 0, 1835008, 0, 4294688736, 2, 70, 2, 69, 0, 33554435, 2, 131, 2, 70, 0, 2952790016, 0, 131075, 0, 3594373096, 0, 67094296, 2, 69, -1, 0, 4294828000, 0, 603979263, 0, 654311424, 0, 3, 0, 4294828001, 0, 602930687, 0, 1610612736, 0, 393219, 0, 4294828016, 0, 671088639, 0, 2154840064, 0, 4227858435, 0, 4236247008, 2, 71, 2, 38, -1, 2, 4, 0, 917503, 2, 38, -1, 2, 72, 0, 537788335, 0, 4026531935, -1, 0, 1, -1, 2, 33, 2, 73, 0, 7936, -3, 2, 0, 0, 2147485695, 0, 1010761728, 0, 4292984930, 0, 16387, 2, 0, 2, 15, 2, 22, 3, 0, 10, 2, 74, 2, 0, 2, 75, 2, 76, 2, 77, 2, 0, 2, 78, 2, 0, 2, 12, -1, 2, 25, 3, 0, 2, 2, 13, 2, 4, 3, 0, 18, 2, 79, 2, 5, 3, 0, 2, 2, 80, 0, 2147745791, 3, 19, 2, 0, 122879, 2, 0, 2, 9, 0, 276824064, -2, 3, 0, 2, 2, 42, 2, 0, 0, 4294903295, 2, 0, 2, 30, 2, 8, -1, 2, 18, 2, 51, 2, 0, 2, 81, 2, 49, -1, 2, 21, 2, 0, 2, 29, -2, 0, 128, -2, 2, 28, 2, 9, 0, 8160, -1, 2, 127, 0, 4227907585, 2, 0, 2, 37, 2, 0, 2, 50, 0, 4227915776, 2, 10, 2, 6, 2, 11, -1, 0, 74440192, 3, 0, 6, -2, 3, 0, 8, 2, 13, 2, 0, 2, 82, 2, 10, 2, 0, 2, 83, 2, 84, 2, 85, -3, 2, 86, 2, 14, -3, 2, 87, 2, 88, 2, 89, 2, 0, 2, 34, -83, 3, 0, 7, 0, 817183, 2, 0, 2, 15, 2, 0, 0, 33023, 2, 21, 3, 90, 2, -17, 2, 91, 0, 524157950, 2, 4, 2, 0, 2, 92, 2, 4, 2, 0, 2, 22, 2, 28, 2, 16, 3, 0, 2, 2, 17, 2, 0, -1, 2, 18, -16, 3, 0, 206, -2, 3, 0, 692, 2, 73, -1, 2, 18, 2, 10, 3, 0, 8, 2, 93, 0, 3072, 2, 0, 0, 2147516415, 2, 10, 3, 0, 2, 2, 25, 2, 94, 2, 95, 3, 0, 2, 2, 96, 2, 0, 2, 97, 2, 46, 0, 4294965179, 0, 7, 2, 0, 2, 9, 2, 95, 2, 9, -1, 0, 1761345536, 2, 98, 0, 4294901823, 2, 38, 2, 20, 2, 99, 2, 35, 2, 100, 0, 2080440287, 2, 0, 2, 34, 2, 153, 0, 3296722943, 2, 0, 0, 1046675455, 0, 939524101, 0, 1837055, 2, 101, 2, 102, 2, 22, 2, 23, 3, 0, 3, 0, 7, 3, 0, 349, 2, 103, 2, 104, 2, 7, -264, 3, 0, 11, 2, 24, 3, 0, 2, 2, 32, -1, 0, 2700607615, 2, 105, 2, 106, 3, 0, 2, 2, 19, 2, 107, 3, 0, 10, 2, 10, 2, 18, 2, 0, 2, 47, 2, 0, 2, 31, 2, 108, -3, 2, 109, 3, 0, 3, 2, 20, -1, 3, 5, 2, 2, 110, 2, 0, 2, 8, 2, 111, -1, 2, 112, 2, 113, 2, 114, -1, 3, 0, 3, 2, 12, -2, 2, 0, 2, 29, -8, 2, 20, 2, 0, 2, 36, -1, 2, 0, 2, 67, 2, 6, 2, 30, 2, 10, 2, 0, 2, 115, -1, 3, 0, 4, 2, 10, 2, 18, 2, 116, 2, 7, 2, 0, 2, 117, 2, 0, 2, 118, 2, 119, 2, 120, 2, 0, 2, 9, 3, 0, 9, 2, 21, 2, 30, 2, 31, 2, 121, 2, 122, -2, 2, 123, 2, 124, 2, 30, 2, 21, 2, 8, -2, 2, 125, 2, 30, 2, 32, -2, 2, 0, 2, 39, -2, 0, 4277075969, 2, 30, -1, 3, 20, 2, -1, 2, 33, 2, 126, 2, 0, 3, 30, 2, 2, 35, 2, 19, -3, 3, 0, 2, 2, 34, -1, 2, 0, 2, 35, 2, 0, 2, 35, 2, 0, 2, 50, 2, 98, 0, 4294934591, 2, 37, -7, 2, 0, 0, 197631, 2, 57, -1, 2, 20, 2, 43, 2, 37, 2, 18, 0, 3, 2, 18, 2, 126, 2, 21, 2, 127, 2, 54, -1, 0, 2490368, 2, 127, 2, 25, 2, 18, 2, 34, 2, 127, 2, 38, 0, 4294901904, 0, 4718591, 2, 127, 2, 35, 0, 335544350, -1, 2, 128, 0, 2147487743, 0, 1, -1, 2, 129, 2, 130, 2, 8, -1, 2, 131, 2, 70, 0, 3758161920, 0, 3, 2, 132, 0, 12582911, 0, 655360, -1, 2, 0, 2, 29, 0, 2147485568, 0, 3, 2, 0, 2, 25, 0, 176, -5, 2, 0, 2, 17, 0, 251658240, -1, 2, 0, 2, 25, 0, 16, -1, 2, 0, 0, 16779263, -2, 2, 12, -1, 2, 38, -5, 2, 0, 2, 133, -3, 3, 0, 2, 2, 55, 2, 134, 0, 2147549183, 0, 2, -2, 2, 135, 2, 36, 0, 10, 0, 4294965249, 0, 67633151, 0, 4026597376, 2, 0, 0, 536871935, 2, 18, 2, 0, 2, 42, -6, 2, 0, 0, 1, 2, 59, 2, 17, 0, 1, 2, 46, 2, 25, -3, 2, 136, 2, 36, 2, 137, 2, 138, 0, 16778239, -10, 2, 35, 0, 4294836212, 2, 9, -3, 2, 69, -2, 3, 0, 28, 2, 32, -3, 3, 0, 3, 2, 17, 3, 0, 6, 2, 50, -81, 2, 18, 3, 0, 2, 2, 36, 3, 0, 33, 2, 25, 0, 126, 3, 0, 124, 2, 12, 3, 0, 18, 2, 38, -213, 2, 10, -55, 3, 0, 17, 2, 42, 2, 8, 2, 18, 2, 0, 2, 8, 2, 18, 2, 60, 2, 0, 2, 25, 2, 50, 2, 139, 2, 25, -13, 2, 0, 2, 73, -6, 3, 0, 2, -4, 3, 0, 2, 0, 67583, -1, 2, 107, -2, 0, 11, 3, 0, 191, 2, 54, 3, 0, 38, 2, 30, 2, 55, 2, 34, -278, 2, 140, 3, 0, 9, 2, 141, 2, 142, 2, 56, 3, 0, 11, 2, 7, -72, 3, 0, 3, 2, 143, 2, 144, -187, 3, 0, 2, 2, 58, 2, 0, 2, 145, 2, 146, 2, 62, 2, 0, 2, 147, 2, 148, 2, 149, 3, 0, 10, 2, 150, 2, 151, 2, 22, 3, 58, 2, 3, 152, 2, 3, 59, 2, 2, 153, -57, 2, 8, 2, 154, -7, 2, 18, 2, 0, 2, 60, -4, 2, 0, 0, 1065361407, 0, 16384, -9, 2, 18, 2, 60, 2, 0, 2, 133, -14, 2, 18, 2, 133, -6, 2, 18, 0, 81919, -15, 2, 155, 3, 0, 6, 2, 126, -1, 3, 0, 2, 0, 2063, -37, 2, 62, 2, 156, 2, 157, 2, 158, 2, 159, 2, 160, -138, 3, 0, 1335, -1, 3, 0, 129, 2, 32, 3, 0, 6, 2, 10, 3, 0, 180, 2, 161, 3, 0, 233, 2, 162, 3, 0, 18, 2, 10, -77, 3, 0, 16, 2, 10, -47, 3, 0, 154, 2, 6, 3, 0, 130, 2, 25, -28386], [4294967295, 4294967291, 4092460543, 4294828031, 4294967294, 134217726, 4294903807, 268435455, 2147483647, 1048575, 1073741823, 3892314111, 134217727, 1061158911, 536805376, 4294910143, 4294901759, 32767, 4294901760, 262143, 536870911, 8388607, 4160749567, 4294902783, 4294918143, 65535, 67043328, 2281701374, 4294967264, 2097151, 4194303, 255, 67108863, 4294967039, 511, 524287, 131071, 63, 127, 3238002687, 4294549487, 4290772991, 33554431, 4294901888, 4286578687, 67043329, 4294705152, 4294770687, 67043583, 1023, 15, 2047999, 67043343, 67051519, 16777215, 2147483648, 4294902000, 28, 4292870143, 4294966783, 16383, 67047423, 4294967279, 262083, 20511, 41943039, 493567, 4294959104, 603979775, 65536, 602799615, 805044223, 4294965206, 8191, 1031749119, 4294917631, 2134769663, 4286578493, 4282253311, 4294942719, 33540095, 4294905855, 2868854591, 1608515583, 265232348, 534519807, 2147614720, 1060109444, 4093640016, 17376, 2139062143, 224, 4169138175, 4294909951, 4286578688, 4294967292, 4294965759, 535511039, 4294966272, 4294967280, 32768, 8289918, 4294934399, 4294901775, 4294965375, 1602223615, 4294967259, 4294443008, 268369920, 4292804608, 4294967232, 486341884, 4294963199, 3087007615, 1073692671, 4128527, 4279238655, 4294902015, 4160684047, 4290246655, 469499899, 4294967231, 134086655, 4294966591, 2445279231, 3670015, 31, 4294967288, 4294705151, 3221208447, 4294902271, 4294549472, 4294921215, 4095, 4285526655, 4294966527, 4294966143, 64, 4294966719, 3774873592, 1877934080, 262151, 2555904, 536807423, 67043839, 3758096383, 3959414372, 3755993023, 2080374783, 4294835295, 4294967103, 4160749565, 4294934527, 4087, 2016, 2147446655, 184024726, 2862017156, 1593309078, 268434431, 268434414, 4294901763, 4294901761]);
const isIDContinue = (code) => (unicodeLookup[(code >>> 5) + 0] >>> code & 31 & 1) !== 0;
const isIDStart = (code) => (unicodeLookup[(code >>> 5) + 34816] >>> code & 31 & 1) !== 0;
function advanceChar(parser) {
parser.column++;
return (parser.currentChar = parser.source.charCodeAt(++parser.index));
}
function consumePossibleSurrogatePair(parser) {
const hi = parser.currentChar;
if ((hi & 0xfc00) !== 55296)
return 0;
const lo = parser.source.charCodeAt(parser.index + 1);
if ((lo & 0xfc00) !== 56320)
return 0;
return 65536 + ((hi & 0x3ff) << 10) + (lo & 0x3ff);
}
function consumeLineFeed(parser, state) {
parser.currentChar = parser.source.charCodeAt(++parser.index);
parser.flags |= 1;
if ((state & 4) === 0) {
parser.column = 0;
parser.line++;
}
}
function scanNewLine(parser) {
parser.flags |= 1;
parser.currentChar = parser.source.charCodeAt(++parser.index);
parser.column = 0;
parser.line++;
}
function isExoticECMAScriptWhitespace(ch) {
return (ch === 160 ||
ch === 65279 ||
ch === 133 ||
ch === 5760 ||
(ch >= 8192 && ch <= 8203) ||
ch === 8239 ||
ch === 8287 ||
ch === 12288 ||
ch === 8201 ||
ch === 65519);
}
function toHex(code) {
return code < 65 ? code - 48 : (code - 65 + 10) & 0xf;
}
function convertTokenType(t) {
switch (t) {
case 134283266:
return 'NumericLiteral';
case 134283267:
return 'StringLiteral';
case 86021:
case 86022:
return 'BooleanLiteral';
case 86023:
return 'NullLiteral';
case 65540:
return 'RegularExpression';
case 67174408:
case 67174409:
case 131:
return 'TemplateLiteral';
default:
if ((t & 143360) === 143360)
return 'Identifier';
if ((t & 4096) === 4096)
return 'Keyword';
return 'Punctuator';
}
}
const CharTypes = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
8 | 1024,
0,
0,
8 | 2048,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
8192,
0,
1 | 2,
0,
0,
8192,
0,
0,
0,
256,
0,
256 | 32768,
0,
0,
2 | 16 | 128 | 32 | 64,
2 | 16 | 128 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 32 | 64,
2 | 16 | 512 | 64,
2 | 16 | 512 | 64,
0,
0,
16384,
0,
0,
0,
0,
1 | 2 | 64,
1 | 2 | 64,
1 | 2 | 64,
1 | 2 | 64,
1 | 2 | 64,
1 | 2 | 64,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
1 | 2,
0,
1,
0,
0,
1 | 2 | 4096,
0,
1 | 2 | 4 | 64,
1 | 2 | 4 | 64,
1 | 2 | 4 | 64,
1 | 2 | 4 | 64,
1 | 2 | 4 | 64,
1 | 2 | 4 | 64,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
1 | 2 | 4,
16384,
0,
0,
0,
0
];
const isIdStart = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0
];
const isIdPart = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0
];
function isIdentifierStart(code) {
return code <= 0x7F
? isIdStart[code] > 0
: isIDStart(code);
}
function isIdentifierPart(code) {
return code <= 0x7F
? isIdPart[code] > 0
: isIDContinue(code) || (code === 8204 || code === 8205);
}
const CommentTypes = ['SingleLine', 'MultiLine', 'HTMLOpen', 'HTMLClose', 'HashbangComment'];
function skipHashBang(parser) {
const { source } = parser;
if (parser.currentChar === 35 && source.charCodeAt(parser.index + 1) === 33) {
advanceChar(parser);
advanceChar(parser);
skipSingleLineComment(parser, source, 0, 4, parser.tokenStart);
}
}
function skipSingleHTMLComment(parser, source, state, context, type, start) {
if (context & 2)
parser.report(0);
return skipSingleLineComment(parser, source, state, type, start);
}
function skipSingleLineComment(parser, source, state, type, start) {
const { index } = parser;
parser.tokenIndex = parser.index;
parser.tokenLine = parser.line;
parser.tokenColumn = parser.column;
while (parser.index < parser.end) {
if (CharTypes[parser.currentChar] & 8) {
const isCR = parser.currentChar === 13;
scanNewLine(parser);
if (isCR && parser.index < parser.end && parser.currentChar === 10)
parser.currentChar = source.charCodeAt(++parser.index);
break;
}
else if ((parser.currentChar ^ 8232) <= 1) {
scanNewLine(parser);
break;
}
advanceChar(parser);
parser.tokenIndex = parser.index;
parser.tokenLine = parser.line;
parser.tokenColumn = parser.column;
}
if (parser.options.onComment) {
const loc = {
start: {
line: start.line,
column: start.column,
},
end: {
line: parser.tokenLine,
column: parser.tokenColumn,
},
};
parser.options.onComment(CommentTypes[type & 0xff], source.slice(index, parser.tokenIndex), start.index, parser.tokenIndex, loc);
}
return state | 1;
}
function skipMultiLineComment(parser, source, state) {
const { index } = parser;
while (parser.index < parser.end) {
if (parser.currentChar < 0x2b) {
let skippedOneAsterisk = false;
while (parser.currentChar === 42) {
if (!skippedOneAsterisk) {
state &= -5;
skippedOneAsterisk = true;
}
if (advanceChar(parser) === 47) {
advanceChar(parser);
if (parser.options.onComment) {
const loc = {
start: {
line: parser.tokenLine,
column: parser.tokenColumn,
},
end: {
line: parser.line,
column: parser.column,
},
};
parser.options.onComment(CommentTypes[1 & 0xff], source.slice(index, parser.index - 2), index - 2, parser.index, loc);
}
parser.tokenIndex = parser.index;
parser.tokenLine = parser.line;
parser.tokenColumn = parser.column;
return state;
}
}
if (skippedOneAsterisk) {
continue;
}
if (CharTypes[parser.currentChar] & 8) {
if (parser.currentChar === 13) {
state |= 1 | 4;
scanNewLine(parser);
}
else {
consumeLineFeed(parser, state);
state = (state & -5) | 1;
}
}
else {
advanceChar(parser);
}
}
else if ((parser.currentChar ^ 8232) <= 1) {
state = (state & -5) | 1;
scanNewLine(parser);
}
else {
state &= -5;
advanceChar(parser);
}
}
parser.report(18);
}
var RegexState;
(function (RegexState) {
RegexState[RegexState["Empty"] = 0] = "Empty";
RegexState[RegexState["Escape"] = 1] = "Escape";
RegexState[RegexState["Class"] = 2] = "Class";
})(RegexState || (RegexState = {}));
var RegexFlags;
(function (RegexFlags) {
RegexFlags[RegexFlags["Empty"] = 0] = "Empty";
RegexFlags[RegexFlags["IgnoreCase"] = 1] = "IgnoreCase";
RegexFlags[RegexFlags["Global"] = 2] = "Global";
RegexFlags[RegexFlags["Multiline"] = 4] = "Multiline";
RegexFlags[RegexFlags["Unicode"] = 16] = "Unicode";
RegexFlags[RegexFlags["Sticky"] = 8] = "Sticky";
RegexFlags[RegexFlags["DotAll"] = 32] = "DotAll";
RegexFlags[RegexFlags["Indices"] = 64] = "Indices";
RegexFlags[RegexFlags["UnicodeSets"] = 128] = "UnicodeSets";
})(RegexFlags || (RegexFlags = {}));
function scanRegularExpression(parser) {
const bodyStart = parser.index;
let preparseState = RegexState.Empty;
loop: while (true) {
const ch = parser.currentChar;
advanceChar(parser);
if (preparseState & RegexState.Escape) {
preparseState &= ~RegexState.Escape;
}
else {
switch (ch) {
case 47:
if (!preparseState)
break loop;
else
break;
case 92:
preparseState |= RegexState.Escape;
break;
case 91:
preparseState |= RegexState.Class;
break;
case 93:
preparseState &= RegexState.Escape;
break;
}
}
if (ch === 13 ||
ch === 10 ||
ch === 8232 ||
ch === 8233) {
parser.report(34);
}
if (parser.index >= parser.source.length) {
return parser.report(34);
}
}
const bodyEnd = parser.index - 1;
let mask = RegexFlags.Empty;
let char = parser.currentChar;
const { index: flagStart } = parser;
while (isIdentifierPart(char)) {
switch (char) {
case 103:
if (mask & RegexFlags.Global)
parser.report(36, 'g');
mask |= RegexFlags.Global;
break;
case 105:
if (mask & RegexFlags.IgnoreCase)
parser.report(36, 'i');
mask |= RegexFlags.IgnoreCase;
break;
case 109:
if (mask & RegexFlags.Multiline)
parser.report(36, 'm');
mask |= RegexFlags.Multiline;
break;
case 117:
if (mask & RegexFlags.Unicode)
parser.report(36, 'u');
if (mask & RegexFlags.UnicodeSets)
parser.report(36, 'vu');
mask |= RegexFlags.Unicode;
break;
case 118:
if (mask & RegexFlags.Unicode)
parser.report(36, 'uv');
if (mask & RegexFlags.UnicodeSets)
parser.report(36, 'v');
mask |= RegexFlags.UnicodeSets;
break;
case 121:
if (mask & RegexFlags.Sticky)
parser.report(36, 'y');
mask |= RegexFlags.Sticky;
break;
case 115:
if (mask & RegexFlags.DotAll)
parser.report(36, 's');
mask |= RegexFlags.DotAll;
break;
case 100:
if (mask & RegexFlags.Indices)
parser.report(36, 'd');
mask |= RegexFlags.Indices;
break;
default:
parser.report(35);
}
char = advanceChar(parser);
}
const flags = parser.source.slice(flagStart, parser.index);
const pattern = parser.source.slice(bodyStart, bodyEnd);
parser.tokenRegExp = { pattern, flags };
if (parser.options.raw)
parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
parser.tokenValue = validate(parser, pattern, flags);
return 65540;
}
function validate(parser, pattern, flags) {
try {
return new RegExp(pattern, flags);
}
catch {
try {
new RegExp(pattern, flags);
return null;
}
catch {
parser.report(34);
}
}
}
function scanString(parser, context, quote) {
const { index: start } = parser;
let ret = '';
let char = advanceChar(parser);
let marker = parser.index;
while ((CharTypes[char] & 8) === 0) {
if (char === quote) {
ret += parser.source.slice(marker, parser.index);
advanceChar(parser);
if (parser.options.raw)
parser.tokenRaw = parser.source.slice(start, parser.index);
parser.tokenValue = ret;
return 134283267;
}
if ((char & 8) === 8 && char === 92) {
ret += parser.source.slice(marker, parser.index);
char = advanceChar(parser);
if (char < 0x7f || char === 8232 || char === 8233) {
const code = parseEscape(parser, context, char);
if (code >= 0)
ret += String.fromCodePoint(code);
else
handleStringError(parser, code, 0);
}
else {
ret += String.fromCodePoint(char);
}
marker = parser.index + 1;
}
else if (char === 8232 || char === 8233) {
parser.column = -1;
parser.line++;
}
if (parser.index >= parser.end)
parser.report(16);
char = advanceChar(parser);
}
parser.report(16);
}
function parseEscape(parser, context, first, isTemplate = 0) {
switch (first) {
case 98:
return 8;
case 102:
return 12;
case 114:
return 13;
case 110:
return 10;
case 116:
return 9;
case 118:
return 11;
case 13: {
if (parser.index < parser.end) {
const nextChar = parser.source.charCodeAt(parser.index + 1);
if (nextChar === 10) {
parser.index = parser.index + 1;
parser.currentChar = nextChar;
}
}
}
case 10:
case 8232:
case 8233:
parser.column = -1;
parser.line++;
return -1;
case 48:
case 49:
case 50:
case 51: {
let code = first - 48;
let index = parser.index + 1;
let column = parser.column + 1;
if (index < parser.end) {
const next = parser.source.charCodeAt(index);
if ((CharTypes[next] & 32) === 0) {
if (code !== 0 || CharTypes[next] & 512) {
if (context & 1 || isTemplate)
return -2;
parser.flags |= 64;
}
}
else if (context & 1 || isTemplate) {
return -2;
}
else {
parser.currentChar = next;
code = (code << 3) | (next - 48);
index++;
column++;
if (index < parser.end) {
const next = parser.source.charCodeAt(index);
if (CharTypes[next] & 32) {
parser.currentChar = next;
code = (code << 3) | (next - 48);
index++;
column++;
}
}
parser.flags |= 64;
}
parser.index = index - 1;
parser.column = column - 1;
}
return code;
}
case 52:
case 53:
case 54:
case 55: {
if (isTemplate || context & 1)
return -2;
let code = first - 48;
const index = parser.index + 1;
const column = parser.column + 1;
if (index < parser.end) {
const next = parser.source.charCodeAt(index);
if (CharTypes[next] & 32) {
code = (code << 3) | (next - 48);
parser.currentChar = next;
parser.index = index;
parser.column = column;
}
}
parser.flags |= 64;
return code;
}
case 120: {
const ch1 = advanceChar(parser);
if ((CharTypes[ch1] & 64) === 0)
return -4;
const hi = toHex(ch1);
const ch2 = advanceChar(parser);
if ((CharTypes[ch2] & 64) === 0)
return -4;
const lo = toHex(ch2);
return (hi << 4) | lo;
}
case 117: {
const ch = advanceChar(parser);
if (parser.currentChar === 123) {
let code = 0;
while ((CharTypes[advanceChar(parser)] & 64) !== 0) {
code = (code << 4) | toHex(parser.currentChar);
if (code > 1114111)
return -5;
}
if (parser.currentChar < 1 || parser.currentChar !== 125) {
return -4;
}
return code;
}
else {
if ((CharTypes[ch] & 64) === 0)
return -4;
const ch2 = parser.source.charCodeAt(parser.index + 1);
if ((CharTypes[ch2] & 64) === 0)
return -4;
const ch3 = parser.source.charCodeAt(parser.index + 2);
if ((CharTypes[ch3] & 64) === 0)
return -4;
const ch4 = parser.source.charCodeAt(parser.index + 3);
if ((CharTypes[ch4] & 64) === 0)
return -4;
parser.index += 3;
parser.column += 3;
parser.currentChar = parser.source.charCodeAt(parser.index);
return (toHex(ch) << 12) | (toHex(ch2) << 8) | (toHex(ch3) << 4) | toHex(ch4);
}
}
case 56:
case 57:
if (isTemplate || !parser.options.webcompat || context & 1)
return -3;
parser.flags |= 4096;
default:
return first;
}
}
function handleStringError(parser, code, isTemplate) {
switch (code) {
case -1:
return;
case -2:
parser.report(isTemplate ? 2 : 1);
case -3:
parser.report(isTemplate ? 3 : 14);
case -4:
parser.report(7);
case -5:
parser.report(104);
}
}
function scanTemplate(parser, context) {
const { index: start } = parser;
let token = 67174409;
let ret = '';
let char = advanceChar(parser);
while (char !== 96) {
if (char === 36 && parser.source.charCodeAt(parser.index + 1) === 123) {
advanceChar(parser);
token = 67174408;
break;
}
else if (char === 92) {
char = advanceChar(parser);
if (char > 0x7e) {
ret += String.fromCodePoint(char);
}
else {
const { index, line, column } = parser;
const code = parseEscape(parser, context | 1, char, 1);
if (code >= 0) {
ret += String.fromCodePoint(code);
}
else if (code !== -1 && context & 64) {
parser.index = index;
parser.line = line;
parser.column = column;
ret = null;
char = scanBadTemplate(parser, char);
if (char < 0)
token = 67174408;
break;
}
else {
handleStringError(parser, code, 1);
}
}
}
else if (parser.index < parser.end) {
if (char === 13 && parser.source.charCodeAt(parser.index) === 10) {
ret += String.fromCodePoint(char);
parser.currentChar = parser.source.charCodeAt(++parser.index);
}
if (((char & 83) < 3 && char === 10) || (char ^ 8232) <= 1) {
parser.column = -1;
parser.line++;
}
ret += String.fromCodePoint(char);
}
if (parser.index >= parser.end)
parser.report(17);
char = advanceChar(parser);
}
advanceChar(parser);
parser.tokenValue = ret;
parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
return token;
}
function scanBadTemplate(parser, ch) {
while (ch !== 96) {
switch (ch) {
case 36: {
const index = parser.index + 1;
if (index < parser.end && parser.source.charCodeAt(index) === 123) {
parser.index = index;
parser.column++;
return -ch;
}
break;
}
case 10:
case 8232:
case 8233:
parser.column = -1;
parser.line++;
}
if (parser.index >= parser.end)
parser.report(17);
ch = advanceChar(parser);
}
return ch;
}
function scanTemplateTail(parser, context) {
if (parser.index >= parser.end)
parser.report(0);
parser.index--;
parser.column--;
return scanTemplate(parser, context);
}
const errorMessages = {
[0]: 'Unexpected token',
[30]: "Unexpected token: '%0'",
[1]: 'Octal escape sequences are not allowed in strict mode',
[2]: 'Octal escape sequences are not allowed in template strings',
[3]: '\\8 and \\9 are not allowed in template strings',
[4]: 'Private identifier #%0 is not defined',
[5]: 'Illegal Unicode escape sequence',
[6]: 'Invalid code point %0',
[7]: 'Invalid hexadecimal escape sequence',
[9]: 'Octal literals are not allowed in strict mode',
[8]: 'Decimal integer literals with a leading zero are forbidden in strict mode',
[10]: 'Expected number in radix %0',
[151]: 'Invalid left-hand side assignment to a destructible right-hand side',
[11]: 'Non-number found after exponent indicator',
[12]: 'Invalid BigIntLiteral',
[13]: 'No identifiers allowed directly after numeric literal',
[14]: 'Escapes \\8 or \\9 are not syntactically valid escapes',
[15]: 'Escapes \\8 or \\9 are not allowed in strict mode',
[16]: 'Unterminated string literal',
[17]: 'Unterminated template literal',
[18]: 'Multiline comment was not closed properly',
[19]: 'The identifier contained dynamic unicode escape that was not closed',
[20]: "Illegal character '%0'",
[21]: 'Missing hexadecimal digits',
[22]: 'Invalid implicit octal',
[23]: 'Invalid line break in string literal',
[24]: 'Only unicode escapes are legal in identifier names',
[25]: "Expected '%0'",
[26]: 'Invalid left-hand side in assignment',
[27]: 'Invalid left-hand side in async arrow',
[28]: 'Calls to super must be in the "constructor" method of a class expression or class declaration that has a superclass',
[29]: 'Member access on super must be in a method',
[31]: 'Await expression not allowed in formal parameter',
[32]: 'Yield expression not allowed in formal parameter',
[95]: "Unexpected token: 'escaped keyword'",
[33]: 'Unary expressions as the left operand of an exponentiation expression must be disambiguated with parentheses',
[123]: 'Async functions can only be declared at the top level or inside a block',
[34]: 'Unterminated regular expression',
[35]: 'Unexpected regular expression flag',
[36]: "Duplicate regular expression flag '%0'",
[37]: '%0 functions must have exactly %1 argument%2',
[38]: 'Setter function argument must not be a rest parameter',
[39]: '%0 declaration must have a name in this context',
[40]: 'Function name may not contain any reserved words or be eval or arguments in strict mode',
[41]: 'The rest operator is missing an argument',
[42]: 'A getter cannot be a generator',
[43]: 'A setter cannot be a generator',
[44]: 'A computed property name must be followed by a colon or paren',
[134]: 'Object literal keys that are strings or numbers must be a method or have a colon',
[46]: 'Found `* async x(){}` but this should be `async * x(){}`',
[45]: 'Getters and setters can not be generators',
[47]: "'%0' can not be generator method",
[48]: "No line break is allowed after '=>'",
[49]: 'The left-hand side of the arrow can only be destructed through assignment',
[50]: 'The binding declaration is not destructible',
[51]: 'Async arrow can not be followed by new expression',
[52]: "Classes may not have a static property named 'prototype'",
[53]: 'Class constructor may not be a %0',
[54]: 'Duplicate constructor method in class',
[55]: 'Invalid increment/decrement operand',
[56]: 'Invalid use of `new` keyword on an increment/decrement expression',
[57]: '`=>` is an invalid assignment target',
[58]: 'Rest element may not have a trailing comma',
[59]: 'Missing initializer in %0 declaration',
[60]: "'for-%0' loop head declarations can not have an initializer",
[61]: 'Invalid left-hand side in for-%0 loop: Must have a single binding',
[62]: 'Invalid shorthand property initializer',
[63]: 'Property name __proto__ appears more than once in object literal',
[64]: 'Let is disallowed as a lexically bound name',
[65]: "Invalid use of '%0' inside new expression",
[66]: "Illegal 'use strict' directive in function with non-simple parameter list",
[67]: 'Identifier "let" disallowed as left-hand side expression in strict mode',
[68]: 'Illegal continue statement',
[69]: 'Illegal break statement',
[70]: 'Cannot have `let[...]` as a var name in strict mode',
[71]: 'Invalid destructuring assignment target',
[72]: 'Rest parameter may not have a default initializer',
[73]: 'The rest argument must the be last parameter',
[74]: 'Invalid rest argument',
[76]: 'In strict mode code, functions can only be declared at top level or inside a block',
[77]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
[78]: 'Without web compatibility enabled functions can not be declared at top level, inside a block, or as the body of an if statement',
[79]: "Class declaration can't appear in single-statement context",
[80]: 'Invalid left-hand side in for-%0',
[81]: 'Invalid assignment in for-%0',
[82]: 'for await (... of ...) is only valid in async functions and async generators',
[83]: 'The first token after the template expression should be a continuation of the template',
[85]: '`let` declaration not allowed here and `let` cannot be a regular var name in strict mode',
[84]: '`let \n [` is a restricted production at the start of a statement',
[86]: 'Catch clause requires exactly one parameter, not more (and no trailing comma)',
[87]: 'Catch clause parameter does not support default values',
[88]: 'Missing catch or finally after try',
[89]: 'More than one default clause in switch statement',
[90]: 'Illegal newline after throw',
[91]: 'Strict mode code may not include a with statement',
[92]: 'Illegal return statement',
[93]: 'The left hand side of the for-header binding declaration is not destructible',
[94]: 'new.target only allowed within functions or static blocks',
[96]: "'#' not followed by identifier",
[102]: 'Invalid keyword',
[101]: "Can not use 'let' as a class name",
[100]: "'A lexical declaration can't define a 'let' binding",
[99]: 'Can not use `let` as variable name in strict mode',
[97]: "'%0' may not be used as an identifier in this context",
[98]: 'Await is only valid in async functions',
[103]: 'The %0 keyword can only be used with the module goal',
[104]: 'Unicode codepoint must not be greater than 0x10FFFF',
[105]: '%0 source must be string',
[106]: 'Only a identifier or string can be used to indicate alias',
[107]: "Only '*' or '{...}' can be imported after default",
[108]: 'Trailing decorator may be followed by method',
[109]: "Decorators can't be used with a constructor",
[110]: 'Can not use `await` as identifier in module or async func',
[111]: 'Can not use `await` as identifier in module',
[112]: 'HTML comments are only allowed with web compatibility (Annex B)',
[113]: "The identifier 'let' must not be in expression position in strict mode",
[114]: 'Cannot assign to `eval` and `arguments` in strict mode',
[115]: "The left-hand side of a for-of loop may not start with 'let'",
[116]: 'Block body arrows can not be immediately invoked without a group',
[117]: 'Block body arrows can not be immediately accessed without a group',
[118]: 'Unexpected strict mode reserved word',
[119]: 'Unexpected eval or arguments in strict mode',
[120]: 'Decorators must not be followed by a semicolon',
[121]: 'Calling delete on expression not allowed in strict mode',
[122]: 'Pattern can not have a tail',
[124]: 'Can not have a `yield` expression on the left side of a ternary',
[125]: 'An arrow function can not have a postfix update operator',
[126]: 'Invalid object literal key character after generator star',
[127]: 'Private fields can not be deleted',
[129]: 'Classes may not have a field called constructor',
[128]: 'Classes may not have a private element named constructor',
[130]: 'A class field initializer or static block may not contain arguments',
[131]: 'Generators can only be declared at the top level or inside a block',
[132]: 'Async methods are a restricted production and cannot have a newline following it',
[133]: 'Unexpected character after object literal property name',
[135]: 'Invalid key token',
[136]: "Label '%0' has already been declared",
[137]: 'continue statement must be nested within an iteration statement',
[138]: "Undefined label '%0'",
[139]: 'Trailing comma is disallowed inside import(...) arguments',
[140]: 'Invalid binding in JSON import',
[141]: 'import() requires exactly one argument',
[142]: 'Cannot use new with import(...)',
[143]: '... is not allowed in import()',
[144]: "Expected '=>'",
[145]: "Duplicate binding '%0'",
[146]: 'Duplicate private identifier #%0',
[147]: "Cannot export a duplicate name '%0'",
[150]: 'Duplicate %0 for-binding',
[148]: "Exported binding '%0' needs to refer to a top-level declared variable",
[149]: 'Unexpected private field',
[153]: 'Numeric separators are not allowed at the end of numeric literals',
[152]: 'Only one underscore is allowed as numeric separator',
[154]: 'JSX value should be either an expression or a quoted JSX text',
[155]: 'Expected corresponding JSX closing tag for %0',
[156]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
[157]: "JSX attributes must only be assigned a non-empty 'expression'",
[158]: "'%0' has already been declared",
[159]: "'%0' shadowed a catch clause binding",
[160]: 'Dot property must be an identifier',
[161]: 'Encountered invalid input after spread/rest argument',
[162]: 'Catch without try',
[163]: 'Finally without try',
[164]: 'Expected corresponding closing tag for JSX fragment',
[165]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
[166]: 'Invalid tagged template on optional chain',
[167]: 'Invalid optional chain from super property',
[168]: 'Invalid optional chain from new expression',
[169]: 'Cannot use "import.meta" outside a module',
[170]: 'Leading decorators must be attached to a class declaration',
[171]: 'An export name cannot include a lone surrogate, found %0',
[172]: 'A string literal cannot be used as an exported binding without `from`',
[173]: "Private fields can't be accessed on super",
[174]: "The only valid meta property for import is 'import.meta'",
[175]: "'import.meta' must not contain escaped characters",
[176]: 'cannot use "await" as identifier inside an async function',
[177]: 'cannot use "await" in static blocks',
};
class ParseError extends SyntaxError {
start;
end;
range;
loc;
description;
constructor(start, end, type, ...params) {
const description = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
const message = '[' + start.line + ':' + start.column + '-' + end.line + ':' + end.column + ']: ' + description;
super(message);
this.start = start.index;
this.end = end.index;
this.range = [start.index, end.index];
this.loc = {
start: { line: start.line, column: start.column },
end: { line: end.line, column: end.column },
};
this.description = description;
}
}
function scanNumber(parser, context, kind) {
let char = parser.currentChar;
let value = 0;
let digit = 9;
let atStart = kind & 64 ? 0 : 1;
let digits = 0;
let allowSeparator = 0;
if (kind & 64) {
value = '.' + scanDecimalDigitsOrSeparator(parser, char);
char = parser.currentChar;
if (char === 110)
parser.report(12);
}
else {
if (char === 48) {
char = advanceChar(parser);
if ((char | 32) === 120) {
kind = 8 | 128;
char = advanceChar(parser);
while (CharTypes[char] & (64 | 4096)) {
if (char === 95) {
if (!allowSeparator)
parser.report(152);
allowSeparator = 0;
char = advanceChar(parser);
continue;
}
allowSeparator = 1;
value = value * 0x10 + toHex(char);
digits++;
char = advanceChar(parser);
}
if (digits === 0 || !allowSeparator) {
parser.report(digits === 0 ? 21 : 153);
}
}
else if ((char | 32) === 111) {
kind = 4 | 128;
char = advanceChar(parser);
while (CharTypes[char] & (32 | 4096)) {
if (char === 95) {
if (!allowSeparator) {
parser.report(152);
}
allowSeparator = 0;
char = advanceChar(parser);
continue;
}
allowSeparator = 1;
value = value * 8 + (char - 48);
digits++;
char = advanceChar(parser);
}
if (digits === 0 || !allowSeparator) {
parser.report(digits === 0 ? 0 : 153);
}
}
else if ((char | 32) === 98) {
kind = 2 | 128;
char = advanceChar(parser);
while (CharTypes[char] & (128 | 4096)) {
if (char === 95) {
if (!allowSeparator) {
parser.report(152);
}
allowSeparator = 0;
char = advanceChar(parser);
continue;
}
allowSeparator = 1;
value = value * 2 + (char - 48);
digits++;
char = advanceChar(parser);
}
if (digits === 0 || !allowSeparator) {
parser.report(digits === 0 ? 0 : 153);
}
}
else if (CharTypes[char] & 32) {
if (context & 1)
parser.report(1);
kind = 1;
while (CharTypes[char] & 16) {
if (CharTypes[char] & 512) {
kind = 32;
atStart = 0;
break;
}
value = value * 8 + (char - 48);
char = advanceChar(parser);
}
}
else if (CharTypes[char] & 512) {
if (context & 1)
parser.report(1);
parser.flags |= 64;
kind = 32;
}
else if (char === 95) {
parser.report(0);
}
}
if (kind & 48) {
if (atStart) {
while (digit >= 0 && CharTypes[char] & (16 | 4096)) {
if (char === 95) {
char = advanceChar(parser);
if (char === 95 || kind & 32) {
throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
}
allowSeparator = 1;
continue;
}
allowSeparator = 0;
value = 10 * value + (char - 48);
char = advanceChar(parser);
--digit;
}
if (allowSeparator) {
throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
}
if (digit >= 0 && !isIdentifierStart(char) && char !== 46) {
parser.tokenValue = value;
if (parser.options.raw)
parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
return 134283266;
}
}
value += scanDecimalDigitsOrSeparator(parser, char);
char = parser.currentChar;
if (char === 46) {
if (advanceChar(parser) === 95)
parser.report(0);
kind = 64;
value += '.' + scanDecimalDigitsOrSeparator(parser, parser.currentChar);
char = parser.currentChar;
}
}
}
const end = parser.index;
let isBigInt = 0;
if (char === 110 && kind & 128) {
isBigInt = 1;
char = advanceChar(parser);
}
else {
if ((char | 32) === 101) {
char = advanceChar(parser);
if (CharTypes[char] & 256)
char = advanceChar(parser);
const { index } = parser;
if ((CharTypes[char] & 16) === 0)
parser.report(11);
value += parser.source.substring(end, index) + scanDecimalDigitsOrSeparator(parser, char);
char = parser.currentChar;
}
}
if ((parser.index < parser.end && CharTypes[char] & 16) || isIdentifierStart(char)) {
parser.report(13);
}
if (isBigInt) {
parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
parser.tokenValue = BigInt(parser.tokenRaw.slice(0, -1).replaceAll('_', ''));
return 134283388;
}
parser.tokenValue =
kind & (1 | 2 | 8 | 4)
? value
: kind & 32
? parseFloat(parser.source.substring(parser.tokenIndex, parser.index))
: +value;
if (parser.options.raw)
parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
return 134283266;
}
function scanDecimalDigitsOrSeparator(parser, char) {
let allowSeparator = 0;
let start = parser.index;
let ret = '';
while (CharTypes[char] & (16 | 4096)) {
if (char === 95) {
const { index } = parser;
char = advanceChar(parser);
if (char === 95) {
throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
}
allowSeparator = 1;
ret += parser.source.substring(start, index);
start = parser.index;
continue;
}
allowSeparator = 0;
char = advanceChar(parser);
}
if (allowSeparator) {
throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
}
return ret + parser.source.substring(start, parser.index);
}
const KeywordDescTable = [
'end of source',
'identifier', 'number', 'string', 'regular expression',
'false', 'true', 'null',
'template continuation', 'template tail',
'=>', '(', '{', '.', '...', '}', ')', ';', ',', '[', ']', ':', '?', '\'', '"',
'++', '--',
'=', '<<=', '>>=', '>>>=', '**=', '+=', '-=', '*=', '/=', '%=', '^=', '|=',
'&=', '||=', '&&=', '??=',
'typeof', 'delete', 'void', '!', '~', '+', '-', 'in', 'instanceof', '*', '%', '/', '**', '&&',
'||', '===', '!==', '==', '!=', '<=', '>=', '<', '>', '<<', '>>', '>>>', '&', '|', '^',
'var', 'let', 'const',
'break', 'case', 'catch', 'class', 'continue', 'debugger', 'default', 'do', 'else', 'export',
'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
'this', 'throw', 'try', 'while', 'with',
'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of',
'enum', 'eval', 'arguments', 'escaped keyword', 'escaped future reserved keyword', 'reserved if strict', '#',
'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
];
const descKeywordTable = {
this: 86111,
function: 86104,
if: 20569,
return: 20572,
var: 86088,
else: 20563,
for: 20567,
new: 86107,
in: 8673330,
typeof: 16863275,
while: 20578,
case: 20556,
break: 20555,
try: 20577,
catch: 20557,
delete: 16863276,
throw: 86112,
switch: 86110,
continue: 20559,
default: 20561,
instanceof: 8411187,
do: 20562,
void: 16863277,
finally: 20566,
async: 209005,
await: 209006,
class: 86094,
const: 86090,
constructor: 12399,
debugger: 20560,
export: 20564,
extends: 20565,
false: 86021,
from: 209011,
get: 209008,
implements: 36964,
import: 86106,
interface: 36965,
let: 241737,
null: 86023,
of: 471156,
package: 36966,
private: 36967,
protected: 36968,
public: 36969,
set: 209009,
static: 36970,
super: 86109,
true: 86022,
with: 20579,
yield: 241771,
enum: 86133,
eval: 537079926,
as: 77932,
arguments: 537079927,
target: 209029,
meta: 209030,
accessor: 12402,
};
function matchOrInsertSemicolon(parser, context) {
if ((parser.flags & 1) === 0 && (parser.getToken() & 1048576) !== 1048576) {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
if (!consumeOpt(parser, context, 1074790417)) {
parser.options.onInsertedSemicolon?.(parser.startIndex);
}
}
function isValidStrictMode(parser, index, tokenIndex, tokenValue) {
if (index - tokenIndex < 13 && tokenValue === 'use strict') {
if ((parser.getToken() & 1048576) === 1048576 || parser.flags & 1) {
return 1;
}
}
return 0;
}
function optionalBit(parser, context, t) {
if (parser.getToken() !== t)
return 0;
nextToken(parser, context);
return 1;
}
function consumeOpt(parser, context, t) {
if (parser.getToken() !== t)
return false;
nextToken(parser, context);
return true;
}
function consume(parser, context, t) {
if (parser.getToken() !== t)
parser.report(25, KeywordDescTable[t & 255]);
nextToken(parser, context);
}
function reinterpretToPattern(parser, node) {
switch (node.type) {
case 'ArrayExpression': {
node.type = 'ArrayPattern';
const { elements } = node;
for (let i = 0, n = elements.length; i < n; ++i) {
const element = elements[i];
if (element)
reinterpretToPattern(parser, element);
}
return;
}
case 'ObjectExpression': {
node.type = 'ObjectPattern';
const { properties } = node;
for (let i = 0, n = properties.length; i < n; ++i) {
reinterpretToPattern(parser, properties[i]);
}
return;
}
case 'AssignmentExpression':
node.type = 'AssignmentPattern';
if (node.operator !== '=')
parser.report(71);
delete node.operator;
reinterpretToPattern(parser, node.left);
return;
case 'Property':
reinterpretToPattern(parser, node.value);
return;
case 'SpreadElement':
node.type = 'RestElement';
reinterpretToPattern(parser, node.argument);
}
}
function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
if (context & 1) {
if ((t & 36864) === 36864) {
parser.report(118);
}
if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
parser.report(119);
}
}
if ((t & 20480) === 20480 || t === -2147483528) {
parser.report(102);
}
if (kind & (8 | 16) && (t & 255) === (241737 & 255)) {
parser.report(100);
}
if (context & (2048 | 2) && t === 209006) {
parser.report(110);
}
if (context & (1024 | 1) && t === 241771) {
parser.report(97, 'yield');
}
}
function validateFunctionName(parser, context, t) {
if (context & 1) {
if ((t & 36864) === 36864) {
parser.report(118);
}
if ((t & 537079808) === 537079808) {
parser.report(119);
}
if (t === -2147483527) {
parser.report(95);
}
if (t === -2147483528) {
parser.report(95);
}
}
if ((t & 20480) === 20480) {
parser.report(102);
}
if (context & (2048 | 2) && t === 209006) {
parser.report(110);
}
if (context & (1024 | 1) && t === 241771) {
parser.report(97, 'yield');
}
}
function isStrictReservedWord(parser, context, t) {
if (t === 209006) {
if (context & (2048 | 2))
parser.report(110);
parser.destructible |= 128;
}
if (t === 241771 && context & 1024)
parser.report(97, 'yield');
return ((t & 20480) === 20480 ||
(t & 36864) === 36864 ||
t == -2147483527);
}
function isPropertyWithPrivateFieldKey(expr) {
return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
}
function isValidLabel(parser, labels, name, isIterationStatement) {
while (labels) {
if (labels['$' + name]) {
if (isIterationStatement)
parser.report(137);
return 1;
}
if (isIterationStatement && labels.loop)
isIterationStatement = 0;
labels = labels['$'];
}
return 0;
}
function validateAndDeclareLabel(parser, labels, name) {
let set = labels;
while (set) {
if (set['$' + name])
parser.report(136, name);
set = set['$'];
}
labels['$' + name] = 1;
}
function isEqualTagName(elementName) {
switch (elementName.type) {
case 'JSXIdentifier':
return elementName.name;
case 'JSXNamespacedName':
return elementName.namespace + ':' + elementName.name;
case 'JSXMemberExpression':
return isEqualTagName(elementName.object) + '.' + isEqualTagName(elementName.property);
}
}
function isValidIdentifier(context, t) {
if (context & (1 | 1024)) {
if (context & 2 && t === 209006)
return false;
if (context & 1024 && t === 241771)
return false;
return (t & 12288) === 12288;
}
return (t & 12288) === 12288 || (t & 36864) === 36864;
}
function classifyIdentifier(parser, context, t) {
if ((t & 537079808) === 537079808) {
if (context & 1)
parser.report(119);
parser.flags |= 512;
}
if (!isValidIdentifier(context, t))
parser.report(0);
}
function getOwnProperty(object, key) {
return Object.hasOwn(object, key) ? object[key] : undefined;
}
function scanIdentifier(parser, context, isValidAsKeyword) {
while (isIdPart[advanceChar(parser)])
;
parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
return parser.currentChar !== 92 && parser.currentChar <= 0x7e
? (getOwnProperty(descKeywordTable, parser.tokenValue) ?? 208897)
: scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
}
function scanUnicodeIdentifier(parser, context) {
const cookedChar = scanIdentifierUnicodeEscape(parser);
if (!isIdentifierStart(cookedChar))
parser.report(5);
parser.tokenValue = String.fromCodePoint(cookedChar);
return scanIdentifierSlowCase(parser, context, 1, CharTypes[cookedChar] & 4);
}
function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
let start = parser.index;
while (parser.index < parser.end) {
if (parser.currentChar === 92) {
parser.tokenValue += parser.source.slice(start, parser.index);
hasEscape = 1;
const code = scanIdentifierUnicodeEscape(parser);
if (!isIdentifierPart(code))
parser.report(5);
isValidAsKeyword = isValidAsKeyword && CharTypes[code] & 4;
parser.tokenValue += String.fromCodePoint(code);
start = parser.index;
}
else {
const merged = consumePossibleSurrogatePair(parser);
if (merged > 0) {
if (!isIdentifierPart(merged)) {
parser.report(20, String.fromCodePoint(merged));
}
parser.currentChar = merged;
parser.index++;
parser.column++;
}
else if (!isIdentifierPart(parser.currentChar)) {
break;
}
advanceChar(parser);
}
}
if (parser.index <= parser.end) {
parser.tokenValue += parser.source.slice(start, parser.index);
}
const { length } = parser.tokenValue;
if (isValidAsKeyword && length >= 2 && length <= 11) {
const token = getOwnProperty(descKeywordTable, parser.tokenValue);
if (token === void 0)
return 208897 | (hasEscape ? -2147483648 : 0);
if (!hasEscape)
return token;
if (token === 209006) {
if ((context & (2 | 2048)) === 0) {
return token | -2147483648;
}
return -2147483528;
}
if (context & 1) {
if (token === 36970) {
return -2147483527;
}
if ((token & 36864) === 36864) {
return -2147483527;
}
if ((token & 20480) === 20480) {
if (context & 262144 && (context & 8) === 0) {
return token | -2147483648;
}
else {
return -2147483528;
}
}
return 209018 | -2147483648;
}
if (context & 262144 &&
(context & 8) === 0 &&
(token & 20480) === 20480) {
return token | -2147483648;
}
if (token === 241771) {
return context & 262144
? 209018 | -2147483648
: context & 1024
? -2147483528
: token | -2147483648;
}
if (token === 209005) {
return 209018 | -2147483648;
}
if ((token & 36864) === 36864) {
return token | 12288 | -2147483648;
}
return -2147483528;
}
return 208897 | (hasEscape ? -2147483648 : 0);
}
function scanPrivateIdentifier(parser) {
let char = advanceChar(parser);
if (char === 92)
return 130;
const merged = consumePossibleSurrogatePair(parser);
if (merged)
char = merged;
if (!isIdentifierStart(char))
parser.report(96);
return 130;
}
function scanIdentifierUnicodeEscape(parser) {
if (parser.source.charCodeAt(parser.index + 1) !== 117) {
parser.report(5);
}
parser.currentChar = parser.source.charCodeAt((parser.index += 2));
parser.column += 2;
return scanUnicodeEscape(parser);
}
function scanUnicodeEscape(parser) {
let codePoint = 0;
const char = parser.currentChar;
if (char === 123) {
const begin = parser.index - 2;
while (CharTypes[advanceChar(parser)] & 64) {
codePoint = (codePoint << 4) | toHex(parser.currentChar);
if (codePoint > 1114111)
throw new ParseError({ index: begin, line: parser.line, column: parser.column }, parser.currentLocation, 104);
}
if (parser.currentChar !== 125) {
throw new ParseError({ index: begin, line: parser.line, column: parser.column }, parser.currentLocation, 7);
}
advanceChar(parser);
return codePoint;
}
if ((CharTypes[char] & 64) === 0)
parser.report(7);
const char2 = parser.source.charCodeAt(parser.index + 1);
if ((CharTypes[char2] & 64) === 0)
parser.report(7);
const char3 = parser.source.charCodeAt(parser.index + 2);
if ((CharTypes[char3] & 64) === 0)
parser.report(7);
const char4 = parser.source.charCodeAt(parser.index + 3);
if ((CharTypes[char4] & 64) === 0)
parser.report(7);
codePoint = (toHex(char) << 12) | (toHex(char2) << 8) | (toHex(char3) << 4) | toHex(char4);
parser.currentChar = parser.source.charCodeAt((parser.index += 4));
parser.column += 4;
return codePoint;
}
const TokenLookup = [
128,
128,
128,
128,
128,
128,
128,
128,
128,
127,
135,
127,
127,
129,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
128,
127,
16842798,
134283267,
130,
208897,
8391477,
8390213,
134283267,
67174411,
16,
8391476,
25233968,
18,
25233969,
67108877,
8457014,
134283266,
134283266,
134283266,
134283266,
134283266,
134283266,
134283266,
134283266,
134283266,
134283266,
21,
1074790417,
8456256,
1077936155,
8390721,
22,
132,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
208897,
69271571,
136,
20,
8389959,
208897,
131,
4096,
4096,
4096,
4096,
4096,
4096,
4096,
208897,
4096,
208897,
208897,
4096,
208897,
4096,
208897,
4096,
208897,
4096,
4096,
4096,
208897,
4096,
4096,
208897,
4096,
4096,
2162700,
8389702,
1074790415,
16842799,
128,
];
function nextToken(parser, context) {
parser.flags = (parser.flags | 1) ^ 1;
parser.startIndex = parser.index;
parser.startColumn = parser.column;
parser.startLine = parser.line;
parser.setToken(scanSingleToken(parser, context, 0));
}
function scanSingleToken(parser, context, state) {
const isStartOfLine = parser.index === 0;
const { source } = parser;
let start = parser.currentLocation;
while (parser.index < parser.end) {
parser.tokenIndex = parser.index;
parser.tokenColumn = parser.column;
parser.tokenLine = parser.line;
let char = parser.currentChar;
if (char <= 0x7e) {
const token = TokenLookup[char];
switch (token) {
case 67174411:
case 16:
case 2162700:
case 1074790415:
case 69271571:
case 20:
case 21:
case 1074790417:
case 18:
case 16842799:
case 132:
case 128:
advanceChar(parser);
return token;
case 208897:
return scanIdentifier(parser, context, 0);
case 4096:
return scanIdentifier(parser, context, 1);
case 134283266:
return scanNumber(parser, context, 16 | 128);
case 134283267:
return scanString(parser, context, char);
case 131:
return scanTemplate(parser, context);
case 136:
return scanUnicodeIdentifier(parser, context);
case 130:
return scanPrivateIdentifier(parser);
case 127:
advanceChar(parser);
break;
case 129:
state |= 1 | 4;
scanNewLine(parser);
break;
case 135:
consumeLineFeed(parser, state);
state = (state & -5) | 1;
break;
case 8456256: {
const ch = advanceChar(parser);
if (parser.index < parser.end) {
if (ch === 60) {
if (parser.index < parser.end && advanceChar(parser) === 61) {
advanceChar(parser);
return 4194332;
}
return 8390978;
}
else if (ch === 61) {
advanceChar(parser);
return 8390718;
}
if (ch === 33) {
const index = parser.index + 1;
if (index + 1 < parser.end &&
source.charCodeAt(index) === 45 &&
source.charCodeAt(index + 1) == 45) {
parser.column += 3;
parser.currentChar = source.charCodeAt((parser.index += 3));
state = skipSingleHTMLComment(parser, source, state, context, 2, parser.tokenStart);
start = parser.tokenStart;
continue;
}
return 8456256;
}
}
return 8456256;
}
case 1077936155: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 61) {
if (advanceChar(parser) === 61) {
advanceChar(parser);
return 8390458;
}
return 8390460;
}
if (ch === 62) {
advanceChar(parser);
return 10;
}
return 1077936155;
}
case 16842798:
if (advanceChar(parser) !== 61) {
return 16842798;
}
if (advanceChar(parser) !== 61) {
return 8390461;
}
advanceChar(parser);
return 8390459;
case 8391477:
if (advanceChar(parser) !== 61)
return 8391477;
advanceChar(parser);
return 4194340;
case 8391476: {
advanceChar(parser);
if (parser.index >= parser.end)
return 8391476;
const ch = parser.currentChar;
if (ch === 61) {
advanceChar(parser);
return 4194338;
}
if (ch !== 42)
return 8391476;
if (advanceChar(parser) !== 61)
return 8391735;
advanceChar(parser);
return 4194335;
}
case 8389959:
if (advanceChar(parser) !== 61)
return 8389959;
advanceChar(parser);
return 4194341;
case 25233968: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 43) {
advanceChar(parser);
return 33619993;
}
if (ch === 61) {
advanceChar(parser);
return 4194336;
}
return 25233968;
}
case 25233969: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 45) {
advanceChar(parser);
if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
if (!parser.options.webcompat)
parser.report(112);
advanceChar(parser);
state = skipSingleHTMLComment(parser, source, state, context, 3, start);
start = parser.tokenStart;
continue;
}
return 33619994;
}
if (ch === 61) {
advanceChar(parser);
return 4194337;
}
return 25233969;
}
case 8457014: {
advanceChar(parser);
if (parser.index < parser.end) {
const ch = parser.currentChar;
if (ch === 47) {
advanceChar(parser);
state = skipSingleLineComment(parser, source, state, 0, parser.tokenStart);
start = parser.tokenStart;
continue;
}
if (ch === 42) {
advanceChar(parser);
state = skipMultiLineComment(parser, source, state);
start = parser.tokenStart;
continue;
}
if (context & 32) {
return scanRegularExpression(parser);
}
if (ch === 61) {
advanceChar(parser);
return 4259875;
}
}
return 8457014;
}
case 67108877: {
const next = advanceChar(parser);
if (next >= 48 && next <= 57)
return scanNumber(parser, context, 64 | 16);
if (next === 46) {
const index = parser.index + 1;
if (index < parser.end && source.charCodeAt(index) === 46) {
parser.column += 2;
parser.currentChar = source.charCodeAt((parser.index += 2));
return 14;
}
}
return 67108877;
}
case 8389702: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 124) {
advanceChar(parser);
if (parser.currentChar === 61) {
advanceChar(parser);
return 4194344;
}
return 8913465;
}
if (ch === 61) {
advanceChar(parser);
return 4194342;
}
return 8389702;
}
case 8390721: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 61) {
advanceChar(parser);
return 8390719;
}
if (ch !== 62)
return 8390721;
advanceChar(parser);
if (parser.index < parser.end) {
const ch = parser.currentChar;
if (ch === 62) {
if (advanceChar(parser) === 61) {
advanceChar(parser);
return 4194334;
}
return 8390980;
}
if (ch === 61) {
advanceChar(parser);
return 4194333;
}
}
return 8390979;
}
case 8390213: {
advanceChar(parser);
const ch = parser.currentChar;
if (ch === 38) {
advanceChar(parser);
if (parser.currentChar === 61) {
advanceChar(parser);
return 4194345;
}
return 8913720;
}
if (ch === 61) {
advanceChar(parser);
return 4194343;
}
return 8390213;
}
case 22: {
let ch = advanceChar(parser);
if (ch === 63) {
advanceChar(parser);
if (parser.currentChar === 61) {
advanceChar(parser);
return 4194346;
}
return 276824445;
}
if (ch === 46) {
const index = parser.index + 1;
if (index < parser.end) {
ch = source.charCodeAt(index);
if (!(ch >= 48 && ch <= 57)) {
advanceChar(parser);
return 67108990;
}
}
}
return 22;
}
}
}
else {
if ((char ^ 8232) <= 1) {
state = (state & -5) | 1;
scanNewLine(parser);
continue;
}
const merged = consumePossibleSurrogatePair(parser);
if (merged > 0)
char = merged;
if (isIDStart(char)) {
parser.tokenValue = '';
return scanIdentifierSlowCase(parser, context, 0, 0);
}
if (isExoticECMAScriptWhitespace(char)) {
advanceChar(parser);
continue;
}
parser.report(20, String.fromCodePoint(char));
}
}
return 1048576;
}
const entities = {
AElig: '\u00C6',
AMP: '\u0026',
Aacute: '\u00C1',
Abreve: '\u0102',
Acirc: '\u00C2',
Acy: '\u0410',
Afr: '\uD835\uDD04',
Agrave: '\u00C0',
Alpha: '\u0391',
Amacr: '\u0100',
And: '\u2A53',
Aogon: '\u0104',
Aopf: '\uD835\uDD38',
ApplyFunction: '\u2061',
Aring: '\u00C5',
Ascr: '\uD835\uDC9C',
Assign: '\u2254',
Atilde: '\u00C3',
Auml: '\u00C4',
Backslash: '\u2216',
Barv: '\u2AE7',
Barwed: '\u2306',
Bcy: '\u0411',
Because: '\u2235',
Bernoullis: '\u212C',
Beta: '\u0392',
Bfr: '\uD835\uDD05',
Bopf: '\uD835\uDD39',
Breve: '\u02D8',
Bscr: '\u212C',
Bumpeq: '\u224E',
CHcy: '\u0427',
COPY: '\u00A9',
Cacute: '\u0106',
Cap: '\u22D2',
CapitalDifferentialD: '\u2145',
Cayleys: '\u212D',
Ccaron: '\u010C',
Ccedil: '\u00C7',
Ccirc: '\u0108',
Cconint: '\u2230',
Cdot: '\u010A',
Cedilla: '\u00B8',
CenterDot: '\u00B7',
Cfr: '\u212D',
Chi: '\u03A7',
CircleDot: '\u2299',
CircleMinus: '\u2296',
CirclePlus: '\u2295',
CircleTimes: '\u2297',
ClockwiseContourIntegral: '\u2232',
CloseCurlyDoubleQuote: '\u201D',
CloseCurlyQuote: '\u2019',
Colon: '\u2237',
Colone: '\u2A74',
Congruent: '\u2261',
Conint: '\u222F',
ContourIntegral: '\u222E',
Copf: '\u2102',
Coproduct: '\u2210',
CounterClockwiseContourIntegral: '\u2233',
Cross: '\u2A2F',
Cscr: '\uD835\uDC9E',
Cup: '\u22D3',
CupCap: '\u224D',
DD: '\u2145',
DDotrahd: '\u2911',
DJcy: '\u0402',
DScy: '\u0405',
DZcy: '\u040F',
Dagger: '\u2021',
Darr: '\u21A1',
Dashv: '\u2AE4',
Dcaron: '\u010E',
Dcy: '\u0414',
Del: '\u2207',
Delta: '\u0394',
Dfr: '\uD835\uDD07',
DiacriticalAcute: '\u00B4',
DiacriticalDot: '\u02D9',
DiacriticalDoubleAcute: '\u02DD',
DiacriticalGrave: '\u0060',
DiacriticalTilde: '\u02DC',
Diamond: '\u22C4',
DifferentialD: '\u2146',
Dopf: '\uD835\uDD3B',
Dot: '\u00A8',
DotDot: '\u20DC',
DotEqual: '\u2250',
DoubleContourIntegral: '\u222F',
DoubleDot: '\u00A8',
DoubleDownArrow: '\u21D3',
DoubleLeftArrow: '\u21D0',
DoubleLeftRightArrow: '\u21D4',
DoubleLeftTee: '\u2AE4',
DoubleLongLeftArrow: '\u27F8',
DoubleLongLeftRightArrow: '\u27FA',
DoubleLongRightArrow: '\u27F9',
DoubleRightArrow: '\u21D2',
DoubleRightTee: '\u22A8',
DoubleUpArrow: '\u21D1',
DoubleUpDownArrow: '\u21D5',
DoubleVerticalBar: '\u2225',
DownArrow: '\u2193',
DownArrowBar: '\u2913',
DownArrowUpArrow: '\u21F5',
DownBreve: '\u0311',
DownLeftRightVector: '\u2950',
DownLeftTeeVector: '\u295E',
DownLeftVector: '\u21BD',
DownLeftVectorBar: '\u2956',
DownRightTeeVector: '\u295F',
DownRightVector: '\u21C1',
DownRightVectorBar: '\u2957',
DownTee: '\u22A4',
DownTeeArrow: '\u21A7',
Downarrow: '\u21D3',
Dscr: '\uD835\uDC9F',
Dstrok: '\u0110',
ENG: '\u014A',
ETH: '\u00D0',
Eacute: '\u00C9',
Ecaron: '\u011A',
Ecirc: '\u00CA',
Ecy: '\u042D',
Edot: '\u0116',
Efr: '\uD835\uDD08',
Egrave: '\u00C8',
Element: '\u2208',
Emacr: '\u0112',
EmptySmallSquare: '\u25FB',
EmptyVerySmallSquare: '\u25AB',
Eogon: '\u0118',
Eopf: '\uD835\uDD3C',
Epsilon: '\u0395',
Equal: '\u2A75',
EqualTilde: '\u2242',
Equilibrium: '\u21CC',
Escr: '\u2130',
Esim: '\u2A73',
Eta: '\u0397',
Euml: '\u00CB',
Exists: '\u2203',
ExponentialE: '\u2147',
Fcy: '\u0424',
Ffr: '\uD835\uDD09',
FilledSmallSquare: '\u25FC',
FilledVerySmallSquare: '\u25AA',
Fopf: '\uD835\uDD3D',
ForAll: '\u2200',
Fouriertrf: '\u2131',
Fscr: '\u2131',
GJcy: '\u0403',
GT: '\u003E',
Gamma: '\u0393',
Gammad: '\u03DC',
Gbreve: '\u011E',
Gcedil: '\u0122',
Gcirc: '\u011C',
Gcy: '\u0413',
Gdot: '\u0120',
Gfr: '\uD835\uDD0A',
Gg: '\u22D9',
Gopf: '\uD835\uDD3E',
GreaterEqual: '\u2265',
GreaterEqualLess: '\u22DB',
GreaterFullEqual: '\u2267',
GreaterGreater: '\u2AA2',
GreaterLess: '\u2277',
GreaterSlantEqual: '\u2A7E',
GreaterTilde: '\u2273',
Gscr: '\uD835\uDCA2',
Gt: '\u226B',
HARDcy: '\u042A',
Hacek: '\u02C7',
Hat: '\u005E',
Hcirc: '\u0124',
Hfr: '\u210C',
HilbertSpace: '\u210B',
Hopf: '\u210D',
HorizontalLine: '\u2500',
Hscr: '\u210B',
Hstrok: '\u0126',
HumpDownHump: '\u224E',
HumpEqual: '\u224F',
IEcy: '\u0415',
IJlig: '\u0132',
IOcy: '\u0401',
Iacute: '\u00CD',
Icirc: '\u00CE',
Icy: '\u0418',
Idot: '\u0130',
Ifr: '\u2111',
Igrave: '\u00CC',
Im: '\u2111',
Imacr: '\u012A',
ImaginaryI: '\u2148',
Implies: '\u21D2',
Int: '\u222C',
Integral: '\u222B',
Intersection: '\u22C2',
InvisibleComma: '\u2063',
InvisibleTimes: '\u2062',
Iogon: '\u012E',
Iopf: '\uD835\uDD40',
Iota: '\u0399',
Iscr: '\u2110',
Itilde: '\u0128',
Iukcy: '\u0406',
Iuml: '\u00CF',
Jcirc: '\u0134',
Jcy: '\u0419',
Jfr: '\uD835\uDD0D',
Jopf: '\uD835\uDD41',
Jscr: '\uD835\uDCA5',
Jsercy: '\u0408',
Jukcy: '\u0404',
KHcy: '\u0425',
KJcy: '\u040C',
Kappa: '\u039A',
Kcedil: '\u0136',
Kcy: '\u041A',
Kfr: '\uD835\uDD0E',
Kopf: '\uD835\uDD42',
Kscr: '\uD835\uDCA6',
LJcy: '\u0409',
LT: '\u003C',
Lacute: '\u0139',
Lambda: '\u039B',
Lang: '\u27EA',
Laplacetrf: '\u2112',
Larr: '\u219E',
Lcaron: '\u013D',
Lcedil: '\u013B',
Lcy: '\u041B',
LeftAngleBracket: '\u27E8',
LeftArrow: '\u2190',
LeftArrowBar: '\u21E4',
LeftArrowRightArrow: '\u21C6',
LeftCeiling: '\u2308',
LeftDoubleBracket: '\u27E6',
LeftDownTeeVector: '\u2961',
LeftDownVector: '\u21C3',
LeftDownVectorBar: '\u2959',
LeftFloor: '\u230A',
LeftRightArrow: '\u2194',
LeftRightVector: '\u294E',
LeftTee: '\u22A3',
LeftTeeArrow: '\u21A4',
LeftTeeVector: '\u295A',
LeftTriangle: '\u22B2',
LeftTriangleBar: '\u29CF',
LeftTriangleEqual: '\u22B4',
LeftUpDownVector: '\u2951',
LeftUpTeeVector: '\u2960',
LeftUpVector: '\u21BF',
LeftUpVectorBar: '\u2958',
LeftVector: '\u21BC',
LeftVectorBar: '\u2952',
Leftarrow: '\u21D0',
Leftrightarrow: '\u21D4',
LessEqualGreater: '\u22DA',
LessFullEqual: '\u2266',
LessGreater: '\u2276',
LessLess: '\u2AA1',
LessSlantEqual: '\u2A7D',
LessTilde: '\u2272',
Lfr: '\uD835\uDD0F',
Ll: '\u22D8',
Lleftarrow: '\u21DA',
Lmidot: '\u013F',
LongLeftArrow: '\u27F5',
LongLeftRightArrow: '\u27F7',
LongRightArrow: '\u27F6',
Longleftarrow: '\u27F8',
Longleftrightarrow: '\u27FA',
Longrightarrow: '\u27F9',
Lopf: '\uD835\uDD43',
LowerLeftArrow: '\u2199',
LowerRightArrow: '\u2198',
Lscr: '\u2112',
Lsh: '\u21B0',
Lstrok: '\u0141',
Lt: '\u226A',
Map: '\u2905',
Mcy: '\u041C',
MediumSpace: '\u205F',
Mellintrf: '\u2133',
Mfr: '\uD835\uDD10',
MinusPlus: '\u2213',
Mopf: '\uD835\uDD44',
Mscr: '\u2133',
Mu: '\u039C',
NJcy: '\u040A',
Nacute: '\u0143',
Ncaron: '\u0147',
Ncedil: '\u0145',
Ncy: '\u041D',
NegativeMediumSpace: '\u200B',
NegativeThickSpace: '\u200B',
NegativeThinSpace: '\u200B',
NegativeVeryThinSpace: '\u200B',
NestedGreaterGreater: '\u226B',
NestedLessLess: '\u226A',
NewLine: '\u000A',
Nfr: '\uD835\uDD11',
NoBreak: '\u2060',
NonBreakingSpace: '\u00A0',
Nopf: '\u2115',
Not: '\u2AEC',
NotCongruent: '\u2262',
NotCupCap: '\u226D',
NotDoubleVerticalBar: '\u2226',
NotElement: '\u2209',
NotEqual: '\u2260',
NotEqualTilde: '\u2242\u0338',
NotExists: '\u2204',
NotGreater: '\u226F',
NotGreaterEqual: '\u2271',
NotGreaterFullEqual: '\u2267\u0338',
NotGreaterGreater: '\u226B\u0338',
NotGreaterLess: '\u2279',
NotGreaterSlantEqual: '\u2A7E\u0338',
NotGreaterTilde: '\u2275',
NotHumpDownHump: '\u224E\u0338',
NotHumpEqual: '\u224F\u0338',
NotLeftTriangle: '\u22EA',
NotLeftTriangleBar: '\u29CF\u0338',
NotLeftTriangleEqual: '\u22EC',
NotLess: '\u226E',
NotLessEqual: '\u2270',
NotLessGreater: '\u2278',
NotLessLess: '\u226A\u0338',
NotLessSlantEqual: '\u2A7D\u0338',
NotLessTilde: '\u2274',
NotNestedGreaterGreater: '\u2AA2\u0338',
NotNestedLessLess: '\u2AA1\u0338',
NotPrecedes: '\u2280',
NotPrecedesEqual: '\u2AAF\u0338',
NotPrecedesSlantEqual: '\u22E0',
NotReverseElement: '\u220C',
NotRightTriangle: '\u22EB',
NotRightTriangleBar: '\u29D0\u0338',
NotRightTriangleEqual: '\u22ED',
NotSquareSubset: '\u228F\u0338',
NotSquareSubsetEqual: '\u22E2',
NotSquareSuperset: '\u2290\u0338',
NotSquareSupersetEqual: '\u22E3',
NotSubset: '\u2282\u20D2',
NotSubsetEqual: '\u2288',
NotSucceeds: '\u2281',
NotSucceedsEqual: '\u2AB0\u0338',
NotSucceedsSlantEqual: '\u22E1',
NotSucceedsTilde: '\u227F\u0338',
NotSuperset: '\u2283\u20D2',
NotSupersetEqual: '\u2289',
NotTilde: '\u2241',
NotTildeEqual: '\u2244',
NotTildeFullEqual: '\u2247',
NotTildeTilde: '\u2249',
NotVerticalBar: '\u2224',
Nscr: '\uD835\uDCA9',
Ntilde: '\u00D1',
Nu: '\u039D',
OElig: '\u0152',
Oacute: '\u00D3',
Ocirc: '\u00D4',
Ocy: '\u041E',
Odblac: '\u0150',
Ofr: '\uD835\uDD12',
Ograve: '\u00D2',
Omacr: '\u014C',
Omega: '\u03A9',
Omicron: '\u039F',
Oopf: '\uD835\uDD46',
OpenCurlyDoubleQuote: '\u201C',
OpenCurlyQuote: '\u2018',
Or: '\u2A54',
Oscr: '\uD835\uDCAA',
Oslash: '\u00D8',
Otilde: '\u00D5',
Otimes: '\u2A37',
Ouml: '\u00D6',
OverBar: '\u203E',
OverBrace: '\u23DE',
OverBracket: '\u23B4',
OverParenthesis: '\u23DC',
PartialD: '\u2202',
Pcy: '\u041F',
Pfr: '\uD835\uDD13',
Phi: '\u03A6',
Pi: '\u03A0',
PlusMinus: '\u00B1',
Poincareplane: '\u210C',
Popf: '\u2119',
Pr: '\u2ABB',
Precedes: '\u227A',
PrecedesEqual: '\u2AAF',
PrecedesSlantEqual: '\u227C',
PrecedesTilde: '\u227E',
Prime: '\u2033',
Product: '\u220F',
Proportion: '\u2237',
Proportional: '\u221D',
Pscr: '\uD835\uDCAB',
Psi: '\u03A8',
QUOT: '\u0022',
Qfr: '\uD835\uDD14',
Qopf: '\u211A',
Qscr: '\uD835\uDCAC',
RBarr: '\u2910',
REG: '\u00AE',
Racute: '\u0154',
Rang: '\u27EB',
Rarr: '\u21A0',
Rarrtl: '\u2916',
Rcaron: '\u0158',
Rcedil: '\u0156',
Rcy: '\u0420',
Re: '\u211C',
ReverseElement: '\u220B',
ReverseEquilibrium: '\u21CB',
ReverseUpEquilibrium: '\u296F',
Rfr: '\u211C',
Rho: '\u03A1',
RightAngleBracket: '\u27E9',
RightArrow: '\u2192',
RightArrowBar: '\u21E5',
RightArrowLeftArrow: '\u21C4',
RightCeiling: '\u2309',
RightDoubleBracket: '\u27E7',
RightDownTeeVector: '\u295D',
RightDownVector: '\u21C2',
RightDownVectorBar: '\u2955',
RightFloor: '\u230B',
RightTee: '\u22A2',
RightTeeArrow: '\u21A6',
RightTeeVector: '\u295B',
RightTriangle: '\u22B3',
RightTriangleBar: '\u29D0',
RightTriangleEqual: '\u22B5',
RightUpDownVector: '\u294F',
RightUpTeeVector: '\u295C',
RightUpVector: '\u21BE',
RightUpVectorBar: '\u2954',
RightVector: '\u21C0',
RightVectorBar: '\u2953',
Rightarrow: '\u21D2',
Ropf: '\u211D',
RoundImplies: '\u2970',
Rrightarrow: '\u21DB',
Rscr: '\u211B',
Rsh: '\u21B1',
RuleDelayed: '\u29F4',
SHCHcy: '\u0429',
SHcy: '\u0428',
SOFTcy: '\u042C',
Sacute: '\u015A',
Sc: '\u2ABC',
Scaron: '\u0160',
Scedil: '\u015E',
Scirc: '\u015C',
Scy: '\u0421',
Sfr: '\uD835\uDD16',
ShortDownArrow: '\u2193',
ShortLeftArrow: '\u2190',
ShortRightArrow: '\u2192',
ShortUpArrow: '\u2191',
Sigma: '\u03A3',
SmallCircle: '\u2218',
Sopf: '\uD835\uDD4A',
Sqrt: '\u221A',
Square: '\u25A1',
SquareIntersection: '\u2293',
SquareSubset: '\u228F',
SquareSubsetEqual: '\u2291',
SquareSuperset: '\u2290',
SquareSupersetEqual: '\u2292',
SquareUnion: '\u2294',
Sscr: '\uD835\uDCAE',
Star: '\u22C6',
Sub: '\u22D0',
Subset: '\u22D0',
SubsetEqual: '\u2286',
Succeeds: '\u227B',
SucceedsEqual: '\u2AB0',
SucceedsSlantEqual: '\u227D',
SucceedsTilde: '\u227F',
SuchThat: '\u220B',
Sum: '\u2211',
Sup: '\u22D1',
Superset: '\u2283',
SupersetEqual: '\u2287',
Supset: '\u22D1',
THORN: '\u00DE',
TRADE: '\u2122',
TSHcy: '\u040B',
TScy: '\u0426',
Tab: '\u0009',
Tau: '\u03A4',
Tcaron: '\u0164',
Tcedil: '\u0162',
Tcy: '\u0422',
Tfr: '\uD835\uDD17',
Therefore: '\u2234',
Theta: '\u0398',
ThickSpace: '\u205F\u200A',
ThinSpace: '\u2009',
Tilde: '\u223C',
TildeEqual: '\u2243',
TildeFullEqual: '\u2245',
TildeTilde: '\u2248',
Topf: '\uD835\uDD4B',
TripleDot: '\u20DB',
Tscr: '\uD835\uDCAF',
Tstrok: '\u0166',
Uacute: '\u00DA',
Uarr: '\u219F',
Uarrocir: '\u2949',
Ubrcy: '\u040E',
Ubreve: '\u016C',
Ucirc: '\u00DB',
Ucy: '\u0423',
Udblac: '\u0170',
Ufr: '\uD835\uDD18',
Ugrave: '\u00D9',
Umacr: '\u016A',
UnderBar: '\u005F',
UnderBrace: '\u23DF',
UnderBracket: '\u23B5',
UnderParenthesis: '\u23DD',
Union: '\u22C3',
UnionPlus: '\u228E',
Uogon: '\u0172',
Uopf: '\uD835\uDD4C',
UpArrow: '\u2191',
UpArrowBar: '\u2912',
UpArrowDownArrow: '\u21C5',
UpDownArrow: '\u2195',
UpEquilibrium: '\u296E',
UpTee: '\u22A5',
UpTeeArrow: '\u21A5',
Uparrow: '\u21D1',
Updownarrow: '\u21D5',
UpperLeftArrow: '\u2196',
UpperRightArrow: '\u2197',
Upsi: '\u03D2',
Upsilon: '\u03A5',
Uring: '\u016E',
Uscr: '\uD835\uDCB0',
Utilde: '\u0168',
Uuml: '\u00DC',
VDash: '\u22AB',
Vbar: '\u2AEB',
Vcy: '\u0412',
Vdash: '\u22A9',
Vdashl: '\u2AE6',
Vee: '\u22C1',
Verbar: '\u2016',
Vert: '\u2016',
VerticalBar: '\u2223',
VerticalLine: '\u007C',
VerticalSeparator: '\u2758',
VerticalTilde: '\u2240',
VeryThinSpace: '\u200A',
Vfr: '\uD835\uDD19',
Vopf: '\uD835\uDD4D',
Vscr: '\uD835\uDCB1',
Vvdash: '\u22AA',
Wcirc: '\u0174',
Wedge: '\u22C0',
Wfr: '\uD835\uDD1A',
Wopf: '\uD835\uDD4E',
Wscr: '\uD835\uDCB2',
Xfr: '\uD835\uDD1B',
Xi: '\u039E',
Xopf: '\uD835\uDD4F',
Xscr: '\uD835\uDCB3',
YAcy: '\u042F',
YIcy: '\u0407',
YUcy: '\u042E',
Yacute: '\u00DD',
Ycirc: '\u0176',
Ycy: '\u042B',
Yfr: '\uD835\uDD1C',
Yopf: '\uD835\uDD50',
Yscr: '\uD835\uDCB4',
Yuml: '\u0178',
ZHcy: '\u0416',
Zacute: '\u0179',
Zcaron: '\u017D',
Zcy: '\u0417',
Zdot: '\u017B',
ZeroWidthSpace: '\u200B',
Zeta: '\u0396',
Zfr: '\u2128',
Zopf: '\u2124',
Zscr: '\uD835\uDCB5',
aacute: '\u00E1',
abreve: '\u0103',
ac: '\u223E',
acE: '\u223E\u0333',
acd: '\u223F',
acirc: '\u00E2',
acute: '\u00B4',
acy: '\u0430',
aelig: '\u00E6',
af: '\u2061',
afr: '\uD835\uDD1E',
agrave: '\u00E0',
alefsym: '\u2135',
aleph: '\u2135',
alpha: '\u03B1',
amacr: '\u0101',
amalg: '\u2A3F',
amp: '\u0026',
and: '\u2227',
andand: '\u2A55',
andd: '\u2A5C',
andslope: '\u2A58',
andv: '\u2A5A',
ang: '\u2220',
ange: '\u29A4',
angle: '\u2220',
angmsd: '\u2221',
angmsdaa: '\u29A8',
angmsdab: '\u29A9',
angmsdac: '\u29AA',
angmsdad: '\u29AB',
angmsdae: '\u29AC',
angmsdaf: '\u29AD',
angmsdag: '\u29AE',
angmsdah: '\u29AF',
angrt: '\u221F',
angrtvb: '\u22BE',
angrtvbd: '\u299D',
angsph: '\u2222',
angst: '\u00C5',
angzarr: '\u237C',
aogon: '\u0105',
aopf: '\uD835\uDD52',
ap: '\u2248',
apE: '\u2A70',
apacir: '\u2A6F',
ape: '\u224A',
apid: '\u224B',
apos: '\u0027',
approx: '\u2248',
approxeq: '\u224A',
aring: '\u00E5',
ascr: '\uD835\uDCB6',
ast: '\u002A',
asymp: '\u2248',
asympeq: '\u224D',
atilde: '\u00E3',
auml: '\u00E4',
awconint: '\u2233',
awint: '\u2A11',
bNot: '\u2AED',
backcong: '\u224C',
backepsilon: '\u03F6',
backprime: '\u2035',
backsim: '\u223D',
backsimeq: '\u22CD',
barvee: '\u22BD',
barwed: '\u2305',
barwedge: '\u2305',
bbrk: '\u23B5',
bbrktbrk: '\u23B6',
bcong: '\u224C',
bcy: '\u0431',
bdquo: '\u201E',
becaus: '\u2235',
because: '\u2235',
bemptyv: '\u29B0',
bepsi: '\u03F6',
bernou: '\u212C',
beta: '\u03B2',
beth: '\u2136',
between: '\u226C',
bfr: '\uD835\uDD1F',
bigcap: '\u22C2',
bigcirc: '\u25EF',
bigcup: '\u22C3',
bigodot: '\u2A00',
bigoplus: '\u2A01',
bigotimes: '\u2A02',
bigsqcup: '\u2A06',
bigstar: '\u2605',
bigtriangledown: '\u25BD',
bigtriangleup: '\u25B3',
biguplus: '\u2A04',
bigvee: '\u22C1',
bigwedge: '\u22C0',
bkarow: '\u290D',
blacklozenge: '\u29EB',
blacksquare: '\u25AA',
blacktriangle: '\u25B4',
blacktriangledown: '\u25BE',
blacktriangleleft: '\u25C2',
blacktriangleright: '\u25B8',
blank: '\u2423',
blk12: '\u2592',
blk14: '\u2591',
blk34: '\u2593',
block: '\u2588',
bne: '\u003D\u20E5',
bnequiv: '\u2261\u20E5',
bnot: '\u2310',
bopf: '\uD835\uDD53',
bot: '\u22A5',
bottom: '\u22A5',
bowtie: '\u22C8',
boxDL: '\u2557',
boxDR: '\u2554',
boxDl: '\u2556',
boxDr: '\u2553',
boxH: '\u2550',
boxHD: '\u2566',
boxHU: '\u2569',
boxHd: '\u2564',
boxHu: '\u2567',
boxUL: '\u255D',
boxUR: '\u255A',
boxUl: '\u255C',
boxUr: '\u2559',
boxV: '\u2551',
boxVH: '\u256C',
boxVL: '\u2563',
boxVR: '\u2560',
boxVh: '\u256B',
boxVl: '\u2562',
boxVr: '\u255F',
boxbox: '\u29C9',
boxdL: '\u2555',
boxdR: '\u2552',
boxdl: '\u2510',
boxdr: '\u250C',
boxh: '\u2500',
boxhD: '\u2565',
boxhU: '\u2568',
boxhd: '\u252C',
boxhu: '\u2534',
boxminus: '\u229F',
boxplus: '\u229E',
boxtimes: '\u22A0',
boxuL: '\u255B',
boxuR: '\u2558',
boxul: '\u2518',
boxur: '\u2514',
boxv: '\u2502',
boxvH: '\u256A',
boxvL: '\u2561',
boxvR: '\u255E',
boxvh: '\u253C',
boxvl: '\u2524',
boxvr: '\u251C',
bprime: '\u2035',
breve: '\u02D8',
brvbar: '\u00A6',
bscr: '\uD835\uDCB7',
bsemi: '\u204F',
bsim: '\u223D',
bsime: '\u22CD',
bsol: '\u005C',
bsolb: '\u29C5',
bsolhsub: '\u27C8',
bull: '\u2022',
bullet: '\u2022',
bump: '\u224E',
bumpE: '\u2AAE',
bumpe: '\u224F',
bumpeq: '\u224F',
cacute: '\u0107',
cap: '\u2229',
capand: '\u2A44',
capbrcup: '\u2A49',
capcap: '\u2A4B',
capcup: '\u2A47',
capdot: '\u2A40',
caps: '\u2229\uFE00',
caret: '\u2041',
caron: '\u02C7',
ccaps: '\u2A4D',
ccaron: '\u010D',
ccedil: '\u00E7',
ccirc: '\u0109',
ccups: '\u2A4C',
ccupssm: '\u2A50',
cdot: '\u010B',
cedil: '\u00B8',
cemptyv: '\u29B2',
cent: '\u00A2',
centerdot: '\u00B7',
cfr: '\uD835\uDD20',
chcy: '\u0447',
check: '\u2713',
checkmark: '\u2713',
chi: '\u03C7',
cir: '\u25CB',
cirE: '\u29C3',
circ: '\u02C6',
circeq: '\u2257',
circlearrowleft: '\u21BA',
circlearrowright: '\u21BB',
circledR: '\u00AE',
circledS: '\u24C8',
circledast: '\u229B',
circledcirc: '\u229A',
circleddash: '\u229D',
cire: '\u2257',
cirfnint: '\u2A10',
cirmid: '\u2AEF',
cirscir: '\u29C2',
clubs: '\u2663',
clubsuit: '\u2663',
colon: '\u003A',
colone: '\u2254',
coloneq: '\u2254',
comma: '\u002C',
commat: '\u0040',
comp: '\u2201',
compfn: '\u2218',
complement: '\u2201',
complexes: '\u2102',
cong: '\u2245',
congdot: '\u2A6D',
conint: '\u222E',
copf: '\uD835\uDD54',
coprod: '\u2210',
copy: '\u00A9',
copysr: '\u2117',
crarr: '\u21B5',
cross: '\u2717',
cscr: '\uD835\uDCB8',
csub: '\u2ACF',
csube: '\u2AD1',
csup: '\u2AD0',
csupe: '\u2AD2',
ctdot: '\u22EF',
cudarrl: '\u2938',
cudarrr: '\u2935',
cuepr: '\u22DE',
cuesc: '\u22DF',
cularr: '\u21B6',
cularrp: '\u293D',
cup: '\u222A',
cupbrcap: '\u2A48',
cupcap: '\u2A46',
cupcup: '\u2A4A',
cupdot: '\u228D',
cupor: '\u2A45',
cups: '\u222A\uFE00',
curarr: '\u21B7',
curarrm: '\u293C',
curlyeqprec: '\u22DE',
curlyeqsucc: '\u22DF',
curlyvee: '\u22CE',
curlywedge: '\u22CF',
curren: '\u00A4',
curvearrowleft: '\u21B6',
curvearrowright: '\u21B7',
cuvee: '\u22CE',
cuwed: '\u22CF',
cwconint: '\u2232',
cwint: '\u2231',
cylcty: '\u232D',
dArr: '\u21D3',
dHar: '\u2965',
dagger: '\u2020',
daleth: '\u2138',
darr: '\u2193',
dash: '\u2010',
dashv: '\u22A3',
dbkarow: '\u290F',
dblac: '\u02DD',
dcaron: '\u010F',
dcy: '\u0434',
dd: '\u2146',
ddagger: '\u2021',
ddarr: '\u21CA',
ddotseq: '\u2A77',
deg: '\u00B0',
delta: '\u03B4',
demptyv: '\u29B1',
dfisht: '\u297F',
dfr: '\uD835\uDD21',
dharl: '\u21C3',
dharr: '\u21C2',
diam: '\u22C4',
diamond: '\u22C4',
diamondsuit: '\u2666',
diams: '\u2666',
die: '\u00A8',
digamma: '\u03DD',
disin: '\u22F2',
div: '\u00F7',
divide: '\u00F7',
divideontimes: '\u22C7',
divonx: '\u22C7',
djcy: '\u0452',
dlcorn: '\u231E',
dlcrop: '\u230D',
dollar: '\u0024',
dopf: '\uD835\uDD55',
dot: '\u02D9',
doteq: '\u2250',
doteqdot: '\u2251',
dotminus: '\u2238',
dotplus: '\u2214',
dotsquare: '\u22A1',
doublebarwedge: '\u2306',
downarrow: '\u2193',
downdownarrows: '\u21CA',
downharpoonleft: '\u21C3',
downharpoonright: '\u21C2',
drbkarow: '\u2910',
drcorn: '\u231F',
drcrop: '\u230C',
dscr: '\uD835\uDCB9',
dscy: '\u0455',
dsol: '\u29F6',
dstrok: '\u0111',
dtdot: '\u22F1',
dtri: '\u25BF',
dtrif: '\u25BE',
duarr: '\u21F5',
duhar: '\u296F',
dwangle: '\u29A6',
dzcy: '\u045F',
dzigrarr: '\u27FF',
eDDot: '\u2A77',
eDot: '\u2251',
eacute: '\u00E9',
easter: '\u2A6E',
ecaron: '\u011B',
ecir: '\u2256',
ecirc: '\u00EA',
ecolon: '\u2255',
ecy: '\u044D',
edot: '\u0117',
ee: '\u2147',
efDot: '\u2252',
efr: '\uD835\uDD22',
eg: '\u2A9A',
egrave: '\u00E8',
egs: '\u2A96',
egsdot: '\u2A98',
el: '\u2A99',
elinters: '\u23E7',
ell: '\u2113',
els: '\u2A95',
elsdot: '\u2A97',
emacr: '\u0113',
empty: '\u2205',
emptyset: '\u2205',
emptyv: '\u2205',
emsp13: '\u2004',
emsp14: '\u2005',
emsp: '\u2003',
eng: '\u014B',
ensp: '\u2002',
eogon: '\u0119',
eopf: '\uD835\uDD56',
epar: '\u22D5',
eparsl: '\u29E3',
eplus: '\u2A71',
epsi: '\u03B5',
epsilon: '\u03B5',
epsiv: '\u03F5',
eqcirc: '\u2256',
eqcolon: '\u2255',
eqsim: '\u2242',
eqslantgtr: '\u2A96',
eqslantless: '\u2A95',
equals: '\u003D',
equest: '\u225F',
equiv: '\u2261',
equivDD: '\u2A78',
eqvparsl: '\u29E5',
erDot: '\u2253',
erarr: '\u2971',
escr: '\u212F',
esdot: '\u2250',
esim: '\u2242',
eta: '\u03B7',
eth: '\u00F0',
euml: '\u00EB',
euro: '\u20AC',
excl: '\u0021',
exist: '\u2203',
expectation: '\u2130',
exponentiale: '\u2147',
fallingdotseq: '\u2252',
fcy: '\u0444',
female: '\u2640',
ffilig: '\uFB03',
fflig: '\uFB00',
ffllig: '\uFB04',
ffr: '\uD835\uDD23',
filig: '\uFB01',
fjlig: '\u0066\u006A',
flat: '\u266D',
fllig: '\uFB02',
fltns: '\u25B1',
fnof: '\u0192',
fopf: '\uD835\uDD57',
forall: '\u2200',
fork: '\u22D4',
forkv: '\u2AD9',
fpartint: '\u2A0D',
frac12: '\u00BD',
frac13: '\u2153',
frac14: '\u00BC',
frac15: '\u2155',
frac16: '\u2159',
frac18: '\u215B',
frac23: '\u2154',
frac25: '\u2156',
frac34: '\u00BE',
frac35: '\u2157',
frac38: '\u215C',
frac45: '\u2158',
frac56: '\u215A',
frac58: '\u215D',
frac78: '\u215E',
frasl: '\u2044',
frown: '\u2322',
fscr: '\uD835\uDCBB',
gE: '\u2267',
gEl: '\u2A8C',
gacute: '\u01F5',
gamma: '\u03B3',
gammad: '\u03DD',
gap: '\u2A86',
gbreve: '\u011F',
gcirc: '\u011D',
gcy: '\u0433',
gdot: '\u0121',
ge: '\u2265',
gel: '\u22DB',
geq: '\u2265',
geqq: '\u2267',
geqslant: '\u2A7E',
ges: '\u2A7E',
gescc: '\u2AA9',
gesdot: '\u2A80',
gesdoto: '\u2A82',
gesdotol: '\u2A84',
gesl: '\u22DB\uFE00',
gesles: '\u2A94',
gfr: '\uD835\uDD24',
gg: '\u226B',
ggg: '\u22D9',
gimel: '\u2137',
gjcy: '\u0453',
gl: '\u2277',
glE: '\u2A92',
gla: '\u2AA5',
glj: '\u2AA4',
gnE: '\u2269',
gnap: '\u2A8A',
gnapprox: '\u2A8A',
gne: '\u2A88',
gneq: '\u2A88',
gneqq: '\u2269',
gnsim: '\u22E7',
gopf: '\uD835\uDD58',
grave: '\u0060',
gscr: '\u210A',
gsim: '\u2273',
gsime: '\u2A8E',
gsiml: '\u2A90',
gt: '\u003E',
gtcc: '\u2AA7',
gtcir: '\u2A7A',
gtdot: '\u22D7',
gtlPar: '\u2995',
gtquest: '\u2A7C',
gtrapprox: '\u2A86',
gtrarr: '\u2978',
gtrdot: '\u22D7',
gtreqless: '\u22DB',
gtreqqless: '\u2A8C',
gtrless: '\u2277',
gtrsim: '\u2273',
gvertneqq: '\u2269\uFE00',
gvnE: '\u2269\uFE00',
hArr: '\u21D4',
hairsp: '\u200A',
half: '\u00BD',
hamilt: '\u210B',
hardcy: '\u044A',
harr: '\u2194',
harrcir: '\u2948',
harrw: '\u21AD',
hbar: '\u210F',
hcirc: '\u0125',
hearts: '\u2665',
heartsuit: '\u2665',
hellip: '\u2026',
hercon: '\u22B9',
hfr: '\uD835\uDD25',
hksearow: '\u2925',
hkswarow: '\u2926',
hoarr: '\u21FF',
homtht: '\u223B',
hookleftarrow: '\u21A9',
hookrightarrow: '\u21AA',
hopf: '\uD835\uDD59',
horbar: '\u2015',
hscr: '\uD835\uDCBD',
hslash: '\u210F',
hstrok: '\u0127',
hybull: '\u2043',
hyphen: '\u2010',
iacute: '\u00ED',
ic: '\u2063',
icirc: '\u00EE',
icy: '\u0438',
iecy: '\u0435',
iexcl: '\u00A1',
iff: '\u21D4',
ifr: '\uD835\uDD26',
igrave: '\u00EC',
ii: '\u2148',
iiiint: '\u2A0C',
iiint: '\u222D',
iinfin: '\u29DC',
iiota: '\u2129',
ijlig: '\u0133',
imacr: '\u012B',
image: '\u2111',
imagline: '\u2110',
imagpart: '\u2111',
imath: '\u0131',
imof: '\u22B7',
imped: '\u01B5',
in: '\u2208',
incare: '\u2105',
infin: '\u221E',
infintie: '\u29DD',
inodot: '\u0131',
int: '\u222B',
intcal: '\u22BA',
integers: '\u2124',
intercal: '\u22BA',
intlarhk: '\u2A17',
intprod: '\u2A3C',
iocy: '\u0451',
iogon: '\u012F',
iopf: '\uD835\uDD5A',
iota: '\u03B9',
iprod: '\u2A3C',
iquest: '\u00BF',
iscr: '\uD835\uDCBE',
isin: '\u2208',
isinE: '\u22F9',
isindot: '\u22F5',
isins: '\u22F4',
isinsv: '\u22F3',
isinv: '\u2208',
it: '\u2062',
itilde: '\u0129',
iukcy: '\u0456',
iuml: '\u00EF',
jcirc: '\u0135',
jcy: '\u0439',
jfr: '\uD835\uDD27',
jmath: '\u0237',
jopf: '\uD835\uDD5B',
jscr: '\uD835\uDCBF',
jsercy: '\u0458',
jukcy: '\u0454',
kappa: '\u03BA',
kappav: '\u03F0',
kcedil: '\u0137',
kcy: '\u043A',
kfr: '\uD835\uDD28',
kgreen: '\u0138',
khcy: '\u0445',
kjcy: '\u045C',
kopf: '\uD835\uDD5C',
kscr: '\uD835\uDCC0',
lAarr: '\u21DA',
lArr: '\u21D0',
lAtail: '\u291B',
lBarr: '\u290E',
lE: '\u2266',
lEg: '\u2A8B',
lHar: '\u2962',
lacute: '\u013A',
laemptyv: '\u29B4',
lagran: '\u2112',
lambda: '\u03BB',
lang: '\u27E8',
langd: '\u2991',
langle: '\u27E8',
lap: '\u2A85',
laquo: '\u00AB',
larr: '\u2190',
larrb: '\u21E4',
larrbfs: '\u291F',
larrfs: '\u291D',
larrhk: '\u21A9',
larrlp: '\u21AB',
larrpl: '\u2939',
larrsim: '\u2973',
larrtl: '\u21A2',
lat: '\u2AAB',
latail: '\u2919',
late: '\u2AAD',
lates: '\u2AAD\uFE00',
lbarr: '\u290C',
lbbrk: '\u2772',
lbrace: '\u007B',
lbrack: '\u005B',
lbrke: '\u298B',
lbrksld: '\u298F',
lbrkslu: '\u298D',
lcaron: '\u013E',
lcedil: '\u013C',
lceil: '\u2308',
lcub: '\u007B',
lcy: '\u043B',
ldca: '\u2936',
ldquo: '\u201C',
ldquor: '\u201E',
ldrdhar: '\u2967',
ldrushar: '\u294B',
ldsh: '\u21B2',
le: '\u2264',
leftarrow: '\u2190',
leftarrowtail: '\u21A2',
leftharpoondown: '\u21BD',
leftharpoonup: '\u21BC',
leftleftarrows: '\u21C7',
leftrightarrow: '\u2194',
leftrightarrows: '\u21C6',
leftrightharpoons: '\u21CB',
leftrightsquigarrow: '\u21AD',
leftthreetimes: '\u22CB',
leg: '\u22DA',
leq: '\u2264',
leqq: '\u2266',
leqslant: '\u2A7D',
les: '\u2A7D',
lescc: '\u2AA8',
lesdot: '\u2A7F',
lesdoto: '\u2A81',
lesdotor: '\u2A83',
lesg: '\u22DA\uFE00',
lesges: '\u2A93',
lessapprox: '\u2A85',
lessdot: '\u22D6',
lesseqgtr: '\u22DA',
lesseqqgtr: '\u2A8B',
lessgtr: '\u2276',
lesssim: '\u2272',
lfisht: '\u297C',
lfloor: '\u230A',
lfr: '\uD835\uDD29',
lg: '\u2276',
lgE: '\u2A91',
lhard: '\u21BD',
lharu: '\u21BC',
lharul: '\u296A',
lhblk: '\u2584',
ljcy: '\u0459',
ll: '\u226A',
llarr: '\u21C7',
llcorner: '\u231E',
llhard: '\u296B',
lltri: '\u25FA',
lmidot: '\u0140',
lmoust: '\u23B0',
lmoustache: '\u23B0',
lnE: '\u2268',
lnap: '\u2A89',
lnapprox: '\u2A89',
lne: '\u2A87',
lneq: '\u2A87',
lneqq: '\u2268',
lnsim: '\u22E6',
loang: '\u27EC',
loarr: '\u21FD',
lobrk: '\u27E6',
longleftarrow: '\u27F5',
longleftrightarrow: '\u27F7',
longmapsto: '\u27FC',
longrightarrow: '\u27F6',
looparrowleft: '\u21AB',
looparrowright: '\u21AC',
lopar: '\u2985',
lopf: '\uD835\uDD5D',
loplus: '\u2A2D',
lotimes: '\u2A34',
lowast: '\u2217',
lowbar: '\u005F',
loz: '\u25CA',
lozenge: '\u25CA',
lozf: '\u29EB',
lpar: '\u0028',
lparlt: '\u2993',
lrarr: '\u21C6',
lrcorner: '\u231F',
lrhar: '\u21CB',
lrhard: '\u296D',
lrm: '\u200E',
lrtri: '\u22BF',
lsaquo: '\u2039',
lscr: '\uD835\uDCC1',
lsh: '\u21B0',
lsim: '\u2272',
lsime: '\u2A8D',
lsimg: '\u2A8F',
lsqb: '\u005B',
lsquo: '\u2018',
lsquor: '\u201A',
lstrok: '\u0142',
lt: '\u003C',
ltcc: '\u2AA6',
ltcir: '\u2A79',
ltdot: '\u22D6',
lthree: '\u22CB',
ltimes: '\u22C9',
ltlarr: '\u2976',
ltquest: '\u2A7B',
ltrPar: '\u2996',
ltri: '\u25C3',
ltrie: '\u22B4',
ltrif: '\u25C2',
lurdshar: '\u294A',
luruhar: '\u2966',
lvertneqq: '\u2268\uFE00',
lvnE: '\u2268\uFE00',
mDDot: '\u223A',
macr: '\u00AF',
male: '\u2642',
malt: '\u2720',
maltese: '\u2720',
map: '\u21A6',
mapsto: '\u21A6',
mapstodown: '\u21A7',
mapstoleft: '\u21A4',
mapstoup: '\u21A5',
marker: '\u25AE',
mcomma: '\u2A29',
mcy: '\u043C',
mdash: '\u2014',
measuredangle: '\u2221',
mfr: '\uD835\uDD2A',
mho: '\u2127',
micro: '\u00B5',
mid: '\u2223',
midast: '\u002A',
midcir: '\u2AF0',
middot: '\u00B7',
minus: '\u2212',
minusb: '\u229F',
minusd: '\u2238',
minusdu: '\u2A2A',
mlcp: '\u2ADB',
mldr: '\u2026',
mnplus: '\u2213',
models: '\u22A7',
mopf: '\uD835\uDD5E',
mp: '\u2213',
mscr: '\uD835\uDCC2',
mstpos: '\u223E',
mu: '\u03BC',
multimap: '\u22B8',
mumap: '\u22B8',
nGg: '\u22D9\u0338',
nGt: '\u226B\u20D2',
nGtv: '\u226B\u0338',
nLeftarrow: '\u21CD',
nLeftrightarrow: '\u21CE',
nLl: '\u22D8\u0338',
nLt: '\u226A\u20D2',
nLtv: '\u226A\u0338',
nRightarrow: '\u21CF',
nVDash: '\u22AF',
nVdash: '\u22AE',
nabla: '\u2207',
nacute: '\u0144',
nang: '\u2220\u20D2',
nap: '\u2249',
napE: '\u2A70\u0338',
napid: '\u224B\u0338',
napos: '\u0149',
napprox: '\u2249',
natur: '\u266E',
natural: '\u266E',
naturals: '\u2115',
nbsp: '\u00A0',
nbump: '\u224E\u0338',
nbumpe: '\u224F\u0338',
ncap: '\u2A43',
ncaron: '\u0148',
ncedil: '\u0146',
ncong: '\u2247',
ncongdot: '\u2A6D\u0338',
ncup: '\u2A42',
ncy: '\u043D',
ndash: '\u2013',
ne: '\u2260',
neArr: '\u21D7',
nearhk: '\u2924',
nearr: '\u2197',
nearrow: '\u2197',
nedot: '\u2250\u0338',
nequiv: '\u2262',
nesear: '\u2928',
nesim: '\u2242\u0338',
nexist: '\u2204',
nexists: '\u2204',
nfr: '\uD835\uDD2B',
ngE: '\u2267\u0338',
nge: '\u2271',
ngeq: '\u2271',
ngeqq: '\u2267\u0338',
ngeqslant: '\u2A7E\u0338',
nges: '\u2A7E\u0338',
ngsim: '\u2275',
ngt: '\u226F',
ngtr: '\u226F',
nhArr: '\u21CE',
nharr: '\u21AE',
nhpar: '\u2AF2',
ni: '\u220B',
nis: '\u22FC',
nisd: '\u22FA',
niv: '\u220B',
njcy: '\u045A',
nlArr: '\u21CD',
nlE: '\u2266\u0338',
nlarr: '\u219A',
nldr: '\u2025',
nle: '\u2270',
nleftarrow: '\u219A',
nleftrightarrow: '\u21AE',
nleq: '\u2270',
nleqq: '\u2266\u0338',
nleqslant: '\u2A7D\u0338',
nles: '\u2A7D\u0338',
nless: '\u226E',
nlsim: '\u2274',
nlt: '\u226E',
nltri: '\u22EA',
nltrie: '\u22EC',
nmid: '\u2224',
nopf: '\uD835\uDD5F',
not: '\u00AC',
notin: '\u2209',
notinE: '\u22F9\u0338',
notindot: '\u22F5\u0338',
notinva: '\u2209',
notinvb: '\u22F7',
notinvc: '\u22F6',
notni: '\u220C',
notniva: '\u220C',
notnivb: '\u22FE',
notnivc: '\u22FD',
npar: '\u2226',
nparallel: '\u2226',
nparsl: '\u2AFD\u20E5',
npart: '\u2202\u0338',
npolint: '\u2A14',
npr: '\u2280',
nprcue: '\u22E0',
npre: '\u2AAF\u0338',
nprec: '\u2280',
npreceq: '\u2AAF\u0338',
nrArr: '\u21CF',
nrarr: '\u219B',
nrarrc: '\u2933\u0338',
nrarrw: '\u219D\u0338',
nrightarrow: '\u219B',
nrtri: '\u22EB',
nrtrie: '\u22ED',
nsc: '\u2281',
nsccue: '\u22E1',
nsce: '\u2AB0\u0338',
nscr: '\uD835\uDCC3',
nshortmid: '\u2224',
nshortparallel: '\u2226',
nsim: '\u2241',
nsime: '\u2244',
nsimeq: '\u2244',
nsmid: '\u2224',
nspar: '\u2226',
nsqsube: '\u22E2',
nsqsupe: '\u22E3',
nsub: '\u2284',
nsubE: '\u2AC5\u0338',
nsube: '\u2288',
nsubset: '\u2282\u20D2',
nsubseteq: '\u2288',
nsubseteqq: '\u2AC5\u0338',
nsucc: '\u2281',
nsucceq: '\u2AB0\u0338',
nsup: '\u2285',
nsupE: '\u2AC6\u0338',
nsupe: '\u2289',
nsupset: '\u2283\u20D2',
nsupseteq: '\u2289',
nsupseteqq: '\u2AC6\u0338',
ntgl: '\u2279',
ntilde: '\u00F1',
ntlg: '\u2278',
ntriangleleft: '\u22EA',
ntrianglelefteq: '\u22EC',
ntriangleright: '\u22EB',
ntrianglerighteq: '\u22ED',
nu: '\u03BD',
num: '\u0023',
numero: '\u2116',
numsp: '\u2007',
nvDash: '\u22AD',
nvHarr: '\u2904',
nvap: '\u224D\u20D2',
nvdash: '\u22AC',
nvge: '\u2265\u20D2',
nvgt: '\u003E\u20D2',
nvinfin: '\u29DE',
nvlArr: '\u2902',
nvle: '\u2264\u20D2',
nvlt: '\u003C\u20D2',
nvltrie: '\u22B4\u20D2',
nvrArr: '\u2903',
nvrtrie: '\u22B5\u20D2',
nvsim: '\u223C\u20D2',
nwArr: '\u21D6',
nwarhk: '\u2923',
nwarr: '\u2196',
nwarrow: '\u2196',
nwnear: '\u2927',
oS: '\u24C8',
oacute: '\u00F3',
oast: '\u229B',
ocir: '\u229A',
ocirc: '\u00F4',
ocy: '\u043E',
odash: '\u229D',
odblac: '\u0151',
odiv: '\u2A38',
odot: '\u2299',
odsold: '\u29BC',
oelig: '\u0153',
ofcir: '\u29BF',
ofr: '\uD835\uDD2C',
ogon: '\u02DB',
ograve: '\u00F2',
ogt: '\u29C1',
ohbar: '\u29B5',
ohm: '\u03A9',
oint: '\u222E',
olarr: '\u21BA',
olcir: '\u29BE',
olcross: '\u29BB',
oline: '\u203E',
olt: '\u29C0',
omacr: '\u014D',
omega: '\u03C9',
omicron: '\u03BF',
omid: '\u29B6',
ominus: '\u2296',
oopf: '\uD835\uDD60',
opar: '\u29B7',
operp: '\u29B9',
oplus: '\u2295',
or: '\u2228',
orarr: '\u21BB',
ord: '\u2A5D',
order: '\u2134',
orderof: '\u2134',
ordf: '\u00AA',
ordm: '\u00BA',
origof: '\u22B6',
oror: '\u2A56',
orslope: '\u2A57',
orv: '\u2A5B',
oscr: '\u2134',
oslash: '\u00F8',
osol: '\u2298',
otilde: '\u00F5',
otimes: '\u2297',
otimesas: '\u2A36',
ouml: '\u00F6',
ovbar: '\u233D',
par: '\u2225',
para: '\u00B6',
parallel: '\u2225',
parsim: '\u2AF3',
parsl: '\u2AFD',
part: '\u2202',
pcy: '\u043F',
percnt: '\u0025',
period: '\u002E',
permil: '\u2030',
perp: '\u22A5',
pertenk: '\u2031',
pfr: '\uD835\uDD2D',
phi: '\u03C6',
phiv: '\u03D5',
phmmat: '\u2133',
phone: '\u260E',
pi: '\u03C0',
pitchfork: '\u22D4',
piv: '\u03D6',
planck: '\u210F',
planckh: '\u210E',
plankv: '\u210F',
plus: '\u002B',
plusacir: '\u2A23',
plusb: '\u229E',
pluscir: '\u2A22',
plusdo: '\u2214',
plusdu: '\u2A25',
pluse: '\u2A72',
plusmn: '\u00B1',
plussim: '\u2A26',
plustwo: '\u2A27',
pm: '\u00B1',
pointint: '\u2A15',
popf: '\uD835\uDD61',
pound: '\u00A3',
pr: '\u227A',
prE: '\u2AB3',
prap: '\u2AB7',
prcue: '\u227C',
pre: '\u2AAF',
prec: '\u227A',
precapprox: '\u2AB7',
preccurlyeq: '\u227C',
preceq: '\u2AAF',
precnapprox: '\u2AB9',
precneqq: '\u2AB5',
precnsim: '\u22E8',
precsim: '\u227E',
prime: '\u2032',
primes: '\u2119',
prnE: '\u2AB5',
prnap: '\u2AB9',
prnsim: '\u22E8',
prod: '\u220F',
profalar: '\u232E',
profline: '\u2312',
profsurf: '\u2313',
prop: '\u221D',
propto: '\u221D',
prsim: '\u227E',
prurel: '\u22B0',
pscr: '\uD835\uDCC5',
psi: '\u03C8',
puncsp: '\u2008',
qfr: '\uD835\uDD2E',
qint: '\u2A0C',
qopf: '\uD835\uDD62',
qprime: '\u2057',
qscr: '\uD835\uDCC6',
quaternions: '\u210D',
quatint: '\u2A16',
quest: '\u003F',
questeq: '\u225F',
quot: '\u0022',
rAarr: '\u21DB',
rArr: '\u21D2',
rAtail: '\u291C',
rBarr: '\u290F',
rHar: '\u2964',
race: '\u223D\u0331',
racute: '\u0155',
radic: '\u221A',
raemptyv: '\u29B3',
rang: '\u27E9',
rangd: '\u2992',
range: '\u29A5',
rangle: '\u27E9',
raquo: '\u00BB',
rarr: '\u2192',
rarrap: '\u2975',
rarrb: '\u21E5',
rarrbfs: '\u2920',
rarrc: '\u2933',
rarrfs: '\u291E',
rarrhk: '\u21AA',
rarrlp: '\u21AC',
rarrpl: '\u2945',
rarrsim: '\u2974',
rarrtl: '\u21A3',
rarrw: '\u219D',
ratail: '\u291A',
ratio: '\u2236',
rationals: '\u211A',
rbarr: '\u290D',
rbbrk: '\u2773',
rbrace: '\u007D',
rbrack: '\u005D',
rbrke: '\u298C',
rbrksld: '\u298E',
rbrkslu: '\u2990',
rcaron: '\u0159',
rcedil: '\u0157',
rceil: '\u2309',
rcub: '\u007D',
rcy: '\u0440',
rdca: '\u2937',
rdldhar: '\u2969',
rdquo: '\u201D',
rdquor: '\u201D',
rdsh: '\u21B3',
real: '\u211C',
realine: '\u211B',
realpart: '\u211C',
reals: '\u211D',
rect: '\u25AD',
reg: '\u00AE',
rfisht: '\u297D',
rfloor: '\u230B',
rfr: '\uD835\uDD2F',
rhard: '\u21C1',
rharu: '\u21C0',
rharul: '\u296C',
rho: '\u03C1',
rhov: '\u03F1',
rightarrow: '\u2192',
rightarrowtail: '\u21A3',
rightharpoondown: '\u21C1',
rightharpoonup: '\u21C0',
rightleftarrows: '\u21C4',
rightleftharpoons: '\u21CC',
rightrightarrows: '\u21C9',
rightsquigarrow: '\u219D',
rightthreetimes: '\u22CC',
ring: '\u02DA',
risingdotseq: '\u2253',
rlarr: '\u21C4',
rlhar: '\u21CC',
rlm: '\u200F',
rmoust: '\u23B1',
rmoustache: '\u23B1',
rnmid: '\u2AEE',
roang: '\u27ED',
roarr: '\u21FE',
robrk: '\u27E7',
ropar: '\u2986',
ropf: '\uD835\uDD63',
roplus: '\u2A2E',
rotimes: '\u2A35',
rpar: '\u0029',
rpargt: '\u2994',
rppolint: '\u2A12',
rrarr: '\u21C9',
rsaquo: '\u203A',
rscr: '\uD835\uDCC7',
rsh: '\u21B1',
rsqb: '\u005D',
rsquo: '\u2019',
rsquor: '\u2019',
rthree: '\u22CC',
rtimes: '\u22CA',
rtri: '\u25B9',
rtrie: '\u22B5',
rtrif: '\u25B8',
rtriltri: '\u29CE',
ruluhar: '\u2968',
rx: '\u211E',
sacute: '\u015B',
sbquo: '\u201A',
sc: '\u227B',
scE: '\u2AB4',
scap: '\u2AB8',
scaron: '\u0161',
sccue: '\u227D',
sce: '\u2AB0',
scedil: '\u015F',
scirc: '\u015D',
scnE: '\u2AB6',
scnap: '\u2ABA',
scnsim: '\u22E9',
scpolint: '\u2A13',
scsim: '\u227F',
scy: '\u0441',
sdot: '\u22C5',
sdotb: '\u22A1',
sdote: '\u2A66',
seArr: '\u21D8',
searhk: '\u2925',
searr: '\u2198',
searrow: '\u2198',
sect: '\u00A7',
semi: '\u003B',
seswar: '\u2929',
setminus: '\u2216',
setmn: '\u2216',
sext: '\u2736',
sfr: '\uD835\uDD30',
sfrown: '\u2322',
sharp: '\u266F',
shchcy: '\u0449',
shcy: '\u0448',
shortmid: '\u2223',
shortparallel: '\u2225',
shy: '\u00AD',
sigma: '\u03C3',
sigmaf: '\u03C2',
sigmav: '\u03C2',
sim: '\u223C',
simdot: '\u2A6A',
sime: '\u2243',
simeq: '\u2243',
simg: '\u2A9E',
simgE: '\u2AA0',
siml: '\u2A9D',
simlE: '\u2A9F',
simne: '\u2246',
simplus: '\u2A24',
simrarr: '\u2972',
slarr: '\u2190',
smallsetminus: '\u2216',
smashp: '\u2A33',
smeparsl: '\u29E4',
smid: '\u2223',
smile: '\u2323',
smt: '\u2AAA',
smte: '\u2AAC',
smtes: '\u2AAC\uFE00',
softcy: '\u044C',
sol: '\u002F',
solb: '\u29C4',
solbar: '\u233F',
sopf: '\uD835\uDD64',
spades: '\u2660',
spadesuit: '\u2660',
spar: '\u2225',
sqcap: '\u2293',
sqcaps: '\u2293\uFE00',
sqcup: '\u2294',
sqcups: '\u2294\uFE00',
sqsub: '\u228F',
sqsube: '\u2291',
sqsubset: '\u228F',
sqsubseteq: '\u2291',
sqsup: '\u2290',
sqsupe: '\u2292',
sqsupset: '\u2290',
sqsupseteq: '\u2292',
squ: '\u25A1',
square: '\u25A1',
squarf: '\u25AA',
squf: '\u25AA',
srarr: '\u2192',
sscr: '\uD835\uDCC8',
ssetmn: '\u2216',
ssmile: '\u2323',
sstarf: '\u22C6',
star: '\u2606',
starf: '\u2605',
straightepsilon: '\u03F5',
straightphi: '\u03D5',
strns: '\u00AF',
sub: '\u2282',
subE: '\u2AC5',
subdot: '\u2ABD',
sube: '\u2286',
subedot: '\u2AC3',
submult: '\u2AC1',
subnE: '\u2ACB',
subne: '\u228A',
subplus: '\u2ABF',
subrarr: '\u2979',
subset: '\u2282',
subseteq: '\u2286',
subseteqq: '\u2AC5',
subsetneq: '\u228A',
subsetneqq: '\u2ACB',
subsim: '\u2AC7',
subsub: '\u2AD5',
subsup: '\u2AD3',
succ: '\u227B',
succapprox: '\u2AB8',
succcurlyeq: '\u227D',
succeq: '\u2AB0',
succnapprox: '\u2ABA',
succneqq: '\u2AB6',
succnsim: '\u22E9',
succsim: '\u227F',
sum: '\u2211',
sung: '\u266A',
sup1: '\u00B9',
sup2: '\u00B2',
sup3: '\u00B3',
sup: '\u2283',
supE: '\u2AC6',
supdot: '\u2ABE',
supdsub: '\u2AD8',
supe: '\u2287',
supedot: '\u2AC4',
suphsol: '\u27C9',
suphsub: '\u2AD7',
suplarr: '\u297B',
supmult: '\u2AC2',
supnE: '\u2ACC',
supne: '\u228B',
supplus: '\u2AC0',
supset: '\u2283',
supseteq: '\u2287',
supseteqq: '\u2AC6',
supsetneq: '\u228B',
supsetneqq: '\u2ACC',
supsim: '\u2AC8',
supsub: '\u2AD4',
supsup: '\u2AD6',
swArr: '\u21D9',
swarhk: '\u2926',
swarr: '\u2199',
swarrow: '\u2199',
swnwar: '\u292A',
szlig: '\u00DF',
target: '\u2316',
tau: '\u03C4',
tbrk: '\u23B4',
tcaron: '\u0165',
tcedil: '\u0163',
tcy: '\u0442',
tdot: '\u20DB',
telrec: '\u2315',
tfr: '\uD835\uDD31',
there4: '\u2234',
therefore: '\u2234',
theta: '\u03B8',
thetasym: '\u03D1',
thetav: '\u03D1',
thickapprox: '\u2248',
thicksim: '\u223C',
thinsp: '\u2009',
thkap: '\u2248',
thksim: '\u223C',
thorn: '\u00FE',
tilde: '\u02DC',
times: '\u00D7',
timesb: '\u22A0',
timesbar: '\u2A31',
timesd: '\u2A30',
tint: '\u222D',
toea: '\u2928',
top: '\u22A4',
topbot: '\u2336',
topcir: '\u2AF1',
topf: '\uD835\uDD65',
topfork: '\u2ADA',
tosa: '\u2929',
tprime: '\u2034',
trade: '\u2122',
triangle: '\u25B5',
triangledown: '\u25BF',
triangleleft: '\u25C3',
trianglelefteq: '\u22B4',
triangleq: '\u225C',
triangleright: '\u25B9',
trianglerighteq: '\u22B5',
tridot: '\u25EC',
trie: '\u225C',
triminus: '\u2A3A',
triplus: '\u2A39',
trisb: '\u29CD',
tritime: '\u2A3B',
trpezium: '\u23E2',
tscr: '\uD835\uDCC9',
tscy: '\u0446',
tshcy: '\u045B',
tstrok: '\u0167',
twixt: '\u226C',
twoheadleftarrow: '\u219E',
twoheadrightarrow: '\u21A0',
uArr: '\u21D1',
uHar: '\u2963',
uacute: '\u00FA',
uarr: '\u2191',
ubrcy: '\u045E',
ubreve: '\u016D',
ucirc: '\u00FB',
ucy: '\u0443',
udarr: '\u21C5',
udblac: '\u0171',
udhar: '\u296E',
ufisht: '\u297E',
ufr: '\uD835\uDD32',
ugrave: '\u00F9',
uharl: '\u21BF',
uharr: '\u21BE',
uhblk: '\u2580',
ulcorn: '\u231C',
ulcorner: '\u231C',
ulcrop: '\u230F',
ultri: '\u25F8',
umacr: '\u016B',
uml: '\u00A8',
uogon: '\u0173',
uopf: '\uD835\uDD66',
uparrow: '\u2191',
updownarrow: '\u2195',
upharpoonleft: '\u21BF',
upharpoonright: '\u21BE',
uplus: '\u228E',
upsi: '\u03C5',
upsih: '\u03D2',
upsilon: '\u03C5',
upuparrows: '\u21C8',
urcorn: '\u231D',
urcorner: '\u231D',
urcrop: '\u230E',
uring: '\u016F',
urtri: '\u25F9',
uscr: '\uD835\uDCCA',
utdot: '\u22F0',
utilde: '\u0169',
utri: '\u25B5',
utrif: '\u25B4',
uuarr: '\u21C8',
uuml: '\u00FC',
uwangle: '\u29A7',
vArr: '\u21D5',
vBar: '\u2AE8',
vBarv: '\u2AE9',
vDash: '\u22A8',
vangrt: '\u299C',
varepsilon: '\u03F5',
varkappa: '\u03F0',
varnothing: '\u2205',
varphi: '\u03D5',
varpi: '\u03D6',
varpropto: '\u221D',
varr: '\u2195',
varrho: '\u03F1',
varsigma: '\u03C2',
varsubsetneq: '\u228A\uFE00',
varsubsetneqq: '\u2ACB\uFE00',
varsupsetneq: '\u228B\uFE00',
varsupsetneqq: '\u2ACC\uFE00',
vartheta: '\u03D1',
vartriangleleft: '\u22B2',
vartriangleright: '\u22B3',
vcy: '\u0432',
vdash: '\u22A2',
vee: '\u2228',
veebar: '\u22BB',
veeeq: '\u225A',
vellip: '\u22EE',
verbar: '\u007C',
vert: '\u007C',
vfr: '\uD835\uDD33',
vltri: '\u22B2',
vnsub: '\u2282\u20D2',
vnsup: '\u2283\u20D2',
vopf: '\uD835\uDD67',
vprop: '\u221D',
vrtri: '\u22B3',
vscr: '\uD835\uDCCB',
vsubnE: '\u2ACB\uFE00',
vsubne: '\u228A\uFE00',
vsupnE: '\u2ACC\uFE00',
vsupne: '\u228B\uFE00',
vzigzag: '\u299A',
wcirc: '\u0175',
wedbar: '\u2A5F',
wedge: '\u2227',
wedgeq: '\u2259',
weierp: '\u2118',
wfr: '\uD835\uDD34',
wopf: '\uD835\uDD68',
wp: '\u2118',
wr: '\u2240',
wreath: '\u2240',
wscr: '\uD835\uDCCC',
xcap: '\u22C2',
xcirc: '\u25EF',
xcup: '\u22C3',
xdtri: '\u25BD',
xfr: '\uD835\uDD35',
xhArr: '\u27FA',
xharr: '\u27F7',
xi: '\u03BE',
xlArr: '\u27F8',
xlarr: '\u27F5',
xmap: '\u27FC',
xnis: '\u22FB',
xodot: '\u2A00',
xopf: '\uD835\uDD69',
xoplus: '\u2A01',
xotime: '\u2A02',
xrArr: '\u27F9',
xrarr: '\u27F6',
xscr: '\uD835\uDCCD',
xsqcup: '\u2A06',
xuplus: '\u2A04',
xutri: '\u25B3',
xvee: '\u22C1',
xwedge: '\u22C0',
yacute: '\u00FD',
yacy: '\u044F',
ycirc: '\u0177',
ycy: '\u044B',
yen: '\u00A5',
yfr: '\uD835\uDD36',
yicy: '\u0457',
yopf: '\uD835\uDD6A',
yscr: '\uD835\uDCCE',
yucy: '\u044E',
yuml: '\u00FF',
zacute: '\u017A',
zcaron: '\u017E',
zcy: '\u0437',
zdot: '\u017C',
zeetrf: '\u2128',
zeta: '\u03B6',
zfr: '\uD835\uDD37',
zhcy: '\u0436',
zigrarr: '\u21DD',
zopf: '\uD835\uDD6B',
zscr: '\uD835\uDCCF',
zwj: '\u200D',
zwnj: '\u200C',
};
const decodeMap = {
'0': 65533,
'128': 8364,
'130': 8218,
'131': 402,
'132': 8222,
'133': 8230,
'134': 8224,
'135': 8225,
'136': 710,
'137': 8240,
'138': 352,
'139': 8249,
'140': 338,
'142': 381,
'145': 8216,
'146': 8217,
'147': 8220,
'148': 8221,
'149': 8226,
'150': 8211,
'151': 8212,
'152': 732,
'153': 8482,
'154': 353,
'155': 8250,
'156': 339,
'158': 382,
'159': 376,
};
function decodeHTMLStrict(text) {
return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
if (key.charAt(1) === '#') {
const secondChar = key.charAt(2);
const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
return decodeCodePoint(codePoint);
}
return getOwnProperty(entities, key.slice(1, -1)) ?? key;
});
}
function decodeCodePoint(codePoint) {
if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
return '\uFFFD';
}
return String.fromCodePoint(getOwnProperty(decodeMap, codePoint) ?? codePoint);
}
function scanJSXAttributeValue(parser, context) {
parser.startIndex = parser.tokenIndex = parser.index;
parser.startColumn = parser.tokenColumn = parser.column;
parser.startLine = parser.tokenLine = parser.line;
parser.setToken(CharTypes[parser.currentChar] & 8192
? scanJSXString(parser)
: scanSingleToken(parser, context, 0));
return parser.getToken();
}
function scanJSXString(parser) {
const quote = parser.currentChar;
let char = advanceChar(parser);
const start = parser.index;
while (char !== quote) {
if (parser.index >= parser.end)
parser.report(16);
char = advanceChar(parser);
}
if (char !== quote)
parser.report(16);
parser.tokenValue = parser.source.slice(start, parser.index);
advanceChar(parser);
if (parser.options.raw)
parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
return 134283267;
}
function nextJSXToken(parser) {
parser.startIndex = parser.tokenIndex = parser.index;
parser.startColumn = parser.tokenColumn = parser.column;
parser.startLine = parser.tokenLine = parser.line;
if (parser.index >= parser.end) {
parser.setToken(1048576);
return;
}
if (parser.currentChar === 60) {
advanceChar(parser);
parser.setToken(8456256);
return;
}
if (parser.currentChar === 123) {
advanceChar(parser);
parser.setToken(2162700);
return;
}
let state = 0;
while (parser.index < parser.end) {
const type = CharTypes[parser.source.charCodeAt(parser.index)];
if (type & 1024) {
state |= 1 | 4;
scanNewLine(parser);
}
else if (type & 2048) {
consumeLineFeed(parser, state);
state = (state & -5) | 1;
}
else {
advanceChar(parser);
}
if (CharTypes[parser.currentChar] & 16384)
break;
}
if (parser.tokenIndex === parser.index)
parser.report(0);
const raw = parser.source.slice(parser.tokenIndex, parser.index);
if (parser.options.raw)
parser.tokenRaw = raw;
parser.tokenValue = decodeHTMLStrict(raw);
parser.setToken(137);
}
function rescanJSXIdentifier(parser) {
if ((parser.getToken() & 143360) === 143360) {
const { index } = parser;
let char = parser.currentChar;
while (CharTypes[char] & (32768 | 2)) {
char = advanceChar(parser);
}
parser.tokenValue += parser.source.slice(index, parser.index);
parser.setToken(208897, true);
}
return parser.getToken();
}
class Scope {
parser;
type;
parent;
scopeError;
variableBindings = new Map();
constructor(parser, type = 2, parent) {
this.parser = parser;
this.type = type;
this.parent = parent;
}
createChildScope(type) {
return new Scope(this.parser, type, this);
}
addVarOrBlock(context, name, kind, origin) {
if (kind & 4) {
this.addVarName(context, name, kind);
}
else {
this.addBlockName(context, name, kind, origin);
}
if (origin & 64) {
this.parser.declareUnboundVariable(name);
}
}
addVarName(context, name, kind) {
const { parser } = this;
let currentScope = this;
while (currentScope && (currentScope.type & 128) === 0) {
const { variableBindings } = currentScope;
const value = variableBindings.get(name);
if (value && value & 248) {
if (parser.options.webcompat &&
(context & 1) === 0 &&
((kind & 128 && value & 68) ||
(value & 128 && kind & 68))) ;
else {
parser.report(145, name);
}
}
if (currentScope === this) {
if (value && value & 1 && kind & 1) {
currentScope.recordScopeError(145, name);
}
}
if (value &&
(value & 256 || (value & 512 && !parser.options.webcompat))) {
parser.report(145, name);
}
currentScope.variableBindings.set(name, kind);
currentScope = currentScope.parent;
}
}
hasVariable(name) {
return this.variableBindings.has(name);
}
addBlockName(context, name, kind, origin) {
const { parser } = this;
const value = this.variableBindings.get(name);
if (value && (value & 2) === 0) {
if (kind & 1) {
this.recordScopeError(145, name);
}
else if (parser.options.webcompat &&
(context & 1) === 0 &&
origin & 2 &&
value === 64 &&
kind === 64) ;
else {
parser.report(145, name);
}
}
if (this.type & 64 &&
this.parent?.hasVariable(name) &&
(this.parent.variableBindings.get(name) & 2) === 0) {
parser.report(145, name);
}
if (this.type & 512 && value && (value & 2) === 0) {
if (kind & 1) {
this.recordScopeError(145, name);
}
}
if (this.type & 32) {
if (this.parent.variableBindings.get(name) & 768)
parser.report(159, name);
}
this.variableBindings.set(name, kind);
}
recordScopeError(type, ...params) {
this.scopeError = {
type,
params,
start: this.parser.tokenStart,
end: this.parser.currentLocation,
};
}
reportScopeError() {
const { scopeError } = this;
if (!scopeError) {
return;
}
throw new ParseError(scopeError.start, scopeError.end, scopeError.type, ...scopeError.params);
}
}
function createArrowHeadParsingScope(parser, context, value) {
const scope = parser.createScope().createChildScope(512);
scope.addBlockName(context, value, 1, 0);
return scope;
}
class PrivateScope {
parser;
parent;
refs = Object.create(null);
privateIdentifiers = new Map();
constructor(parser, parent) {
this.parser = parser;
this.parent = parent;
}
addPrivateIdentifier(name, kind) {
const { privateIdentifiers } = this;
let focusKind = kind & (32 | 768);
if (!(focusKind & 768))
focusKind |= 768;
const value = privateIdentifiers.get(name);
if (this.hasPrivateIdentifier(name) &&
((value & 32) !== (focusKind & 32) || value & focusKind & 768)) {
this.parser.report(146, name);
}
privateIdentifiers.set(name, this.hasPrivateIdentifier(name) ? value | focusKind : focusKind);
}
addPrivateIdentifierRef(name) {
this.refs[name] ??= [];
this.refs[name].push(this.parser.tokenStart);
}
isPrivateIdentifierDefined(name) {
return this.hasPrivateIdentifier(name) || Boolean(this.parent?.isPrivateIdentifierDefined(name));
}
validatePrivateIdentifierRefs() {
for (const name in this.refs) {
if (!this.isPrivateIdentifierDefined(name)) {
const { index, line, column } = this.refs[name][0];
throw new ParseError({ index, line, column }, { index: index + name.length, line, column: column + name.length }, 4, name);
}
}
}
hasPrivateIdentifier(name) {
return this.privateIdentifiers.has(name);
}
}
class Parser {
source;
options;
lastOnToken = null;
token = 1048576;
flags = 0;
index = 0;
line = 1;
column = 0;
startIndex = 0;
end = 0;
tokenIndex = 0;
startColumn = 0;
tokenColumn = 0;
tokenLine = 1;
startLine = 1;
tokenValue = '';
tokenRaw = '';
tokenRegExp = void 0;
currentChar = 0;
exportedNames = new Set();
exportedBindings = new Set();
assignable = 1;
destructible = 0;
leadingDecorators = { decorators: [] };
constructor(source, options = {}) {
this.source = source;
this.options = options;
this.end = source.length;
this.currentChar = source.charCodeAt(0);
}
getToken() {
return this.token;
}
setToken(value, replaceLast = false) {
this.token = value;
const { onToken } = this.options;
if (onToken) {
if (value !== 1048576) {
const loc = {
start: {
line: this.tokenLine,
column: this.tokenColumn,
},
end: {
line: this.line,
column: this.column,
},
};
if (!replaceLast && this.lastOnToken) {
onToken(...this.lastOnToken);
}
this.lastOnToken = [convertTokenType(value), this.tokenIndex, this.index, loc];
}
else {
if (this.lastOnToken) {
onToken(...this.lastOnToken);
this.lastOnToken = null;
}
}
}
return value;
}
get tokenStart() {
return {
index: this.tokenIndex,
line: this.tokenLine,
column: this.tokenColumn,
};
}
get currentLocation() {
return { index: this.index, line: this.line, column: this.column };
}
finishNode(node, start, end) {
if (this.options.ranges) {
node.start = start.index;
const endIndex = end ? end.index : this.startIndex;
node.end = endIndex;
node.range = [start.index, endIndex];
}
if (this.options.loc) {
node.loc = {
start: {
line: start.line,
column: start.column,
},
end: end ? { line: end.line, column: end.column } : { line: this.startLine, column: this.startColumn },
};
if (this.options.source) {
node.loc.source = this.options.source;
}
}
return node;
}
addBindingToExports(name) {
this.exportedBindings.add(name);
}
declareUnboundVariable(name) {
const { exportedNames } = this;
if (exportedNames.has(name)) {
this.report(147, name);
}
exportedNames.add(name);
}
report(type, ...params) {
throw new ParseError(this.tokenStart, this.currentLocation, type, ...params);
}
createScopeIfLexical(type, parent) {
if (this.options.lexical) {
return this.createScope(type, parent);
}
return undefined;
}
createScope(type, parent) {
return new Scope(this, type, parent);
}
createPrivateScopeIfLexical(parent) {
if (this.options.lexical) {
return new PrivateScope(this, parent);
}
return undefined;
}
}
function pushComment(comments, options) {
return function (type, value, start, end, loc) {
const comment = {
type,
value,
};
if (options.ranges) {
comment.start = start;
comment.end = end;
comment.range = [start, end];
}
if (options.loc) {
comment.loc = loc;
}
comments.push(comment);
};
}
function pushToken(tokens, options) {
return function (type, start, end, loc) {
const token = {
token: type,
};
if (options.ranges) {
token.start = start;
token.end = end;
token.range = [start, end];
}
if (options.loc) {
token.loc = loc;
}
tokens.push(token);
};
}
function normalizeOptions(rawOptions) {
const options = { ...rawOptions };
if (options.onComment) {
options.onComment = Array.isArray(options.onComment) ? pushComment(options.onComment, options) : options.onComment;
}
if (options.onToken) {
options.onToken = Array.isArray(options.onToken) ? pushToken(options.onToken, options) : options.onToken;
}
return options;
}
function parseSource(source, rawOptions = {}, context = 0) {
const options = normalizeOptions(rawOptions);
if (options.module)
context |= 2 | 1;
if (options.globalReturn)
context |= 4096;
if (options.impliedStrict)
context |= 1;
const parser = new Parser(source, options);
skipHashBang(parser);
const scope = parser.createScopeIfLexical();
let body = [];
let sourceType = 'script';
if (context & 2) {
sourceType = 'module';
body = parseModuleItemList(parser, context | 8, scope);
if (scope) {
for (const name of parser.exportedBindings) {
if (!scope.hasVariable(name))
parser.report(148, name);
}
}
}
else {
body = parseStatementList(parser, context | 8, scope);
}
return parser.finishNode({
type: 'Program',
sourceType,
body,
}, { index: 0, line: 1, column: 0 }, parser.currentLocation);
}
function parseStatementList(parser, context, scope) {
nextToken(parser, context | 32 | 262144);
const statements = [];
while (parser.getToken() === 134283267) {
const { index, tokenValue, tokenStart, tokenIndex } = parser;
const token = parser.getToken();
const expr = parseLiteral(parser, context);
if (isValidStrictMode(parser, index, tokenIndex, tokenValue)) {
context |= 1;
if (parser.flags & 64) {
throw new ParseError(parser.tokenStart, parser.currentLocation, 9);
}
if (parser.flags & 4096) {
throw new ParseError(parser.tokenStart, parser.currentLocation, 15);
}
}
statements.push(parseDirective(parser, context, expr, token, tokenStart));
}
while (parser.getToken() !== 1048576) {
statements.push(parseStatementListItem(parser, context, scope, undefined, 4, {}));
}
return statements;
}
function parseModuleItemList(parser, context, scope) {
nextToken(parser, context | 32);
const statements = [];
while (parser.getToken() === 134283267) {
const { tokenStart } = parser;
const token = parser.getToken();
statements.push(parseDirective(parser, context, parseLiteral(parser, context), token, tokenStart));
}
while (parser.getToken() !== 1048576) {
statements.push(parseModuleItem(parser, context, scope));
}
return statements;
}
function parseModuleItem(parser, context, scope) {
if (parser.getToken() === 132) {
Object.assign(parser.leadingDecorators, {
start: parser.tokenStart,
decorators: parseDecorators(parser, context, undefined),
});
}
let moduleItem;
switch (parser.getToken()) {
case 20564:
moduleItem = parseExportDeclaration(parser, context, scope);
break;
case 86106:
moduleItem = parseImportDeclaration(parser, context, scope);
break;
default:
moduleItem = parseStatementListItem(parser, context, scope, undefined, 4, {});
}
if (parser.leadingDecorators?.decorators.length) {
parser.report(170);
}
return moduleItem;
}
function parseStatementListItem(parser, context, scope, privateScope, origin, labels) {
const start = parser.tokenStart;
switch (parser.getToken()) {
case 86104:
return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start);
case 132:
case 86094:
return parseClassDeclaration(parser, context, scope, privateScope, 0);
case 86090:
return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
case 241737:
return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
case 20564:
parser.report(103, 'export');
case 86106:
nextToken(parser, context);
switch (parser.getToken()) {
case 67174411:
return parseImportCallDeclaration(parser, context, privateScope, start);
case 67108877:
return parseImportMetaDeclaration(parser, context, start);
default:
parser.report(103, 'import');
}
case 209005:
return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1);
default:
return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
}
}
function parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
switch (parser.getToken()) {
case 86088:
return parseVariableStatement(parser, context, scope, privateScope, 0);
case 20572:
return parseReturnStatement(parser, context, privateScope);
case 20569:
return parseIfStatement(parser, context, scope, privateScope, labels);
case 20567:
return parseForStatement(parser, context, scope, privateScope, labels);
case 20562:
return parseDoWhileStatement(parser, context, scope, privateScope, labels);
case 20578:
return parseWhileStatement(parser, context, scope, privateScope, labels);
case 86110:
return parseSwitchStatement(parser, context, scope, privateScope, labels);
case 1074790417:
return parseEmptyStatement(parser, context);
case 2162700:
return parseBlock(parser, context, scope?.createChildScope(), privateScope, labels, parser.tokenStart);
case 86112:
return parseThrowStatement(parser, context, privateScope);
case 20555:
return parseBreakStatement(parser, context, labels);
case 20559:
return parseContinueStatement(parser, context, labels);
case 20577:
return parseTryStatement(parser, context, scope, privateScope, labels);
case 20579:
return parseWithStatement(parser, context, scope, privateScope, labels);
case 20560:
return parseDebuggerStatement(parser, context);
case 209005:
return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
case 20557:
parser.report(162);
case 20566:
parser.report(163);
case 86104:
parser.report(context & 1
? 76
: !parser.options.webcompat
? 78
: 77);
case 86094:
parser.report(79);
default:
return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
}
}
function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
const { tokenValue, tokenStart } = parser;
const token = parser.getToken();
let expr;
switch (token) {
case 241737:
expr = parseIdentifier(parser, context);
if (context & 1)
parser.report(85);
if (parser.getToken() === 69271571)
parser.report(84);
break;
default:
expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart);
}
if (token & 143360 && parser.getToken() === 21) {
return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, tokenStart);
}
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
if (parser.getToken() === 18) {
expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
}
return parseExpressionStatement(parser, context, expr, tokenStart);
}
function parseBlock(parser, context, scope, privateScope, labels, start = parser.tokenStart, type = 'BlockStatement') {
const body = [];
consume(parser, context | 32, 2162700);
while (parser.getToken() !== 1074790415) {
body.push(parseStatementListItem(parser, context, scope, privateScope, 2, { $: labels }));
}
consume(parser, context | 32, 1074790415);
return parser.finishNode({
type,
body,
}, start);
}
function parseReturnStatement(parser, context, privateScope) {
if ((context & 4096) === 0)
parser.report(92);
const start = parser.tokenStart;
nextToken(parser, context | 32);
const argument = parser.flags & 1 || parser.getToken() & 1048576
? null
: parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'ReturnStatement',
argument,
}, start);
}
function parseExpressionStatement(parser, context, expression, start) {
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'ExpressionStatement',
expression,
}, start);
}
function parseLabelledStatement(parser, context, scope, privateScope, origin, labels, value, expr, token, allowFuncDecl, start) {
validateBindingIdentifier(parser, context, 0, token, 1);
validateAndDeclareLabel(parser, labels, value);
nextToken(parser, context | 32);
const body = allowFuncDecl &&
(context & 1) === 0 &&
parser.options.webcompat &&
parser.getToken() === 86104
? parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, origin, 0, 0, 0, parser.tokenStart)
: parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
return parser.finishNode({
type: 'LabeledStatement',
label: expr,
body,
}, start);
}
function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
const { tokenValue, tokenStart: start } = parser;
const token = parser.getToken();
let expr = parseIdentifier(parser, context);
if (parser.getToken() === 21) {
return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, 1, start);
}
const asyncNewLine = parser.flags & 1;
if (!asyncNewLine) {
if (parser.getToken() === 86104) {
if (!allowFuncDecl)
parser.report(123);
return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
}
if (isValidIdentifier(context, parser.getToken())) {
expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start);
if (parser.getToken() === 18)
expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
return parseExpressionStatement(parser, context, expr, start);
}
}
if (parser.getToken() === 67174411) {
expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, 0, asyncNewLine, start);
}
else {
if (parser.getToken() === 10) {
classifyIdentifier(parser, context, token);
if ((token & 36864) === 36864) {
parser.flags |= 256;
}
expr = parseArrowFromIdentifier(parser, context | 2048, privateScope, parser.tokenValue, expr, 0, 1, 0, start);
}
parser.assignable = 1;
}
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, expr);
parser.assignable = 1;
if (parser.getToken() === 18) {
expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
}
return parseExpressionStatement(parser, context, expr, start);
}
function parseDirective(parser, context, expression, token, start) {
const endIndex = parser.startIndex;
if (token !== 1074790417) {
parser.assignable = 2;
expression = parseMemberOrUpdateExpression(parser, context, undefined, expression, 0, 0, start);
if (parser.getToken() !== 1074790417) {
expression = parseAssignmentExpression(parser, context, undefined, 0, 0, start, expression);
if (parser.getToken() === 18) {
expression = parseSequenceExpression(parser, context, undefined, 0, start, expression);
}
}
matchOrInsertSemicolon(parser, context | 32);
}
const node = {
type: 'ExpressionStatement',
expression,
};
if (expression.type === 'Literal' && typeof expression.value === 'string') {
node.directive = parser.source.slice(start.index + 1, endIndex - 1);
}
return parser.finishNode(node, start);
}
function parseEmptyStatement(parser, context) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
return parser.finishNode({
type: 'EmptyStatement',
}, start);
}
function parseThrowStatement(parser, context, privateScope) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
if (parser.flags & 1)
parser.report(90);
const argument = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'ThrowStatement',
argument,
}, start);
}
function parseIfStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context);
consume(parser, context | 32, 67174411);
parser.assignable = 1;
const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
const consequent = parseConsequentOrAlternative(parser, context, scope, privateScope, labels);
let alternate = null;
if (parser.getToken() === 20563) {
nextToken(parser, context | 32);
alternate = parseConsequentOrAlternative(parser, context, scope, privateScope, labels);
}
return parser.finishNode({
type: 'IfStatement',
test,
consequent,
alternate,
}, start);
}
function parseConsequentOrAlternative(parser, context, scope, privateScope, labels) {
const { tokenStart } = parser;
return context & 1 ||
!parser.options.webcompat ||
parser.getToken() !== 86104
? parseStatement(parser, context, scope, privateScope, 0, { $: labels }, 0)
: parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, 0, tokenStart);
}
function parseSwitchStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context);
consume(parser, context | 32, 67174411);
const discriminant = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context, 16);
consume(parser, context, 2162700);
const cases = [];
let seenDefault = 0;
scope = scope?.createChildScope(8);
while (parser.getToken() !== 1074790415) {
const { tokenStart } = parser;
let test = null;
const consequent = [];
if (consumeOpt(parser, context | 32, 20556)) {
test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
}
else {
consume(parser, context | 32, 20561);
if (seenDefault)
parser.report(89);
seenDefault = 1;
}
consume(parser, context | 32, 21);
while (parser.getToken() !== 20556 &&
parser.getToken() !== 1074790415 &&
parser.getToken() !== 20561) {
consequent.push(parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
$: labels,
}));
}
cases.push(parser.finishNode({
type: 'SwitchCase',
test,
consequent,
}, tokenStart));
}
consume(parser, context | 32, 1074790415);
return parser.finishNode({
type: 'SwitchStatement',
discriminant,
cases,
}, start);
}
function parseWhileStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context);
consume(parser, context | 32, 67174411);
const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
return parser.finishNode({
type: 'WhileStatement',
test,
body,
}, start);
}
function parseIterationStatementBody(parser, context, scope, privateScope, labels) {
return parseStatement(parser, ((context | 131072) ^ 131072) | 128, scope, privateScope, 0, { loop: 1, $: labels }, 0);
}
function parseContinueStatement(parser, context, labels) {
if ((context & 128) === 0)
parser.report(68);
const start = parser.tokenStart;
nextToken(parser, context);
let label = null;
if ((parser.flags & 1) === 0 && parser.getToken() & 143360) {
const { tokenValue } = parser;
label = parseIdentifier(parser, context | 32);
if (!isValidLabel(parser, labels, tokenValue, 1))
parser.report(138, tokenValue);
}
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'ContinueStatement',
label,
}, start);
}
function parseBreakStatement(parser, context, labels) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
let label = null;
if ((parser.flags & 1) === 0 && parser.getToken() & 143360) {
const { tokenValue } = parser;
label = parseIdentifier(parser, context | 32);
if (!isValidLabel(parser, labels, tokenValue, 0))
parser.report(138, tokenValue);
}
else if ((context & (4 | 128)) === 0) {
parser.report(69);
}
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'BreakStatement',
label,
}, start);
}
function parseWithStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context);
if (context & 1)
parser.report(91);
consume(parser, context | 32, 67174411);
const object = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
const body = parseStatement(parser, context, scope, privateScope, 2, labels, 0);
return parser.finishNode({
type: 'WithStatement',
object,
body,
}, start);
}
function parseDebuggerStatement(parser, context) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'DebuggerStatement',
}, start);
}
function parseTryStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
const firstScope = scope?.createChildScope(16);
const block = parseBlock(parser, context, firstScope, privateScope, { $: labels });
const { tokenStart } = parser;
const handler = consumeOpt(parser, context | 32, 20557)
? parseCatchBlock(parser, context, scope, privateScope, labels, tokenStart)
: null;
let finalizer = null;
if (parser.getToken() === 20566) {
nextToken(parser, context | 32);
const finalizerScope = scope?.createChildScope(4);
const block = parseBlock(parser, context, finalizerScope, privateScope, { $: labels });
finalizer = block;
}
if (!handler && !finalizer) {
parser.report(88);
}
return parser.finishNode({
type: 'TryStatement',
block,
handler,
finalizer,
}, start);
}
function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
let param = null;
let additionalScope = scope;
if (consumeOpt(parser, context, 67174411)) {
scope = scope?.createChildScope(4);
param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
? 256
: 512, 0);
if (parser.getToken() === 18) {
parser.report(86);
}
else if (parser.getToken() === 1077936155) {
parser.report(87);
}
consume(parser, context | 32, 16);
}
additionalScope = scope?.createChildScope(32);
const body = parseBlock(parser, context, additionalScope, privateScope, { $: labels });
return parser.finishNode({
type: 'CatchClause',
param,
body,
}, start);
}
function parseStaticBlock(parser, context, scope, privateScope, start) {
scope = scope?.createChildScope();
const ctorContext = 512 | 4096 | 1024 | 4 | 128;
context =
((context | ctorContext) ^ ctorContext) |
256 |
2048 |
524288 |
65536;
return parseBlock(parser, context, scope, privateScope, {}, start, 'StaticBlock');
}
function parseDoWhileStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
consume(parser, context, 20578);
consume(parser, context | 32, 67174411);
const test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
consumeOpt(parser, context | 32, 1074790417);
return parser.finishNode({
type: 'DoWhileStatement',
body,
test,
}, start);
}
function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin) {
const { tokenValue, tokenStart } = parser;
const token = parser.getToken();
let expr = parseIdentifier(parser, context);
if (parser.getToken() & (143360 | 2097152)) {
const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'VariableDeclaration',
kind: 'let',
declarations,
}, tokenStart);
}
parser.assignable = 1;
if (context & 1)
parser.report(85);
if (parser.getToken() === 21) {
return parseLabelledStatement(parser, context, scope, privateScope, origin, {}, tokenValue, expr, token, 0, tokenStart);
}
if (parser.getToken() === 10) {
let scope = void 0;
if (parser.options.lexical)
scope = createArrowHeadParsingScope(parser, context, tokenValue);
parser.flags = (parser.flags | 128) ^ 128;
expr = parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, tokenStart);
}
else {
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
}
if (parser.getToken() === 18) {
expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
}
return parseExpressionStatement(parser, context, expr, tokenStart);
}
function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin) {
const start = parser.tokenStart;
nextToken(parser, context);
const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'VariableDeclaration',
kind: kind & 8 ? 'let' : 'const',
declarations,
}, start);
}
function parseVariableStatement(parser, context, scope, privateScope, origin) {
const start = parser.tokenStart;
nextToken(parser, context);
const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 4, origin);
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode({
type: 'VariableDeclaration',
kind: 'var',
declarations,
}, start);
}
function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin) {
let bindingCount = 1;
const list = [
parseVariableDeclaration(parser, context, scope, privateScope, kind, origin),
];
while (consumeOpt(parser, context, 18)) {
bindingCount++;
list.push(parseVariableDeclaration(parser, context, scope, privateScope, kind, origin));
}
if (bindingCount > 1 && origin & 32 && parser.getToken() & 262144) {
parser.report(61, KeywordDescTable[parser.getToken() & 255]);
}
return list;
}
function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin) {
const { tokenStart } = parser;
const token = parser.getToken();
let init = null;
const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
if (parser.getToken() === 1077936155) {
nextToken(parser, context | 32);
init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
if (origin & 32 || (token & 2097152) === 0) {
if (parser.getToken() === 471156 ||
(parser.getToken() === 8673330 &&
(token & 2097152 || (kind & 4) === 0 || context & 1))) {
throw new ParseError(tokenStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
}
}
}
else if ((kind & 16 || (token & 2097152) > 0) &&
(parser.getToken() & 262144) !== 262144) {
parser.report(59, kind & 16 ? 'const' : 'destructuring');
}
return parser.finishNode({
type: 'VariableDeclarator',
id,
init,
}, tokenStart);
}
function parseForStatement(parser, context, scope, privateScope, labels) {
const start = parser.tokenStart;
nextToken(parser, context);
const forAwait = ((context & 2048) > 0 || ((context & 2) > 0 && (context & 8) > 0)) &&
consumeOpt(parser, context, 209006);
consume(parser, context | 32, 67174411);
scope = scope?.createChildScope(1);
let test = null;
let update = null;
let destructible = 0;
let init = null;
let isVarDecl = parser.getToken() === 86088 ||
parser.getToken() === 241737 ||
parser.getToken() === 86090;
let right;
const { tokenStart } = parser;
const token = parser.getToken();
if (isVarDecl) {
if (token === 241737) {
init = parseIdentifier(parser, context);
if (parser.getToken() & (143360 | 2097152)) {
if (parser.getToken() === 8673330) {
if (context & 1)
parser.report(67);
}
else {
init = parser.finishNode({
type: 'VariableDeclaration',
kind: 'let',
declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 8, 32),
}, tokenStart);
}
parser.assignable = 1;
}
else if (context & 1) {
parser.report(67);
}
else {
isVarDecl = false;
parser.assignable = 1;
init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
if (parser.getToken() === 471156)
parser.report(115);
}
}
else {
nextToken(parser, context);
init = parser.finishNode(token === 86088
? {
type: 'VariableDeclaration',
kind: 'var',
declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 4, 32),
}
: {
type: 'VariableDeclaration',
kind: 'const',
declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32),
}, tokenStart);
parser.assignable = 1;
}
}
else if (token === 1074790417) {
if (forAwait)
parser.report(82);
}
else if ((token & 2097152) === 2097152) {
const patternStart = parser.tokenStart;
init =
token === 2162700
? parseObjectLiteralOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32)
: parseArrayExpressionOrPattern(parser, context, void 0, privateScope, 1, 0, 0, 2, 32);
destructible = parser.destructible;
if (destructible & 64) {
parser.report(63);
}
parser.assignable =
destructible & 16 ? 2 : 1;
init = parseMemberOrUpdateExpression(parser, context | 131072, privateScope, init, 0, 0, patternStart);
}
else {
init = parseLeftHandSideExpression(parser, context | 131072, privateScope, 1, 0, 1);
}
if ((parser.getToken() & 262144) === 262144) {
if (parser.getToken() === 471156) {
if (parser.assignable & 2)
parser.report(80, forAwait ? 'await' : 'of');
reinterpretToPattern(parser, init);
nextToken(parser, context | 32);
right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
consume(parser, context | 32, 16);
const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
return parser.finishNode({
type: 'ForOfStatement',
left: init,
right,
body,
await: forAwait,
}, start);
}
if (parser.assignable & 2)
parser.report(80, 'in');
reinterpretToPattern(parser, init);
nextToken(parser, context | 32);
if (forAwait)
parser.report(82);
right = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
return parser.finishNode({
type: 'ForInStatement',
body,
left: init,
right,
}, start);
}
if (forAwait)
parser.report(82);
if (!isVarDecl) {
if (destructible & 8 && parser.getToken() !== 1077936155) {
parser.report(80, 'loop');
}
init = parseAssignmentExpression(parser, context | 131072, privateScope, 0, 0, tokenStart, init);
}
if (parser.getToken() === 18)
init = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, init);
consume(parser, context | 32, 1074790417);
if (parser.getToken() !== 1074790417)
test = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 1074790417);
if (parser.getToken() !== 16)
update = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
consume(parser, context | 32, 16);
const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
return parser.finishNode({
type: 'ForStatement',
init,
test,
update,
body,
}, start);
}
function parseRestrictedIdentifier(parser, context, scope) {
if (!isValidIdentifier(context, parser.getToken()))
parser.report(118);
if ((parser.getToken() & 537079808) === 537079808)
parser.report(119);
scope?.addBlockName(context, parser.tokenValue, 8, 0);
return parseIdentifier(parser, context);
}
function parseImportDeclaration(parser, context, scope) {
const start = parser.tokenStart;
nextToken(parser, context);
let source = null;
const { tokenStart } = parser;
let specifiers = [];
if (parser.getToken() === 134283267) {
source = parseLiteral(parser, context);
}
else {
if (parser.getToken() & 143360) {
const local = parseRestrictedIdentifier(parser, context, scope);
specifiers = [
parser.finishNode({
type: 'ImportDefaultSpecifier',
local,
}, tokenStart),
];
if (consumeOpt(parser, context, 18)) {
switch (parser.getToken()) {
case 8391476:
specifiers.push(parseImportNamespaceSpecifier(parser, context, scope));
break;
case 2162700:
parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
break;
default:
parser.report(107);
}
}
}
else {
switch (parser.getToken()) {
case 8391476:
specifiers = [parseImportNamespaceSpecifier(parser, context, scope)];
break;
case 2162700:
parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
break;
case 67174411:
return parseImportCallDeclaration(parser, context, undefined, start);
case 67108877:
return parseImportMetaDeclaration(parser, context, start);
default:
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
source = parseModuleSpecifier(parser, context);
}
const attributes = parseImportAttributes(parser, context);
const node = {
type: 'ImportDeclaration',
specifiers,
source,
attributes,
};
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode(node, start);
}
function parseImportNamespaceSpecifier(parser, context, scope) {
const { tokenStart } = parser;
nextToken(parser, context);
consume(parser, context, 77932);
if ((parser.getToken() & 134217728) === 134217728) {
throw new ParseError(tokenStart, parser.currentLocation, 30, KeywordDescTable[parser.getToken() & 255]);
}
return parser.finishNode({
type: 'ImportNamespaceSpecifier',
local: parseRestrictedIdentifier(parser, context, scope),
}, tokenStart);
}
function parseModuleSpecifier(parser, context) {
consume(parser, context, 209011);
if (parser.getToken() !== 134283267)
parser.report(105, 'Import');
return parseLiteral(parser, context);
}
function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
nextToken(parser, context);
while (parser.getToken() & 143360 || parser.getToken() === 134283267) {
let { tokenValue, tokenStart } = parser;
const token = parser.getToken();
const imported = parseModuleExportName(parser, context);
let local;
if (consumeOpt(parser, context, 77932)) {
if ((parser.getToken() & 134217728) === 134217728 ||
parser.getToken() === 18) {
parser.report(106);
}
else {
validateBindingIdentifier(parser, context, 16, parser.getToken(), 0);
}
tokenValue = parser.tokenValue;
local = parseIdentifier(parser, context);
}
else if (imported.type === 'Identifier') {
validateBindingIdentifier(parser, context, 16, token, 0);
local = imported;
}
else {
parser.report(25, KeywordDescTable[77932 & 255]);
}
scope?.addBlockName(context, tokenValue, 8, 0);
specifiers.push(parser.finishNode({
type: 'ImportSpecifier',
local,
imported,
}, tokenStart));
if (parser.getToken() !== 1074790415)
consume(parser, context, 18);
}
consume(parser, context, 1074790415);
return specifiers;
}
function parseImportMetaDeclaration(parser, context, start) {
let expr = parseImportMetaExpression(parser, context, parser.finishNode({
type: 'Identifier',
name: 'import',
}, start), start);
expr = parseMemberOrUpdateExpression(parser, context, undefined, expr, 0, 0, start);
expr = parseAssignmentExpression(parser, context, undefined, 0, 0, start, expr);
if (parser.getToken() === 18) {
expr = parseSequenceExpression(parser, context, undefined, 0, start, expr);
}
return parseExpressionStatement(parser, context, expr, start);
}
function parseImportCallDeclaration(parser, context, privateScope, start) {
let expr = parseImportExpression(parser, context, privateScope, 0, start);
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
if (parser.getToken() === 18) {
expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
}
return parseExpressionStatement(parser, context, expr, start);
}
function parseExportDeclaration(parser, context, scope) {
const start = parser.leadingDecorators.decorators.length ? parser.leadingDecorators.start : parser.tokenStart;
nextToken(parser, context | 32);
const specifiers = [];
let declaration = null;
let source = null;
let attributes = [];
if (consumeOpt(parser, context | 32, 20561)) {
switch (parser.getToken()) {
case 86104: {
declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 0, parser.tokenStart);
break;
}
case 132:
case 86094:
declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
break;
case 209005: {
const { tokenStart } = parser;
declaration = parseIdentifier(parser, context);
const { flags } = parser;
if ((flags & 1) === 0) {
if (parser.getToken() === 86104) {
declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 1, tokenStart);
}
else {
if (parser.getToken() === 67174411) {
declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, 0, flags, tokenStart);
declaration = parseMemberOrUpdateExpression(parser, context, undefined, declaration, 0, 0, tokenStart);
declaration = parseAssignmentExpression(parser, context, undefined, 0, 0, tokenStart, declaration);
}
else if (parser.getToken() & 143360) {
if (scope)
scope = createArrowHeadParsingScope(parser, context, parser.tokenValue);
declaration = parseIdentifier(parser, context);
declaration = parseArrowFunctionExpression(parser, context, scope, undefined, [declaration], 1, tokenStart);
}
}
}
break;
}
default:
declaration = parseExpression(parser, context, undefined, 1, 0, parser.tokenStart);
matchOrInsertSemicolon(parser, context | 32);
}
if (scope)
parser.declareUnboundVariable('default');
return parser.finishNode({
type: 'ExportDefaultDeclaration',
declaration,
}, start);
}
switch (parser.getToken()) {
case 8391476: {
nextToken(parser, context);
let exported = null;
const isNamedDeclaration = consumeOpt(parser, context, 77932);
if (isNamedDeclaration) {
if (scope)
parser.declareUnboundVariable(parser.tokenValue);
exported = parseModuleExportName(parser, context);
}
consume(parser, context, 209011);
if (parser.getToken() !== 134283267)
parser.report(105, 'Export');
source = parseLiteral(parser, context);
const attributes = parseImportAttributes(parser, context);
const node = {
type: 'ExportAllDeclaration',
source,
exported,
attributes,
};
matchOrInsertSemicolon(parser, context | 32);
return parser.finishNode(node, start);
}
case 2162700: {
nextToken(parser, context);
const tmpExportedNames = [];
const tmpExportedBindings = [];
let hasLiteralLocal = 0;
while (parser.getToken() & 143360 || parser.getToken() === 134283267) {
const { tokenStart, tokenValue } = parser;
const local = parseModuleExportName(parser, context);
if (local.type === 'Literal') {
hasLiteralLocal = 1;
}
let exported;
if (parser.getToken() === 77932) {
nextToken(parser, context);
if ((parser.getToken() & 143360) === 0 && parser.getToken() !== 134283267) {
parser.report(106);
}
if (scope) {
tmpExportedNames.push(parser.tokenValue);
tmpExportedBindings.push(tokenValue);
}
exported = parseModuleExportName(parser, context);
}
else {
if (scope) {
tmpExportedNames.push(parser.tokenValue);
tmpExportedBindings.push(parser.tokenValue);
}
exported = local;
}
specifiers.push(parser.finishNode({
type: 'ExportSpecifier',
local,
exported,
}, tokenStart));
if (parser.getToken() !== 1074790415)
consume(parser, context, 18);
}
consume(parser, context, 1074790415);
if (consumeOpt(parser, context, 209011)) {
if (parser.getToken() !== 134283267)
parser.report(105, 'Export');
source = parseLiteral(parser, context);
attributes = parseImportAttributes(parser, context);
if (scope) {
tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
}
}
else {
if (hasLiteralLocal) {
parser.report(172);
}
if (scope) {
tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
tmpExportedBindings.forEach((b) => parser.addBindingToExports(b));
}
}
matchOrInsertSemicolon(parser, context | 32);
break;
}
case 132:
case 86094:
declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
break;
case 86104:
declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 0, parser.tokenStart);
break;
case 241737:
declaration = parseLexicalDeclaration(parser, context, scope, undefined, 8, 64);
break;
case 86090:
declaration = parseLexicalDeclaration(parser, context, scope, undefined, 16, 64);
break;
case 86088:
declaration = parseVariableStatement(parser, context, scope, undefined, 64);
break;
case 209005: {
const { tokenStart } = parser;
nextToken(parser, context);
if ((parser.flags & 1) === 0 && parser.getToken() === 86104) {
declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 1, tokenStart);
break;
}
}
default:
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
const node = {
type: 'ExportNamedDeclaration',
declaration,
specifiers,
source,
attributes: attributes,
};
return parser.finishNode(node, start);
}
function parseExpression(parser, context, privateScope, canAssign, inGroup, start) {
let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start);
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
return parseAssignmentExpression(parser, context, privateScope, inGroup, 0, start, expr);
}
function parseSequenceExpression(parser, context, privateScope, inGroup, start, expr) {
const expressions = [expr];
while (consumeOpt(parser, context | 32, 18)) {
expressions.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart));
}
return parser.finishNode({
type: 'SequenceExpression',
expressions,
}, start);
}
function parseExpressions(parser, context, privateScope, inGroup, canAssign, start) {
const expr = parseExpression(parser, context, privateScope, canAssign, inGroup, start);
return parser.getToken() === 18
? parseSequenceExpression(parser, context, privateScope, inGroup, start, expr)
: expr;
}
function parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, start, left) {
const token = parser.getToken();
if ((token & 4194304) === 4194304) {
if (parser.assignable & 2)
parser.report(26);
if ((!isPattern && token === 1077936155 && left.type === 'ArrayExpression') ||
left.type === 'ObjectExpression') {
reinterpretToPattern(parser, left);
}
nextToken(parser, context | 32);
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
parser.assignable = 2;
return parser.finishNode(isPattern
? {
type: 'AssignmentPattern',
left,
right,
}
: {
type: 'AssignmentExpression',
left,
operator: KeywordDescTable[token & 255],
right,
}, start);
}
if ((token & 8388608) === 8388608) {
left = parseBinaryExpression(parser, context, privateScope, inGroup, start, 4, token, left);
}
if (consumeOpt(parser, context | 32, 22)) {
left = parseConditionalExpression(parser, context, privateScope, left, start);
}
return left;
}
function parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, start, left) {
const token = parser.getToken();
nextToken(parser, context | 32);
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
left = parser.finishNode(isPattern
? {
type: 'AssignmentPattern',
left,
right,
}
: {
type: 'AssignmentExpression',
left,
operator: KeywordDescTable[token & 255],
right,
}, start);
parser.assignable = 2;
return left;
}
function parseConditionalExpression(parser, context, privateScope, test, start) {
const consequent = parseExpression(parser, (context | 131072) ^ 131072, privateScope, 1, 0, parser.tokenStart);
consume(parser, context | 32, 21);
parser.assignable = 1;
const alternate = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
parser.assignable = 2;
return parser.finishNode({
type: 'ConditionalExpression',
test,
consequent,
alternate,
}, start);
}
function parseBinaryExpression(parser, context, privateScope, inGroup, start, minPrecedence, operator, left) {
const bit = -((context & 131072) > 0) & 8673330;
let t;
let precedence;
parser.assignable = 2;
while (parser.getToken() & 8388608) {
t = parser.getToken();
precedence = t & 3840;
if ((t & 524288 && operator & 268435456) || (operator & 524288 && t & 268435456)) {
parser.report(165);
}
if (precedence + ((t === 8391735) << 8) - ((bit === t) << 12) <= minPrecedence)
break;
nextToken(parser, context | 32);
left = parser.finishNode({
type: t & 524288 || t & 268435456 ? 'LogicalExpression' : 'BinaryExpression',
left,
right: parseBinaryExpression(parser, context, privateScope, inGroup, parser.tokenStart, precedence, t, parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1)),
operator: KeywordDescTable[t & 255],
}, start);
}
if (parser.getToken() === 1077936155)
parser.report(26);
return left;
}
function parseUnaryExpression(parser, context, privateScope, isLHS, inGroup) {
if (!isLHS)
parser.report(0);
const { tokenStart } = parser;
const unaryOperator = parser.getToken();
nextToken(parser, context | 32);
const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 1);
if (parser.getToken() === 8391735)
parser.report(33);
if (context & 1 && unaryOperator === 16863276) {
if (arg.type === 'Identifier') {
parser.report(121);
}
else if (isPropertyWithPrivateFieldKey(arg)) {
parser.report(127);
}
}
parser.assignable = 2;
return parser.finishNode({
type: 'UnaryExpression',
operator: KeywordDescTable[unaryOperator & 255],
argument: arg,
prefix: true,
}, tokenStart);
}
function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start) {
const token = parser.getToken();
const expr = parseIdentifier(parser, context);
const { flags } = parser;
if ((flags & 1) === 0) {
if (parser.getToken() === 86104) {
return parseFunctionExpression(parser, context, privateScope, 1, inGroup, start);
}
if (isValidIdentifier(context, parser.getToken())) {
if (!isLHS)
parser.report(0);
if ((parser.getToken() & 36864) === 36864) {
parser.flags |= 256;
}
return parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start);
}
}
if (!inNew && parser.getToken() === 67174411) {
return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, 0, flags, start);
}
if (parser.getToken() === 10) {
classifyIdentifier(parser, context, token);
if (inNew)
parser.report(51);
if ((token & 36864) === 36864) {
parser.flags |= 256;
}
return parseArrowFromIdentifier(parser, context, privateScope, parser.tokenValue, expr, inNew, canAssign, 0, start);
}
parser.assignable = 1;
return expr;
}
function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start) {
if (inGroup)
parser.destructible |= 256;
if (context & 1024) {
nextToken(parser, context | 32);
if (context & 8192)
parser.report(32);
if (!canAssign)
parser.report(26);
if (parser.getToken() === 22)
parser.report(124);
let argument = null;
let delegate = false;
if ((parser.flags & 1) === 0) {
delegate = consumeOpt(parser, context | 32, 8391476);
if (parser.getToken() & (12288 | 65536) || delegate) {
argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
}
}
else if (parser.getToken() === 8391476) {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
parser.assignable = 2;
return parser.finishNode({
type: 'YieldExpression',
argument,
delegate,
}, start);
}
if (context & 1)
parser.report(97, 'yield');
return parseIdentifierOrArrow(parser, context, privateScope);
}
function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start) {
if (inGroup)
parser.destructible |= 128;
if (context & 524288)
parser.report(177);
const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope);
const isIdentifier = possibleIdentifierOrArrowFunc.type === 'ArrowFunctionExpression' ||
(parser.getToken() & 65536) === 0;
if (isIdentifier) {
if (context & 2048)
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 176);
if (context & 2)
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
if (context & 8192 && context & 2048)
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
return possibleIdentifierOrArrowFunc;
}
if (context & 8192) {
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 31);
}
if (context & 2048 || (context & 2 && context & 8)) {
if (inNew)
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 0);
const argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
if (parser.getToken() === 8391735)
parser.report(33);
parser.assignable = 2;
return parser.finishNode({
type: 'AwaitExpression',
argument,
}, start);
}
if (context & 2)
throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 98);
return possibleIdentifierOrArrowFunc;
}
function parseFunctionBody(parser, context, scope, privateScope, origin, funcNameToken, functionScope) {
const { tokenStart } = parser;
consume(parser, context | 32, 2162700);
const body = [];
if (parser.getToken() !== 1074790415) {
while (parser.getToken() === 134283267) {
const { index, tokenStart, tokenIndex, tokenValue } = parser;
const token = parser.getToken();
const expr = parseLiteral(parser, context);
if (isValidStrictMode(parser, index, tokenIndex, tokenValue)) {
context |= 1;
if (parser.flags & 128) {
throw new ParseError(tokenStart, parser.currentLocation, 66);
}
if (parser.flags & 64) {
throw new ParseError(tokenStart, parser.currentLocation, 9);
}
if (parser.flags & 4096) {
throw new ParseError(tokenStart, parser.currentLocation, 15);
}
functionScope?.reportScopeError();
}
body.push(parseDirective(parser, context, expr, token, tokenStart));
}
if (context & 1) {
if (funcNameToken) {
if ((funcNameToken & 537079808) === 537079808) {
parser.report(119);
}
if ((funcNameToken & 36864) === 36864) {
parser.report(40);
}
}
if (parser.flags & 512)
parser.report(119);
if (parser.flags & 256)
parser.report(118);
}
}
parser.flags =
(parser.flags | 512 | 256 | 64 | 4096) ^
(512 | 256 | 64 | 4096);
parser.destructible = (parser.destructible | 256) ^ 256;
while (parser.getToken() !== 1074790415) {
body.push(parseStatementListItem(parser, context, scope, privateScope, 4, {}));
}
consume(parser, origin & (16 | 8) ? context | 32 : context, 1074790415);
parser.flags &= -4289;
if (parser.getToken() === 1077936155)
parser.report(26);
return parser.finishNode({
type: 'BlockStatement',
body,
}, tokenStart);
}
function parseSuperExpression(parser, context) {
const { tokenStart } = parser;
nextToken(parser, context);
switch (parser.getToken()) {
case 67108990:
parser.report(167);
case 67174411: {
if ((context & 512) === 0)
parser.report(28);
parser.assignable = 2;
break;
}
case 69271571:
case 67108877: {
if ((context & 256) === 0)
parser.report(29);
parser.assignable = 1;
break;
}
default:
parser.report(30, 'super');
}
return parser.finishNode({ type: 'Super' }, tokenStart);
}
function parseLeftHandSideExpression(parser, context, privateScope, canAssign, inGroup, isLHS) {
const start = parser.tokenStart;
const expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, isLHS, start);
return parseMemberOrUpdateExpression(parser, context, privateScope, expression, inGroup, 0, start);
}
function parseUpdateExpression(parser, context, expr, start) {
if (parser.assignable & 2)
parser.report(55);
const token = parser.getToken();
nextToken(parser, context);
parser.assignable = 2;
return parser.finishNode({
type: 'UpdateExpression',
argument: expr,
operator: KeywordDescTable[token & 255],
prefix: false,
}, start);
}
function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, inChain, start) {
if ((parser.getToken() & 33619968) === 33619968 && (parser.flags & 1) === 0) {
expr = parseUpdateExpression(parser, context, expr, start);
}
else if ((parser.getToken() & 67108864) === 67108864) {
context = (context | 131072) ^ 131072;
switch (parser.getToken()) {
case 67108877: {
nextToken(parser, (context | 262144 | 8) ^ 8);
if (context & 16 && parser.getToken() === 130 && parser.tokenValue === 'super') {
parser.report(173);
}
parser.assignable = 1;
const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
expr = parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: false,
property,
optional: false,
}, start);
break;
}
case 69271571: {
let restoreHasOptionalChaining = false;
if ((parser.flags & 2048) === 2048) {
restoreHasOptionalChaining = true;
parser.flags = (parser.flags | 2048) ^ 2048;
}
nextToken(parser, context | 32);
const { tokenStart } = parser;
const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
consume(parser, context, 20);
parser.assignable = 1;
expr = parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: true,
property,
optional: false,
}, start);
if (restoreHasOptionalChaining) {
parser.flags |= 2048;
}
break;
}
case 67174411: {
if ((parser.flags & 1024) === 1024) {
parser.flags = (parser.flags | 1024) ^ 1024;
return expr;
}
let restoreHasOptionalChaining = false;
if ((parser.flags & 2048) === 2048) {
restoreHasOptionalChaining = true;
parser.flags = (parser.flags | 2048) ^ 2048;
}
const args = parseArguments(parser, context, privateScope, inGroup);
parser.assignable = 2;
expr = parser.finishNode({
type: 'CallExpression',
callee: expr,
arguments: args,
optional: false,
}, start);
if (restoreHasOptionalChaining) {
parser.flags |= 2048;
}
break;
}
case 67108990: {
nextToken(parser, (context | 262144 | 8) ^ 8);
parser.flags |= 2048;
parser.assignable = 2;
expr = parseOptionalChain(parser, context, privateScope, expr, start);
break;
}
default:
if ((parser.flags & 2048) === 2048) {
parser.report(166);
}
parser.assignable = 2;
expr = parser.finishNode({
type: 'TaggedTemplateExpression',
tag: expr,
quasi: parser.getToken() === 67174408
? parseTemplate(parser, context | 64, privateScope)
: parseTemplateLiteral(parser, context),
}, start);
}
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 1, start);
}
if (inChain === 0 && (parser.flags & 2048) === 2048) {
parser.flags = (parser.flags | 2048) ^ 2048;
expr = parser.finishNode({
type: 'ChainExpression',
expression: expr,
}, start);
}
return expr;
}
function parseOptionalChain(parser, context, privateScope, expr, start) {
let restoreHasOptionalChaining = false;
let node;
if (parser.getToken() === 69271571 || parser.getToken() === 67174411) {
if ((parser.flags & 2048) === 2048) {
restoreHasOptionalChaining = true;
parser.flags = (parser.flags | 2048) ^ 2048;
}
}
if (parser.getToken() === 69271571) {
nextToken(parser, context | 32);
const { tokenStart } = parser;
const property = parseExpressions(parser, context, privateScope, 0, 1, tokenStart);
consume(parser, context, 20);
parser.assignable = 2;
node = parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: true,
optional: true,
property,
}, start);
}
else if (parser.getToken() === 67174411) {
const args = parseArguments(parser, context, privateScope, 0);
parser.assignable = 2;
node = parser.finishNode({
type: 'CallExpression',
callee: expr,
arguments: args,
optional: true,
}, start);
}
else {
const property = parsePropertyOrPrivatePropertyName(parser, context, privateScope);
parser.assignable = 2;
node = parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: false,
optional: true,
property,
}, start);
}
if (restoreHasOptionalChaining) {
parser.flags |= 2048;
}
return node;
}
function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
if ((parser.getToken() & 143360) === 0 &&
parser.getToken() !== -2147483528 &&
parser.getToken() !== -2147483527 &&
parser.getToken() !== 130) {
parser.report(160);
}
return parser.getToken() === 130
? parsePrivateIdentifier(parser, context, privateScope, 0)
: parseIdentifier(parser, context);
}
function parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start) {
if (inNew)
parser.report(56);
if (!isLHS)
parser.report(0);
const token = parser.getToken();
nextToken(parser, context | 32);
const arg = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
if (parser.assignable & 2) {
parser.report(55);
}
parser.assignable = 2;
return parser.finishNode({
type: 'UpdateExpression',
argument: arg,
operator: KeywordDescTable[token & 255],
prefix: true,
}, start);
}
function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start) {
if ((parser.getToken() & 143360) === 143360) {
switch (parser.getToken()) {
case 209006:
return parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start);
case 241771:
return parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start);
case 209005:
return parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, canAssign, inNew, start);
}
const { tokenValue } = parser;
const token = parser.getToken();
const expr = parseIdentifier(parser, context | 64);
if (parser.getToken() === 10) {
if (!isLHS)
parser.report(0);
classifyIdentifier(parser, context, token);
if ((token & 36864) === 36864) {
parser.flags |= 256;
}
return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start);
}
if (context & 16 &&
!(context & 32768) &&
!(context & 8192) &&
parser.tokenValue === 'arguments')
parser.report(130);
if ((token & 255) === (241737 & 255)) {
if (context & 1)
parser.report(113);
if (kind & (8 | 16))
parser.report(100);
}
parser.assignable =
context & 1 && (token & 537079808) === 537079808
? 2
: 1;
return expr;
}
if ((parser.getToken() & 134217728) === 134217728) {
return parseLiteral(parser, context);
}
switch (parser.getToken()) {
case 33619993:
case 33619994:
return parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isLHS, start);
case 16863276:
case 16842798:
case 16842799:
case 25233968:
case 25233969:
case 16863275:
case 16863277:
return parseUnaryExpression(parser, context, privateScope, isLHS, inGroup);
case 86104:
return parseFunctionExpression(parser, context, privateScope, 0, inGroup, start);
case 2162700:
return parseObjectLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
case 69271571:
return parseArrayLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
case 67174411:
return parseParenthesizedExpression(parser, context | 64, privateScope, canAssign, 1, 0, start);
case 86021:
case 86022:
case 86023:
return parseNullOrTrueOrFalseLiteral(parser, context);
case 86111:
return parseThisExpression(parser, context);
case 65540:
return parseRegExpLiteral(parser, context);
case 132:
case 86094:
return parseClassExpression(parser, context, privateScope, inGroup, start);
case 86109:
return parseSuperExpression(parser, context);
case 67174409:
return parseTemplateLiteral(parser, context);
case 67174408:
return parseTemplate(parser, context, privateScope);
case 86107:
return parseNewExpression(parser, context, privateScope, inGroup);
case 134283388:
return parseBigIntLiteral(parser, context);
case 130:
return parsePrivateIdentifier(parser, context, privateScope, 0);
case 86106:
return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start);
case 8456256:
if (parser.options.jsx)
return parseJSXRootElementOrFragment(parser, context, privateScope, 0, parser.tokenStart);
default:
if (isValidIdentifier(context, parser.getToken()))
return parseIdentifierOrArrow(parser, context, privateScope);
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
function parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start) {
let expr = parseIdentifier(parser, context);
if (parser.getToken() === 67108877) {
return parseImportMetaExpression(parser, context, expr, start);
}
if (inNew)
parser.report(142);
expr = parseImportExpression(parser, context, privateScope, inGroup, start);
parser.assignable = 2;
return parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
}
function parseImportMetaExpression(parser, context, meta, start) {
if ((context & 2) === 0)
parser.report(169);
nextToken(parser, context);
const token = parser.getToken();
if (token !== 209030 && parser.tokenValue !== 'meta') {
parser.report(174);
}
else if (token & -2147483648) {
parser.report(175);
}
parser.assignable = 2;
return parser.finishNode({
type: 'MetaProperty',
meta,
property: parseIdentifier(parser, context),
}, start);
}
function parseImportExpression(parser, context, privateScope, inGroup, start) {
consume(parser, context | 32, 67174411);
if (parser.getToken() === 14)
parser.report(143);
const source = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
let options = null;
if (parser.getToken() === 18) {
consume(parser, context, 18);
if (parser.getToken() !== 16) {
const expContext = (context | 131072) ^ 131072;
options = parseExpression(parser, expContext, privateScope, 1, inGroup, parser.tokenStart);
}
consumeOpt(parser, context, 18);
}
const node = {
type: 'ImportExpression',
source,
options,
};
consume(parser, context, 16);
return parser.finishNode(node, start);
}
function parseImportAttributes(parser, context) {
if (!consumeOpt(parser, context, 20579))
return [];
consume(parser, context, 2162700);
const attributes = [];
const keysContent = new Set();
while (parser.getToken() !== 1074790415) {
const start = parser.tokenStart;
const key = parseIdentifierOrStringLiteral(parser, context);
consume(parser, context, 21);
const value = parseStringLiteral(parser, context);
const keyContent = key.type === 'Literal' ? key.value : key.name;
if (keysContent.has(keyContent)) {
parser.report(145, `${keyContent}`);
}
keysContent.add(keyContent);
attributes.push(parser.finishNode({
type: 'ImportAttribute',
key,
value,
}, start));
if (parser.getToken() !== 1074790415) {
consume(parser, context, 18);
}
}
consume(parser, context, 1074790415);
return attributes;
}
function parseStringLiteral(parser, context) {
if (parser.getToken() === 134283267) {
return parseLiteral(parser, context);
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
function parseIdentifierOrStringLiteral(parser, context) {
if (parser.getToken() === 134283267) {
return parseLiteral(parser, context);
}
else if (parser.getToken() & 143360) {
return parseIdentifier(parser, context);
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
function validateStringWellFormed(parser, str) {
const len = str.length;
for (let i = 0; i < len; i++) {
const code = str.charCodeAt(i);
if ((code & 0xfc00) !== 55296)
continue;
if (code > 56319 || ++i >= len || (str.charCodeAt(i) & 0xfc00) !== 56320) {
parser.report(171, JSON.stringify(str.charAt(i--)));
}
}
}
function parseModuleExportName(parser, context) {
if (parser.getToken() === 134283267) {
validateStringWellFormed(parser, parser.tokenValue);
return parseLiteral(parser, context);
}
else if (parser.getToken() & 143360) {
return parseIdentifier(parser, context);
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
function parseBigIntLiteral(parser, context) {
const { tokenRaw, tokenValue, tokenStart } = parser;
nextToken(parser, context);
parser.assignable = 2;
const node = {
type: 'Literal',
value: tokenValue,
bigint: String(tokenValue),
};
if (parser.options.raw) {
node.raw = tokenRaw;
}
return parser.finishNode(node, tokenStart);
}
function parseTemplateLiteral(parser, context) {
parser.assignable = 2;
const { tokenValue, tokenRaw, tokenStart } = parser;
consume(parser, context, 67174409);
const quasis = [parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, true)];
return parser.finishNode({
type: 'TemplateLiteral',
expressions: [],
quasis,
}, tokenStart);
}
function parseTemplate(parser, context, privateScope) {
context = (context | 131072) ^ 131072;
const { tokenValue, tokenRaw, tokenStart } = parser;
consume(parser, (context & -65) | 32, 67174408);
const quasis = [parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, false)];
const expressions = [
parseExpressions(parser, context & -65, privateScope, 0, 1, parser.tokenStart),
];
if (parser.getToken() !== 1074790415)
parser.report(83);
while (parser.setToken(scanTemplateTail(parser, context), true) !== 67174409) {
const { tokenValue, tokenRaw, tokenStart } = parser;
consume(parser, (context & -65) | 32, 67174408);
quasis.push(parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, false));
expressions.push(parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart));
if (parser.getToken() !== 1074790415)
parser.report(83);
}
{
const { tokenValue, tokenRaw, tokenStart } = parser;
consume(parser, context, 67174409);
quasis.push(parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, true));
}
return parser.finishNode({
type: 'TemplateLiteral',
expressions,
quasis,
}, tokenStart);
}
function parseTemplateElement(parser, cooked, raw, start, tail) {
const node = parser.finishNode({
type: 'TemplateElement',
value: {
cooked,
raw,
},
tail,
}, start);
const tailSize = tail ? 1 : 2;
if (parser.options.ranges) {
node.start += 1;
node.range[0] += 1;
node.end -= tailSize;
node.range[1] -= tailSize;
}
if (parser.options.loc) {
node.loc.start.column += 1;
node.loc.end.column -= tailSize;
}
return node;
}
function parseSpreadElement(parser, context, privateScope) {
const start = parser.tokenStart;
context = (context | 131072) ^ 131072;
consume(parser, context | 32, 14);
const argument = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
parser.assignable = 1;
return parser.finishNode({
type: 'SpreadElement',
argument,
}, start);
}
function parseArguments(parser, context, privateScope, inGroup) {
nextToken(parser, context | 32);
const args = [];
if (parser.getToken() === 16) {
nextToken(parser, context | 64);
return args;
}
while (parser.getToken() !== 16) {
if (parser.getToken() === 14) {
args.push(parseSpreadElement(parser, context, privateScope));
}
else {
args.push(parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart));
}
if (parser.getToken() !== 18)
break;
nextToken(parser, context | 32);
if (parser.getToken() === 16)
break;
}
consume(parser, context | 64, 16);
return args;
}
function parseIdentifier(parser, context) {
const { tokenValue, tokenStart } = parser;
const allowRegex = tokenValue === 'await' && (parser.getToken() & -2147483648) === 0;
nextToken(parser, context | (allowRegex ? 32 : 0));
return parser.finishNode({
type: 'Identifier',
name: tokenValue,
}, tokenStart);
}
function parseLiteral(parser, context) {
const { tokenValue, tokenRaw, tokenStart } = parser;
if (parser.getToken() === 134283388) {
return parseBigIntLiteral(parser, context);
}
nextToken(parser, context);
parser.assignable = 2;
return parser.finishNode(parser.options.raw
? {
type: 'Literal',
value: tokenValue,
raw: tokenRaw,
}
: {
type: 'Literal',
value: tokenValue,
}, tokenStart);
}
function parseNullOrTrueOrFalseLiteral(parser, context) {
const start = parser.tokenStart;
const raw = KeywordDescTable[parser.getToken() & 255];
const value = parser.getToken() === 86023 ? null : raw === 'true';
nextToken(parser, context);
parser.assignable = 2;
return parser.finishNode(parser.options.raw
? {
type: 'Literal',
value,
raw,
}
: {
type: 'Literal',
value,
}, start);
}
function parseThisExpression(parser, context) {
const { tokenStart } = parser;
nextToken(parser, context);
parser.assignable = 2;
return parser.finishNode({
type: 'ThisExpression',
}, tokenStart);
}
function parseFunctionDeclaration(parser, context, scope, privateScope, origin, allowGen, flags, isAsync, start) {
nextToken(parser, context | 32);
const isGenerator = allowGen ? optionalBit(parser, context, 8391476) : 0;
let id = null;
let funcNameToken;
let functionScope = scope ? parser.createScope() : void 0;
if (parser.getToken() === 67174411) {
if ((flags & 1) === 0)
parser.report(39, 'Function');
}
else {
const kind = origin & 4 && ((context & 8) === 0 || (context & 2) === 0)
? 4
: 64 | (isAsync ? 1024 : 0) | (isGenerator ? 1024 : 0);
validateFunctionName(parser, context, parser.getToken());
if (scope) {
if (kind & 4) {
scope.addVarName(context, parser.tokenValue, kind);
}
else {
scope.addBlockName(context, parser.tokenValue, kind, origin);
}
functionScope = functionScope?.createChildScope(128);
if (flags) {
if (flags & 2) {
parser.declareUnboundVariable(parser.tokenValue);
}
}
}
funcNameToken = parser.getToken();
if (parser.getToken() & 143360) {
id = parseIdentifier(parser, context);
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
}
{
const modifierFlags = 256 |
512 |
1024 |
2048 |
8192 |
16384;
context =
((context | modifierFlags) ^ modifierFlags) |
65536 |
(isAsync ? 2048 : 0) |
(isGenerator ? 1024 : 0) |
(isGenerator ? 0 : 262144);
}
functionScope = functionScope?.createChildScope(256);
const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, functionScope, privateScope, 0, 1);
const modifierFlags = 8 | 4 | 128 | 524288;
const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 32768 | 4096, functionScope?.createChildScope(64), privateScope, 8, funcNameToken, functionScope);
return parser.finishNode({
type: 'FunctionDeclaration',
id,
params,
body,
async: isAsync === 1,
generator: isGenerator === 1,
}, start);
}
function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup, start) {
nextToken(parser, context | 32);
const isGenerator = optionalBit(parser, context, 8391476);
const generatorAndAsyncFlags = (isAsync ? 2048 : 0) | (isGenerator ? 1024 : 0);
let id = null;
let funcNameToken;
let scope = parser.createScopeIfLexical();
const modifierFlags = 256 |
512 |
1024 |
2048 |
8192 |
16384 |
524288;
if (parser.getToken() & 143360) {
validateFunctionName(parser, ((context | modifierFlags) ^ modifierFlags) | generatorAndAsyncFlags, parser.getToken());
scope = scope?.createChildScope(128);
funcNameToken = parser.getToken();
id = parseIdentifier(parser, context);
}
context =
((context | modifierFlags) ^ modifierFlags) |
65536 |
generatorAndAsyncFlags |
(isGenerator ? 0 : 262144);
scope = scope?.createChildScope(256);
const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, scope, privateScope, inGroup, 1);
const body = parseFunctionBody(parser, (context & -131229) |
32768 |
4096, scope?.createChildScope(64), privateScope, 0, funcNameToken, scope);
parser.assignable = 2;
return parser.finishNode({
type: 'FunctionExpression',
id,
params,
body,
async: isAsync === 1,
generator: isGenerator === 1,
}, start);
}
function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGroup) {
const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
if (parser.destructible & 64) {
parser.report(63);
}
if (parser.destructible & 8) {
parser.report(62);
}
return expr;
}
function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
const { tokenStart: start } = parser;
nextToken(parser, context | 32);
const elements = [];
let destructible = 0;
context = (context | 131072) ^ 131072;
while (parser.getToken() !== 20) {
if (consumeOpt(parser, context | 32, 18)) {
elements.push(null);
}
else {
let left;
const { tokenStart, tokenValue } = parser;
const token = parser.getToken();
if (token & 143360) {
left = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
if (parser.getToken() === 1077936155) {
if (parser.assignable & 2)
parser.report(26);
nextToken(parser, context | 32);
scope?.addVarOrBlock(context, tokenValue, kind, origin);
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
left = parser.finishNode(isPattern
? {
type: 'AssignmentPattern',
left,
right,
}
: {
type: 'AssignmentExpression',
operator: '=',
left,
right,
}, tokenStart);
destructible |=
parser.destructible & 256
? 256
: 0 | (parser.destructible & 128)
? 128
: 0;
}
else if (parser.getToken() === 18 || parser.getToken() === 20) {
if (parser.assignable & 2) {
destructible |= 16;
}
else {
scope?.addVarOrBlock(context, tokenValue, kind, origin);
}
destructible |=
parser.destructible & 256
? 256
: 0 | (parser.destructible & 128)
? 128
: 0;
}
else {
destructible |=
kind & 1
? 32
: (kind & 2) === 0
? 16
: 0;
left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenStart);
if (parser.getToken() !== 18 && parser.getToken() !== 20) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
}
else if (parser.getToken() !== 1077936155) {
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
}
else if (token & 2097152) {
left =
parser.getToken() === 2162700
? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
: parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
destructible |= parser.destructible;
parser.assignable =
parser.destructible & 16
? 2
: 1;
if (parser.getToken() === 18 || parser.getToken() === 20) {
if (parser.assignable & 2) {
destructible |= 16;
}
}
else if (parser.destructible & 8) {
parser.report(71);
}
else {
left = parseMemberOrUpdateExpression(parser, context, privateScope, left, inGroup, 0, tokenStart);
destructible = parser.assignable & 2 ? 16 : 0;
if (parser.getToken() !== 18 && parser.getToken() !== 20) {
left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
}
else if (parser.getToken() !== 1077936155) {
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
}
else if (token === 14) {
left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, origin, 0, inGroup, isPattern);
destructible |= parser.destructible;
if (parser.getToken() !== 18 && parser.getToken() !== 20)
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
else {
left = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
if (parser.getToken() !== 18 && parser.getToken() !== 20) {
left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
if ((kind & (2 | 1)) === 0 && token === 67174411)
destructible |= 16;
}
else if (parser.assignable & 2) {
destructible |= 16;
}
else if (token === 67174411) {
destructible |=
parser.assignable & 1 && kind & (2 | 1)
? 32
: 16;
}
}
elements.push(left);
if (consumeOpt(parser, context | 32, 18)) {
if (parser.getToken() === 20)
break;
}
else
break;
}
}
consume(parser, context, 20);
const node = parser.finishNode({
type: isPattern ? 'ArrayPattern' : 'ArrayExpression',
elements,
}, start);
if (!skipInitializer && parser.getToken() & 4194304) {
return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node);
}
parser.destructible = destructible;
return node;
}
function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node) {
if (parser.getToken() !== 1077936155)
parser.report(26);
nextToken(parser, context | 32);
if (destructible & 16)
parser.report(26);
if (!isPattern)
reinterpretToPattern(parser, node);
const { tokenStart } = parser;
const right = parseExpression(parser, context, privateScope, 1, inGroup, tokenStart);
parser.destructible =
((destructible | 64 | 8) ^
(8 | 64)) |
(parser.destructible & 128 ? 128 : 0) |
(parser.destructible & 256 ? 256 : 0);
return parser.finishNode(isPattern
? {
type: 'AssignmentPattern',
left: node,
right,
}
: {
type: 'AssignmentExpression',
left: node,
operator: '=',
right,
}, start);
}
function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, origin, isAsync, inGroup, isPattern) {
const { tokenStart: start } = parser;
nextToken(parser, context | 32);
let argument = null;
let destructible = 0;
const { tokenValue, tokenStart } = parser;
let token = parser.getToken();
if (token & 143360) {
parser.assignable = 1;
argument = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
token = parser.getToken();
argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenStart);
if (parser.getToken() !== 18 && parser.getToken() !== closingToken) {
if (parser.assignable & 2 && parser.getToken() === 1077936155)
parser.report(71);
destructible |= 16;
argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
}
if (parser.assignable & 2) {
destructible |= 16;
}
else if (token === closingToken || token === 18) {
scope?.addVarOrBlock(context, tokenValue, kind, origin);
}
else {
destructible |= 32;
}
destructible |= parser.destructible & 128 ? 128 : 0;
}
else if (token === closingToken) {
parser.report(41);
}
else if (token & 2097152) {
argument =
parser.getToken() === 2162700
? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin)
: parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, isPattern, kind, origin);
token = parser.getToken();
if (token !== 1077936155 && token !== closingToken && token !== 18) {
if (parser.destructible & 8)
parser.report(71);
argument = parseMemberOrUpdateExpression(parser, context, privateScope, argument, inGroup, 0, tokenStart);
destructible |= parser.assignable & 2 ? 16 : 0;
if ((parser.getToken() & 4194304) === 4194304) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
}
else {
if ((parser.getToken() & 8388608) === 8388608) {
argument = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, argument);
}
if (consumeOpt(parser, context | 32, 22)) {
argument = parseConditionalExpression(parser, context, privateScope, argument, tokenStart);
}
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
else {
destructible |=
closingToken === 1074790415 && token !== 1077936155
? 16
: parser.destructible;
}
}
else {
destructible |= 32;
argument = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
const { tokenStart } = parser;
const token = parser.getToken();
if (token === 1077936155) {
if (parser.assignable & 2)
parser.report(26);
argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
destructible |= 16;
}
else {
if (token === 18) {
destructible |= 16;
}
else if (token !== closingToken) {
argument = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, argument);
}
destructible |=
parser.assignable & 1 ? 32 : 16;
}
parser.destructible = destructible;
if (parser.getToken() !== closingToken && parser.getToken() !== 18)
parser.report(161);
return parser.finishNode({
type: isPattern ? 'RestElement' : 'SpreadElement',
argument: argument,
}, start);
}
if (parser.getToken() !== closingToken) {
if (kind & 1)
destructible |= isAsync ? 16 : 32;
if (consumeOpt(parser, context | 32, 1077936155)) {
if (destructible & 16)
parser.report(26);
reinterpretToPattern(parser, argument);
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
argument = parser.finishNode(isPattern
? {
type: 'AssignmentPattern',
left: argument,
right,
}
: {
type: 'AssignmentExpression',
left: argument,
operator: '=',
right,
}, tokenStart);
destructible = 16;
}
else {
destructible |= 16;
}
}
parser.destructible = destructible;
return parser.finishNode({
type: isPattern ? 'RestElement' : 'SpreadElement',
argument: argument,
}, start);
}
function parseMethodDefinition(parser, context, privateScope, kind, inGroup, start) {
const modifierFlags = 1024 |
2048 |
8192 |
((kind & 64) === 0 ? 512 | 16384 : 0);
context =
((context | modifierFlags) ^ modifierFlags) |
(kind & 8 ? 1024 : 0) |
(kind & 16 ? 2048 : 0) |
(kind & 64 ? 16384 : 0) |
256 |
32768 |
65536;
let scope = parser.createScopeIfLexical(256);
const params = parseMethodFormals(parser, (context | 8192) & -524289, scope, privateScope, kind, 1, inGroup);
scope = scope?.createChildScope(64);
const body = parseFunctionBody(parser, (context & -655373) |
32768 |
4096, scope, privateScope, 0, void 0, scope?.parent);
return parser.finishNode({
type: 'FunctionExpression',
params,
body,
async: (kind & 16) > 0,
generator: (kind & 8) > 0,
id: null,
}, start);
}
function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGroup) {
const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
if (parser.destructible & 64) {
parser.report(63);
}
if (parser.destructible & 8) {
parser.report(62);
}
return expr;
}
function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
const { tokenStart: start } = parser;
nextToken(parser, context);
const properties = [];
let destructible = 0;
let prototypeCount = 0;
context = (context | 131072) ^ 131072;
while (parser.getToken() !== 1074790415) {
const { tokenValue, tokenStart } = parser;
const token = parser.getToken();
if (token === 14) {
properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, origin, 0, inGroup, isPattern));
}
else {
let state = 0;
let key = null;
let value;
if (parser.getToken() & 143360 ||
parser.getToken() === -2147483528 ||
parser.getToken() === -2147483527) {
if (parser.getToken() === -2147483527)
destructible |= 16;
key = parseIdentifier(parser, context);
if (parser.getToken() === 18 ||
parser.getToken() === 1074790415 ||
parser.getToken() === 1077936155) {
state |= 4;
if (context & 1 && (token & 537079808) === 537079808) {
destructible |= 16;
}
else {
validateBindingIdentifier(parser, context, kind, token, 0);
}
scope?.addVarOrBlock(context, tokenValue, kind, origin);
if (consumeOpt(parser, context | 32, 1077936155)) {
destructible |= 8;
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
destructible |=
parser.destructible & 256
? 256
: 0 | (parser.destructible & 128)
? 128
: 0;
value = parser.finishNode({
type: 'AssignmentPattern',
left: parser.options.uniqueKeyInPattern ? Object.assign({}, key) : key,
right,
}, tokenStart);
}
else {
destructible |=
(token === 209006 ? 128 : 0) |
(token === -2147483528 ? 16 : 0);
value = parser.options.uniqueKeyInPattern ? Object.assign({}, key) : key;
}
}
else if (consumeOpt(parser, context | 32, 21)) {
const { tokenStart } = parser;
if (tokenValue === '__proto__')
prototypeCount++;
if (parser.getToken() & 143360) {
const tokenAfterColon = parser.getToken();
const valueAfterColon = parser.tokenValue;
value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
const token = parser.getToken();
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (token === 1077936155 || token === 1074790415 || token === 18) {
destructible |= parser.destructible & 128 ? 128 : 0;
if (parser.assignable & 2) {
destructible |= 16;
}
else if ((tokenAfterColon & 143360) === 143360) {
scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
}
}
else {
destructible |=
parser.assignable & 1
? 32
: 16;
}
}
else if ((parser.getToken() & 4194304) === 4194304) {
if (parser.assignable & 2) {
destructible |= 16;
}
else if (token !== 1077936155) {
destructible |= 32;
}
else {
scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
}
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else {
destructible |= 16;
if ((parser.getToken() & 8388608) === 8388608) {
value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
}
if (consumeOpt(parser, context | 32, 22)) {
value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
}
}
}
else if ((parser.getToken() & 2097152) === 2097152) {
value =
parser.getToken() === 69271571
? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
: parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
destructible = parser.destructible;
parser.assignable =
destructible & 16 ? 2 : 1;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2)
destructible |= 16;
}
else if (parser.destructible & 8) {
parser.report(71);
}
else {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible = parser.assignable & 2 ? 16 : 0;
if ((parser.getToken() & 4194304) === 4194304) {
value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else {
if ((parser.getToken() & 8388608) === 8388608) {
value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
}
if (consumeOpt(parser, context | 32, 22)) {
value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
}
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
}
else {
value = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
destructible |=
parser.assignable & 1
? 32
: 16;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2)
destructible |= 16;
}
else {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible = parser.assignable & 2 ? 16 : 0;
if (parser.getToken() !== 18 && token !== 1074790415) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
}
}
}
else if (parser.getToken() === 69271571) {
destructible |= 16;
if (token === 209005)
state |= 16;
state |=
(token === 209008
? 256
: token === 209009
? 512
: 1) | 2;
key = parseComputedPropertyName(parser, context, privateScope, inGroup);
destructible |= parser.assignable;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else if (parser.getToken() & 143360) {
destructible |= 16;
if (token === -2147483528)
parser.report(95);
if (token === 209005) {
if (parser.flags & 1)
parser.report(132);
state |= 16 | 1;
}
else if (token === 209008) {
state |= 256;
}
else if (token === 209009) {
state |= 512;
}
else {
parser.report(0);
}
key = parseIdentifier(parser, context);
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else if (parser.getToken() === 67174411) {
destructible |= 16;
state |= 1;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else if (parser.getToken() === 8391476) {
destructible |= 16;
if (token === 209008) {
parser.report(42);
}
else if (token === 209009) {
parser.report(43);
}
else if (token !== 209005) {
parser.report(30, KeywordDescTable[8391476 & 255]);
}
nextToken(parser, context);
state |=
8 | 1 | (token === 209005 ? 16 : 0);
if (parser.getToken() & 143360) {
key = parseIdentifier(parser, context);
}
else if ((parser.getToken() & 134217728) === 134217728) {
key = parseLiteral(parser, context);
}
else if (parser.getToken() === 69271571) {
state |= 2;
key = parseComputedPropertyName(parser, context, privateScope, inGroup);
destructible |= parser.assignable;
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else if ((parser.getToken() & 134217728) === 134217728) {
if (token === 209005)
state |= 16;
state |=
token === 209008
? 256
: token === 209009
? 512
: 1;
destructible |= 16;
key = parseLiteral(parser, context);
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else {
parser.report(133);
}
}
else if ((parser.getToken() & 134217728) === 134217728) {
key = parseLiteral(parser, context);
if (parser.getToken() === 21) {
consume(parser, context | 32, 21);
const { tokenStart } = parser;
if (tokenValue === '__proto__')
prototypeCount++;
if (parser.getToken() & 143360) {
value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
const { tokenValue: valueAfterColon } = parser;
const token = parser.getToken();
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (token === 1077936155 || token === 1074790415 || token === 18) {
if (parser.assignable & 2) {
destructible |= 16;
}
else {
scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
}
}
else {
destructible |=
parser.assignable & 1
? 32
: 16;
}
}
else if (parser.getToken() === 1077936155) {
if (parser.assignable & 2)
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else {
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
}
else if ((parser.getToken() & 2097152) === 2097152) {
value =
parser.getToken() === 69271571
? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
: parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
destructible = parser.destructible;
parser.assignable =
destructible & 16 ? 2 : 1;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2) {
destructible |= 16;
}
}
else if ((parser.destructible & 8) !== 8) {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible = parser.assignable & 2 ? 16 : 0;
if ((parser.getToken() & 4194304) === 4194304) {
value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else {
if ((parser.getToken() & 8388608) === 8388608) {
value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
}
if (consumeOpt(parser, context | 32, 22)) {
value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
}
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
}
else {
value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
destructible |=
parser.assignable & 1
? 32
: 16;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2) {
destructible |= 16;
}
}
else {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible = parser.assignable & 1 ? 0 : 16;
if (parser.getToken() !== 18 && parser.getToken() !== 1074790415) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
}
}
}
else if (parser.getToken() === 67174411) {
state |= 1;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
destructible = parser.assignable | 16;
}
else {
parser.report(134);
}
}
else if (parser.getToken() === 69271571) {
key = parseComputedPropertyName(parser, context, privateScope, inGroup);
destructible |= parser.destructible & 256 ? 256 : 0;
state |= 2;
if (parser.getToken() === 21) {
nextToken(parser, context | 32);
const { tokenStart, tokenValue } = parser;
const tokenAfterColon = parser.getToken();
if (parser.getToken() & 143360) {
value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
const token = parser.getToken();
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
if ((parser.getToken() & 4194304) === 4194304) {
destructible |=
parser.assignable & 2
? 16
: token === 1077936155
? 0
: 32;
value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (token === 1077936155 || token === 1074790415 || token === 18) {
if (parser.assignable & 2) {
destructible |= 16;
}
else if ((tokenAfterColon & 143360) === 143360) {
scope?.addVarOrBlock(context, tokenValue, kind, origin);
}
}
else {
destructible |=
parser.assignable & 1
? 32
: 16;
}
}
else {
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
}
else if ((parser.getToken() & 2097152) === 2097152) {
value =
parser.getToken() === 69271571
? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin)
: parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, inGroup, isPattern, kind, origin);
destructible = parser.destructible;
parser.assignable =
destructible & 16 ? 2 : 1;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2)
destructible |= 16;
}
else if (destructible & 8) {
parser.report(62);
}
else {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible =
parser.assignable & 2 ? destructible | 16 : 0;
if ((parser.getToken() & 4194304) === 4194304) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
value = parseAssignmentExpressionOrPattern(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
else {
if ((parser.getToken() & 8388608) === 8388608) {
value = parseBinaryExpression(parser, context, privateScope, 1, tokenStart, 4, token, value);
}
if (consumeOpt(parser, context | 32, 22)) {
value = parseConditionalExpression(parser, context, privateScope, value, tokenStart);
}
destructible |=
parser.assignable & 2
? 16
: 32;
}
}
}
else {
value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
destructible |=
parser.assignable & 1
? 32
: 16;
if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
if (parser.assignable & 2)
destructible |= 16;
}
else {
value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
destructible = parser.assignable & 1 ? 0 : 16;
if (parser.getToken() !== 18 && parser.getToken() !== 1074790415) {
if (parser.getToken() !== 1077936155)
destructible |= 16;
value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
}
}
}
}
else if (parser.getToken() === 67174411) {
state |= 1;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
destructible = 16;
}
else {
parser.report(44);
}
}
else if (token === 8391476) {
consume(parser, context | 32, 8391476);
state |= 8;
if (parser.getToken() & 143360) {
const token = parser.getToken();
key = parseIdentifier(parser, context);
state |= 1;
if (parser.getToken() === 67174411) {
destructible |= 16;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else {
throw new ParseError(parser.tokenStart, parser.currentLocation, token === 209005
? 46
: token === 209008 || parser.getToken() === 209009
? 45
: 47, KeywordDescTable[token & 255]);
}
}
else if ((parser.getToken() & 134217728) === 134217728) {
destructible |= 16;
key = parseLiteral(parser, context);
state |= 1;
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else if (parser.getToken() === 69271571) {
destructible |= 16;
state |= 2 | 1;
key = parseComputedPropertyName(parser, context, privateScope, inGroup);
value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
}
else {
parser.report(126);
}
}
else {
parser.report(30, KeywordDescTable[token & 255]);
}
destructible |= parser.destructible & 128 ? 128 : 0;
parser.destructible = destructible;
properties.push(parser.finishNode({
type: 'Property',
key: key,
value,
kind: !(state & 768) ? 'init' : state & 512 ? 'set' : 'get',
computed: (state & 2) > 0,
method: (state & 1) > 0,
shorthand: (state & 4) > 0,
}, tokenStart));
}
destructible |= parser.destructible;
if (parser.getToken() !== 18)
break;
nextToken(parser, context);
}
consume(parser, context, 1074790415);
if (prototypeCount > 1)
destructible |= 64;
const node = parser.finishNode({
type: isPattern ? 'ObjectPattern' : 'ObjectExpression',
properties,
}, start);
if (!skipInitializer && parser.getToken() & 4194304) {
return parseArrayOrObjectAssignmentPattern(parser, context, privateScope, destructible, inGroup, isPattern, start, node);
}
parser.destructible = destructible;
return node;
}
function parseMethodFormals(parser, context, scope, privateScope, kind, type, inGroup) {
consume(parser, context, 67174411);
const params = [];
parser.flags = (parser.flags | 128) ^ 128;
if (parser.getToken() === 16) {
if (kind & 512) {
parser.report(37, 'Setter', 'one', '');
}
nextToken(parser, context);
return params;
}
if (kind & 256) {
parser.report(37, 'Getter', 'no', 's');
}
if (kind & 512 && parser.getToken() === 14) {
parser.report(38);
}
context = (context | 131072) ^ 131072;
let setterArgs = 0;
let isNonSimpleParameterList = 0;
while (parser.getToken() !== 18) {
let left = null;
const { tokenStart } = parser;
if (parser.getToken() & 143360) {
if ((context & 1) === 0) {
if ((parser.getToken() & 36864) === 36864) {
parser.flags |= 256;
}
if ((parser.getToken() & 537079808) === 537079808) {
parser.flags |= 512;
}
}
left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
}
else {
if (parser.getToken() === 2162700) {
left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
}
else if (parser.getToken() === 69271571) {
left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
}
else if (parser.getToken() === 14) {
left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, 0, inGroup, 1);
}
isNonSimpleParameterList = 1;
if (parser.destructible & (32 | 16))
parser.report(50);
}
if (parser.getToken() === 1077936155) {
nextToken(parser, context | 32);
isNonSimpleParameterList = 1;
const right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
left = parser.finishNode({
type: 'AssignmentPattern',
left: left,
right,
}, tokenStart);
}
setterArgs++;
params.push(left);
if (!consumeOpt(parser, context, 18))
break;
if (parser.getToken() === 16) {
break;
}
}
if (kind & 512 && setterArgs !== 1) {
parser.report(37, 'Setter', 'one', '');
}
scope?.reportScopeError();
if (isNonSimpleParameterList)
parser.flags |= 128;
consume(parser, context, 16);
return params;
}
function parseComputedPropertyName(parser, context, privateScope, inGroup) {
nextToken(parser, context | 32);
const key = parseExpression(parser, (context | 131072) ^ 131072, privateScope, 1, inGroup, parser.tokenStart);
consume(parser, context, 20);
return key;
}
function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, origin, start) {
parser.flags = (parser.flags | 128) ^ 128;
const parenthesesStart = parser.tokenStart;
nextToken(parser, context | 32 | 262144);
const scope = parser.createScopeIfLexical()?.createChildScope(512);
context = (context | 131072) ^ 131072;
if (consumeOpt(parser, context, 16)) {
return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start);
}
let destructible = 0;
parser.destructible &= -385;
let expr;
let expressions = [];
let isSequence = 0;
let isNonSimpleParameterList = 0;
let hasStrictReserved = 0;
const tokenAfterParenthesesStart = parser.tokenStart;
parser.assignable = 1;
while (parser.getToken() !== 16) {
const { tokenStart } = parser;
const token = parser.getToken();
if (token & 143360) {
scope?.addBlockName(context, parser.tokenValue, 1, 0);
if ((token & 537079808) === 537079808) {
isNonSimpleParameterList = 1;
}
else if ((token & 36864) === 36864) {
hasStrictReserved = 1;
}
expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
if (parser.getToken() === 16 || parser.getToken() === 18) {
if (parser.assignable & 2) {
destructible |= 16;
isNonSimpleParameterList = 1;
}
}
else {
if (parser.getToken() === 1077936155) {
isNonSimpleParameterList = 1;
}
else {
destructible |= 16;
}
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenStart);
if (parser.getToken() !== 16 && parser.getToken() !== 18) {
expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenStart, expr);
}
}
}
else if ((token & 2097152) === 2097152) {
expr =
token === 2162700
? parseObjectLiteralOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin)
: parseArrayExpressionOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin);
destructible |= parser.destructible;
isNonSimpleParameterList = 1;
parser.assignable = 2;
if (parser.getToken() !== 16 && parser.getToken() !== 18) {
if (destructible & 8)
parser.report(122);
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
destructible |= 16;
if (parser.getToken() !== 16 && parser.getToken() !== 18) {
expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
}
}
}
else if (token === 14) {
expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 0, 1, 0);
if (parser.destructible & 16)
parser.report(74);
isNonSimpleParameterList = 1;
if (isSequence && (parser.getToken() === 16 || parser.getToken() === 18)) {
expressions.push(expr);
}
destructible |= 8;
break;
}
else {
destructible |= 16;
expr = parseExpression(parser, context, privateScope, 1, 1, tokenStart);
if (isSequence && (parser.getToken() === 16 || parser.getToken() === 18)) {
expressions.push(expr);
}
if (parser.getToken() === 18) {
if (!isSequence) {
isSequence = 1;
expressions = [expr];
}
}
if (isSequence) {
while (consumeOpt(parser, context | 32, 18)) {
expressions.push(parseExpression(parser, context, privateScope, 1, 1, parser.tokenStart));
}
parser.assignable = 2;
expr = parser.finishNode({
type: 'SequenceExpression',
expressions,
}, tokenAfterParenthesesStart);
}
consume(parser, context, 16);
parser.destructible = destructible;
return parser.options.preserveParens
? parser.finishNode({
type: 'ParenthesizedExpression',
expression: expr,
}, parenthesesStart)
: expr;
}
if (isSequence && (parser.getToken() === 16 || parser.getToken() === 18)) {
expressions.push(expr);
}
if (!consumeOpt(parser, context | 32, 18))
break;
if (!isSequence) {
isSequence = 1;
expressions = [expr];
}
if (parser.getToken() === 16) {
destructible |= 8;
break;
}
}
if (isSequence) {
parser.assignable = 2;
expr = parser.finishNode({
type: 'SequenceExpression',
expressions,
}, tokenAfterParenthesesStart);
}
consume(parser, context, 16);
if (destructible & 16 && destructible & 8)
parser.report(151);
destructible |=
parser.destructible & 256
? 256
: 0 | (parser.destructible & 128)
? 128
: 0;
if (parser.getToken() === 10) {
if (destructible & (32 | 16))
parser.report(49);
if (context & (2048 | 2) && destructible & 128)
parser.report(31);
if (context & (1 | 1024) && destructible & 256) {
parser.report(32);
}
if (isNonSimpleParameterList)
parser.flags |= 128;
if (hasStrictReserved)
parser.flags |= 256;
return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start);
}
if (destructible & 64) {
parser.report(63);
}
if (destructible & 8) {
parser.report(144);
}
parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
return parser.options.preserveParens
? parser.finishNode({
type: 'ParenthesizedExpression',
expression: expr,
}, parenthesesStart)
: expr;
}
function parseIdentifierOrArrow(parser, context, privateScope) {
const { tokenStart: start } = parser;
const { tokenValue } = parser;
let isNonSimpleParameterList = 0;
let hasStrictReserved = 0;
if ((parser.getToken() & 537079808) === 537079808) {
isNonSimpleParameterList = 1;
}
else if ((parser.getToken() & 36864) === 36864) {
hasStrictReserved = 1;
}
const expr = parseIdentifier(parser, context);
parser.assignable = 1;
if (parser.getToken() === 10) {
const scope = parser.options.lexical ? createArrowHeadParsingScope(parser, context, tokenValue) : undefined;
if (isNonSimpleParameterList)
parser.flags |= 128;
if (hasStrictReserved)
parser.flags |= 256;
return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, start);
}
return expr;
}
function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start) {
if (!canAssign)
parser.report(57);
if (inNew)
parser.report(51);
parser.flags &= -129;
const scope = parser.options.lexical ? createArrowHeadParsingScope(parser, context, value) : void 0;
return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start);
}
function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start) {
if (!canAssign)
parser.report(57);
for (let i = 0; i < params.length; ++i)
reinterpretToPattern(parser, params[i]);
return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start);
}
function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start) {
if (parser.flags & 1)
parser.report(48);
consume(parser, context | 32, 10);
const modifierFlags = 1024 | 2048 | 8192 | 524288;
context = ((context | modifierFlags) ^ modifierFlags) | (isAsync ? 2048 : 0);
const expression = parser.getToken() !== 2162700;
let body;
scope?.reportScopeError();
if (expression) {
parser.flags =
(parser.flags | 512 | 256 | 64 | 4096) ^
(512 | 256 | 64 | 4096);
body = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
}
else {
scope = scope?.createChildScope(64);
const modifierFlags = 4 | 131072 | 8;
body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, 16, void 0, void 0);
switch (parser.getToken()) {
case 69271571:
if ((parser.flags & 1) === 0) {
parser.report(116);
}
break;
case 67108877:
case 67174409:
case 22:
parser.report(117);
case 67174411:
if ((parser.flags & 1) === 0) {
parser.report(116);
}
parser.flags |= 1024;
break;
}
if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0)
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
if ((parser.getToken() & 33619968) === 33619968)
parser.report(125);
}
parser.assignable = 2;
return parser.finishNode({
type: 'ArrowFunctionExpression',
params,
body,
async: isAsync === 1,
expression,
generator: false,
}, start);
}
function parseFormalParametersOrFormalList(parser, context, scope, privateScope, inGroup, kind) {
consume(parser, context, 67174411);
parser.flags = (parser.flags | 128) ^ 128;
const params = [];
if (consumeOpt(parser, context, 16))
return params;
context = (context | 131072) ^ 131072;
let isNonSimpleParameterList = 0;
while (parser.getToken() !== 18) {
let left;
const { tokenStart } = parser;
const token = parser.getToken();
if (token & 143360) {
if ((context & 1) === 0) {
if ((token & 36864) === 36864) {
parser.flags |= 256;
}
if ((token & 537079808) === 537079808) {
parser.flags |= 512;
}
}
left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
}
else {
if (token === 2162700) {
left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
}
else if (token === 69271571) {
left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
}
else if (token === 14) {
left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 0, inGroup, 1);
}
else {
parser.report(30, KeywordDescTable[token & 255]);
}
isNonSimpleParameterList = 1;
if (parser.destructible & (32 | 16)) {
parser.report(50);
}
}
if (parser.getToken() === 1077936155) {
nextToken(parser, context | 32);
isNonSimpleParameterList = 1;
const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
left = parser.finishNode({
type: 'AssignmentPattern',
left,
right,
}, tokenStart);
}
params.push(left);
if (!consumeOpt(parser, context, 18))
break;
if (parser.getToken() === 16) {
break;
}
}
if (isNonSimpleParameterList)
parser.flags |= 128;
if (isNonSimpleParameterList || context & 1) {
scope?.reportScopeError();
}
consume(parser, context, 16);
return params;
}
function parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, start) {
const token = parser.getToken();
if (token & 67108864) {
if (token === 67108877) {
nextToken(parser, context | 262144);
parser.assignable = 1;
const property = parsePropertyOrPrivatePropertyName(parser, context, privateScope);
return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: false,
property,
optional: false,
}, start), 0, start);
}
else if (token === 69271571) {
nextToken(parser, context | 32);
const { tokenStart } = parser;
const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
consume(parser, context, 20);
parser.assignable = 1;
return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
type: 'MemberExpression',
object: expr,
computed: true,
property,
optional: false,
}, start), 0, start);
}
else if (token === 67174408 || token === 67174409) {
parser.assignable = 2;
return parseMemberExpressionNoCall(parser, context, privateScope, parser.finishNode({
type: 'TaggedTemplateExpression',
tag: expr,
quasi: parser.getToken() === 67174408
? parseTemplate(parser, context | 64, privateScope)
: parseTemplateLiteral(parser, context | 64),
}, start), 0, start);
}
}
return expr;
}
function parseNewExpression(parser, context, privateScope, inGroup) {
const { tokenStart: start } = parser;
const id = parseIdentifier(parser, context | 32);
const { tokenStart } = parser;
if (consumeOpt(parser, context, 67108877)) {
if (context & 65536 && parser.getToken() === 209029) {
parser.assignable = 2;
return parseMetaProperty(parser, context, id, start);
}
parser.report(94);
}
parser.assignable = 2;
if ((parser.getToken() & 16842752) === 16842752) {
parser.report(65, KeywordDescTable[parser.getToken() & 255]);
}
const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
context = (context | 131072) ^ 131072;
if (parser.getToken() === 67108990)
parser.report(168);
const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
parser.assignable = 2;
return parser.finishNode({
type: 'NewExpression',
callee,
arguments: parser.getToken() === 67174411 ? parseArguments(parser, context, privateScope, inGroup) : [],
}, start);
}
function parseMetaProperty(parser, context, meta, start) {
const property = parseIdentifier(parser, context);
return parser.finishNode({
type: 'MetaProperty',
meta,
property,
}, start);
}
function parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, start) {
if (parser.getToken() === 209006)
parser.report(31);
if (context & (1 | 1024) && parser.getToken() === 241771) {
parser.report(32);
}
classifyIdentifier(parser, context, parser.getToken());
if ((parser.getToken() & 36864) === 36864) {
parser.flags |= 256;
}
return parseArrowFromIdentifier(parser, (context & -524289) | 2048, privateScope, parser.tokenValue, parseIdentifier(parser, context), 0, canAssign, 1, start);
}
function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, origin, flags, start) {
nextToken(parser, context | 32);
const scope = parser.createScopeIfLexical()?.createChildScope(512);
context = (context | 131072) ^ 131072;
if (consumeOpt(parser, context, 16)) {
if (parser.getToken() === 10) {
if (flags & 1)
parser.report(48);
return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 1, start);
}
return parser.finishNode({
type: 'CallExpression',
callee,
arguments: [],
optional: false,
}, start);
}
let destructible = 0;
let expr = null;
let isNonSimpleParameterList = 0;
parser.destructible =
(parser.destructible | 256 | 128) ^
(256 | 128);
const params = [];
while (parser.getToken() !== 16) {
const { tokenStart } = parser;
const token = parser.getToken();
if (token & 143360) {
scope?.addBlockName(context, parser.tokenValue, kind, 0);
if ((token & 537079808) === 537079808) {
parser.flags |= 512;
}
else if ((token & 36864) === 36864) {
parser.flags |= 256;
}
expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
if (parser.getToken() === 16 || parser.getToken() === 18) {
if (parser.assignable & 2) {
destructible |= 16;
isNonSimpleParameterList = 1;
}
}
else {
if (parser.getToken() === 1077936155) {
isNonSimpleParameterList = 1;
}
else {
destructible |= 16;
}
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 1, 0, tokenStart);
if (parser.getToken() !== 16 && parser.getToken() !== 18) {
expr = parseAssignmentExpression(parser, context, privateScope, 1, 0, tokenStart, expr);
}
}
}
else if (token & 2097152) {
expr =
token === 2162700
? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin)
: parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin);
destructible |= parser.destructible;
isNonSimpleParameterList = 1;
if (parser.getToken() !== 16 && parser.getToken() !== 18) {
if (destructible & 8)
parser.report(122);
expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
destructible |= 16;
if ((parser.getToken() & 8388608) === 8388608) {
expr = parseBinaryExpression(parser, context, privateScope, 1, start, 4, token, expr);
}
if (consumeOpt(parser, context | 32, 22)) {
expr = parseConditionalExpression(parser, context, privateScope, expr, start);
}
}
}
else if (token === 14) {
expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 1, 1, 0);
destructible |=
(parser.getToken() === 16 ? 0 : 16) | parser.destructible;
isNonSimpleParameterList = 1;
}
else {
expr = parseExpression(parser, context, privateScope, 1, 0, tokenStart);
destructible = parser.assignable;
params.push(expr);
while (consumeOpt(parser, context | 32, 18)) {
params.push(parseExpression(parser, context, privateScope, 1, 0, tokenStart));
}
destructible |= parser.assignable;
consume(parser, context, 16);
parser.destructible = destructible | 16;
parser.assignable = 2;
return parser.finishNode({
type: 'CallExpression',
callee,
arguments: params,
optional: false,
}, start);
}
params.push(expr);
if (!consumeOpt(parser, context | 32, 18))
break;
}
consume(parser, context, 16);
destructible |=
parser.destructible & 256
? 256
: 0 | (parser.destructible & 128)
? 128
: 0;
if (parser.getToken() === 10) {
if (destructible & (32 | 16))
parser.report(27);
if (parser.flags & 1 || flags & 1)
parser.report(48);
if (destructible & 128)
parser.report(31);
if (context & (1 | 1024) && destructible & 256)
parser.report(32);
if (isNonSimpleParameterList)
parser.flags |= 128;
return parseParenthesizedArrow(parser, context | 2048, scope, privateScope, params, canAssign, 1, start);
}
if (destructible & 64) {
parser.report(63);
}
if (destructible & 8) {
parser.report(62);
}
parser.assignable = 2;
return parser.finishNode({
type: 'CallExpression',
callee,
arguments: params,
optional: false,
}, start);
}
function parseRegExpLiteral(parser, context) {
const { tokenRaw, tokenRegExp, tokenValue, tokenStart } = parser;
nextToken(parser, context);
parser.assignable = 2;
const node = {
type: 'Literal',
value: tokenValue,
regex: tokenRegExp,
};
if (parser.options.raw) {
node.raw = tokenRaw;
}
return parser.finishNode(node, tokenStart);
}
function parseClassDeclaration(parser, context, scope, privateScope, flags) {
let start;
let decorators;
if (parser.leadingDecorators.decorators.length) {
if (parser.getToken() === 132) {
parser.report(30, '@');
}
start = parser.leadingDecorators.start;
decorators = [...parser.leadingDecorators.decorators];
parser.leadingDecorators.decorators.length = 0;
}
else {
start = parser.tokenStart;
decorators = parseDecorators(parser, context, privateScope);
}
context = (context | 16384 | 1) ^ 16384;
nextToken(parser, context);
let id = null;
let superClass = null;
const { tokenValue } = parser;
if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
if (isStrictReservedWord(parser, context, parser.getToken())) {
parser.report(118);
}
if ((parser.getToken() & 537079808) === 537079808) {
parser.report(119);
}
if (scope) {
scope.addBlockName(context, tokenValue, 32, 0);
if (flags) {
if (flags & 2) {
parser.declareUnboundVariable(tokenValue);
}
}
}
id = parseIdentifier(parser, context);
}
else {
if ((flags & 1) === 0)
parser.report(39, 'Class');
}
let inheritedContext = context;
if (consumeOpt(parser, context | 32, 20565)) {
superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 0);
inheritedContext |= 512;
}
else {
inheritedContext = (inheritedContext | 512) ^ 512;
}
const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 8, 0);
return parser.finishNode({
type: 'ClassDeclaration',
id,
superClass,
body,
...(parser.options.next ? { decorators } : null),
}, start);
}
function parseClassExpression(parser, context, privateScope, inGroup, start) {
let id = null;
let superClass = null;
const decorators = parseDecorators(parser, context, privateScope);
context = (context | 1 | 16384) ^ 16384;
nextToken(parser, context);
if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
if (isStrictReservedWord(parser, context, parser.getToken()))
parser.report(118);
if ((parser.getToken() & 537079808) === 537079808) {
parser.report(119);
}
id = parseIdentifier(parser, context);
}
let inheritedContext = context;
if (consumeOpt(parser, context | 32, 20565)) {
superClass = parseLeftHandSideExpression(parser, context, privateScope, 0, inGroup, 0);
inheritedContext |= 512;
}
else {
inheritedContext = (inheritedContext | 512) ^ 512;
}
const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, 0, inGroup);
parser.assignable = 2;
return parser.finishNode({
type: 'ClassExpression',
id,
superClass,
body,
...(parser.options.next ? { decorators } : null),
}, start);
}
function parseDecorators(parser, context, privateScope) {
const list = [];
if (parser.options.next) {
while (parser.getToken() === 132) {
list.push(parseDecoratorList(parser, context, privateScope));
}
}
return list;
}
function parseDecoratorList(parser, context, privateScope) {
const start = parser.tokenStart;
nextToken(parser, context | 32);
let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, parser.tokenStart);
return parser.finishNode({
type: 'Decorator',
expression,
}, start);
}
function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, origin, inGroup) {
const { tokenStart } = parser;
const privateScope = parser.createPrivateScopeIfLexical(parentScope);
consume(parser, context | 32, 2162700);
const modifierFlags = 131072 | 524288;
context = (context | modifierFlags) ^ modifierFlags;
const hasConstr = parser.flags & 32;
parser.flags = (parser.flags | 32) ^ 32;
const body = [];
while (parser.getToken() !== 1074790415) {
const decoratorStart = parser.tokenStart;
const decorators = parseDecorators(parser, context, privateScope);
if (decorators.length > 0 && parser.tokenValue === 'constructor') {
parser.report(109);
}
if (parser.getToken() === 1074790415)
parser.report(108);
if (consumeOpt(parser, context, 1074790417)) {
if (decorators.length > 0)
parser.report(120);
continue;
}
body.push(parseClassElementList(parser, context, scope, privateScope, inheritedContext, kind, decorators, 0, inGroup, decorators.length > 0 ? decoratorStart : parser.tokenStart));
}
consume(parser, origin & 8 ? context | 32 : context, 1074790415);
privateScope?.validatePrivateIdentifierRefs();
parser.flags = (parser.flags & -33) | hasConstr;
return parser.finishNode({
type: 'ClassBody',
body,
}, tokenStart);
}
function parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, isStatic, inGroup, start) {
let kind = isStatic ? 32 : 0;
let key = null;
const token = parser.getToken();
if (token & (143360 | 36864) || token === -2147483528) {
key = parseIdentifier(parser, context);
switch (token) {
case 36970:
if (!isStatic &&
parser.getToken() !== 67174411 &&
(parser.getToken() & 1048576) !== 1048576 &&
parser.getToken() !== 1077936155) {
return parseClassElementList(parser, context, scope, privateScope, inheritedContext, type, decorators, 1, inGroup, start);
}
break;
case 209005:
if (parser.getToken() !== 67174411 && (parser.flags & 1) === 0) {
if ((parser.getToken() & 1073741824) === 1073741824) {
return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
}
kind |= 16 | (optionalBit(parser, context, 8391476) ? 8 : 0);
}
break;
case 209008:
if (parser.getToken() !== 67174411) {
if ((parser.getToken() & 1073741824) === 1073741824) {
return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
}
kind |= 256;
}
break;
case 209009:
if (parser.getToken() !== 67174411) {
if ((parser.getToken() & 1073741824) === 1073741824) {
return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
}
kind |= 512;
}
break;
case 12402:
if (parser.getToken() !== 67174411 && (parser.flags & 1) === 0) {
if ((parser.getToken() & 1073741824) === 1073741824) {
return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
}
if (parser.options.next)
kind |= 1024;
}
break;
}
}
else if (token === 69271571) {
kind |= 2;
key = parseComputedPropertyName(parser, inheritedContext, privateScope, inGroup);
}
else if ((token & 134217728) === 134217728) {
key = parseLiteral(parser, context);
}
else if (token === 8391476) {
kind |= 8;
nextToken(parser, context);
}
else if (parser.getToken() === 130) {
kind |= 8192;
key = parsePrivateIdentifier(parser, context | 16, privateScope, 768);
}
else if ((parser.getToken() & 1073741824) === 1073741824) {
kind |= 128;
}
else if (isStatic && token === 2162700) {
return parseStaticBlock(parser, context | 16, scope, privateScope, start);
}
else if (token === -2147483527) {
key = parseIdentifier(parser, context);
if (parser.getToken() !== 67174411)
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
else {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
if (kind & (8 | 16 | 768 | 1024)) {
if (parser.getToken() & 143360 ||
parser.getToken() === -2147483528 ||
parser.getToken() === -2147483527) {
key = parseIdentifier(parser, context);
}
else if ((parser.getToken() & 134217728) === 134217728) {
key = parseLiteral(parser, context);
}
else if (parser.getToken() === 69271571) {
kind |= 2;
key = parseComputedPropertyName(parser, context, privateScope, 0);
}
else if (parser.getToken() === 130) {
kind |= 8192;
key = parsePrivateIdentifier(parser, context, privateScope, kind);
}
else
parser.report(135);
}
if ((kind & 2) === 0) {
if (parser.tokenValue === 'constructor') {
if ((parser.getToken() & 1073741824) === 1073741824) {
parser.report(129);
}
else if ((kind & 32) === 0 && parser.getToken() === 67174411) {
if (kind & (768 | 16 | 128 | 8)) {
parser.report(53, 'accessor');
}
else if ((context & 512) === 0) {
if (parser.flags & 32)
parser.report(54);
else
parser.flags |= 32;
}
}
kind |= 64;
}
else if ((kind & 8192) === 0 &&
kind & 32 &&
parser.tokenValue === 'prototype') {
parser.report(52);
}
}
if (kind & 1024 || (parser.getToken() !== 67174411 && (kind & 768) === 0)) {
return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
}
const value = parseMethodDefinition(parser, context | 16, privateScope, kind, inGroup, parser.tokenStart);
return parser.finishNode({
type: 'MethodDefinition',
kind: (kind & 32) === 0 && kind & 64
? 'constructor'
: kind & 256
? 'get'
: kind & 512
? 'set'
: 'method',
static: (kind & 32) > 0,
computed: (kind & 2) > 0,
key,
value,
...(parser.options.next ? { decorators } : null),
}, start);
}
function parsePrivateIdentifier(parser, context, privateScope, kind) {
const { tokenStart } = parser;
nextToken(parser, context);
const { tokenValue } = parser;
if (tokenValue === 'constructor')
parser.report(128);
if (parser.options.lexical) {
if (!privateScope)
parser.report(4, tokenValue);
if (kind) {
privateScope.addPrivateIdentifier(tokenValue, kind);
}
else {
privateScope.addPrivateIdentifierRef(tokenValue);
}
}
nextToken(parser, context);
return parser.finishNode({
type: 'PrivateIdentifier',
name: tokenValue,
}, tokenStart);
}
function parsePropertyDefinition(parser, context, privateScope, key, state, decorators, start) {
let value = null;
if (state & 8)
parser.report(0);
if (parser.getToken() === 1077936155) {
nextToken(parser, context | 32);
const { tokenStart } = parser;
if (parser.getToken() === 537079927)
parser.report(119);
const modifierFlags = 1024 |
2048 |
8192 |
((state & 64) === 0 ? 512 | 16384 : 0);
context =
((context | modifierFlags) ^ modifierFlags) |
(state & 8 ? 1024 : 0) |
(state & 16 ? 2048 : 0) |
(state & 64 ? 16384 : 0) |
256 |
65536;
value = parsePrimaryExpression(parser, context | 16, privateScope, 2, 0, 1, 0, 1, tokenStart);
if ((parser.getToken() & 1073741824) !== 1073741824 ||
(parser.getToken() & 4194304) === 4194304) {
value = parseMemberOrUpdateExpression(parser, context | 16, privateScope, value, 0, 0, tokenStart);
value = parseAssignmentExpression(parser, context | 16, privateScope, 0, 0, tokenStart, value);
}
}
matchOrInsertSemicolon(parser, context);
return parser.finishNode({
type: state & 1024 ? 'AccessorProperty' : 'PropertyDefinition',
key,
value,
static: (state & 32) > 0,
computed: (state & 2) > 0,
...(parser.options.next ? { decorators } : null),
}, start);
}
function parseBindingPattern(parser, context, scope, privateScope, type, origin) {
if (parser.getToken() & 143360 ||
((context & 1) === 0 && parser.getToken() === -2147483527))
return parseAndClassifyIdentifier(parser, context, scope, type, origin);
if ((parser.getToken() & 2097152) !== 2097152)
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
const left = parser.getToken() === 69271571
? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin)
: parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin);
if (parser.destructible & 16)
parser.report(50);
if (parser.destructible & 32)
parser.report(50);
return left;
}
function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
const token = parser.getToken();
if (context & 1) {
if ((token & 537079808) === 537079808) {
parser.report(119);
}
else if ((token & 36864) === 36864 || token === -2147483527) {
parser.report(118);
}
}
if ((token & 20480) === 20480) {
parser.report(102);
}
if (token === 241771) {
if (context & 1024)
parser.report(32);
if (context & 2)
parser.report(111);
}
if ((token & 255) === (241737 & 255)) {
if (kind & (8 | 16))
parser.report(100);
}
if (token === 209006) {
if (context & 2048)
parser.report(176);
if (context & 2)
parser.report(110);
}
const { tokenValue, tokenStart: start } = parser;
nextToken(parser, context);
scope?.addVarOrBlock(context, tokenValue, kind, origin);
return parser.finishNode({
type: 'Identifier',
name: tokenValue,
}, start);
}
function parseJSXRootElementOrFragment(parser, context, privateScope, inJSXChild, start) {
if (!inJSXChild)
consume(parser, context, 8456256);
if (parser.getToken() === 8390721) {
const openingFragment = parseJSXOpeningFragment(parser, start);
const [children, closingFragment] = parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSXChild);
return parser.finishNode({
type: 'JSXFragment',
openingFragment,
children,
closingFragment,
}, start);
}
if (parser.getToken() === 8457014)
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
let closingElement = null;
let children = [];
const openingElement = parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start);
if (!openingElement.selfClosing) {
[children, closingElement] = parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXChild);
const close = isEqualTagName(closingElement.name);
if (isEqualTagName(openingElement.name) !== close)
parser.report(155, close);
}
return parser.finishNode({
type: 'JSXElement',
children,
openingElement,
closingElement,
}, start);
}
function parseJSXOpeningFragment(parser, start) {
nextJSXToken(parser);
return parser.finishNode({
type: 'JSXOpeningFragment',
}, start);
}
function parseJSXClosingElement(parser, context, inJSXChild, start) {
consume(parser, context, 8457014);
const name = parseJSXElementName(parser, context);
if (parser.getToken() !== 8390721) {
parser.report(25, KeywordDescTable[8390721 & 255]);
}
if (inJSXChild) {
nextJSXToken(parser);
}
else {
nextToken(parser, context);
}
return parser.finishNode({
type: 'JSXClosingElement',
name,
}, start);
}
function parseJSXClosingFragment(parser, context, inJSXChild, start) {
consume(parser, context, 8457014);
if (parser.getToken() !== 8390721) {
parser.report(25, KeywordDescTable[8390721 & 255]);
}
if (inJSXChild) {
nextJSXToken(parser);
}
else {
nextToken(parser, context);
}
return parser.finishNode({
type: 'JSXClosingFragment',
}, start);
}
function parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXChild) {
const children = [];
while (true) {
const child = parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild);
if (child.type === 'JSXClosingElement') {
return [children, child];
}
children.push(child);
}
}
function parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSXChild) {
const children = [];
while (true) {
const child = parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild);
if (child.type === 'JSXClosingFragment') {
return [children, child];
}
children.push(child);
}
}
function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
if (parser.getToken() === 137)
return parseJSXText(parser, context);
if (parser.getToken() === 2162700)
return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
if (parser.getToken() === 8456256) {
const { tokenStart } = parser;
nextToken(parser, context);
if (parser.getToken() === 8457014)
return parseJSXClosingElement(parser, context, inJSXChild, tokenStart);
return parseJSXRootElementOrFragment(parser, context, privateScope, 1, tokenStart);
}
parser.report(0);
}
function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
if (parser.getToken() === 137)
return parseJSXText(parser, context);
if (parser.getToken() === 2162700)
return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
if (parser.getToken() === 8456256) {
const { tokenStart } = parser;
nextToken(parser, context);
if (parser.getToken() === 8457014)
return parseJSXClosingFragment(parser, context, inJSXChild, tokenStart);
return parseJSXRootElementOrFragment(parser, context, privateScope, 1, tokenStart);
}
parser.report(0);
}
function parseJSXText(parser, context) {
const start = parser.tokenStart;
nextToken(parser, context);
const node = {
type: 'JSXText',
value: parser.tokenValue,
};
if (parser.options.raw) {
node.raw = parser.tokenRaw;
}
return parser.finishNode(node, start);
}
function parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope, inJSXChild, start) {
if ((parser.getToken() & 143360) !== 143360 &&
(parser.getToken() & 4096) !== 4096)
parser.report(0);
const tagName = parseJSXElementName(parser, context);
const attributes = parseJSXAttributes(parser, context, privateScope);
const selfClosing = parser.getToken() === 8457014;
if (selfClosing)
consume(parser, context, 8457014);
if (parser.getToken() !== 8390721) {
parser.report(25, KeywordDescTable[8390721 & 255]);
}
if (inJSXChild || !selfClosing) {
nextJSXToken(parser);
}
else {
nextToken(parser, context);
}
return parser.finishNode({
type: 'JSXOpeningElement',
name: tagName,
attributes,
selfClosing,
}, start);
}
function parseJSXElementName(parser, context) {
const { tokenStart } = parser;
rescanJSXIdentifier(parser);
let key = parseJSXIdentifier(parser, context);
if (parser.getToken() === 21)
return parseJSXNamespacedName(parser, context, key, tokenStart);
while (consumeOpt(parser, context, 67108877)) {
rescanJSXIdentifier(parser);
key = parseJSXMemberExpression(parser, context, key, tokenStart);
}
return key;
}
function parseJSXMemberExpression(parser, context, object, start) {
const property = parseJSXIdentifier(parser, context);
return parser.finishNode({
type: 'JSXMemberExpression',
object,
property,
}, start);
}
function parseJSXAttributes(parser, context, privateScope) {
const attributes = [];
while (parser.getToken() !== 8457014 &&
parser.getToken() !== 8390721 &&
parser.getToken() !== 1048576) {
attributes.push(parseJsxAttribute(parser, context, privateScope));
}
return attributes;
}
function parseJSXSpreadAttribute(parser, context, privateScope) {
const start = parser.tokenStart;
nextToken(parser, context);
consume(parser, context, 14);
const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
consume(parser, context, 1074790415);
return parser.finishNode({
type: 'JSXSpreadAttribute',
argument: expression,
}, start);
}
function parseJsxAttribute(parser, context, privateScope) {
const { tokenStart } = parser;
if (parser.getToken() === 2162700)
return parseJSXSpreadAttribute(parser, context, privateScope);
rescanJSXIdentifier(parser);
let value = null;
let name = parseJSXIdentifier(parser, context);
if (parser.getToken() === 21) {
name = parseJSXNamespacedName(parser, context, name, tokenStart);
}
if (parser.getToken() === 1077936155) {
const token = scanJSXAttributeValue(parser, context);
switch (token) {
case 134283267:
value = parseLiteral(parser, context);
break;
case 8456256:
value = parseJSXRootElementOrFragment(parser, context, privateScope, 0, parser.tokenStart);
break;
case 2162700:
value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
break;
default:
parser.report(154);
}
}
return parser.finishNode({
type: 'JSXAttribute',
value,
name,
}, tokenStart);
}
function parseJSXNamespacedName(parser, context, namespace, start) {
consume(parser, context, 21);
const name = parseJSXIdentifier(parser, context);
return parser.finishNode({
type: 'JSXNamespacedName',
namespace,
name,
}, start);
}
function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild, isAttr) {
const { tokenStart: start } = parser;
nextToken(parser, context | 32);
const { tokenStart } = parser;
if (parser.getToken() === 14)
return parseJSXSpreadChild(parser, context, privateScope, start);
let expression = null;
if (parser.getToken() === 1074790415) {
if (isAttr)
parser.report(157);
expression = parseJSXEmptyExpression(parser, {
index: parser.startIndex,
line: parser.startLine,
column: parser.startColumn,
});
}
else {
expression = parseExpression(parser, context, privateScope, 1, 0, tokenStart);
}
if (parser.getToken() !== 1074790415) {
parser.report(25, KeywordDescTable[1074790415 & 255]);
}
if (inJSXChild) {
nextJSXToken(parser);
}
else {
nextToken(parser, context);
}
return parser.finishNode({
type: 'JSXExpressionContainer',
expression,
}, start);
}
function parseJSXSpreadChild(parser, context, privateScope, start) {
consume(parser, context, 14);
const expression = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
consume(parser, context, 1074790415);
return parser.finishNode({
type: 'JSXSpreadChild',
expression,
}, start);
}
function parseJSXEmptyExpression(parser, start) {
return parser.finishNode({
type: 'JSXEmptyExpression',
}, start, parser.tokenStart);
}
function parseJSXIdentifier(parser, context) {
const start = parser.tokenStart;
if (!(parser.getToken() & 143360)) {
parser.report(30, KeywordDescTable[parser.getToken() & 255]);
}
const { tokenValue } = parser;
nextToken(parser, context);
return parser.finishNode({
type: 'JSXIdentifier',
name: tokenValue,
}, start);
}
var version$1 = "6.1.4";
const version = version$1;
function parseScript(source, options) {
return parseSource(source, options);
}
function parseModule(source, options) {
return parseSource(source, options, 1 | 2);
}
function parse(source, options) {
return parseSource(source, options);
}
export { parse, parseModule, parseScript, version };
Reference in New Issue View Git Blame Copy Permalink