964 lines
56 KiB
Plaintext
964 lines
56 KiB
Plaintext
(program [0, 0] - [180, 0]
|
|
(import_statement [0, 0] - [0, 37]
|
|
(import_clause [0, 7] - [0, 17]
|
|
(named_imports [0, 7] - [0, 17]
|
|
(import_specifier [0, 9] - [0, 15]
|
|
name: (identifier [0, 9] - [0, 15]))))
|
|
source: (string [0, 23] - [0, 36]
|
|
(string_fragment [0, 24] - [0, 35])))
|
|
(comment [2, 0] - [5, 3])
|
|
(export_statement [6, 0] - [19, 1]
|
|
declaration: (function_declaration [6, 7] - [19, 1]
|
|
name: (identifier [6, 22] - [6, 42])
|
|
parameters: (formal_parameters [6, 42] - [8, 1]
|
|
(required_parameter [7, 2] - [7, 46]
|
|
pattern: (identifier [7, 2] - [7, 5])
|
|
type: (type_annotation [7, 5] - [7, 46]
|
|
(object_type [7, 7] - [7, 46]
|
|
(property_signature [7, 9] - [7, 20]
|
|
name: (property_identifier [7, 9] - [7, 12])
|
|
type: (type_annotation [7, 12] - [7, 20]
|
|
(predefined_type [7, 14] - [7, 20])))
|
|
(property_signature [7, 22] - [7, 33]
|
|
name: (property_identifier [7, 22] - [7, 25])
|
|
type: (type_annotation [7, 25] - [7, 33]
|
|
(predefined_type [7, 27] - [7, 33])))
|
|
(property_signature [7, 35] - [7, 44]
|
|
name: (property_identifier [7, 35] - [7, 36])
|
|
type: (type_annotation [7, 36] - [7, 44]
|
|
(predefined_type [7, 38] - [7, 44])))))))
|
|
return_type: (type_annotation [8, 1] - [8, 18]
|
|
(generic_type [8, 3] - [8, 18]
|
|
name: (type_identifier [8, 3] - [8, 10])
|
|
type_arguments: (type_arguments [8, 10] - [8, 18]
|
|
(predefined_type [8, 11] - [8, 17]))))
|
|
body: (statement_block [8, 19] - [19, 1]
|
|
(if_statement [9, 2] - [11, 3]
|
|
condition: (parenthesized_expression [9, 5] - [9, 59]
|
|
(binary_expression [9, 6] - [9, 58]
|
|
left: (binary_expression [9, 6] - [9, 48]
|
|
left: (binary_expression [9, 6] - [9, 23]
|
|
left: (member_expression [9, 6] - [9, 13]
|
|
object: (identifier [9, 6] - [9, 9])
|
|
property: (property_identifier [9, 10] - [9, 13]))
|
|
right: (string [9, 18] - [9, 23]
|
|
(string_fragment [9, 19] - [9, 22])))
|
|
right: (binary_expression [9, 27] - [9, 48]
|
|
left: (member_expression [9, 27] - [9, 34]
|
|
object: (identifier [9, 27] - [9, 30])
|
|
property: (property_identifier [9, 31] - [9, 34]))
|
|
right: (string [9, 39] - [9, 48]
|
|
(string_fragment [9, 40] - [9, 47]))))
|
|
right: (unary_expression [9, 52] - [9, 58]
|
|
argument: (member_expression [9, 53] - [9, 58]
|
|
object: (identifier [9, 53] - [9, 56])
|
|
property: (property_identifier [9, 57] - [9, 58])))))
|
|
consequence: (statement_block [9, 60] - [11, 3]
|
|
(throw_statement [10, 4] - [10, 43]
|
|
(new_expression [10, 10] - [10, 42]
|
|
constructor: (identifier [10, 14] - [10, 19])
|
|
arguments: (arguments [10, 19] - [10, 42]
|
|
(string [10, 20] - [10, 41]
|
|
(string_fragment [10, 21] - [10, 40])))))))
|
|
(lexical_declaration [13, 2] - [13, 70]
|
|
(variable_declarator [13, 8] - [13, 69]
|
|
name: (identifier [13, 8] - [13, 20])
|
|
value: (template_string [13, 23] - [13, 69]
|
|
(string_fragment [13, 24] - [13, 58])
|
|
(template_substitution [13, 58] - [13, 66]
|
|
(member_expression [13, 60] - [13, 65]
|
|
object: (identifier [13, 60] - [13, 63])
|
|
property: (property_identifier [13, 64] - [13, 65])))
|
|
(string_fragment [13, 66] - [13, 68]))))
|
|
(lexical_declaration [14, 2] - [14, 54]
|
|
(variable_declarator [14, 8] - [14, 53]
|
|
name: (identifier [14, 8] - [14, 12])
|
|
value: (call_expression [14, 15] - [14, 53]
|
|
function: (member_expression [14, 15] - [14, 39]
|
|
object: (new_expression [14, 15] - [14, 32]
|
|
constructor: (identifier [14, 19] - [14, 30])
|
|
arguments: (arguments [14, 30] - [14, 32]))
|
|
property: (property_identifier [14, 33] - [14, 39]))
|
|
arguments: (arguments [14, 39] - [14, 53]
|
|
(identifier [14, 40] - [14, 52])))))
|
|
(lexical_declaration [15, 2] - [15, 65]
|
|
(variable_declarator [15, 8] - [15, 64]
|
|
name: (identifier [15, 8] - [15, 18])
|
|
value: (await_expression [15, 21] - [15, 64]
|
|
(call_expression [15, 27] - [15, 64]
|
|
function: (member_expression [15, 27] - [15, 47]
|
|
object: (member_expression [15, 27] - [15, 40]
|
|
object: (identifier [15, 27] - [15, 33])
|
|
property: (property_identifier [15, 34] - [15, 40]))
|
|
property: (property_identifier [15, 41] - [15, 47]))
|
|
arguments: (arguments [15, 47] - [15, 64]
|
|
(string [15, 48] - [15, 57]
|
|
(string_fragment [15, 49] - [15, 56]))
|
|
(identifier [15, 59] - [15, 63]))))))
|
|
(lexical_declaration [16, 2] - [16, 59]
|
|
(variable_declarator [16, 8] - [16, 58]
|
|
name: (identifier [16, 8] - [16, 17])
|
|
value: (call_expression [16, 20] - [16, 58]
|
|
function: (member_expression [16, 20] - [16, 30]
|
|
object: (identifier [16, 20] - [16, 25])
|
|
property: (property_identifier [16, 26] - [16, 30]))
|
|
arguments: (arguments [16, 30] - [16, 58]
|
|
(new_expression [16, 31] - [16, 57]
|
|
constructor: (identifier [16, 35] - [16, 45])
|
|
arguments: (arguments [16, 45] - [16, 57]
|
|
(identifier [16, 46] - [16, 56])))))))
|
|
(lexical_declaration [17, 2] - [17, 77]
|
|
(variable_declarator [17, 8] - [17, 76]
|
|
name: (identifier [17, 8] - [17, 11])
|
|
value: (call_expression [17, 14] - [17, 76]
|
|
function: (member_expression [17, 14] - [17, 72]
|
|
object: (call_expression [17, 14] - [17, 67]
|
|
function: (member_expression [17, 14] - [17, 27]
|
|
object: (identifier [17, 14] - [17, 23])
|
|
property: (property_identifier [17, 24] - [17, 27]))
|
|
arguments: (arguments [17, 27] - [17, 67]
|
|
(arrow_function [17, 28] - [17, 66]
|
|
parameters: (formal_parameters [17, 28] - [17, 31]
|
|
(required_parameter [17, 29] - [17, 30]
|
|
pattern: (identifier [17, 29] - [17, 30])))
|
|
body: (call_expression [17, 35] - [17, 66]
|
|
function: (member_expression [17, 35] - [17, 58]
|
|
object: (call_expression [17, 35] - [17, 49]
|
|
function: (member_expression [17, 35] - [17, 45]
|
|
object: (identifier [17, 35] - [17, 36])
|
|
property: (property_identifier [17, 37] - [17, 45]))
|
|
arguments: (arguments [17, 45] - [17, 49]
|
|
(number [17, 46] - [17, 48])))
|
|
property: (property_identifier [17, 50] - [17, 58]))
|
|
arguments: (arguments [17, 58] - [17, 66]
|
|
(number [17, 59] - [17, 60])
|
|
(string [17, 62] - [17, 65]
|
|
(string_fragment [17, 63] - [17, 64])))))))
|
|
property: (property_identifier [17, 68] - [17, 72]))
|
|
arguments: (arguments [17, 72] - [17, 76]
|
|
(string [17, 73] - [17, 75])))))
|
|
(return_statement [18, 2] - [18, 13]
|
|
(identifier [18, 9] - [18, 12])))))
|
|
(comment [21, 0] - [24, 3])
|
|
(export_statement [25, 0] - [179, 1]
|
|
declaration: (function_declaration [25, 7] - [179, 1]
|
|
name: (identifier [25, 22] - [25, 41])
|
|
parameters: (formal_parameters [25, 41] - [25, 55]
|
|
(required_parameter [25, 42] - [25, 54]
|
|
pattern: (identifier [25, 42] - [25, 45])
|
|
type: (type_annotation [25, 45] - [25, 54]
|
|
(type_identifier [25, 47] - [25, 54]))))
|
|
return_type: (type_annotation [25, 55] - [25, 72]
|
|
(generic_type [25, 57] - [25, 72]
|
|
name: (type_identifier [25, 57] - [25, 64])
|
|
type_arguments: (type_arguments [25, 64] - [25, 72]
|
|
(predefined_type [25, 65] - [25, 71]))))
|
|
body: (statement_block [25, 73] - [179, 1]
|
|
(lexical_declaration [26, 2] - [26, 60]
|
|
(variable_declarator [26, 8] - [26, 59]
|
|
name: (identifier [26, 8] - [26, 22])
|
|
value: (call_expression [26, 25] - [26, 59]
|
|
function: (member_expression [26, 25] - [26, 40]
|
|
object: (member_expression [26, 25] - [26, 36]
|
|
object: (identifier [26, 25] - [26, 28])
|
|
property: (property_identifier [26, 29] - [26, 36]))
|
|
property: (property_identifier [26, 37] - [26, 40]))
|
|
arguments: (arguments [26, 40] - [26, 59]
|
|
(string [26, 41] - [26, 58]
|
|
(string_fragment [26, 42] - [26, 57]))))))
|
|
(lexical_declaration [27, 2] - [27, 49]
|
|
(variable_declarator [27, 8] - [27, 48]
|
|
name: (identifier [27, 8] - [27, 17])
|
|
value: (call_expression [27, 20] - [27, 48]
|
|
function: (member_expression [27, 20] - [27, 35]
|
|
object: (member_expression [27, 20] - [27, 31]
|
|
object: (identifier [27, 20] - [27, 23])
|
|
property: (property_identifier [27, 24] - [27, 31]))
|
|
property: (property_identifier [27, 32] - [27, 35]))
|
|
arguments: (arguments [27, 35] - [27, 48]
|
|
(string [27, 36] - [27, 47]
|
|
(string_fragment [27, 37] - [27, 46]))))))
|
|
(if_statement [29, 2] - [31, 3]
|
|
condition: (parenthesized_expression [29, 5] - [29, 36]
|
|
(binary_expression [29, 6] - [29, 35]
|
|
left: (unary_expression [29, 6] - [29, 21]
|
|
argument: (identifier [29, 7] - [29, 21]))
|
|
right: (unary_expression [29, 25] - [29, 35]
|
|
argument: (identifier [29, 26] - [29, 35]))))
|
|
consequence: (statement_block [29, 37] - [31, 3]
|
|
(throw_statement [30, 4] - [30, 62]
|
|
(new_expression [30, 10] - [30, 61]
|
|
constructor: (identifier [30, 14] - [30, 19])
|
|
arguments: (arguments [30, 19] - [30, 61]
|
|
(string [30, 20] - [30, 60]
|
|
(string_fragment [30, 21] - [30, 59])))))))
|
|
(lexical_declaration [33, 2] - [33, 64]
|
|
(variable_declarator [33, 8] - [33, 63]
|
|
name: (identifier [33, 8] - [33, 16])
|
|
value: (call_expression [33, 19] - [33, 63]
|
|
function: (member_expression [33, 19] - [33, 39]
|
|
object: (identifier [33, 19] - [33, 33])
|
|
property: (property_identifier [33, 34] - [33, 39]))
|
|
arguments: (arguments [33, 39] - [33, 63]
|
|
(regex [33, 40] - [33, 62]
|
|
pattern: (regex_pattern [33, 41] - [33, 61]))))))
|
|
(if_statement [34, 2] - [36, 3]
|
|
condition: (parenthesized_expression [34, 5] - [34, 16]
|
|
(unary_expression [34, 6] - [34, 15]
|
|
argument: (identifier [34, 7] - [34, 15])))
|
|
consequence: (statement_block [34, 17] - [36, 3]
|
|
(throw_statement [35, 4] - [35, 54]
|
|
(new_expression [35, 10] - [35, 53]
|
|
constructor: (identifier [35, 14] - [35, 19])
|
|
arguments: (arguments [35, 19] - [35, 53]
|
|
(string [35, 20] - [35, 52]
|
|
(string_fragment [35, 21] - [35, 51])))))))
|
|
(lexical_declaration [38, 2] - [38, 36]
|
|
(variable_declarator [38, 8] - [38, 35]
|
|
name: (identifier [38, 8] - [38, 21])
|
|
value: (subscript_expression [38, 24] - [38, 35]
|
|
object: (identifier [38, 24] - [38, 32])
|
|
index: (number [38, 33] - [38, 34]))))
|
|
(lexical_declaration [39, 2] - [39, 32]
|
|
(variable_declarator [39, 8] - [39, 31]
|
|
name: (identifier [39, 8] - [39, 17])
|
|
value: (subscript_expression [39, 20] - [39, 31]
|
|
object: (identifier [39, 20] - [39, 28])
|
|
index: (number [39, 29] - [39, 30]))))
|
|
(lexical_declaration [41, 2] - [41, 78]
|
|
(variable_declarator [41, 8] - [41, 77]
|
|
name: (identifier [41, 8] - [41, 18])
|
|
value: (call_expression [41, 21] - [41, 77]
|
|
function: (member_expression [41, 21] - [41, 49]
|
|
object: (call_expression [41, 21] - [41, 45]
|
|
function: (member_expression [41, 21] - [41, 40]
|
|
object: (identifier [41, 21] - [41, 34])
|
|
property: (property_identifier [41, 35] - [41, 40]))
|
|
arguments: (arguments [41, 40] - [41, 45]
|
|
(string [41, 41] - [41, 44]
|
|
(string_fragment [41, 42] - [41, 43]))))
|
|
property: (property_identifier [41, 46] - [41, 49]))
|
|
arguments: (arguments [41, 49] - [41, 77]
|
|
(arrow_function [41, 50] - [41, 76]
|
|
parameters: (formal_parameters [41, 50] - [41, 53]
|
|
(required_parameter [41, 51] - [41, 52]
|
|
pattern: (identifier [41, 51] - [41, 52])))
|
|
body: (call_expression [41, 57] - [41, 76]
|
|
function: (member_expression [41, 57] - [41, 66]
|
|
object: (identifier [41, 57] - [41, 58])
|
|
property: (property_identifier [41, 59] - [41, 66]))
|
|
arguments: (arguments [41, 66] - [41, 76]
|
|
(regex [41, 67] - [41, 71]
|
|
pattern: (regex_pattern [41, 68] - [41, 69])
|
|
flags: (regex_flags [41, 70] - [41, 71]))
|
|
(string [41, 73] - [41, 75]))))))))
|
|
(lexical_declaration [43, 2] - [43, 43]
|
|
(variable_declarator [43, 8] - [43, 42]
|
|
name: (identifier [43, 8] - [43, 14])
|
|
value: (new_expression [43, 17] - [43, 42]
|
|
constructor: (identifier [43, 21] - [43, 24])
|
|
type_arguments: (type_arguments [43, 24] - [43, 40]
|
|
(predefined_type [43, 25] - [43, 31])
|
|
(predefined_type [43, 33] - [43, 39]))
|
|
arguments: (arguments [43, 40] - [43, 42]))))
|
|
(lexical_declaration [44, 2] - [44, 42]
|
|
(variable_declarator [44, 8] - [44, 41]
|
|
name: (identifier [44, 8] - [44, 18])
|
|
value: (regex [44, 21] - [44, 41]
|
|
pattern: (regex_pattern [44, 22] - [44, 39])
|
|
flags: (regex_flags [44, 40] - [44, 41]))))
|
|
(lexical_declaration [45, 2] - [45, 12]
|
|
(variable_declarator [45, 6] - [45, 11]
|
|
name: (identifier [45, 6] - [45, 11])))
|
|
(while_statement [46, 2] - [52, 3]
|
|
condition: (parenthesized_expression [46, 8] - [46, 55]
|
|
(binary_expression [46, 9] - [46, 54]
|
|
left: (parenthesized_expression [46, 9] - [46, 45]
|
|
(assignment_expression [46, 10] - [46, 44]
|
|
left: (identifier [46, 10] - [46, 15])
|
|
right: (call_expression [46, 18] - [46, 44]
|
|
function: (member_expression [46, 18] - [46, 33]
|
|
object: (identifier [46, 18] - [46, 28])
|
|
property: (property_identifier [46, 29] - [46, 33]))
|
|
arguments: (arguments [46, 33] - [46, 44]
|
|
(identifier [46, 34] - [46, 43])))))
|
|
right: (null [46, 50] - [46, 54])))
|
|
body: (statement_block [46, 56] - [52, 3]
|
|
(lexical_declaration [47, 4] - [47, 23]
|
|
(variable_declarator [47, 8] - [47, 22]
|
|
name: (identifier [47, 8] - [47, 11])
|
|
value: (subscript_expression [47, 14] - [47, 22]
|
|
object: (identifier [47, 14] - [47, 19])
|
|
index: (number [47, 20] - [47, 21]))))
|
|
(if_statement [48, 4] - [50, 5]
|
|
condition: (parenthesized_expression [48, 7] - [48, 49]
|
|
(binary_expression [48, 8] - [48, 48]
|
|
left: (call_expression [48, 8] - [48, 27]
|
|
function: (member_expression [48, 8] - [48, 22]
|
|
object: (identifier [48, 8] - [48, 11])
|
|
property: (property_identifier [48, 12] - [48, 22]))
|
|
arguments: (arguments [48, 22] - [48, 27]
|
|
(string [48, 23] - [48, 26]
|
|
(string_fragment [48, 24] - [48, 25]))))
|
|
right: (call_expression [48, 31] - [48, 48]
|
|
function: (member_expression [48, 31] - [48, 43]
|
|
object: (identifier [48, 31] - [48, 34])
|
|
property: (property_identifier [48, 35] - [48, 43]))
|
|
arguments: (arguments [48, 43] - [48, 48]
|
|
(string [48, 44] - [48, 47]
|
|
(string_fragment [48, 45] - [48, 46]))))))
|
|
consequence: (statement_block [48, 50] - [50, 5]
|
|
(expression_statement [49, 6] - [49, 29]
|
|
(assignment_expression [49, 6] - [49, 28]
|
|
left: (identifier [49, 6] - [49, 9])
|
|
right: (call_expression [49, 12] - [49, 28]
|
|
function: (member_expression [49, 12] - [49, 21]
|
|
object: (identifier [49, 12] - [49, 15])
|
|
property: (property_identifier [49, 16] - [49, 21]))
|
|
arguments: (arguments [49, 21] - [49, 28]
|
|
(number [49, 22] - [49, 23])
|
|
(unary_expression [49, 25] - [49, 27]
|
|
argument: (number [49, 26] - [49, 27]))))))))
|
|
(expression_statement [51, 4] - [51, 30]
|
|
(call_expression [51, 4] - [51, 29]
|
|
function: (member_expression [51, 4] - [51, 14]
|
|
object: (identifier [51, 4] - [51, 10])
|
|
property: (property_identifier [51, 11] - [51, 14]))
|
|
arguments: (arguments [51, 14] - [51, 29]
|
|
(subscript_expression [51, 15] - [51, 23]
|
|
object: (identifier [51, 15] - [51, 20])
|
|
index: (number [51, 21] - [51, 22]))
|
|
(identifier [51, 25] - [51, 28]))))))
|
|
(comment [54, 2] - [54, 30])
|
|
(lexical_declaration [55, 2] - [55, 61]
|
|
(variable_declarator [55, 8] - [55, 60]
|
|
name: (identifier [55, 8] - [55, 15])
|
|
value: (call_expression [55, 18] - [55, 60]
|
|
function: (identifier [55, 18] - [55, 26])
|
|
arguments: (arguments [55, 26] - [55, 60]
|
|
(binary_expression [55, 27] - [55, 55]
|
|
left: (call_expression [55, 27] - [55, 48]
|
|
function: (member_expression [55, 27] - [55, 37]
|
|
object: (identifier [55, 27] - [55, 33])
|
|
property: (property_identifier [55, 34] - [55, 37]))
|
|
arguments: (arguments [55, 37] - [55, 48]
|
|
(string [55, 38] - [55, 47]
|
|
(string_fragment [55, 39] - [55, 46]))))
|
|
right: (string [55, 52] - [55, 55]
|
|
(string_fragment [55, 53] - [55, 54])))
|
|
(number [55, 57] - [55, 59])))))
|
|
(lexical_declaration [56, 2] - [56, 61]
|
|
(variable_declarator [56, 8] - [56, 60]
|
|
name: (identifier [56, 8] - [56, 15])
|
|
value: (call_expression [56, 18] - [56, 60]
|
|
function: (identifier [56, 18] - [56, 26])
|
|
arguments: (arguments [56, 26] - [56, 60]
|
|
(binary_expression [56, 27] - [56, 55]
|
|
left: (call_expression [56, 27] - [56, 48]
|
|
function: (member_expression [56, 27] - [56, 37]
|
|
object: (identifier [56, 27] - [56, 33])
|
|
property: (property_identifier [56, 34] - [56, 37]))
|
|
arguments: (arguments [56, 37] - [56, 48]
|
|
(string [56, 38] - [56, 47]
|
|
(string_fragment [56, 39] - [56, 46]))))
|
|
right: (string [56, 52] - [56, 55]
|
|
(string_fragment [56, 53] - [56, 54])))
|
|
(number [56, 57] - [56, 59])))))
|
|
(if_statement [58, 2] - [60, 3]
|
|
condition: (parenthesized_expression [58, 5] - [58, 27]
|
|
(binary_expression [58, 6] - [58, 26]
|
|
left: (unary_expression [58, 6] - [58, 14]
|
|
argument: (identifier [58, 7] - [58, 14]))
|
|
right: (unary_expression [58, 18] - [58, 26]
|
|
argument: (identifier [58, 19] - [58, 26]))))
|
|
consequence: (statement_block [58, 28] - [60, 3]
|
|
(throw_statement [59, 4] - [59, 60]
|
|
(new_expression [59, 10] - [59, 59]
|
|
constructor: (identifier [59, 14] - [59, 19])
|
|
arguments: (arguments [59, 19] - [59, 59]
|
|
(string [59, 20] - [59, 58]
|
|
(string_fragment [59, 21] - [59, 57])))))))
|
|
(lexical_declaration [62, 2] - [62, 44]
|
|
(variable_declarator [62, 8] - [62, 43]
|
|
name: (identifier [62, 8] - [62, 11])
|
|
value: (call_expression [62, 14] - [62, 43]
|
|
function: (member_expression [62, 14] - [62, 24]
|
|
object: (identifier [62, 14] - [62, 18])
|
|
property: (property_identifier [62, 19] - [62, 24]))
|
|
arguments: (arguments [62, 24] - [62, 43]
|
|
(binary_expression [62, 25] - [62, 42]
|
|
left: (call_expression [62, 25] - [62, 35]
|
|
function: (member_expression [62, 25] - [62, 33]
|
|
object: (identifier [62, 25] - [62, 29])
|
|
property: (property_identifier [62, 30] - [62, 33]))
|
|
arguments: (arguments [62, 33] - [62, 35]))
|
|
right: (number [62, 38] - [62, 42]))))))
|
|
(if_statement [63, 2] - [65, 3]
|
|
condition: (parenthesized_expression [63, 5] - [63, 35]
|
|
(binary_expression [63, 6] - [63, 34]
|
|
left: (call_expression [63, 6] - [63, 29]
|
|
function: (member_expression [63, 6] - [63, 14]
|
|
object: (identifier [63, 6] - [63, 10])
|
|
property: (property_identifier [63, 11] - [63, 14]))
|
|
arguments: (arguments [63, 14] - [63, 29]
|
|
(binary_expression [63, 15] - [63, 28]
|
|
left: (identifier [63, 15] - [63, 18])
|
|
right: (identifier [63, 21] - [63, 28]))))
|
|
right: (number [63, 32] - [63, 34])))
|
|
consequence: (statement_block [63, 36] - [65, 3]
|
|
(throw_statement [64, 4] - [64, 71]
|
|
(new_expression [64, 10] - [64, 70]
|
|
constructor: (identifier [64, 14] - [64, 19])
|
|
arguments: (arguments [64, 19] - [64, 70]
|
|
(string [64, 20] - [64, 69]
|
|
(string_fragment [64, 21] - [64, 68])))))))
|
|
(if_statement [66, 2] - [68, 3]
|
|
condition: (parenthesized_expression [66, 5] - [66, 20]
|
|
(binary_expression [66, 6] - [66, 19]
|
|
left: (identifier [66, 6] - [66, 9])
|
|
right: (identifier [66, 12] - [66, 19])))
|
|
consequence: (statement_block [66, 21] - [68, 3]
|
|
(throw_statement [67, 4] - [67, 41]
|
|
(new_expression [67, 10] - [67, 40]
|
|
constructor: (identifier [67, 14] - [67, 19])
|
|
arguments: (arguments [67, 19] - [67, 40]
|
|
(string [67, 20] - [67, 39]
|
|
(string_fragment [67, 21] - [67, 38])))))))
|
|
(comment [70, 2] - [70, 17])
|
|
(lexical_declaration [71, 2] - [71, 38]
|
|
(variable_declarator [71, 8] - [71, 37]
|
|
name: (identifier [71, 8] - [71, 17])
|
|
value: (call_expression [71, 20] - [71, 37]
|
|
function: (member_expression [71, 20] - [71, 30]
|
|
object: (identifier [71, 20] - [71, 26])
|
|
property: (property_identifier [71, 27] - [71, 30]))
|
|
arguments: (arguments [71, 30] - [71, 37]
|
|
(string [71, 31] - [71, 36]
|
|
(string_fragment [71, 32] - [71, 35]))))))
|
|
(if_statement [72, 2] - [74, 3]
|
|
condition: (parenthesized_expression [72, 5] - [72, 17]
|
|
(unary_expression [72, 6] - [72, 16]
|
|
argument: (identifier [72, 7] - [72, 16])))
|
|
consequence: (statement_block [72, 18] - [74, 3]
|
|
(throw_statement [73, 4] - [73, 52]
|
|
(new_expression [73, 10] - [73, 51]
|
|
constructor: (identifier [73, 14] - [73, 19])
|
|
arguments: (arguments [73, 19] - [73, 51]
|
|
(string [73, 20] - [73, 50]
|
|
(string_fragment [73, 21] - [73, 49])))))))
|
|
(lexical_declaration [76, 2] - [76, 10]
|
|
(variable_declarator [76, 6] - [76, 9]
|
|
name: (identifier [76, 6] - [76, 9])))
|
|
(try_statement [77, 2] - [82, 3]
|
|
body: (statement_block [77, 6] - [80, 3]
|
|
(lexical_declaration [78, 4] - [78, 74]
|
|
(variable_declarator [78, 10] - [78, 73]
|
|
name: (identifier [78, 10] - [78, 17])
|
|
value: (call_expression [78, 20] - [78, 73]
|
|
function: (identifier [78, 20] - [78, 24])
|
|
arguments: (arguments [78, 24] - [78, 73]
|
|
(call_expression [78, 25] - [78, 72]
|
|
function: (member_expression [78, 25] - [78, 61]
|
|
object: (call_expression [78, 25] - [78, 53]
|
|
function: (member_expression [78, 25] - [78, 42]
|
|
object: (identifier [78, 25] - [78, 34])
|
|
property: (property_identifier [78, 35] - [78, 42]))
|
|
arguments: (arguments [78, 42] - [78, 53]
|
|
(regex [78, 43] - [78, 47]
|
|
pattern: (regex_pattern [78, 44] - [78, 45])
|
|
flags: (regex_flags [78, 46] - [78, 47]))
|
|
(string [78, 49] - [78, 52]
|
|
(string_fragment [78, 50] - [78, 51]))))
|
|
property: (property_identifier [78, 54] - [78, 61]))
|
|
arguments: (arguments [78, 61] - [78, 72]
|
|
(regex [78, 62] - [78, 66]
|
|
pattern: (regex_pattern [78, 63] - [78, 64])
|
|
flags: (regex_flags [78, 65] - [78, 66]))
|
|
(string [78, 68] - [78, 71]
|
|
(string_fragment [78, 69] - [78, 70]))))))))
|
|
(expression_statement [79, 4] - [79, 30]
|
|
(assignment_expression [79, 4] - [79, 29]
|
|
left: (identifier [79, 4] - [79, 7])
|
|
right: (call_expression [79, 10] - [79, 29]
|
|
function: (member_expression [79, 10] - [79, 20]
|
|
object: (identifier [79, 10] - [79, 14])
|
|
property: (property_identifier [79, 15] - [79, 20]))
|
|
arguments: (arguments [79, 20] - [79, 29]
|
|
(identifier [79, 21] - [79, 28]))))))
|
|
handler: (catch_clause [80, 4] - [82, 3]
|
|
parameter: (identifier [80, 11] - [80, 15])
|
|
body: (statement_block [80, 17] - [82, 3]
|
|
(throw_statement [81, 4] - [81, 66]
|
|
(new_expression [81, 10] - [81, 65]
|
|
constructor: (identifier [81, 14] - [81, 19])
|
|
arguments: (arguments [81, 19] - [81, 65]
|
|
(string [81, 20] - [81, 64]
|
|
(string_fragment [81, 21] - [81, 63]))))))))
|
|
(if_statement [84, 2] - [86, 3]
|
|
condition: (parenthesized_expression [84, 5] - [84, 59]
|
|
(binary_expression [84, 6] - [84, 58]
|
|
left: (binary_expression [84, 6] - [84, 48]
|
|
left: (binary_expression [84, 6] - [84, 23]
|
|
left: (member_expression [84, 6] - [84, 13]
|
|
object: (identifier [84, 6] - [84, 9])
|
|
property: (property_identifier [84, 10] - [84, 13]))
|
|
right: (string [84, 18] - [84, 23]
|
|
(string_fragment [84, 19] - [84, 22])))
|
|
right: (binary_expression [84, 27] - [84, 48]
|
|
left: (member_expression [84, 27] - [84, 34]
|
|
object: (identifier [84, 27] - [84, 30])
|
|
property: (property_identifier [84, 31] - [84, 34]))
|
|
right: (string [84, 39] - [84, 48]
|
|
(string_fragment [84, 40] - [84, 47]))))
|
|
right: (unary_expression [84, 52] - [84, 58]
|
|
argument: (member_expression [84, 53] - [84, 58]
|
|
object: (identifier [84, 53] - [84, 56])
|
|
property: (property_identifier [84, 57] - [84, 58])))))
|
|
consequence: (statement_block [84, 60] - [86, 3]
|
|
(throw_statement [85, 4] - [85, 59]
|
|
(new_expression [85, 10] - [85, 58]
|
|
constructor: (identifier [85, 14] - [85, 19])
|
|
arguments: (arguments [85, 19] - [85, 58]
|
|
(string [85, 20] - [85, 57]
|
|
(string_fragment [85, 21] - [85, 56])))))))
|
|
(lexical_declaration [88, 2] - [88, 54]
|
|
(variable_declarator [88, 8] - [88, 53]
|
|
name: (identifier [88, 8] - [88, 19])
|
|
value: (await_expression [88, 22] - [88, 53]
|
|
(call_expression [88, 28] - [88, 53]
|
|
function: (identifier [88, 28] - [88, 48])
|
|
arguments: (arguments [88, 48] - [88, 53]
|
|
(identifier [88, 49] - [88, 52]))))))
|
|
(comment [90, 2] - [90, 40])
|
|
(try_statement [91, 2] - [105, 3]
|
|
body: (statement_block [91, 6] - [99, 3]
|
|
(lexical_declaration [92, 4] - [95, 6]
|
|
(variable_declarator [92, 10] - [95, 5]
|
|
name: (identifier [92, 10] - [92, 18])
|
|
value: (await_expression [92, 21] - [95, 5]
|
|
(call_expression [92, 27] - [95, 5]
|
|
function: (member_expression [92, 27] - [92, 43]
|
|
object: (identifier [92, 27] - [92, 33])
|
|
property: (property_identifier [92, 34] - [92, 43]))
|
|
arguments: (arguments [92, 43] - [95, 5]
|
|
(string [93, 6] - [93, 29]
|
|
(string_fragment [93, 7] - [93, 28]))
|
|
(identifier [94, 6] - [94, 17]))))))
|
|
(if_statement [96, 4] - [98, 5]
|
|
condition: (parenthesized_expression [96, 7] - [96, 23]
|
|
(binary_expression [96, 8] - [96, 22]
|
|
left: (identifier [96, 8] - [96, 16])
|
|
right: (number [96, 21] - [96, 22])))
|
|
consequence: (statement_block [96, 24] - [98, 5]
|
|
(throw_statement [97, 6] - [97, 52]
|
|
(new_expression [97, 12] - [97, 51]
|
|
constructor: (identifier [97, 16] - [97, 21])
|
|
arguments: (arguments [97, 21] - [97, 51]
|
|
(string [97, 22] - [97, 50]
|
|
(string_fragment [97, 23] - [97, 49]))))))))
|
|
handler: (catch_clause [99, 4] - [105, 3]
|
|
parameter: (identifier [99, 11] - [99, 14])
|
|
type: (type_annotation [99, 14] - [99, 19]
|
|
(predefined_type [99, 16] - [99, 19]))
|
|
body: (statement_block [99, 21] - [105, 3]
|
|
(if_statement [100, 4] - [102, 5]
|
|
condition: (parenthesized_expression [100, 7] - [100, 60]
|
|
(call_expression [100, 8] - [100, 59]
|
|
function: (member_expression [100, 8] - [100, 29]
|
|
object: (member_expression [100, 8] - [100, 19]
|
|
object: (identifier [100, 8] - [100, 11])
|
|
property: (property_identifier [100, 12] - [100, 19]))
|
|
optional_chain: (optional_chain [100, 19] - [100, 21])
|
|
property: (property_identifier [100, 21] - [100, 29]))
|
|
arguments: (arguments [100, 29] - [100, 59]
|
|
(string [100, 30] - [100, 58]
|
|
(string_fragment [100, 31] - [100, 57])))))
|
|
consequence: (statement_block [100, 61] - [102, 5]
|
|
(throw_statement [101, 6] - [101, 16]
|
|
(identifier [101, 12] - [101, 15]))))
|
|
(expression_statement [103, 4] - [103, 70]
|
|
(call_expression [103, 4] - [103, 69]
|
|
function: (member_expression [103, 4] - [103, 17]
|
|
object: (identifier [103, 4] - [103, 11])
|
|
property: (property_identifier [103, 12] - [103, 17]))
|
|
arguments: (arguments [103, 17] - [103, 69]
|
|
(string [103, 18] - [103, 63]
|
|
(string_fragment [103, 19] - [103, 62]))
|
|
(identifier [103, 65] - [103, 68]))))
|
|
(throw_statement [104, 4] - [104, 45]
|
|
(new_expression [104, 10] - [104, 44]
|
|
constructor: (identifier [104, 14] - [104, 19])
|
|
arguments: (arguments [104, 19] - [104, 44]
|
|
(string [104, 20] - [104, 43]
|
|
(string_fragment [104, 21] - [104, 42]))))))))
|
|
(comment [107, 2] - [107, 38])
|
|
(lexical_declaration [108, 2] - [108, 31]
|
|
(variable_declarator [108, 8] - [108, 30]
|
|
name: (identifier [108, 8] - [108, 11])
|
|
value: (new_expression [108, 14] - [108, 30]
|
|
constructor: (identifier [108, 18] - [108, 21])
|
|
arguments: (arguments [108, 21] - [108, 30]
|
|
(member_expression [108, 22] - [108, 29]
|
|
object: (identifier [108, 22] - [108, 25])
|
|
property: (property_identifier [108, 26] - [108, 29]))))))
|
|
(lexical_declaration [109, 2] - [109, 25]
|
|
(variable_declarator [109, 6] - [109, 24]
|
|
name: (identifier [109, 6] - [109, 19])
|
|
value: (string [109, 22] - [109, 24])))
|
|
(lexical_declaration [111, 2] - [111, 65]
|
|
(variable_declarator [111, 8] - [111, 64]
|
|
name: (identifier [111, 8] - [111, 24])
|
|
value: (call_expression [111, 27] - [111, 64]
|
|
function: (member_expression [111, 27] - [111, 42]
|
|
object: (member_expression [111, 27] - [111, 38]
|
|
object: (identifier [111, 27] - [111, 30])
|
|
property: (property_identifier [111, 31] - [111, 38]))
|
|
property: (property_identifier [111, 39] - [111, 42]))
|
|
arguments: (arguments [111, 42] - [111, 64]
|
|
(string [111, 43] - [111, 63]
|
|
(string_fragment [111, 44] - [111, 62]))))))
|
|
(lexical_declaration [112, 2] - [112, 59]
|
|
(variable_declarator [112, 8] - [112, 58]
|
|
name: (identifier [112, 8] - [112, 21])
|
|
value: (call_expression [112, 24] - [112, 58]
|
|
function: (member_expression [112, 24] - [112, 39]
|
|
object: (member_expression [112, 24] - [112, 35]
|
|
object: (identifier [112, 24] - [112, 27])
|
|
property: (property_identifier [112, 28] - [112, 35]))
|
|
property: (property_identifier [112, 36] - [112, 39]))
|
|
arguments: (arguments [112, 39] - [112, 58]
|
|
(string [112, 40] - [112, 57]
|
|
(string_fragment [112, 41] - [112, 56]))))))
|
|
(lexical_declaration [113, 2] - [113, 61]
|
|
(variable_declarator [113, 8] - [113, 60]
|
|
name: (identifier [113, 8] - [113, 22])
|
|
value: (call_expression [113, 25] - [113, 60]
|
|
function: (member_expression [113, 25] - [113, 40]
|
|
object: (member_expression [113, 25] - [113, 36]
|
|
object: (identifier [113, 25] - [113, 28])
|
|
property: (property_identifier [113, 29] - [113, 36]))
|
|
property: (property_identifier [113, 37] - [113, 40]))
|
|
arguments: (arguments [113, 40] - [113, 60]
|
|
(string [113, 41] - [113, 59]
|
|
(string_fragment [113, 42] - [113, 58]))))))
|
|
(lexical_declaration [115, 2] - [115, 56]
|
|
(variable_declarator [115, 8] - [115, 55]
|
|
name: (identifier [115, 8] - [115, 22])
|
|
value: (binary_expression [115, 25] - [115, 55]
|
|
left: (identifier [115, 25] - [115, 41])
|
|
right: (member_expression [115, 45] - [115, 55]
|
|
object: (identifier [115, 45] - [115, 48])
|
|
property: (property_identifier [115, 49] - [115, 55])))))
|
|
(lexical_declaration [116, 2] - [119, 32]
|
|
(variable_declarator [116, 8] - [119, 31]
|
|
name: (identifier [116, 8] - [116, 20])
|
|
value: (ternary_expression [116, 23] - [119, 31]
|
|
condition: (identifier [116, 23] - [116, 36])
|
|
consequence: (binary_expression [117, 6] - [118, 55]
|
|
left: (member_expression [117, 6] - [117, 57]
|
|
object: (new_expression [117, 6] - [117, 48]
|
|
constructor: (identifier [117, 10] - [117, 13])
|
|
arguments: (arguments [117, 13] - [117, 48]
|
|
(identifier [117, 14] - [117, 27])
|
|
(string [117, 29] - [117, 47]
|
|
(string_fragment [117, 30] - [117, 46]))))
|
|
property: (property_identifier [117, 49] - [117, 57]))
|
|
right: (member_expression [118, 6] - [118, 55]
|
|
object: (new_expression [118, 6] - [118, 48]
|
|
constructor: (identifier [118, 10] - [118, 13])
|
|
arguments: (arguments [118, 13] - [118, 48]
|
|
(identifier [118, 14] - [118, 27])
|
|
(string [118, 29] - [118, 47]
|
|
(string_fragment [118, 30] - [118, 46]))))
|
|
property: (property_identifier [118, 49] - [118, 55])))
|
|
alternative: (binary_expression [119, 6] - [119, 31]
|
|
left: (member_expression [119, 6] - [119, 18]
|
|
object: (identifier [119, 6] - [119, 9])
|
|
property: (property_identifier [119, 10] - [119, 18]))
|
|
right: (member_expression [119, 21] - [119, 31]
|
|
object: (identifier [119, 21] - [119, 24])
|
|
property: (property_identifier [119, 25] - [119, 31]))))))
|
|
(lexical_declaration [120, 2] - [120, 77]
|
|
(variable_declarator [120, 8] - [120, 76]
|
|
name: (identifier [120, 8] - [120, 20])
|
|
value: (binary_expression [120, 23] - [120, 76]
|
|
left: (binary_expression [120, 23] - [120, 64]
|
|
left: (identifier [120, 23] - [120, 37])
|
|
right: (call_expression [120, 41] - [120, 64]
|
|
function: (member_expression [120, 41] - [120, 56]
|
|
object: (member_expression [120, 41] - [120, 52]
|
|
object: (identifier [120, 41] - [120, 44])
|
|
property: (property_identifier [120, 45] - [120, 52]))
|
|
property: (property_identifier [120, 53] - [120, 56]))
|
|
arguments: (arguments [120, 56] - [120, 64]
|
|
(string [120, 57] - [120, 63]
|
|
(string_fragment [120, 58] - [120, 62])))))
|
|
right: (member_expression [120, 68] - [120, 76]
|
|
object: (identifier [120, 68] - [120, 71])
|
|
property: (property_identifier [120, 72] - [120, 76])))))
|
|
(for_in_statement [122, 2] - [136, 3]
|
|
left: (identifier [122, 13] - [122, 17])
|
|
right: (identifier [122, 21] - [122, 31])
|
|
body: (statement_block [122, 33] - [136, 3]
|
|
(if_statement [123, 4] - [135, 5]
|
|
condition: (parenthesized_expression [123, 7] - [123, 27]
|
|
(binary_expression [123, 8] - [123, 26]
|
|
left: (identifier [123, 8] - [123, 12])
|
|
right: (string [123, 17] - [123, 26]
|
|
(string_fragment [123, 18] - [123, 25]))))
|
|
consequence: (statement_block [123, 28] - [125, 5]
|
|
(expression_statement [124, 6] - [124, 70]
|
|
(augmented_assignment_expression [124, 6] - [124, 69]
|
|
left: (identifier [124, 6] - [124, 19])
|
|
right: (template_string [124, 23] - [124, 69]
|
|
(string_fragment [124, 24] - [124, 35])
|
|
(template_substitution [124, 35] - [124, 66]
|
|
(call_expression [124, 37] - [124, 65]
|
|
function: (member_expression [124, 37] - [124, 63]
|
|
object: (identifier [124, 37] - [124, 51])
|
|
property: (property_identifier [124, 52] - [124, 63]))
|
|
arguments: (arguments [124, 63] - [124, 65])))
|
|
(escape_sequence [124, 66] - [124, 68])))))
|
|
alternative: (else_clause [125, 6] - [135, 5]
|
|
(if_statement [125, 11] - [135, 5]
|
|
condition: (parenthesized_expression [125, 14] - [125, 32]
|
|
(binary_expression [125, 15] - [125, 31]
|
|
left: (identifier [125, 15] - [125, 19])
|
|
right: (string [125, 24] - [125, 31]
|
|
(string_fragment [125, 25] - [125, 30]))))
|
|
consequence: (statement_block [125, 33] - [127, 5]
|
|
(expression_statement [126, 6] - [126, 52]
|
|
(augmented_assignment_expression [126, 6] - [126, 51]
|
|
left: (identifier [126, 6] - [126, 19])
|
|
right: (template_string [126, 23] - [126, 51]
|
|
(string_fragment [126, 24] - [126, 33])
|
|
(template_substitution [126, 33] - [126, 48]
|
|
(identifier [126, 35] - [126, 47]))
|
|
(escape_sequence [126, 48] - [126, 50])))))
|
|
alternative: (else_clause [127, 6] - [135, 5]
|
|
(if_statement [127, 11] - [135, 5]
|
|
condition: (parenthesized_expression [127, 14] - [127, 37]
|
|
(binary_expression [127, 15] - [127, 36]
|
|
left: (identifier [127, 15] - [127, 19])
|
|
right: (string [127, 24] - [127, 36]
|
|
(string_fragment [127, 25] - [127, 35]))))
|
|
consequence: (statement_block [127, 38] - [129, 5]
|
|
(expression_statement [128, 6] - [128, 57]
|
|
(augmented_assignment_expression [128, 6] - [128, 56]
|
|
left: (identifier [128, 6] - [128, 19])
|
|
right: (template_string [128, 23] - [128, 56]
|
|
(string_fragment [128, 24] - [128, 38])
|
|
(template_substitution [128, 38] - [128, 53]
|
|
(identifier [128, 40] - [128, 52]))
|
|
(escape_sequence [128, 53] - [128, 55])))))
|
|
alternative: (else_clause [129, 6] - [135, 5]
|
|
(statement_block [129, 11] - [135, 5]
|
|
(lexical_declaration [130, 6] - [130, 46]
|
|
(variable_declarator [130, 12] - [130, 45]
|
|
name: (identifier [130, 12] - [130, 21])
|
|
value: (call_expression [130, 24] - [130, 45]
|
|
function: (member_expression [130, 24] - [130, 39]
|
|
object: (member_expression [130, 24] - [130, 35]
|
|
object: (identifier [130, 24] - [130, 27])
|
|
property: (property_identifier [130, 28] - [130, 35]))
|
|
property: (property_identifier [130, 36] - [130, 39]))
|
|
arguments: (arguments [130, 39] - [130, 45]
|
|
(identifier [130, 40] - [130, 44])))))
|
|
(if_statement [131, 6] - [133, 7]
|
|
condition: (parenthesized_expression [131, 9] - [131, 29]
|
|
(binary_expression [131, 10] - [131, 28]
|
|
left: (identifier [131, 10] - [131, 19])
|
|
right: (null [131, 24] - [131, 28])))
|
|
consequence: (statement_block [131, 30] - [133, 7]
|
|
(throw_statement [132, 8] - [132, 73]
|
|
(new_expression [132, 14] - [132, 72]
|
|
constructor: (identifier [132, 18] - [132, 23])
|
|
arguments: (arguments [132, 23] - [132, 72]
|
|
(template_string [132, 24] - [132, 71]
|
|
(string_fragment [132, 25] - [132, 63])
|
|
(template_substitution [132, 63] - [132, 70]
|
|
(identifier [132, 65] - [132, 69]))))))))
|
|
(expression_statement [134, 6] - [134, 51]
|
|
(augmented_assignment_expression [134, 6] - [134, 50]
|
|
left: (identifier [134, 6] - [134, 19])
|
|
right: (template_string [134, 23] - [134, 50]
|
|
(string_fragment [134, 24] - [134, 25])
|
|
(template_substitution [134, 25] - [134, 32]
|
|
(identifier [134, 27] - [134, 31]))
|
|
(string_fragment [134, 32] - [134, 35])
|
|
(template_substitution [134, 35] - [134, 47]
|
|
(identifier [134, 37] - [134, 46]))
|
|
(escape_sequence [134, 47] - [134, 49])))))))))))))
|
|
(expression_statement [138, 2] - [138, 73]
|
|
(augmented_assignment_expression [138, 2] - [138, 72]
|
|
left: (identifier [138, 2] - [138, 15])
|
|
right: (template_string [138, 19] - [138, 72]
|
|
(string_fragment [138, 20] - [138, 42])
|
|
(template_substitution [138, 42] - [138, 58]
|
|
(identifier [138, 44] - [138, 57]))
|
|
(string_fragment [138, 58] - [138, 59])
|
|
(template_substitution [138, 59] - [138, 71]
|
|
(identifier [138, 61] - [138, 70])))))
|
|
(comment [140, 2] - [140, 28])
|
|
(lexical_declaration [141, 2] - [141, 58]
|
|
(variable_declarator [141, 8] - [141, 57]
|
|
name: (identifier [141, 8] - [141, 21])
|
|
value: (call_expression [141, 24] - [141, 57]
|
|
function: (member_expression [141, 24] - [141, 39]
|
|
object: (identifier [141, 24] - [141, 33])
|
|
property: (property_identifier [141, 34] - [141, 39]))
|
|
arguments: (arguments [141, 39] - [141, 57]
|
|
(regex [141, 40] - [141, 56]
|
|
pattern: (regex_pattern [141, 41] - [141, 55]))))))
|
|
(if_statement [142, 2] - [144, 3]
|
|
condition: (parenthesized_expression [142, 5] - [142, 21]
|
|
(unary_expression [142, 6] - [142, 20]
|
|
argument: (identifier [142, 7] - [142, 20])))
|
|
consequence: (statement_block [142, 22] - [144, 3]
|
|
(throw_statement [143, 4] - [143, 55]
|
|
(new_expression [143, 10] - [143, 54]
|
|
constructor: (identifier [143, 14] - [143, 19])
|
|
arguments: (arguments [143, 19] - [143, 54]
|
|
(string [143, 20] - [143, 53]
|
|
(string_fragment [143, 21] - [143, 52])))))))
|
|
(lexical_declaration [146, 2] - [146, 39]
|
|
(variable_declarator [146, 8] - [146, 38]
|
|
name: (identifier [146, 8] - [146, 19])
|
|
value: (subscript_expression [146, 22] - [146, 38]
|
|
object: (identifier [146, 22] - [146, 35])
|
|
index: (number [146, 36] - [146, 37]))))
|
|
(lexical_declaration [147, 2] - [147, 15]
|
|
(variable_declarator [147, 6] - [147, 14]
|
|
name: (identifier [147, 6] - [147, 14])))
|
|
(try_statement [148, 2] - [156, 3]
|
|
body: (statement_block [148, 6] - [154, 3]
|
|
(lexical_declaration [149, 4] - [149, 75]
|
|
(variable_declarator [149, 10] - [149, 74]
|
|
name: (identifier [149, 10] - [149, 16])
|
|
value: (call_expression [149, 19] - [149, 74]
|
|
function: (identifier [149, 19] - [149, 23])
|
|
arguments: (arguments [149, 23] - [149, 74]
|
|
(call_expression [149, 24] - [149, 73]
|
|
function: (member_expression [149, 24] - [149, 62]
|
|
object: (call_expression [149, 24] - [149, 54]
|
|
function: (member_expression [149, 24] - [149, 43]
|
|
object: (identifier [149, 24] - [149, 35])
|
|
property: (property_identifier [149, 36] - [149, 43]))
|
|
arguments: (arguments [149, 43] - [149, 54]
|
|
(regex [149, 44] - [149, 48]
|
|
pattern: (regex_pattern [149, 45] - [149, 46])
|
|
flags: (regex_flags [149, 47] - [149, 48]))
|
|
(string [149, 50] - [149, 53]
|
|
(string_fragment [149, 51] - [149, 52]))))
|
|
property: (property_identifier [149, 55] - [149, 62]))
|
|
arguments: (arguments [149, 62] - [149, 73]
|
|
(regex [149, 63] - [149, 67]
|
|
pattern: (regex_pattern [149, 64] - [149, 65])
|
|
flags: (regex_flags [149, 66] - [149, 67]))
|
|
(string [149, 69] - [149, 72]
|
|
(string_fragment [149, 70] - [149, 71]))))))))
|
|
(expression_statement [150, 4] - [150, 45]
|
|
(assignment_expression [150, 4] - [150, 44]
|
|
left: (identifier [150, 4] - [150, 12])
|
|
right: (new_expression [150, 15] - [150, 44]
|
|
constructor: (identifier [150, 19] - [150, 29])
|
|
arguments: (arguments [150, 29] - [150, 44]
|
|
(member_expression [150, 30] - [150, 43]
|
|
object: (identifier [150, 30] - [150, 36])
|
|
property: (property_identifier [150, 37] - [150, 43]))))))
|
|
(for_statement [151, 4] - [153, 5]
|
|
initializer: (lexical_declaration [151, 9] - [151, 19]
|
|
(variable_declarator [151, 13] - [151, 18]
|
|
name: (identifier [151, 13] - [151, 14])
|
|
value: (number [151, 17] - [151, 18])))
|
|
condition: (binary_expression [151, 20] - [151, 37]
|
|
left: (identifier [151, 20] - [151, 21])
|
|
right: (member_expression [151, 24] - [151, 37]
|
|
object: (identifier [151, 24] - [151, 30])
|
|
property: (property_identifier [151, 31] - [151, 37])))
|
|
increment: (update_expression [151, 39] - [151, 42]
|
|
argument: (identifier [151, 39] - [151, 40]))
|
|
body: (statement_block [151, 44] - [153, 5]
|
|
(expression_statement [152, 6] - [152, 41]
|
|
(assignment_expression [152, 6] - [152, 40]
|
|
left: (subscript_expression [152, 6] - [152, 17]
|
|
object: (identifier [152, 6] - [152, 14])
|
|
index: (identifier [152, 15] - [152, 16]))
|
|
right: (call_expression [152, 20] - [152, 40]
|
|
function: (member_expression [152, 20] - [152, 37]
|
|
object: (identifier [152, 20] - [152, 26])
|
|
property: (property_identifier [152, 27] - [152, 37]))
|
|
arguments: (arguments [152, 37] - [152, 40]
|
|
(identifier [152, 38] - [152, 39]))))))))
|
|
handler: (catch_clause [154, 4] - [156, 3]
|
|
body: (statement_block [154, 10] - [156, 3]
|
|
(throw_statement [155, 4] - [155, 60]
|
|
(new_expression [155, 10] - [155, 59]
|
|
constructor: (identifier [155, 14] - [155, 19])
|
|
arguments: (arguments [155, 19] - [155, 59]
|
|
(string [155, 20] - [155, 58]
|
|
(string_fragment [155, 21] - [155, 57]))))))))
|
|
(lexical_declaration [158, 2] - [164, 4]
|
|
(variable_declarator [158, 8] - [164, 3]
|
|
name: (identifier [158, 8] - [158, 19])
|
|
value: (await_expression [158, 22] - [164, 3]
|
|
(call_expression [158, 28] - [164, 3]
|
|
function: (member_expression [158, 28] - [158, 51]
|
|
object: (member_expression [158, 28] - [158, 41]
|
|
object: (identifier [158, 28] - [158, 34])
|
|
property: (property_identifier [158, 35] - [158, 41]))
|
|
property: (property_identifier [158, 42] - [158, 51]))
|
|
arguments: (arguments [158, 51] - [164, 3]
|
|
(string [159, 4] - [159, 9]
|
|
(string_fragment [159, 5] - [159, 8]))
|
|
(identifier [160, 4] - [160, 7])
|
|
(object [161, 4] - [161, 23]
|
|
(pair [161, 6] - [161, 21]
|
|
key: (property_identifier [161, 6] - [161, 10])
|
|
value: (string [161, 12] - [161, 21]
|
|
(string_fragment [161, 13] - [161, 20]))))
|
|
(false [162, 4] - [162, 9])
|
|
(array [163, 4] - [163, 14]
|
|
(string [163, 5] - [163, 13]
|
|
(string_fragment [163, 6] - [163, 12]))))))))
|
|
(lexical_declaration [166, 2] - [166, 59]
|
|
(variable_declarator [166, 8] - [166, 58]
|
|
name: (identifier [166, 8] - [166, 16])
|
|
value: (call_expression [166, 19] - [166, 58]
|
|
function: (member_expression [166, 19] - [166, 43]
|
|
object: (new_expression [166, 19] - [166, 36]
|
|
constructor: (identifier [166, 23] - [166, 34])
|
|
arguments: (arguments [166, 34] - [166, 36]))
|
|
property: (property_identifier [166, 37] - [166, 43]))
|
|
arguments: (arguments [166, 43] - [166, 58]
|
|
(identifier [166, 44] - [166, 57])))))
|
|
(lexical_declaration [167, 2] - [172, 4]
|
|
(variable_declarator [167, 8] - [172, 3]
|
|
name: (identifier [167, 8] - [167, 15])
|
|
value: (await_expression [167, 18] - [172, 3]
|
|
(call_expression [167, 24] - [172, 3]
|
|
function: (member_expression [167, 24] - [167, 44]
|
|
object: (member_expression [167, 24] - [167, 37]
|
|
object: (identifier [167, 24] - [167, 30])
|
|
property: (property_identifier [167, 31] - [167, 37]))
|
|
property: (property_identifier [167, 38] - [167, 44]))
|
|
arguments: (arguments [167, 44] - [172, 3]
|
|
(string [168, 4] - [168, 13]
|
|
(string_fragment [168, 5] - [168, 12]))
|
|
(identifier [169, 4] - [169, 15])
|
|
(identifier [170, 4] - [170, 12])
|
|
(identifier [171, 4] - [171, 12]))))))
|
|
(if_statement [174, 2] - [176, 3]
|
|
condition: (parenthesized_expression [174, 5] - [174, 15]
|
|
(unary_expression [174, 6] - [174, 14]
|
|
argument: (identifier [174, 7] - [174, 14])))
|
|
consequence: (statement_block [174, 16] - [176, 3]
|
|
(throw_statement [175, 4] - [175, 55]
|
|
(new_expression [175, 10] - [175, 54]
|
|
constructor: (identifier [175, 14] - [175, 19])
|
|
arguments: (arguments [175, 19] - [175, 54]
|
|
(string [175, 20] - [175, 53]
|
|
(string_fragment [175, 21] - [175, 52])))))))
|
|
(return_statement [178, 2] - [178, 21]
|
|
(identifier [178, 9] - [178, 20]))))))
|