1343 lines
82 KiB
Plaintext
1343 lines
82 KiB
Plaintext
(program [0, 0] - [257, 0]
|
|
(import_statement [0, 0] - [0, 40]
|
|
(import_clause [0, 7] - [0, 15]
|
|
(named_imports [0, 7] - [0, 15]
|
|
(import_specifier [0, 9] - [0, 13]
|
|
name: (identifier [0, 9] - [0, 13]))))
|
|
source: (string [0, 21] - [0, 39]
|
|
(string_fragment [0, 22] - [0, 38])))
|
|
(import_statement [1, 0] - [5, 31]
|
|
(import_clause [1, 7] - [5, 1]
|
|
(named_imports [1, 7] - [5, 1]
|
|
(import_specifier [2, 2] - [2, 22]
|
|
name: (identifier [2, 2] - [2, 22]))
|
|
(import_specifier [3, 2] - [3, 10]
|
|
name: (identifier [3, 2] - [3, 10]))
|
|
(import_specifier [4, 2] - [4, 15]
|
|
name: (identifier [4, 2] - [4, 15]))))
|
|
source: (string [5, 7] - [5, 30]
|
|
(string_fragment [5, 8] - [5, 29])))
|
|
(import_statement [6, 0] - [6, 55]
|
|
(import_clause [6, 7] - [6, 22]
|
|
(named_imports [6, 7] - [6, 22]
|
|
(import_specifier [6, 9] - [6, 20]
|
|
name: (identifier [6, 9] - [6, 20]))))
|
|
source: (string [6, 28] - [6, 54]
|
|
(string_fragment [6, 29] - [6, 53])))
|
|
(import_statement [7, 0] - [7, 51]
|
|
(import_clause [7, 7] - [7, 23]
|
|
(named_imports [7, 7] - [7, 23]
|
|
(import_specifier [7, 9] - [7, 21]
|
|
name: (identifier [7, 9] - [7, 21]))))
|
|
source: (string [7, 29] - [7, 50]
|
|
(string_fragment [7, 30] - [7, 49])))
|
|
(import_statement [8, 0] - [8, 40]
|
|
(import_clause [8, 7] - [8, 19]
|
|
(namespace_import [8, 7] - [8, 19]
|
|
(identifier [8, 12] - [8, 19])))
|
|
source: (string [8, 25] - [8, 39]
|
|
(string_fragment [8, 26] - [8, 38])))
|
|
(export_statement [10, 0] - [10, 46]
|
|
declaration: (lexical_declaration [10, 7] - [10, 46]
|
|
(variable_declarator [10, 13] - [10, 45]
|
|
name: (identifier [10, 13] - [10, 32])
|
|
value: (new_expression [10, 35] - [10, 45]
|
|
constructor: (identifier [10, 39] - [10, 43])
|
|
arguments: (arguments [10, 43] - [10, 45])))))
|
|
(comment [12, 0] - [12, 60])
|
|
(comment [13, 0] - [13, 41])
|
|
(comment [14, 0] - [14, 60])
|
|
(expression_statement [15, 0] - [76, 3]
|
|
(call_expression [15, 0] - [76, 2]
|
|
function: (member_expression [15, 0] - [15, 24]
|
|
object: (identifier [15, 0] - [15, 19])
|
|
property: (property_identifier [15, 20] - [15, 24]))
|
|
arguments: (arguments [15, 24] - [76, 2]
|
|
(string [15, 25] - [15, 38]
|
|
(string_fragment [15, 26] - [15, 37]))
|
|
(arrow_function [15, 40] - [76, 1]
|
|
parameters: (formal_parameters [15, 46] - [15, 49]
|
|
(required_parameter [15, 47] - [15, 48]
|
|
pattern: (identifier [15, 47] - [15, 48])))
|
|
body: (statement_block [15, 53] - [76, 1]
|
|
(lexical_declaration [16, 2] - [16, 45]
|
|
(variable_declarator [16, 8] - [16, 44]
|
|
name: (identifier [16, 8] - [16, 12])
|
|
value: (await_expression [16, 15] - [16, 44]
|
|
(call_expression [16, 21] - [16, 44]
|
|
function: (identifier [16, 21] - [16, 41])
|
|
arguments: (arguments [16, 41] - [16, 44]
|
|
(identifier [16, 42] - [16, 43]))))))
|
|
(if_statement [17, 2] - [17, 59]
|
|
condition: (parenthesized_expression [17, 5] - [17, 12]
|
|
(unary_expression [17, 6] - [17, 11]
|
|
argument: (identifier [17, 7] - [17, 11])))
|
|
consequence: (return_statement [17, 13] - [17, 59]
|
|
(call_expression [17, 20] - [17, 58]
|
|
function: (member_expression [17, 20] - [17, 26]
|
|
object: (identifier [17, 20] - [17, 21])
|
|
property: (property_identifier [17, 22] - [17, 26]))
|
|
arguments: (arguments [17, 26] - [17, 58]
|
|
(object [17, 27] - [17, 52]
|
|
(pair [17, 29] - [17, 50]
|
|
key: (property_identifier [17, 29] - [17, 34])
|
|
value: (string [17, 36] - [17, 50]
|
|
(string_fragment [17, 37] - [17, 49]))))
|
|
(number [17, 54] - [17, 57])))))
|
|
(if_statement [19, 2] - [21, 3]
|
|
condition: (parenthesized_expression [19, 5] - [19, 38]
|
|
(unary_expression [19, 6] - [19, 37]
|
|
argument: (call_expression [19, 7] - [19, 37]
|
|
function: (identifier [19, 7] - [19, 15])
|
|
arguments: (arguments [19, 15] - [19, 37]
|
|
(identifier [19, 16] - [19, 20])
|
|
(string [19, 22] - [19, 36]
|
|
(string_fragment [19, 23] - [19, 35]))))))
|
|
consequence: (statement_block [19, 39] - [21, 3]
|
|
(return_statement [20, 4] - [20, 68]
|
|
(call_expression [20, 11] - [20, 67]
|
|
function: (member_expression [20, 11] - [20, 17]
|
|
object: (identifier [20, 11] - [20, 12])
|
|
property: (property_identifier [20, 13] - [20, 17]))
|
|
arguments: (arguments [20, 17] - [20, 67]
|
|
(object [20, 18] - [20, 61]
|
|
(pair [20, 20] - [20, 59]
|
|
key: (property_identifier [20, 20] - [20, 25])
|
|
value: (string [20, 27] - [20, 59]
|
|
(string_fragment [20, 28] - [20, 58]))))
|
|
(number [20, 63] - [20, 66]))))))
|
|
(try_statement [23, 2] - [75, 3]
|
|
body: (statement_block [23, 6] - [72, 3]
|
|
(lexical_declaration [24, 4] - [24, 54]
|
|
(variable_declarator [24, 10] - [24, 53]
|
|
name: (identifier [24, 10] - [24, 14])
|
|
value: (await_expression [24, 17] - [24, 53]
|
|
(call_expression [24, 23] - [24, 53]
|
|
function: (member_expression [24, 23] - [24, 41]
|
|
object: (call_expression [24, 23] - [24, 35]
|
|
function: (member_expression [24, 23] - [24, 33]
|
|
object: (member_expression [24, 23] - [24, 28]
|
|
object: (identifier [24, 23] - [24, 24])
|
|
property: (property_identifier [24, 25] - [24, 28]))
|
|
property: (property_identifier [24, 29] - [24, 33]))
|
|
arguments: (arguments [24, 33] - [24, 35]))
|
|
property: (property_identifier [24, 36] - [24, 41]))
|
|
arguments: (arguments [24, 41] - [24, 53]
|
|
(arrow_function [24, 42] - [24, 52]
|
|
parameters: (formal_parameters [24, 42] - [24, 44])
|
|
body: (parenthesized_expression [24, 48] - [24, 52]
|
|
(object [24, 49] - [24, 51]))))))))
|
|
(lexical_declaration [25, 4] - [25, 42]
|
|
(variable_declarator [25, 10] - [25, 41]
|
|
name: (identifier [25, 10] - [25, 14])
|
|
value: (call_expression [25, 17] - [25, 41]
|
|
function: (member_expression [25, 17] - [25, 39]
|
|
object: (parenthesized_expression [25, 17] - [25, 34]
|
|
(binary_expression [25, 18] - [25, 33]
|
|
left: (member_expression [25, 18] - [25, 27]
|
|
object: (identifier [25, 18] - [25, 22])
|
|
property: (property_identifier [25, 23] - [25, 27]))
|
|
right: (string [25, 31] - [25, 33])))
|
|
property: (property_identifier [25, 35] - [25, 39]))
|
|
arguments: (arguments [25, 39] - [25, 41]))))
|
|
(if_statement [26, 4] - [26, 71]
|
|
condition: (parenthesized_expression [26, 7] - [26, 14]
|
|
(unary_expression [26, 8] - [26, 13]
|
|
argument: (identifier [26, 9] - [26, 13])))
|
|
consequence: (return_statement [26, 15] - [26, 71]
|
|
(call_expression [26, 22] - [26, 70]
|
|
function: (member_expression [26, 22] - [26, 28]
|
|
object: (identifier [26, 22] - [26, 23])
|
|
property: (property_identifier [26, 24] - [26, 28]))
|
|
arguments: (arguments [26, 28] - [26, 70]
|
|
(object [26, 29] - [26, 64]
|
|
(pair [26, 31] - [26, 62]
|
|
key: (property_identifier [26, 31] - [26, 36])
|
|
value: (string [26, 38] - [26, 62]
|
|
(string_fragment [26, 39] - [26, 61]))))
|
|
(number [26, 66] - [26, 69])))))
|
|
(lexical_declaration [28, 4] - [28, 37]
|
|
(variable_declarator [28, 10] - [28, 36]
|
|
name: (identifier [28, 10] - [28, 15])
|
|
value: (binary_expression [28, 18] - [28, 36]
|
|
left: (member_expression [28, 18] - [28, 28]
|
|
object: (identifier [28, 18] - [28, 22])
|
|
property: (property_identifier [28, 23] - [28, 28]))
|
|
right: (null [28, 32] - [28, 36]))))
|
|
(lexical_declaration [29, 4] - [29, 39]
|
|
(variable_declarator [29, 10] - [29, 38]
|
|
name: (identifier [29, 10] - [29, 14])
|
|
value: (binary_expression [29, 17] - [29, 38]
|
|
left: (member_expression [29, 17] - [29, 26]
|
|
object: (identifier [29, 17] - [29, 21])
|
|
property: (property_identifier [29, 22] - [29, 26]))
|
|
right: (string [29, 30] - [29, 38]
|
|
(string_fragment [29, 31] - [29, 37])))))
|
|
(lexical_declaration [30, 4] - [30, 67]
|
|
(variable_declarator [30, 10] - [30, 66]
|
|
name: (identifier [30, 10] - [30, 18])
|
|
value: (call_expression [30, 21] - [30, 66]
|
|
function: (member_expression [30, 21] - [30, 29]
|
|
object: (identifier [30, 21] - [30, 25])
|
|
property: (property_identifier [30, 26] - [30, 29]))
|
|
arguments: (arguments [30, 29] - [30, 66]
|
|
(number [30, 30] - [30, 31])
|
|
(binary_expression [30, 33] - [30, 65]
|
|
left: (call_expression [30, 33] - [30, 60]
|
|
function: (identifier [30, 33] - [30, 41])
|
|
arguments: (arguments [30, 41] - [30, 60]
|
|
(member_expression [30, 42] - [30, 55]
|
|
object: (identifier [30, 42] - [30, 46])
|
|
property: (property_identifier [30, 47] - [30, 55]))
|
|
(number [30, 57] - [30, 59])))
|
|
right: (number [30, 64] - [30, 65]))))))
|
|
(lexical_declaration [31, 4] - [31, 77]
|
|
(variable_declarator [31, 10] - [31, 76]
|
|
name: (identifier [31, 10] - [31, 23])
|
|
value: (call_expression [31, 26] - [31, 76]
|
|
function: (member_expression [31, 26] - [31, 34]
|
|
object: (identifier [31, 26] - [31, 30])
|
|
property: (property_identifier [31, 31] - [31, 34]))
|
|
arguments: (arguments [31, 34] - [31, 76]
|
|
(number [31, 35] - [31, 36])
|
|
(binary_expression [31, 38] - [31, 75]
|
|
left: (call_expression [31, 38] - [31, 70]
|
|
function: (identifier [31, 38] - [31, 46])
|
|
arguments: (arguments [31, 46] - [31, 70]
|
|
(member_expression [31, 47] - [31, 65]
|
|
object: (identifier [31, 47] - [31, 51])
|
|
property: (property_identifier [31, 52] - [31, 65]))
|
|
(number [31, 67] - [31, 69])))
|
|
right: (number [31, 74] - [31, 75]))))))
|
|
(comment [33, 4] - [33, 34])
|
|
(lexical_declaration [34, 4] - [36, 63]
|
|
(variable_declarator [34, 10] - [36, 62]
|
|
name: (identifier [34, 10] - [34, 16])
|
|
value: (ternary_expression [34, 19] - [36, 62]
|
|
condition: (binary_expression [34, 19] - [34, 77]
|
|
left: (member_expression [34, 19] - [34, 31]
|
|
object: (identifier [34, 19] - [34, 23])
|
|
property: (property_identifier [34, 24] - [34, 31]))
|
|
right: (call_expression [34, 35] - [34, 77]
|
|
function: (member_expression [34, 35] - [34, 56]
|
|
object: (regex [34, 35] - [34, 51]
|
|
pattern: (regex_pattern [34, 36] - [34, 50]))
|
|
property: (property_identifier [34, 52] - [34, 56]))
|
|
arguments: (arguments [34, 56] - [34, 77]
|
|
(call_expression [34, 57] - [34, 76]
|
|
function: (member_expression [34, 57] - [34, 74]
|
|
object: (member_expression [34, 57] - [34, 69]
|
|
object: (identifier [34, 57] - [34, 61])
|
|
property: (property_identifier [34, 62] - [34, 69]))
|
|
property: (property_identifier [34, 70] - [34, 74]))
|
|
arguments: (arguments [34, 74] - [34, 76])))))
|
|
consequence: (call_expression [35, 8] - [35, 27]
|
|
function: (member_expression [35, 8] - [35, 25]
|
|
object: (member_expression [35, 8] - [35, 20]
|
|
object: (identifier [35, 8] - [35, 12])
|
|
property: (property_identifier [35, 13] - [35, 20]))
|
|
property: (property_identifier [35, 21] - [35, 25]))
|
|
arguments: (arguments [35, 25] - [35, 27]))
|
|
alternative: (call_expression [36, 8] - [36, 62]
|
|
function: (member_expression [36, 8] - [36, 60]
|
|
object: (call_expression [36, 8] - [36, 51]
|
|
function: (member_expression [36, 8] - [36, 18]
|
|
object: (identifier [36, 8] - [36, 12])
|
|
property: (property_identifier [36, 13] - [36, 18]))
|
|
arguments: (arguments [36, 18] - [36, 51]
|
|
(binary_expression [36, 19] - [36, 50]
|
|
left: (number [36, 19] - [36, 25])
|
|
right: (binary_expression [36, 28] - [36, 50]
|
|
left: (call_expression [36, 28] - [36, 41]
|
|
function: (member_expression [36, 28] - [36, 39]
|
|
object: (identifier [36, 28] - [36, 32])
|
|
property: (property_identifier [36, 33] - [36, 39]))
|
|
arguments: (arguments [36, 39] - [36, 41]))
|
|
right: (number [36, 44] - [36, 50])))))
|
|
property: (property_identifier [36, 52] - [36, 60]))
|
|
arguments: (arguments [36, 60] - [36, 62])))))
|
|
(lexical_declaration [37, 4] - [39, 51]
|
|
(variable_declarator [37, 10] - [39, 50]
|
|
name: (identifier [37, 10] - [37, 17])
|
|
value: (ternary_expression [37, 20] - [39, 50]
|
|
condition: (call_expression [37, 20] - [37, 40]
|
|
function: (member_expression [37, 20] - [37, 35]
|
|
object: (identifier [37, 20] - [37, 26])
|
|
property: (property_identifier [37, 27] - [37, 35]))
|
|
arguments: (arguments [37, 35] - [37, 40]
|
|
(string [37, 36] - [37, 39]
|
|
(string_fragment [37, 37] - [37, 38]))))
|
|
consequence: (identifier [38, 8] - [38, 14])
|
|
alternative: (template_string [39, 8] - [39, 50]
|
|
(template_substitution [39, 9] - [39, 30]
|
|
(call_expression [39, 11] - [39, 29]
|
|
function: (member_expression [39, 11] - [39, 23]
|
|
object: (identifier [39, 11] - [39, 17])
|
|
property: (property_identifier [39, 18] - [39, 23]))
|
|
arguments: (arguments [39, 23] - [39, 29]
|
|
(number [39, 24] - [39, 25])
|
|
(number [39, 27] - [39, 28]))))
|
|
(string_fragment [39, 30] - [39, 31])
|
|
(template_substitution [39, 31] - [39, 49]
|
|
(call_expression [39, 33] - [39, 48]
|
|
function: (member_expression [39, 33] - [39, 45]
|
|
object: (identifier [39, 33] - [39, 39])
|
|
property: (property_identifier [39, 40] - [39, 45]))
|
|
arguments: (arguments [39, 45] - [39, 48]
|
|
(number [39, 46] - [39, 47]))))))))
|
|
(comment [41, 4] - [41, 27])
|
|
(lexical_declaration [42, 4] - [44, 74]
|
|
(variable_declarator [42, 8] - [44, 73]
|
|
name: (identifier [42, 8] - [42, 16])
|
|
value: (ternary_expression [42, 19] - [44, 73]
|
|
condition: (member_expression [42, 19] - [42, 28]
|
|
object: (identifier [42, 19] - [42, 23])
|
|
property: (property_identifier [42, 24] - [42, 28]))
|
|
consequence: (call_expression [43, 8] - [43, 66]
|
|
function: (member_expression [43, 8] - [43, 46]
|
|
object: (call_expression [43, 8] - [43, 38]
|
|
function: (member_expression [43, 8] - [43, 36]
|
|
object: (call_expression [43, 8] - [43, 24]
|
|
function: (member_expression [43, 8] - [43, 22]
|
|
object: (member_expression [43, 8] - [43, 17]
|
|
object: (identifier [43, 8] - [43, 12])
|
|
property: (property_identifier [43, 13] - [43, 17]))
|
|
property: (property_identifier [43, 18] - [43, 22]))
|
|
arguments: (arguments [43, 22] - [43, 24]))
|
|
property: (property_identifier [43, 25] - [43, 36]))
|
|
arguments: (arguments [43, 36] - [43, 38]))
|
|
property: (property_identifier [43, 39] - [43, 46]))
|
|
arguments: (arguments [43, 46] - [43, 66]
|
|
(regex [43, 47] - [43, 61]
|
|
pattern: (regex_pattern [43, 48] - [43, 59])
|
|
flags: (regex_flags [43, 60] - [43, 61]))
|
|
(string [43, 63] - [43, 65])))
|
|
alternative: (call_expression [44, 8] - [44, 73]
|
|
function: (member_expression [44, 8] - [44, 61]
|
|
object: (call_expression [44, 8] - [44, 53]
|
|
function: (member_expression [44, 8] - [44, 34]
|
|
object: (call_expression [44, 8] - [44, 26]
|
|
function: (member_expression [44, 8] - [44, 24]
|
|
object: (identifier [44, 8] - [44, 12])
|
|
property: (property_identifier [44, 13] - [44, 24]))
|
|
arguments: (arguments [44, 24] - [44, 26]))
|
|
property: (property_identifier [44, 27] - [44, 34]))
|
|
arguments: (arguments [44, 34] - [44, 53]
|
|
(regex [44, 35] - [44, 47]
|
|
pattern: (regex_pattern [44, 36] - [44, 45])
|
|
flags: (regex_flags [44, 46] - [44, 47]))
|
|
(string [44, 49] - [44, 52]
|
|
(string_fragment [44, 50] - [44, 51]))))
|
|
property: (property_identifier [44, 54] - [44, 61]))
|
|
arguments: (arguments [44, 61] - [44, 73]
|
|
(regex [44, 62] - [44, 67]
|
|
pattern: (regex_pattern [44, 63] - [44, 65])
|
|
flags: (regex_flags [44, 66] - [44, 67]))
|
|
(string [44, 69] - [44, 72]
|
|
(string_fragment [44, 70] - [44, 71])))))))
|
|
(if_statement [45, 4] - [45, 41]
|
|
condition: (parenthesized_expression [45, 7] - [45, 18]
|
|
(unary_expression [45, 8] - [45, 17]
|
|
argument: (identifier [45, 9] - [45, 17])))
|
|
consequence: (expression_statement [45, 19] - [45, 41]
|
|
(assignment_expression [45, 19] - [45, 40]
|
|
left: (identifier [45, 19] - [45, 27])
|
|
right: (string [45, 30] - [45, 40]
|
|
(string_fragment [45, 31] - [45, 39])))))
|
|
(lexical_declaration [46, 4] - [46, 66]
|
|
(variable_declarator [46, 10] - [46, 65]
|
|
name: (identifier [46, 10] - [46, 20])
|
|
value: (call_expression [46, 23] - [46, 65]
|
|
function: (member_expression [46, 23] - [46, 59]
|
|
object: (call_expression [46, 23] - [46, 49]
|
|
function: (member_expression [46, 23] - [46, 45]
|
|
object: (call_expression [46, 23] - [46, 36]
|
|
function: (member_expression [46, 23] - [46, 34]
|
|
object: (identifier [46, 23] - [46, 27])
|
|
property: (property_identifier [46, 28] - [46, 34]))
|
|
arguments: (arguments [46, 34] - [46, 36]))
|
|
property: (property_identifier [46, 37] - [46, 45]))
|
|
arguments: (arguments [46, 45] - [46, 49]
|
|
(number [46, 46] - [46, 48])))
|
|
property: (property_identifier [46, 50] - [46, 59]))
|
|
arguments: (arguments [46, 59] - [46, 65]
|
|
(number [46, 60] - [46, 61])
|
|
(number [46, 63] - [46, 64])))))
|
|
(lexical_declaration [47, 4] - [47, 45]
|
|
(variable_declarator [47, 10] - [47, 44]
|
|
name: (identifier [47, 10] - [47, 14])
|
|
value: (template_string [47, 17] - [47, 44]
|
|
(template_substitution [47, 18] - [47, 29]
|
|
(identifier [47, 20] - [47, 28]))
|
|
(string_fragment [47, 29] - [47, 30])
|
|
(template_substitution [47, 30] - [47, 43]
|
|
(identifier [47, 32] - [47, 42])))))
|
|
(lexical_declaration [49, 4] - [49, 73]
|
|
(variable_declarator [49, 10] - [49, 72]
|
|
name: (identifier [49, 10] - [49, 19])
|
|
value: (new_expression [49, 22] - [49, 72]
|
|
constructor: (identifier [49, 26] - [49, 30])
|
|
arguments: (arguments [49, 30] - [49, 72]
|
|
(binary_expression [49, 31] - [49, 71]
|
|
left: (call_expression [49, 31] - [49, 41]
|
|
function: (member_expression [49, 31] - [49, 39]
|
|
object: (identifier [49, 31] - [49, 35])
|
|
property: (property_identifier [49, 36] - [49, 39]))
|
|
arguments: (arguments [49, 39] - [49, 41]))
|
|
right: (binary_expression [49, 44] - [49, 71]
|
|
left: (binary_expression [49, 44] - [49, 64]
|
|
left: (identifier [49, 44] - [49, 57])
|
|
right: (number [49, 60] - [49, 64]))
|
|
right: (number [49, 67] - [49, 71])))))))
|
|
(lexical_declaration [51, 4] - [61, 6]
|
|
(variable_declarator [51, 10] - [61, 5]
|
|
name: (identifier [51, 10] - [51, 15])
|
|
value: (await_expression [51, 18] - [61, 5]
|
|
(call_expression [51, 24] - [61, 5]
|
|
function: (member_expression [51, 24] - [51, 47]
|
|
object: (identifier [51, 24] - [51, 31])
|
|
property: (property_identifier [51, 32] - [51, 47]))
|
|
arguments: (arguments [51, 47] - [61, 5]
|
|
(identifier [52, 6] - [52, 10])
|
|
(identifier [53, 6] - [53, 10])
|
|
(identifier [54, 6] - [54, 13])
|
|
(identifier [55, 6] - [55, 11])
|
|
(identifier [56, 6] - [56, 10])
|
|
(identifier [57, 6] - [57, 14])
|
|
(identifier [58, 6] - [58, 19])
|
|
(member_expression [59, 6] - [59, 17]
|
|
object: (identifier [59, 6] - [59, 10])
|
|
property: (property_identifier [59, 11] - [59, 17]))
|
|
(identifier [60, 6] - [60, 15]))))))
|
|
(expression_statement [63, 4] - [69, 6]
|
|
(call_expression [63, 4] - [69, 5]
|
|
function: (member_expression [63, 4] - [63, 25]
|
|
object: (identifier [63, 4] - [63, 16])
|
|
property: (property_identifier [63, 17] - [63, 25]))
|
|
arguments: (arguments [63, 25] - [69, 5]
|
|
(member_expression [64, 6] - [64, 17]
|
|
object: (identifier [64, 6] - [64, 10])
|
|
property: (property_identifier [64, 11] - [64, 17]))
|
|
(string [65, 6] - [65, 26]
|
|
(string_fragment [65, 7] - [65, 25]))
|
|
(ternary_expression [66, 6] - [66, 29]
|
|
condition: (identifier [66, 6] - [66, 11])
|
|
consequence: (member_expression [66, 14] - [66, 22]
|
|
object: (identifier [66, 14] - [66, 19])
|
|
property: (property_identifier [66, 20] - [66, 22]))
|
|
alternative: (null [66, 25] - [66, 29]))
|
|
(object [67, 6] - [67, 45]
|
|
(shorthand_property_identifier [67, 8] - [67, 12])
|
|
(shorthand_property_identifier [67, 14] - [67, 18])
|
|
(shorthand_property_identifier [67, 20] - [67, 28])
|
|
(shorthand_property_identifier [67, 30] - [67, 43]))
|
|
(call_expression [68, 6] - [68, 20]
|
|
function: (identifier [68, 6] - [68, 17])
|
|
arguments: (arguments [68, 17] - [68, 20]
|
|
(identifier [68, 18] - [68, 19]))))))
|
|
(return_statement [71, 4] - [71, 44]
|
|
(call_expression [71, 11] - [71, 43]
|
|
function: (member_expression [71, 11] - [71, 17]
|
|
object: (identifier [71, 11] - [71, 12])
|
|
property: (property_identifier [71, 13] - [71, 17]))
|
|
arguments: (arguments [71, 17] - [71, 43]
|
|
(object [71, 18] - [71, 42]
|
|
(pair [71, 20] - [71, 33]
|
|
key: (property_identifier [71, 20] - [71, 27])
|
|
value: (true [71, 29] - [71, 33]))
|
|
(shorthand_property_identifier [71, 35] - [71, 40]))))))
|
|
handler: (catch_clause [72, 4] - [75, 3]
|
|
parameter: (identifier [72, 11] - [72, 14])
|
|
type: (type_annotation [72, 14] - [72, 19]
|
|
(predefined_type [72, 16] - [72, 19]))
|
|
body: (statement_block [72, 21] - [75, 3]
|
|
(expression_statement [73, 4] - [73, 64]
|
|
(call_expression [73, 4] - [73, 63]
|
|
function: (member_expression [73, 4] - [73, 17]
|
|
object: (identifier [73, 4] - [73, 11])
|
|
property: (property_identifier [73, 12] - [73, 17]))
|
|
arguments: (arguments [73, 17] - [73, 63]
|
|
(string [73, 18] - [73, 57]
|
|
(string_fragment [73, 19] - [73, 56]))
|
|
(identifier [73, 59] - [73, 62]))))
|
|
(return_statement [74, 4] - [74, 80]
|
|
(call_expression [74, 11] - [74, 79]
|
|
function: (member_expression [74, 11] - [74, 17]
|
|
object: (identifier [74, 11] - [74, 12])
|
|
property: (property_identifier [74, 13] - [74, 17]))
|
|
arguments: (arguments [74, 17] - [74, 79]
|
|
(object [74, 18] - [74, 73]
|
|
(pair [74, 20] - [74, 71]
|
|
key: (property_identifier [74, 20] - [74, 25])
|
|
value: (binary_expression [74, 27] - [74, 71]
|
|
left: (member_expression [74, 27] - [74, 38]
|
|
object: (identifier [74, 27] - [74, 30])
|
|
property: (property_identifier [74, 31] - [74, 38]))
|
|
right: (string [74, 42] - [74, 71]
|
|
(string_fragment [74, 43] - [74, 70])))))
|
|
(number [74, 75] - [74, 78]))))))))))))
|
|
(comment [78, 0] - [78, 60])
|
|
(comment [79, 0] - [79, 40])
|
|
(comment [80, 0] - [80, 60])
|
|
(expression_statement [81, 0] - [113, 3]
|
|
(call_expression [81, 0] - [113, 2]
|
|
function: (member_expression [81, 0] - [81, 24]
|
|
object: (identifier [81, 0] - [81, 19])
|
|
property: (property_identifier [81, 20] - [81, 24]))
|
|
arguments: (arguments [81, 24] - [113, 2]
|
|
(string [81, 25] - [81, 53]
|
|
(string_fragment [81, 26] - [81, 52]))
|
|
(arrow_function [81, 55] - [113, 1]
|
|
parameters: (formal_parameters [81, 61] - [81, 64]
|
|
(required_parameter [81, 62] - [81, 63]
|
|
pattern: (identifier [81, 62] - [81, 63])))
|
|
body: (statement_block [81, 68] - [113, 1]
|
|
(lexical_declaration [82, 2] - [82, 45]
|
|
(variable_declarator [82, 8] - [82, 44]
|
|
name: (identifier [82, 8] - [82, 12])
|
|
value: (await_expression [82, 15] - [82, 44]
|
|
(call_expression [82, 21] - [82, 44]
|
|
function: (identifier [82, 21] - [82, 41])
|
|
arguments: (arguments [82, 41] - [82, 44]
|
|
(identifier [82, 42] - [82, 43]))))))
|
|
(if_statement [83, 2] - [83, 59]
|
|
condition: (parenthesized_expression [83, 5] - [83, 12]
|
|
(unary_expression [83, 6] - [83, 11]
|
|
argument: (identifier [83, 7] - [83, 11])))
|
|
consequence: (return_statement [83, 13] - [83, 59]
|
|
(call_expression [83, 20] - [83, 58]
|
|
function: (member_expression [83, 20] - [83, 26]
|
|
object: (identifier [83, 20] - [83, 21])
|
|
property: (property_identifier [83, 22] - [83, 26]))
|
|
arguments: (arguments [83, 26] - [83, 58]
|
|
(object [83, 27] - [83, 52]
|
|
(pair [83, 29] - [83, 50]
|
|
key: (property_identifier [83, 29] - [83, 34])
|
|
value: (string [83, 36] - [83, 50]
|
|
(string_fragment [83, 37] - [83, 49]))))
|
|
(number [83, 54] - [83, 57])))))
|
|
(if_statement [85, 2] - [87, 3]
|
|
condition: (parenthesized_expression [85, 5] - [85, 38]
|
|
(unary_expression [85, 6] - [85, 37]
|
|
argument: (call_expression [85, 7] - [85, 37]
|
|
function: (identifier [85, 7] - [85, 15])
|
|
arguments: (arguments [85, 15] - [85, 37]
|
|
(identifier [85, 16] - [85, 20])
|
|
(string [85, 22] - [85, 36]
|
|
(string_fragment [85, 23] - [85, 35]))))))
|
|
consequence: (statement_block [85, 39] - [87, 3]
|
|
(return_statement [86, 4] - [86, 68]
|
|
(call_expression [86, 11] - [86, 67]
|
|
function: (member_expression [86, 11] - [86, 17]
|
|
object: (identifier [86, 11] - [86, 12])
|
|
property: (property_identifier [86, 13] - [86, 17]))
|
|
arguments: (arguments [86, 17] - [86, 67]
|
|
(object [86, 18] - [86, 61]
|
|
(pair [86, 20] - [86, 59]
|
|
key: (property_identifier [86, 20] - [86, 25])
|
|
value: (string [86, 27] - [86, 59]
|
|
(string_fragment [86, 28] - [86, 58]))))
|
|
(number [86, 63] - [86, 66]))))))
|
|
(lexical_declaration [89, 2] - [89, 36]
|
|
(variable_declarator [89, 8] - [89, 35]
|
|
name: (identifier [89, 8] - [89, 15])
|
|
value: (call_expression [89, 18] - [89, 35]
|
|
function: (member_expression [89, 18] - [89, 29]
|
|
object: (member_expression [89, 18] - [89, 23]
|
|
object: (identifier [89, 18] - [89, 19])
|
|
property: (property_identifier [89, 20] - [89, 23]))
|
|
property: (property_identifier [89, 24] - [89, 29]))
|
|
arguments: (arguments [89, 29] - [89, 35]
|
|
(string [89, 30] - [89, 34]
|
|
(string_fragment [89, 31] - [89, 33]))))))
|
|
(lexical_declaration [90, 2] - [90, 51]
|
|
(variable_declarator [90, 8] - [90, 50]
|
|
name: (identifier [90, 8] - [90, 15])
|
|
value: (await_expression [90, 18] - [90, 50]
|
|
(call_expression [90, 24] - [90, 50]
|
|
function: (identifier [90, 24] - [90, 37])
|
|
arguments: (arguments [90, 37] - [90, 50]
|
|
(member_expression [90, 38] - [90, 49]
|
|
object: (identifier [90, 38] - [90, 42])
|
|
property: (property_identifier [90, 43] - [90, 49])))))))
|
|
(lexical_declaration [91, 2] - [91, 79]
|
|
(variable_declarator [91, 8] - [91, 78]
|
|
name: (identifier [91, 8] - [91, 16])
|
|
value: (await_expression [91, 19] - [91, 78]
|
|
(call_expression [91, 25] - [91, 78]
|
|
function: (member_expression [91, 25] - [91, 47]
|
|
object: (identifier [91, 25] - [91, 32])
|
|
property: (property_identifier [91, 33] - [91, 47]))
|
|
arguments: (arguments [91, 47] - [91, 78]
|
|
(identifier [91, 48] - [91, 55])
|
|
(member_expression [91, 57] - [91, 68]
|
|
object: (identifier [91, 57] - [91, 61])
|
|
property: (property_identifier [91, 62] - [91, 68]))
|
|
(identifier [91, 70] - [91, 77]))))))
|
|
(if_statement [93, 2] - [98, 3]
|
|
condition: (parenthesized_expression [93, 5] - [93, 16]
|
|
(unary_expression [93, 6] - [93, 15]
|
|
argument: (identifier [93, 7] - [93, 15])))
|
|
consequence: (statement_block [93, 17] - [98, 3]
|
|
(return_statement [94, 4] - [97, 6]
|
|
(call_expression [94, 11] - [97, 5]
|
|
function: (member_expression [94, 11] - [94, 17]
|
|
object: (identifier [94, 11] - [94, 12])
|
|
property: (property_identifier [94, 13] - [94, 17]))
|
|
arguments: (arguments [94, 17] - [97, 5]
|
|
(object [95, 6] - [95, 61]
|
|
(pair [95, 8] - [95, 59]
|
|
key: (property_identifier [95, 8] - [95, 13])
|
|
value: (string [95, 15] - [95, 59]
|
|
(string_fragment [95, 16] - [95, 58]))))
|
|
(number [96, 6] - [96, 9]))))))
|
|
(expression_statement [100, 2] - [106, 4]
|
|
(call_expression [100, 2] - [106, 3]
|
|
function: (member_expression [100, 2] - [100, 23]
|
|
object: (identifier [100, 2] - [100, 14])
|
|
property: (property_identifier [100, 15] - [100, 23]))
|
|
arguments: (arguments [100, 23] - [106, 3]
|
|
(member_expression [101, 4] - [101, 15]
|
|
object: (identifier [101, 4] - [101, 8])
|
|
property: (property_identifier [101, 9] - [101, 15]))
|
|
(string [102, 4] - [102, 27]
|
|
(string_fragment [102, 5] - [102, 26]))
|
|
(identifier [103, 4] - [103, 11])
|
|
(object [104, 4] - [104, 58]
|
|
(pair [104, 6] - [104, 31]
|
|
key: (property_identifier [104, 6] - [104, 13])
|
|
value: (member_expression [104, 15] - [104, 31]
|
|
object: (identifier [104, 15] - [104, 23])
|
|
property: (property_identifier [104, 24] - [104, 31])))
|
|
(pair [104, 33] - [104, 56]
|
|
key: (property_identifier [104, 33] - [104, 41])
|
|
value: (member_expression [104, 43] - [104, 56]
|
|
object: (identifier [104, 43] - [104, 51])
|
|
property: (property_identifier [104, 52] - [104, 56]))))
|
|
(call_expression [105, 4] - [105, 18]
|
|
function: (identifier [105, 4] - [105, 15])
|
|
arguments: (arguments [105, 15] - [105, 18]
|
|
(identifier [105, 16] - [105, 17]))))))
|
|
(return_statement [108, 2] - [112, 5]
|
|
(call_expression [108, 9] - [112, 4]
|
|
function: (member_expression [108, 9] - [108, 15]
|
|
object: (identifier [108, 9] - [108, 10])
|
|
property: (property_identifier [108, 11] - [108, 15]))
|
|
arguments: (arguments [108, 15] - [112, 4]
|
|
(object [108, 16] - [112, 3]
|
|
(pair [109, 4] - [109, 17]
|
|
key: (property_identifier [109, 4] - [109, 11])
|
|
value: (true [109, 13] - [109, 17]))
|
|
(pair [110, 4] - [110, 29]
|
|
key: (property_identifier [110, 4] - [110, 11])
|
|
value: (member_expression [110, 13] - [110, 29]
|
|
object: (identifier [110, 13] - [110, 21])
|
|
property: (property_identifier [110, 22] - [110, 29])))
|
|
(pair [111, 4] - [111, 23]
|
|
key: (property_identifier [111, 4] - [111, 8])
|
|
value: (member_expression [111, 10] - [111, 23]
|
|
object: (identifier [111, 10] - [111, 18])
|
|
property: (property_identifier [111, 19] - [111, 23]))))))))))))
|
|
(comment [115, 0] - [115, 60])
|
|
(comment [116, 0] - [116, 28])
|
|
(comment [117, 0] - [117, 60])
|
|
(expression_statement [118, 0] - [151, 3]
|
|
(call_expression [118, 0] - [151, 2]
|
|
function: (member_expression [118, 0] - [118, 24]
|
|
object: (identifier [118, 0] - [118, 19])
|
|
property: (property_identifier [118, 20] - [118, 24]))
|
|
arguments: (arguments [118, 24] - [151, 2]
|
|
(string [118, 25] - [118, 49]
|
|
(string_fragment [118, 26] - [118, 48]))
|
|
(arrow_function [118, 51] - [151, 1]
|
|
parameters: (formal_parameters [118, 57] - [118, 60]
|
|
(required_parameter [118, 58] - [118, 59]
|
|
pattern: (identifier [118, 58] - [118, 59])))
|
|
body: (statement_block [118, 64] - [151, 1]
|
|
(lexical_declaration [119, 2] - [119, 45]
|
|
(variable_declarator [119, 8] - [119, 44]
|
|
name: (identifier [119, 8] - [119, 12])
|
|
value: (await_expression [119, 15] - [119, 44]
|
|
(call_expression [119, 21] - [119, 44]
|
|
function: (identifier [119, 21] - [119, 41])
|
|
arguments: (arguments [119, 41] - [119, 44]
|
|
(identifier [119, 42] - [119, 43]))))))
|
|
(if_statement [120, 2] - [120, 59]
|
|
condition: (parenthesized_expression [120, 5] - [120, 12]
|
|
(unary_expression [120, 6] - [120, 11]
|
|
argument: (identifier [120, 7] - [120, 11])))
|
|
consequence: (return_statement [120, 13] - [120, 59]
|
|
(call_expression [120, 20] - [120, 58]
|
|
function: (member_expression [120, 20] - [120, 26]
|
|
object: (identifier [120, 20] - [120, 21])
|
|
property: (property_identifier [120, 22] - [120, 26]))
|
|
arguments: (arguments [120, 26] - [120, 58]
|
|
(object [120, 27] - [120, 52]
|
|
(pair [120, 29] - [120, 50]
|
|
key: (property_identifier [120, 29] - [120, 34])
|
|
value: (string [120, 36] - [120, 50]
|
|
(string_fragment [120, 37] - [120, 49]))))
|
|
(number [120, 54] - [120, 57])))))
|
|
(if_statement [122, 2] - [124, 3]
|
|
condition: (parenthesized_expression [122, 5] - [122, 38]
|
|
(unary_expression [122, 6] - [122, 37]
|
|
argument: (call_expression [122, 7] - [122, 37]
|
|
function: (identifier [122, 7] - [122, 15])
|
|
arguments: (arguments [122, 15] - [122, 37]
|
|
(identifier [122, 16] - [122, 20])
|
|
(string [122, 22] - [122, 36]
|
|
(string_fragment [122, 23] - [122, 35]))))))
|
|
consequence: (statement_block [122, 39] - [124, 3]
|
|
(return_statement [123, 4] - [123, 68]
|
|
(call_expression [123, 11] - [123, 67]
|
|
function: (member_expression [123, 11] - [123, 17]
|
|
object: (identifier [123, 11] - [123, 12])
|
|
property: (property_identifier [123, 13] - [123, 17]))
|
|
arguments: (arguments [123, 17] - [123, 67]
|
|
(object [123, 18] - [123, 61]
|
|
(pair [123, 20] - [123, 59]
|
|
key: (property_identifier [123, 20] - [123, 25])
|
|
value: (string [123, 27] - [123, 59]
|
|
(string_fragment [123, 28] - [123, 58]))))
|
|
(number [123, 63] - [123, 66]))))))
|
|
(lexical_declaration [126, 2] - [126, 36]
|
|
(variable_declarator [126, 8] - [126, 35]
|
|
name: (identifier [126, 8] - [126, 15])
|
|
value: (call_expression [126, 18] - [126, 35]
|
|
function: (member_expression [126, 18] - [126, 29]
|
|
object: (member_expression [126, 18] - [126, 23]
|
|
object: (identifier [126, 18] - [126, 19])
|
|
property: (property_identifier [126, 20] - [126, 23]))
|
|
property: (property_identifier [126, 24] - [126, 29]))
|
|
arguments: (arguments [126, 29] - [126, 35]
|
|
(string [126, 30] - [126, 34]
|
|
(string_fragment [126, 31] - [126, 33]))))))
|
|
(lexical_declaration [127, 2] - [127, 65]
|
|
(variable_declarator [127, 8] - [127, 64]
|
|
name: (identifier [127, 8] - [127, 12])
|
|
value: (await_expression [127, 15] - [127, 64]
|
|
(call_expression [127, 21] - [127, 64]
|
|
function: (member_expression [127, 21] - [127, 39]
|
|
object: (call_expression [127, 21] - [127, 33]
|
|
function: (member_expression [127, 21] - [127, 31]
|
|
object: (member_expression [127, 21] - [127, 26]
|
|
object: (identifier [127, 21] - [127, 22])
|
|
property: (property_identifier [127, 23] - [127, 26]))
|
|
property: (property_identifier [127, 27] - [127, 31]))
|
|
arguments: (arguments [127, 31] - [127, 33]))
|
|
property: (property_identifier [127, 34] - [127, 39]))
|
|
arguments: (arguments [127, 39] - [127, 64]
|
|
(arrow_function [127, 40] - [127, 63]
|
|
parameters: (formal_parameters [127, 40] - [127, 42])
|
|
body: (parenthesized_expression [127, 46] - [127, 63]
|
|
(object [127, 47] - [127, 62]
|
|
(pair [127, 49] - [127, 60]
|
|
key: (property_identifier [127, 49] - [127, 57])
|
|
value: (number [127, 59] - [127, 60]))))))))))
|
|
(lexical_declaration [128, 2] - [128, 59]
|
|
(variable_declarator [128, 8] - [128, 58]
|
|
name: (identifier [128, 8] - [128, 16])
|
|
value: (call_expression [128, 19] - [128, 58]
|
|
function: (member_expression [128, 19] - [128, 27]
|
|
object: (identifier [128, 19] - [128, 23])
|
|
property: (property_identifier [128, 24] - [128, 27]))
|
|
arguments: (arguments [128, 27] - [128, 58]
|
|
(binary_expression [128, 28] - [128, 54]
|
|
left: (call_expression [128, 28] - [128, 49]
|
|
function: (identifier [128, 28] - [128, 34])
|
|
arguments: (arguments [128, 34] - [128, 49]
|
|
(member_expression [128, 35] - [128, 48]
|
|
object: (identifier [128, 35] - [128, 39])
|
|
property: (property_identifier [128, 40] - [128, 48]))))
|
|
right: (number [128, 53] - [128, 54]))
|
|
(number [128, 56] - [128, 57])))))
|
|
(lexical_declaration [129, 2] - [129, 51]
|
|
(variable_declarator [129, 8] - [129, 50]
|
|
name: (identifier [129, 8] - [129, 15])
|
|
value: (await_expression [129, 18] - [129, 50]
|
|
(call_expression [129, 24] - [129, 50]
|
|
function: (identifier [129, 24] - [129, 37])
|
|
arguments: (arguments [129, 37] - [129, 50]
|
|
(member_expression [129, 38] - [129, 49]
|
|
object: (identifier [129, 38] - [129, 42])
|
|
property: (property_identifier [129, 43] - [129, 49])))))))
|
|
(lexical_declaration [131, 2] - [136, 4]
|
|
(variable_declarator [131, 8] - [136, 3]
|
|
name: (identifier [131, 8] - [131, 16])
|
|
value: (await_expression [131, 19] - [136, 3]
|
|
(call_expression [131, 25] - [136, 3]
|
|
function: (member_expression [131, 25] - [131, 49]
|
|
object: (identifier [131, 25] - [131, 32])
|
|
property: (property_identifier [131, 33] - [131, 49]))
|
|
arguments: (arguments [131, 49] - [136, 3]
|
|
(identifier [132, 4] - [132, 11])
|
|
(identifier [133, 4] - [133, 12])
|
|
(member_expression [134, 4] - [134, 15]
|
|
object: (identifier [134, 4] - [134, 8])
|
|
property: (property_identifier [134, 9] - [134, 15]))
|
|
(identifier [135, 4] - [135, 11]))))))
|
|
(if_statement [138, 2] - [143, 3]
|
|
condition: (parenthesized_expression [138, 5] - [138, 24]
|
|
(binary_expression [138, 6] - [138, 23]
|
|
left: (identifier [138, 6] - [138, 14])
|
|
right: (null [138, 19] - [138, 23])))
|
|
consequence: (statement_block [138, 25] - [143, 3]
|
|
(return_statement [139, 4] - [142, 6]
|
|
(call_expression [139, 11] - [142, 5]
|
|
function: (member_expression [139, 11] - [139, 17]
|
|
object: (identifier [139, 11] - [139, 12])
|
|
property: (property_identifier [139, 13] - [139, 17]))
|
|
arguments: (arguments [139, 17] - [142, 5]
|
|
(object [140, 6] - [140, 61]
|
|
(pair [140, 8] - [140, 59]
|
|
key: (property_identifier [140, 8] - [140, 13])
|
|
value: (string [140, 15] - [140, 59]
|
|
(string_fragment [140, 16] - [140, 58]))))
|
|
(number [141, 6] - [141, 9]))))))
|
|
(expression_statement [145, 2] - [148, 21]
|
|
(call_expression [145, 2] - [148, 20]
|
|
function: (member_expression [145, 2] - [145, 23]
|
|
object: (identifier [145, 2] - [145, 14])
|
|
property: (property_identifier [145, 15] - [145, 23]))
|
|
arguments: (arguments [145, 23] - [148, 20]
|
|
(member_expression [145, 24] - [145, 35]
|
|
object: (identifier [145, 24] - [145, 28])
|
|
property: (property_identifier [145, 29] - [145, 35]))
|
|
(string [145, 37] - [145, 59]
|
|
(string_fragment [145, 38] - [145, 58]))
|
|
(identifier [145, 61] - [145, 68])
|
|
(object [145, 70] - [148, 3]
|
|
(pair [146, 4] - [146, 19]
|
|
key: (property_identifier [146, 4] - [146, 9])
|
|
value: (identifier [146, 11] - [146, 19]))
|
|
(pair [147, 4] - [147, 20]
|
|
key: (property_identifier [147, 4] - [147, 10])
|
|
value: (identifier [147, 12] - [147, 20])))
|
|
(call_expression [148, 5] - [148, 19]
|
|
function: (identifier [148, 5] - [148, 16])
|
|
arguments: (arguments [148, 16] - [148, 19]
|
|
(identifier [148, 17] - [148, 18]))))))
|
|
(return_statement [150, 2] - [150, 45]
|
|
(call_expression [150, 9] - [150, 44]
|
|
function: (member_expression [150, 9] - [150, 15]
|
|
object: (identifier [150, 9] - [150, 10])
|
|
property: (property_identifier [150, 11] - [150, 15]))
|
|
arguments: (arguments [150, 15] - [150, 44]
|
|
(object [150, 16] - [150, 43]
|
|
(pair [150, 18] - [150, 31]
|
|
key: (property_identifier [150, 18] - [150, 25])
|
|
value: (true [150, 27] - [150, 31]))
|
|
(shorthand_property_identifier [150, 33] - [150, 41]))))))))))
|
|
(comment [153, 0] - [153, 60])
|
|
(comment [154, 0] - [154, 24])
|
|
(comment [155, 0] - [155, 60])
|
|
(expression_statement [156, 0] - [189, 3]
|
|
(call_expression [156, 0] - [189, 2]
|
|
function: (member_expression [156, 0] - [156, 24]
|
|
object: (identifier [156, 0] - [156, 19])
|
|
property: (property_identifier [156, 20] - [156, 24]))
|
|
arguments: (arguments [156, 24] - [189, 2]
|
|
(string [156, 25] - [156, 49]
|
|
(string_fragment [156, 26] - [156, 48]))
|
|
(arrow_function [156, 51] - [189, 1]
|
|
parameters: (formal_parameters [156, 57] - [156, 60]
|
|
(required_parameter [156, 58] - [156, 59]
|
|
pattern: (identifier [156, 58] - [156, 59])))
|
|
body: (statement_block [156, 64] - [189, 1]
|
|
(lexical_declaration [157, 2] - [157, 45]
|
|
(variable_declarator [157, 8] - [157, 44]
|
|
name: (identifier [157, 8] - [157, 12])
|
|
value: (await_expression [157, 15] - [157, 44]
|
|
(call_expression [157, 21] - [157, 44]
|
|
function: (identifier [157, 21] - [157, 41])
|
|
arguments: (arguments [157, 41] - [157, 44]
|
|
(identifier [157, 42] - [157, 43]))))))
|
|
(if_statement [158, 2] - [158, 59]
|
|
condition: (parenthesized_expression [158, 5] - [158, 12]
|
|
(unary_expression [158, 6] - [158, 11]
|
|
argument: (identifier [158, 7] - [158, 11])))
|
|
consequence: (return_statement [158, 13] - [158, 59]
|
|
(call_expression [158, 20] - [158, 58]
|
|
function: (member_expression [158, 20] - [158, 26]
|
|
object: (identifier [158, 20] - [158, 21])
|
|
property: (property_identifier [158, 22] - [158, 26]))
|
|
arguments: (arguments [158, 26] - [158, 58]
|
|
(object [158, 27] - [158, 52]
|
|
(pair [158, 29] - [158, 50]
|
|
key: (property_identifier [158, 29] - [158, 34])
|
|
value: (string [158, 36] - [158, 50]
|
|
(string_fragment [158, 37] - [158, 49]))))
|
|
(number [158, 54] - [158, 57])))))
|
|
(if_statement [160, 2] - [162, 3]
|
|
condition: (parenthesized_expression [160, 5] - [160, 38]
|
|
(unary_expression [160, 6] - [160, 37]
|
|
argument: (call_expression [160, 7] - [160, 37]
|
|
function: (identifier [160, 7] - [160, 15])
|
|
arguments: (arguments [160, 15] - [160, 37]
|
|
(identifier [160, 16] - [160, 20])
|
|
(string [160, 22] - [160, 36]
|
|
(string_fragment [160, 23] - [160, 35]))))))
|
|
consequence: (statement_block [160, 39] - [162, 3]
|
|
(return_statement [161, 4] - [161, 68]
|
|
(call_expression [161, 11] - [161, 67]
|
|
function: (member_expression [161, 11] - [161, 17]
|
|
object: (identifier [161, 11] - [161, 12])
|
|
property: (property_identifier [161, 13] - [161, 17]))
|
|
arguments: (arguments [161, 17] - [161, 67]
|
|
(object [161, 18] - [161, 61]
|
|
(pair [161, 20] - [161, 59]
|
|
key: (property_identifier [161, 20] - [161, 25])
|
|
value: (string [161, 27] - [161, 59]
|
|
(string_fragment [161, 28] - [161, 58]))))
|
|
(number [161, 63] - [161, 66]))))))
|
|
(lexical_declaration [164, 2] - [164, 36]
|
|
(variable_declarator [164, 8] - [164, 35]
|
|
name: (identifier [164, 8] - [164, 15])
|
|
value: (call_expression [164, 18] - [164, 35]
|
|
function: (member_expression [164, 18] - [164, 29]
|
|
object: (member_expression [164, 18] - [164, 23]
|
|
object: (identifier [164, 18] - [164, 19])
|
|
property: (property_identifier [164, 20] - [164, 23]))
|
|
property: (property_identifier [164, 24] - [164, 29]))
|
|
arguments: (arguments [164, 29] - [164, 35]
|
|
(string [164, 30] - [164, 34]
|
|
(string_fragment [164, 31] - [164, 33]))))))
|
|
(lexical_declaration [165, 2] - [165, 68]
|
|
(variable_declarator [165, 8] - [165, 67]
|
|
name: (identifier [165, 8] - [165, 12])
|
|
value: (await_expression [165, 15] - [165, 67]
|
|
(call_expression [165, 21] - [165, 67]
|
|
function: (member_expression [165, 21] - [165, 39]
|
|
object: (call_expression [165, 21] - [165, 33]
|
|
function: (member_expression [165, 21] - [165, 31]
|
|
object: (member_expression [165, 21] - [165, 26]
|
|
object: (identifier [165, 21] - [165, 22])
|
|
property: (property_identifier [165, 23] - [165, 26]))
|
|
property: (property_identifier [165, 27] - [165, 31]))
|
|
arguments: (arguments [165, 31] - [165, 33]))
|
|
property: (property_identifier [165, 34] - [165, 39]))
|
|
arguments: (arguments [165, 39] - [165, 67]
|
|
(arrow_function [165, 40] - [165, 66]
|
|
parameters: (formal_parameters [165, 40] - [165, 42])
|
|
body: (parenthesized_expression [165, 46] - [165, 66]
|
|
(object [165, 47] - [165, 65]
|
|
(pair [165, 49] - [165, 63]
|
|
key: (property_identifier [165, 49] - [165, 60])
|
|
value: (number [165, 62] - [165, 63]))))))))))
|
|
(lexical_declaration [166, 2] - [166, 65]
|
|
(variable_declarator [166, 8] - [166, 64]
|
|
name: (identifier [166, 8] - [166, 19])
|
|
value: (call_expression [166, 22] - [166, 64]
|
|
function: (member_expression [166, 22] - [166, 30]
|
|
object: (identifier [166, 22] - [166, 26])
|
|
property: (property_identifier [166, 27] - [166, 30]))
|
|
arguments: (arguments [166, 30] - [166, 64]
|
|
(binary_expression [166, 31] - [166, 60]
|
|
left: (call_expression [166, 31] - [166, 55]
|
|
function: (identifier [166, 31] - [166, 37])
|
|
arguments: (arguments [166, 37] - [166, 55]
|
|
(member_expression [166, 38] - [166, 54]
|
|
object: (identifier [166, 38] - [166, 42])
|
|
property: (property_identifier [166, 43] - [166, 54]))))
|
|
right: (number [166, 59] - [166, 60]))
|
|
(number [166, 62] - [166, 63])))))
|
|
(lexical_declaration [167, 2] - [167, 51]
|
|
(variable_declarator [167, 8] - [167, 50]
|
|
name: (identifier [167, 8] - [167, 15])
|
|
value: (await_expression [167, 18] - [167, 50]
|
|
(call_expression [167, 24] - [167, 50]
|
|
function: (identifier [167, 24] - [167, 37])
|
|
arguments: (arguments [167, 37] - [167, 50]
|
|
(member_expression [167, 38] - [167, 49]
|
|
object: (identifier [167, 38] - [167, 42])
|
|
property: (property_identifier [167, 43] - [167, 49])))))))
|
|
(lexical_declaration [169, 2] - [174, 4]
|
|
(variable_declarator [169, 8] - [174, 3]
|
|
name: (identifier [169, 8] - [169, 14])
|
|
value: (await_expression [169, 17] - [174, 3]
|
|
(call_expression [169, 23] - [174, 3]
|
|
function: (member_expression [169, 23] - [169, 50]
|
|
object: (identifier [169, 23] - [169, 30])
|
|
property: (property_identifier [169, 31] - [169, 50]))
|
|
arguments: (arguments [169, 50] - [174, 3]
|
|
(identifier [170, 4] - [170, 11])
|
|
(identifier [171, 4] - [171, 15])
|
|
(member_expression [172, 4] - [172, 15]
|
|
object: (identifier [172, 4] - [172, 8])
|
|
property: (property_identifier [172, 9] - [172, 15]))
|
|
(identifier [173, 4] - [173, 11]))))))
|
|
(if_statement [176, 2] - [181, 3]
|
|
condition: (parenthesized_expression [176, 5] - [176, 14]
|
|
(unary_expression [176, 6] - [176, 13]
|
|
argument: (identifier [176, 7] - [176, 13])))
|
|
consequence: (statement_block [176, 15] - [181, 3]
|
|
(return_statement [177, 4] - [180, 6]
|
|
(call_expression [177, 11] - [180, 5]
|
|
function: (member_expression [177, 11] - [177, 17]
|
|
object: (identifier [177, 11] - [177, 12])
|
|
property: (property_identifier [177, 13] - [177, 17]))
|
|
arguments: (arguments [177, 17] - [180, 5]
|
|
(object [178, 6] - [178, 61]
|
|
(pair [178, 8] - [178, 59]
|
|
key: (property_identifier [178, 8] - [178, 13])
|
|
value: (string [178, 15] - [178, 59]
|
|
(string_fragment [178, 16] - [178, 58]))))
|
|
(number [179, 6] - [179, 9]))))))
|
|
(expression_statement [183, 2] - [186, 21]
|
|
(call_expression [183, 2] - [186, 20]
|
|
function: (member_expression [183, 2] - [183, 23]
|
|
object: (identifier [183, 2] - [183, 14])
|
|
property: (property_identifier [183, 15] - [183, 23]))
|
|
arguments: (arguments [183, 23] - [186, 20]
|
|
(member_expression [183, 24] - [183, 35]
|
|
object: (identifier [183, 24] - [183, 28])
|
|
property: (property_identifier [183, 29] - [183, 35]))
|
|
(string [183, 37] - [183, 53]
|
|
(string_fragment [183, 38] - [183, 52]))
|
|
(identifier [183, 55] - [183, 62])
|
|
(object [183, 64] - [186, 3]
|
|
(pair [184, 4] - [184, 34]
|
|
key: (property_identifier [184, 4] - [184, 21])
|
|
value: (identifier [184, 23] - [184, 34]))
|
|
(pair [185, 4] - [185, 37]
|
|
key: (property_identifier [185, 4] - [185, 18])
|
|
value: (member_expression [185, 20] - [185, 37]
|
|
object: (identifier [185, 20] - [185, 26])
|
|
property: (property_identifier [185, 27] - [185, 37]))))
|
|
(call_expression [186, 5] - [186, 19]
|
|
function: (identifier [186, 5] - [186, 16])
|
|
arguments: (arguments [186, 16] - [186, 19]
|
|
(identifier [186, 17] - [186, 18]))))))
|
|
(return_statement [188, 2] - [188, 68]
|
|
(call_expression [188, 9] - [188, 67]
|
|
function: (member_expression [188, 9] - [188, 15]
|
|
object: (identifier [188, 9] - [188, 10])
|
|
property: (property_identifier [188, 11] - [188, 15]))
|
|
arguments: (arguments [188, 15] - [188, 67]
|
|
(object [188, 16] - [188, 66]
|
|
(pair [188, 18] - [188, 31]
|
|
key: (property_identifier [188, 18] - [188, 25])
|
|
value: (true [188, 27] - [188, 31]))
|
|
(pair [188, 33] - [188, 64]
|
|
key: (property_identifier [188, 33] - [188, 45])
|
|
value: (member_expression [188, 47] - [188, 64]
|
|
object: (identifier [188, 47] - [188, 53])
|
|
property: (property_identifier [188, 54] - [188, 64]))))))))))))
|
|
(comment [191, 0] - [191, 60])
|
|
(comment [192, 0] - [192, 46])
|
|
(comment [193, 0] - [193, 60])
|
|
(expression_statement [194, 0] - [226, 3]
|
|
(call_expression [194, 0] - [226, 2]
|
|
function: (member_expression [194, 0] - [194, 23]
|
|
object: (identifier [194, 0] - [194, 19])
|
|
property: (property_identifier [194, 20] - [194, 23]))
|
|
arguments: (arguments [194, 23] - [226, 2]
|
|
(string [194, 24] - [194, 51]
|
|
(string_fragment [194, 25] - [194, 50]))
|
|
(arrow_function [194, 53] - [226, 1]
|
|
parameters: (formal_parameters [194, 59] - [194, 62]
|
|
(required_parameter [194, 60] - [194, 61]
|
|
pattern: (identifier [194, 60] - [194, 61])))
|
|
body: (statement_block [194, 66] - [226, 1]
|
|
(lexical_declaration [195, 2] - [195, 45]
|
|
(variable_declarator [195, 8] - [195, 44]
|
|
name: (identifier [195, 8] - [195, 12])
|
|
value: (await_expression [195, 15] - [195, 44]
|
|
(call_expression [195, 21] - [195, 44]
|
|
function: (identifier [195, 21] - [195, 41])
|
|
arguments: (arguments [195, 41] - [195, 44]
|
|
(identifier [195, 42] - [195, 43]))))))
|
|
(if_statement [196, 2] - [196, 59]
|
|
condition: (parenthesized_expression [196, 5] - [196, 12]
|
|
(unary_expression [196, 6] - [196, 11]
|
|
argument: (identifier [196, 7] - [196, 11])))
|
|
consequence: (return_statement [196, 13] - [196, 59]
|
|
(call_expression [196, 20] - [196, 58]
|
|
function: (member_expression [196, 20] - [196, 26]
|
|
object: (identifier [196, 20] - [196, 21])
|
|
property: (property_identifier [196, 22] - [196, 26]))
|
|
arguments: (arguments [196, 26] - [196, 58]
|
|
(object [196, 27] - [196, 52]
|
|
(pair [196, 29] - [196, 50]
|
|
key: (property_identifier [196, 29] - [196, 34])
|
|
value: (string [196, 36] - [196, 50]
|
|
(string_fragment [196, 37] - [196, 49]))))
|
|
(number [196, 54] - [196, 57])))))
|
|
(if_statement [198, 2] - [200, 3]
|
|
condition: (parenthesized_expression [198, 5] - [198, 37]
|
|
(unary_expression [198, 6] - [198, 36]
|
|
argument: (call_expression [198, 7] - [198, 36]
|
|
function: (identifier [198, 7] - [198, 15])
|
|
arguments: (arguments [198, 15] - [198, 36]
|
|
(identifier [198, 16] - [198, 20])
|
|
(string [198, 22] - [198, 35]
|
|
(string_fragment [198, 23] - [198, 34]))))))
|
|
consequence: (statement_block [198, 38] - [200, 3]
|
|
(return_statement [199, 4] - [199, 68]
|
|
(call_expression [199, 11] - [199, 67]
|
|
function: (member_expression [199, 11] - [199, 17]
|
|
object: (identifier [199, 11] - [199, 12])
|
|
property: (property_identifier [199, 13] - [199, 17]))
|
|
arguments: (arguments [199, 17] - [199, 67]
|
|
(object [199, 18] - [199, 61]
|
|
(pair [199, 20] - [199, 59]
|
|
key: (property_identifier [199, 20] - [199, 25])
|
|
value: (string [199, 27] - [199, 59]
|
|
(string_fragment [199, 28] - [199, 58]))))
|
|
(number [199, 63] - [199, 66]))))))
|
|
(lexical_declaration [202, 2] - [202, 36]
|
|
(variable_declarator [202, 8] - [202, 35]
|
|
name: (identifier [202, 8] - [202, 15])
|
|
value: (call_expression [202, 18] - [202, 35]
|
|
function: (member_expression [202, 18] - [202, 29]
|
|
object: (member_expression [202, 18] - [202, 23]
|
|
object: (identifier [202, 18] - [202, 19])
|
|
property: (property_identifier [202, 20] - [202, 23]))
|
|
property: (property_identifier [202, 24] - [202, 29]))
|
|
arguments: (arguments [202, 29] - [202, 35]
|
|
(string [202, 30] - [202, 34]
|
|
(string_fragment [202, 31] - [202, 33]))))))
|
|
(lexical_declaration [203, 2] - [203, 51]
|
|
(variable_declarator [203, 8] - [203, 50]
|
|
name: (identifier [203, 8] - [203, 15])
|
|
value: (await_expression [203, 18] - [203, 50]
|
|
(call_expression [203, 24] - [203, 50]
|
|
function: (identifier [203, 24] - [203, 37])
|
|
arguments: (arguments [203, 37] - [203, 50]
|
|
(member_expression [203, 38] - [203, 49]
|
|
object: (identifier [203, 38] - [203, 42])
|
|
property: (property_identifier [203, 43] - [203, 49])))))))
|
|
(lexical_declaration [204, 2] - [208, 4]
|
|
(variable_declarator [204, 8] - [208, 3]
|
|
name: (identifier [204, 8] - [204, 12])
|
|
value: (await_expression [204, 15] - [208, 3]
|
|
(call_expression [204, 21] - [208, 3]
|
|
function: (member_expression [204, 21] - [204, 50]
|
|
object: (identifier [204, 21] - [204, 28])
|
|
property: (property_identifier [204, 29] - [204, 50]))
|
|
arguments: (arguments [204, 50] - [208, 3]
|
|
(identifier [205, 4] - [205, 11])
|
|
(member_expression [206, 4] - [206, 15]
|
|
object: (identifier [206, 4] - [206, 8])
|
|
property: (property_identifier [206, 9] - [206, 15]))
|
|
(identifier [207, 4] - [207, 11]))))))
|
|
(if_statement [210, 2] - [212, 3]
|
|
condition: (parenthesized_expression [210, 5] - [210, 12]
|
|
(unary_expression [210, 6] - [210, 11]
|
|
argument: (identifier [210, 7] - [210, 11])))
|
|
consequence: (statement_block [210, 13] - [212, 3]
|
|
(return_statement [211, 4] - [211, 69]
|
|
(call_expression [211, 11] - [211, 68]
|
|
function: (member_expression [211, 11] - [211, 17]
|
|
object: (identifier [211, 11] - [211, 12])
|
|
property: (property_identifier [211, 13] - [211, 17]))
|
|
arguments: (arguments [211, 17] - [211, 68]
|
|
(object [211, 18] - [211, 62]
|
|
(pair [211, 20] - [211, 60]
|
|
key: (property_identifier [211, 20] - [211, 25])
|
|
value: (string [211, 27] - [211, 60]
|
|
(string_fragment [211, 28] - [211, 59]))))
|
|
(number [211, 64] - [211, 67]))))))
|
|
(return_statement [214, 2] - [225, 5]
|
|
(call_expression [214, 9] - [225, 4]
|
|
function: (member_expression [214, 9] - [214, 15]
|
|
object: (identifier [214, 9] - [214, 10])
|
|
property: (property_identifier [214, 11] - [214, 15]))
|
|
arguments: (arguments [214, 15] - [225, 4]
|
|
(object [214, 16] - [225, 3]
|
|
(pair [215, 4] - [215, 17]
|
|
key: (property_identifier [215, 4] - [215, 11])
|
|
value: (true [215, 13] - [215, 17]))
|
|
(pair [216, 4] - [216, 29]
|
|
key: (property_identifier [216, 4] - [216, 13])
|
|
value: (member_expression [216, 15] - [216, 29]
|
|
object: (identifier [216, 15] - [216, 19])
|
|
property: (property_identifier [216, 20] - [216, 29])))
|
|
(pair [217, 4] - [224, 5]
|
|
key: (property_identifier [217, 4] - [217, 9])
|
|
value: (object [217, 11] - [224, 5]
|
|
(pair [218, 6] - [218, 23]
|
|
key: (property_identifier [218, 6] - [218, 8])
|
|
value: (member_expression [218, 10] - [218, 23]
|
|
object: (member_expression [218, 10] - [218, 20]
|
|
object: (identifier [218, 10] - [218, 14])
|
|
property: (property_identifier [218, 15] - [218, 20]))
|
|
property: (property_identifier [218, 21] - [218, 23])))
|
|
(pair [219, 6] - [219, 27]
|
|
key: (property_identifier [219, 6] - [219, 10])
|
|
value: (member_expression [219, 12] - [219, 27]
|
|
object: (member_expression [219, 12] - [219, 22]
|
|
object: (identifier [219, 12] - [219, 16])
|
|
property: (property_identifier [219, 17] - [219, 22]))
|
|
property: (property_identifier [219, 23] - [219, 27])))
|
|
(pair [220, 6] - [220, 27]
|
|
key: (property_identifier [220, 6] - [220, 10])
|
|
value: (member_expression [220, 12] - [220, 27]
|
|
object: (member_expression [220, 12] - [220, 22]
|
|
object: (identifier [220, 12] - [220, 16])
|
|
property: (property_identifier [220, 17] - [220, 22]))
|
|
property: (property_identifier [220, 23] - [220, 27])))
|
|
(pair [221, 6] - [221, 37]
|
|
key: (property_identifier [221, 6] - [221, 15])
|
|
value: (member_expression [221, 17] - [221, 37]
|
|
object: (member_expression [221, 17] - [221, 27]
|
|
object: (identifier [221, 17] - [221, 21])
|
|
property: (property_identifier [221, 22] - [221, 27]))
|
|
property: (property_identifier [221, 28] - [221, 37])))
|
|
(pair [222, 6] - [222, 45]
|
|
key: (property_identifier [222, 6] - [222, 19])
|
|
value: (member_expression [222, 21] - [222, 45]
|
|
object: (member_expression [222, 21] - [222, 31]
|
|
object: (identifier [222, 21] - [222, 25])
|
|
property: (property_identifier [222, 26] - [222, 31]))
|
|
property: (property_identifier [222, 32] - [222, 45])))
|
|
(pair [223, 6] - [223, 39]
|
|
key: (property_identifier [223, 6] - [223, 16])
|
|
value: (member_expression [223, 18] - [223, 39]
|
|
object: (member_expression [223, 18] - [223, 28]
|
|
object: (identifier [223, 18] - [223, 22])
|
|
property: (property_identifier [223, 23] - [223, 28]))
|
|
property: (property_identifier [223, 29] - [223, 39]))))))))))))))
|
|
(comment [228, 0] - [228, 60])
|
|
(comment [229, 0] - [229, 52])
|
|
(comment [230, 0] - [230, 60])
|
|
(expression_statement [231, 0] - [256, 3]
|
|
(call_expression [231, 0] - [256, 2]
|
|
function: (member_expression [231, 0] - [231, 24]
|
|
object: (identifier [231, 0] - [231, 19])
|
|
property: (property_identifier [231, 20] - [231, 24]))
|
|
arguments: (arguments [231, 24] - [256, 2]
|
|
(string [231, 25] - [231, 46]
|
|
(string_fragment [231, 26] - [231, 45]))
|
|
(arrow_function [231, 48] - [256, 1]
|
|
parameters: (formal_parameters [231, 54] - [231, 57]
|
|
(required_parameter [231, 55] - [231, 56]
|
|
pattern: (identifier [231, 55] - [231, 56])))
|
|
body: (statement_block [231, 61] - [256, 1]
|
|
(lexical_declaration [232, 2] - [232, 45]
|
|
(variable_declarator [232, 8] - [232, 44]
|
|
name: (identifier [232, 8] - [232, 12])
|
|
value: (await_expression [232, 15] - [232, 44]
|
|
(call_expression [232, 21] - [232, 44]
|
|
function: (identifier [232, 21] - [232, 41])
|
|
arguments: (arguments [232, 41] - [232, 44]
|
|
(identifier [232, 42] - [232, 43]))))))
|
|
(if_statement [233, 2] - [233, 59]
|
|
condition: (parenthesized_expression [233, 5] - [233, 12]
|
|
(unary_expression [233, 6] - [233, 11]
|
|
argument: (identifier [233, 7] - [233, 11])))
|
|
consequence: (return_statement [233, 13] - [233, 59]
|
|
(call_expression [233, 20] - [233, 58]
|
|
function: (member_expression [233, 20] - [233, 26]
|
|
object: (identifier [233, 20] - [233, 21])
|
|
property: (property_identifier [233, 22] - [233, 26]))
|
|
arguments: (arguments [233, 26] - [233, 58]
|
|
(object [233, 27] - [233, 52]
|
|
(pair [233, 29] - [233, 50]
|
|
key: (property_identifier [233, 29] - [233, 34])
|
|
value: (string [233, 36] - [233, 50]
|
|
(string_fragment [233, 37] - [233, 49]))))
|
|
(number [233, 54] - [233, 57])))))
|
|
(if_statement [235, 2] - [237, 3]
|
|
condition: (parenthesized_expression [235, 5] - [235, 38]
|
|
(unary_expression [235, 6] - [235, 37]
|
|
argument: (call_expression [235, 7] - [235, 37]
|
|
function: (identifier [235, 7] - [235, 15])
|
|
arguments: (arguments [235, 15] - [235, 37]
|
|
(identifier [235, 16] - [235, 20])
|
|
(string [235, 22] - [235, 36]
|
|
(string_fragment [235, 23] - [235, 35]))))))
|
|
consequence: (statement_block [235, 39] - [237, 3]
|
|
(return_statement [236, 4] - [236, 68]
|
|
(call_expression [236, 11] - [236, 67]
|
|
function: (member_expression [236, 11] - [236, 17]
|
|
object: (identifier [236, 11] - [236, 12])
|
|
property: (property_identifier [236, 13] - [236, 17]))
|
|
arguments: (arguments [236, 17] - [236, 67]
|
|
(object [236, 18] - [236, 61]
|
|
(pair [236, 20] - [236, 59]
|
|
key: (property_identifier [236, 20] - [236, 25])
|
|
value: (string [236, 27] - [236, 59]
|
|
(string_fragment [236, 28] - [236, 58]))))
|
|
(number [236, 63] - [236, 66]))))))
|
|
(lexical_declaration [239, 2] - [239, 36]
|
|
(variable_declarator [239, 8] - [239, 35]
|
|
name: (identifier [239, 8] - [239, 15])
|
|
value: (call_expression [239, 18] - [239, 35]
|
|
function: (member_expression [239, 18] - [239, 29]
|
|
object: (member_expression [239, 18] - [239, 23]
|
|
object: (identifier [239, 18] - [239, 19])
|
|
property: (property_identifier [239, 20] - [239, 23]))
|
|
property: (property_identifier [239, 24] - [239, 29]))
|
|
arguments: (arguments [239, 29] - [239, 35]
|
|
(string [239, 30] - [239, 34]
|
|
(string_fragment [239, 31] - [239, 33]))))))
|
|
(lexical_declaration [240, 2] - [240, 51]
|
|
(variable_declarator [240, 8] - [240, 50]
|
|
name: (identifier [240, 8] - [240, 15])
|
|
value: (await_expression [240, 18] - [240, 50]
|
|
(call_expression [240, 24] - [240, 50]
|
|
function: (identifier [240, 24] - [240, 37])
|
|
arguments: (arguments [240, 37] - [240, 50]
|
|
(member_expression [240, 38] - [240, 49]
|
|
object: (identifier [240, 38] - [240, 42])
|
|
property: (property_identifier [240, 43] - [240, 49])))))))
|
|
(lexical_declaration [241, 2] - [241, 69]
|
|
(variable_declarator [241, 8] - [241, 68]
|
|
name: (identifier [241, 8] - [241, 12])
|
|
value: (await_expression [241, 15] - [241, 68]
|
|
(call_expression [241, 21] - [241, 68]
|
|
function: (member_expression [241, 21] - [241, 37]
|
|
object: (identifier [241, 21] - [241, 28])
|
|
property: (property_identifier [241, 29] - [241, 37]))
|
|
arguments: (arguments [241, 37] - [241, 68]
|
|
(identifier [241, 38] - [241, 45])
|
|
(member_expression [241, 47] - [241, 58]
|
|
object: (identifier [241, 47] - [241, 51])
|
|
property: (property_identifier [241, 52] - [241, 58]))
|
|
(identifier [241, 60] - [241, 67]))))))
|
|
(if_statement [243, 2] - [245, 3]
|
|
condition: (parenthesized_expression [243, 5] - [243, 12]
|
|
(unary_expression [243, 6] - [243, 11]
|
|
argument: (identifier [243, 7] - [243, 11])))
|
|
consequence: (statement_block [243, 13] - [245, 3]
|
|
(return_statement [244, 4] - [244, 69]
|
|
(call_expression [244, 11] - [244, 68]
|
|
function: (member_expression [244, 11] - [244, 17]
|
|
object: (identifier [244, 11] - [244, 12])
|
|
property: (property_identifier [244, 13] - [244, 17]))
|
|
arguments: (arguments [244, 17] - [244, 68]
|
|
(object [244, 18] - [244, 62]
|
|
(pair [244, 20] - [244, 60]
|
|
key: (property_identifier [244, 20] - [244, 25])
|
|
value: (string [244, 27] - [244, 60]
|
|
(string_fragment [244, 28] - [244, 59]))))
|
|
(number [244, 64] - [244, 67]))))))
|
|
(expression_statement [247, 2] - [253, 4]
|
|
(call_expression [247, 2] - [253, 3]
|
|
function: (member_expression [247, 2] - [247, 23]
|
|
object: (identifier [247, 2] - [247, 14])
|
|
property: (property_identifier [247, 15] - [247, 23]))
|
|
arguments: (arguments [247, 23] - [253, 3]
|
|
(member_expression [248, 4] - [248, 15]
|
|
object: (identifier [248, 4] - [248, 8])
|
|
property: (property_identifier [248, 9] - [248, 15]))
|
|
(string [249, 4] - [249, 17]
|
|
(string_fragment [249, 5] - [249, 16]))
|
|
(identifier [250, 4] - [250, 11])
|
|
(object [251, 4] - [251, 6])
|
|
(call_expression [252, 4] - [252, 18]
|
|
function: (identifier [252, 4] - [252, 15])
|
|
arguments: (arguments [252, 15] - [252, 18]
|
|
(identifier [252, 16] - [252, 17]))))))
|
|
(return_statement [255, 2] - [255, 35]
|
|
(call_expression [255, 9] - [255, 34]
|
|
function: (member_expression [255, 9] - [255, 15]
|
|
object: (identifier [255, 9] - [255, 10])
|
|
property: (property_identifier [255, 11] - [255, 15]))
|
|
arguments: (arguments [255, 15] - [255, 34]
|
|
(object [255, 16] - [255, 33]
|
|
(pair [255, 18] - [255, 31]
|
|
key: (property_identifier [255, 18] - [255, 25])
|
|
value: (true [255, 27] - [255, 31]))))))))))))
|