1554 lines
94 KiB
Plaintext
1554 lines
94 KiB
Plaintext
(program [0, 0] - [307, 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 [2, 0] - [2, 46]
|
|
(import_clause [2, 7] - [2, 17]
|
|
(named_imports [2, 7] - [2, 17]
|
|
(import_specifier [2, 9] - [2, 15]
|
|
name: (identifier [2, 9] - [2, 15]))))
|
|
source: (string [2, 23] - [2, 45]
|
|
(string_fragment [2, 24] - [2, 44])))
|
|
(import_statement [3, 0] - [3, 51]
|
|
(import_clause [3, 7] - [3, 23]
|
|
(named_imports [3, 7] - [3, 23]
|
|
(import_specifier [3, 9] - [3, 21]
|
|
name: (identifier [3, 9] - [3, 21]))))
|
|
source: (string [3, 29] - [3, 50]
|
|
(string_fragment [3, 30] - [3, 49])))
|
|
(import_statement [4, 0] - [4, 55]
|
|
(import_clause [4, 7] - [4, 22]
|
|
(named_imports [4, 7] - [4, 22]
|
|
(import_specifier [4, 9] - [4, 20]
|
|
name: (identifier [4, 9] - [4, 20]))))
|
|
source: (string [4, 28] - [4, 54]
|
|
(string_fragment [4, 29] - [4, 53])))
|
|
(import_statement [5, 0] - [5, 71]
|
|
(import_clause [5, 7] - [5, 41]
|
|
(named_imports [5, 7] - [5, 41]
|
|
(import_specifier [5, 9] - [5, 29]
|
|
name: (identifier [5, 9] - [5, 29]))
|
|
(import_specifier [5, 31] - [5, 39]
|
|
name: (identifier [5, 31] - [5, 39]))))
|
|
source: (string [5, 47] - [5, 70]
|
|
(string_fragment [5, 48] - [5, 69])))
|
|
(import_statement [7, 0] - [17, 22]
|
|
(import_clause [7, 7] - [17, 1]
|
|
(named_imports [7, 7] - [17, 1]
|
|
(import_specifier [8, 2] - [8, 17]
|
|
name: (identifier [8, 2] - [8, 17]))
|
|
(import_specifier [9, 2] - [9, 21]
|
|
name: (identifier [9, 2] - [9, 21]))
|
|
(import_specifier [10, 2] - [10, 19]
|
|
name: (identifier [10, 2] - [10, 19]))
|
|
(import_specifier [11, 2] - [11, 16]
|
|
name: (identifier [11, 2] - [11, 16]))
|
|
(import_specifier [12, 2] - [12, 25]
|
|
name: (identifier [12, 2] - [12, 25]))
|
|
(import_specifier [13, 2] - [13, 30]
|
|
name: (identifier [13, 2] - [13, 30]))
|
|
(import_specifier [14, 2] - [14, 15]
|
|
name: (identifier [14, 2] - [14, 15]))
|
|
(import_specifier [15, 2] - [15, 18]
|
|
name: (identifier [15, 2] - [15, 18]))
|
|
(import_specifier [16, 2] - [16, 21]
|
|
name: (identifier [16, 2] - [16, 21]))))
|
|
source: (string [17, 7] - [17, 21]
|
|
(string_fragment [17, 8] - [17, 20])))
|
|
(export_statement [19, 0] - [19, 47]
|
|
declaration: (lexical_declaration [19, 7] - [19, 47]
|
|
(variable_declarator [19, 13] - [19, 46]
|
|
name: (identifier [19, 13] - [19, 33])
|
|
value: (new_expression [19, 36] - [19, 46]
|
|
constructor: (identifier [19, 40] - [19, 44])
|
|
arguments: (arguments [19, 44] - [19, 46])))))
|
|
(comment [21, 0] - [21, 60])
|
|
(comment [22, 0] - [22, 32])
|
|
(comment [23, 0] - [23, 60])
|
|
(expression_statement [24, 0] - [30, 3]
|
|
(call_expression [24, 0] - [30, 2]
|
|
function: (member_expression [24, 0] - [24, 24]
|
|
object: (identifier [24, 0] - [24, 20])
|
|
property: (property_identifier [24, 21] - [24, 24]))
|
|
arguments: (arguments [24, 24] - [30, 2]
|
|
(string [24, 25] - [24, 40]
|
|
(string_fragment [24, 26] - [24, 39]))
|
|
(arrow_function [24, 42] - [30, 1]
|
|
parameters: (formal_parameters [24, 48] - [24, 51]
|
|
(required_parameter [24, 49] - [24, 50]
|
|
pattern: (identifier [24, 49] - [24, 50])))
|
|
body: (statement_block [24, 55] - [30, 1]
|
|
(lexical_declaration [25, 2] - [25, 45]
|
|
(variable_declarator [25, 8] - [25, 44]
|
|
name: (identifier [25, 8] - [25, 12])
|
|
value: (await_expression [25, 15] - [25, 44]
|
|
(call_expression [25, 21] - [25, 44]
|
|
function: (identifier [25, 21] - [25, 41])
|
|
arguments: (arguments [25, 41] - [25, 44]
|
|
(identifier [25, 42] - [25, 43]))))))
|
|
(if_statement [26, 2] - [26, 59]
|
|
condition: (parenthesized_expression [26, 5] - [26, 12]
|
|
(unary_expression [26, 6] - [26, 11]
|
|
argument: (identifier [26, 7] - [26, 11])))
|
|
consequence: (return_statement [26, 13] - [26, 59]
|
|
(call_expression [26, 20] - [26, 58]
|
|
function: (member_expression [26, 20] - [26, 26]
|
|
object: (identifier [26, 20] - [26, 21])
|
|
property: (property_identifier [26, 22] - [26, 26]))
|
|
arguments: (arguments [26, 26] - [26, 58]
|
|
(object [26, 27] - [26, 52]
|
|
(pair [26, 29] - [26, 50]
|
|
key: (property_identifier [26, 29] - [26, 34])
|
|
value: (string [26, 36] - [26, 50]
|
|
(string_fragment [26, 37] - [26, 49]))))
|
|
(number [26, 54] - [26, 57])))))
|
|
(lexical_declaration [28, 2] - [28, 56]
|
|
(variable_declarator [28, 8] - [28, 55]
|
|
name: (identifier [28, 8] - [28, 16])
|
|
value: (await_expression [28, 19] - [28, 55]
|
|
(call_expression [28, 25] - [28, 55]
|
|
function: (identifier [28, 25] - [28, 42])
|
|
arguments: (arguments [28, 42] - [28, 55]
|
|
(member_expression [28, 43] - [28, 54]
|
|
object: (identifier [28, 43] - [28, 47])
|
|
property: (property_identifier [28, 48] - [28, 54])))))))
|
|
(return_statement [29, 2] - [29, 64]
|
|
(call_expression [29, 9] - [29, 63]
|
|
function: (member_expression [29, 9] - [29, 15]
|
|
object: (identifier [29, 9] - [29, 10])
|
|
property: (property_identifier [29, 11] - [29, 15]))
|
|
arguments: (arguments [29, 15] - [29, 63]
|
|
(object [29, 16] - [29, 62]
|
|
(shorthand_property_identifier [29, 18] - [29, 26])
|
|
(pair [29, 28] - [29, 60]
|
|
key: (property_identifier [29, 28] - [29, 44])
|
|
value: (member_expression [29, 46] - [29, 60]
|
|
object: (identifier [29, 46] - [29, 50])
|
|
property: (property_identifier [29, 51] - [29, 60]))))))))))))
|
|
(comment [32, 0] - [32, 60])
|
|
(comment [33, 0] - [33, 65])
|
|
(comment [34, 0] - [34, 60])
|
|
(expression_statement [35, 0] - [124, 3]
|
|
(call_expression [35, 0] - [124, 2]
|
|
function: (member_expression [35, 0] - [35, 25]
|
|
object: (identifier [35, 0] - [35, 20])
|
|
property: (property_identifier [35, 21] - [35, 25]))
|
|
arguments: (arguments [35, 25] - [124, 2]
|
|
(string [35, 26] - [35, 50]
|
|
(string_fragment [35, 27] - [35, 49]))
|
|
(arrow_function [35, 52] - [124, 1]
|
|
parameters: (formal_parameters [35, 58] - [35, 61]
|
|
(required_parameter [35, 59] - [35, 60]
|
|
pattern: (identifier [35, 59] - [35, 60])))
|
|
body: (statement_block [35, 65] - [124, 1]
|
|
(lexical_declaration [36, 2] - [36, 45]
|
|
(variable_declarator [36, 8] - [36, 44]
|
|
name: (identifier [36, 8] - [36, 12])
|
|
value: (await_expression [36, 15] - [36, 44]
|
|
(call_expression [36, 21] - [36, 44]
|
|
function: (identifier [36, 21] - [36, 41])
|
|
arguments: (arguments [36, 41] - [36, 44]
|
|
(identifier [36, 42] - [36, 43]))))))
|
|
(if_statement [37, 2] - [37, 59]
|
|
condition: (parenthesized_expression [37, 5] - [37, 12]
|
|
(unary_expression [37, 6] - [37, 11]
|
|
argument: (identifier [37, 7] - [37, 11])))
|
|
consequence: (return_statement [37, 13] - [37, 59]
|
|
(call_expression [37, 20] - [37, 58]
|
|
function: (member_expression [37, 20] - [37, 26]
|
|
object: (identifier [37, 20] - [37, 21])
|
|
property: (property_identifier [37, 22] - [37, 26]))
|
|
arguments: (arguments [37, 26] - [37, 58]
|
|
(object [37, 27] - [37, 52]
|
|
(pair [37, 29] - [37, 50]
|
|
key: (property_identifier [37, 29] - [37, 34])
|
|
value: (string [37, 36] - [37, 50]
|
|
(string_fragment [37, 37] - [37, 49]))))
|
|
(number [37, 54] - [37, 57])))))
|
|
(if_statement [39, 2] - [43, 3]
|
|
condition: (parenthesized_expression [39, 5] - [39, 19]
|
|
(member_expression [39, 6] - [39, 18]
|
|
object: (identifier [39, 6] - [39, 10])
|
|
property: (property_identifier [39, 11] - [39, 18])))
|
|
consequence: (statement_block [39, 20] - [43, 3]
|
|
(if_statement [40, 4] - [42, 5]
|
|
condition: (parenthesized_expression [40, 7] - [40, 57]
|
|
(binary_expression [40, 8] - [40, 56]
|
|
left: (unary_expression [40, 8] - [40, 32]
|
|
argument: (call_expression [40, 9] - [40, 32]
|
|
function: (identifier [40, 9] - [40, 17])
|
|
arguments: (arguments [40, 17] - [40, 32]
|
|
(identifier [40, 18] - [40, 22])
|
|
(string [40, 24] - [40, 31]
|
|
(string_fragment [40, 25] - [40, 30])))))
|
|
right: (unary_expression [40, 36] - [40, 56]
|
|
argument: (call_expression [40, 37] - [40, 56]
|
|
function: (identifier [40, 37] - [40, 45])
|
|
arguments: (arguments [40, 45] - [40, 56]
|
|
(identifier [40, 46] - [40, 50])
|
|
(string [40, 52] - [40, 55]
|
|
(string_fragment [40, 53] - [40, 54])))))))
|
|
consequence: (statement_block [40, 58] - [42, 5]
|
|
(return_statement [41, 6] - [41, 70]
|
|
(call_expression [41, 13] - [41, 69]
|
|
function: (member_expression [41, 13] - [41, 19]
|
|
object: (identifier [41, 13] - [41, 14])
|
|
property: (property_identifier [41, 15] - [41, 19]))
|
|
arguments: (arguments [41, 19] - [41, 69]
|
|
(object [41, 20] - [41, 63]
|
|
(pair [41, 22] - [41, 61]
|
|
key: (property_identifier [41, 22] - [41, 27])
|
|
value: (string [41, 29] - [41, 61]
|
|
(string_fragment [41, 30] - [41, 60]))))
|
|
(number [41, 65] - [41, 68]))))))))
|
|
(lexical_declaration [45, 2] - [50, 25]
|
|
(variable_declarator [45, 8] - [50, 24]
|
|
name: (object_pattern [45, 8] - [50, 3]
|
|
(shorthand_property_identifier_pattern [46, 4] - [46, 9])
|
|
(object_assignment_pattern [47, 4] - [47, 21]
|
|
left: (shorthand_property_identifier_pattern [47, 4] - [47, 17])
|
|
right: (number [47, 20] - [47, 21]))
|
|
(object_assignment_pattern [48, 4] - [48, 22]
|
|
left: (shorthand_property_identifier_pattern [48, 4] - [48, 8])
|
|
right: (string [48, 11] - [48, 22]
|
|
(string_fragment [48, 12] - [48, 21])))
|
|
(object_assignment_pattern [49, 4] - [49, 21]
|
|
left: (shorthand_property_identifier_pattern [49, 4] - [49, 16])
|
|
right: (array [49, 19] - [49, 21])))
|
|
value: (await_expression [50, 6] - [50, 24]
|
|
(call_expression [50, 12] - [50, 24]
|
|
function: (member_expression [50, 12] - [50, 22]
|
|
object: (member_expression [50, 12] - [50, 17]
|
|
object: (identifier [50, 12] - [50, 13])
|
|
property: (property_identifier [50, 14] - [50, 17]))
|
|
property: (property_identifier [50, 18] - [50, 22]))
|
|
arguments: (arguments [50, 22] - [50, 24])))))
|
|
(lexical_declaration [52, 2] - [54, 26]
|
|
(variable_declarator [52, 8] - [54, 25]
|
|
name: (identifier [52, 8] - [52, 18])
|
|
value: (ternary_expression [52, 21] - [54, 25]
|
|
condition: (parenthesized_expression [52, 21] - [52, 73]
|
|
(binary_expression [52, 22] - [52, 72]
|
|
left: (binary_expression [52, 22] - [52, 56]
|
|
left: (identifier [52, 22] - [52, 27])
|
|
right: (binary_expression [52, 31] - [52, 56]
|
|
left: (unary_expression [52, 31] - [52, 43]
|
|
argument: (identifier [52, 38] - [52, 43]))
|
|
right: (string [52, 48] - [52, 56]
|
|
(string_fragment [52, 49] - [52, 55]))))
|
|
right: (call_expression [52, 60] - [52, 72]
|
|
function: (member_expression [52, 60] - [52, 70]
|
|
object: (identifier [52, 60] - [52, 65])
|
|
property: (property_identifier [52, 66] - [52, 70]))
|
|
arguments: (arguments [52, 70] - [52, 72]))))
|
|
consequence: (call_expression [53, 6] - [53, 18]
|
|
function: (member_expression [53, 6] - [53, 16]
|
|
object: (identifier [53, 6] - [53, 11])
|
|
property: (property_identifier [53, 12] - [53, 16]))
|
|
arguments: (arguments [53, 16] - [53, 18]))
|
|
alternative: (string [54, 6] - [54, 25]
|
|
(string_fragment [54, 7] - [54, 24])))))
|
|
(lexical_declaration [55, 2] - [55, 71]
|
|
(variable_declarator [55, 8] - [55, 70]
|
|
name: (identifier [55, 8] - [55, 13])
|
|
value: (call_expression [55, 16] - [55, 70]
|
|
function: (member_expression [55, 16] - [55, 24]
|
|
object: (identifier [55, 16] - [55, 20])
|
|
property: (property_identifier [55, 21] - [55, 24]))
|
|
arguments: (arguments [55, 24] - [55, 70]
|
|
(call_expression [55, 25] - [55, 64]
|
|
function: (member_expression [55, 25] - [55, 33]
|
|
object: (identifier [55, 25] - [55, 29])
|
|
property: (property_identifier [55, 30] - [55, 33]))
|
|
arguments: (arguments [55, 33] - [55, 64]
|
|
(binary_expression [55, 34] - [55, 60]
|
|
left: (call_expression [55, 34] - [55, 55]
|
|
function: (identifier [55, 34] - [55, 40])
|
|
arguments: (arguments [55, 40] - [55, 55]
|
|
(identifier [55, 41] - [55, 54])))
|
|
right: (number [55, 59] - [55, 60]))
|
|
(number [55, 62] - [55, 63])))
|
|
(number [55, 66] - [55, 69])))))
|
|
(lexical_declaration [56, 2] - [56, 63]
|
|
(variable_declarator [56, 8] - [56, 62]
|
|
name: (identifier [56, 8] - [56, 17])
|
|
value: (new_expression [56, 20] - [56, 62]
|
|
constructor: (identifier [56, 24] - [56, 28])
|
|
arguments: (arguments [56, 28] - [56, 62]
|
|
(binary_expression [56, 29] - [56, 61]
|
|
left: (call_expression [56, 29] - [56, 39]
|
|
function: (member_expression [56, 29] - [56, 37]
|
|
object: (identifier [56, 29] - [56, 33])
|
|
property: (property_identifier [56, 34] - [56, 37]))
|
|
arguments: (arguments [56, 37] - [56, 39]))
|
|
right: (binary_expression [56, 42] - [56, 61]
|
|
left: (binary_expression [56, 42] - [56, 54]
|
|
left: (identifier [56, 42] - [56, 47])
|
|
right: (number [56, 50] - [56, 54]))
|
|
right: (number [56, 57] - [56, 61])))))))
|
|
(lexical_declaration [58, 2] - [58, 37]
|
|
(variable_declarator [58, 6] - [58, 36]
|
|
name: (identifier [58, 6] - [58, 21])
|
|
type: (type_annotation [58, 21] - [58, 31]
|
|
(array_type [58, 23] - [58, 31]
|
|
(predefined_type [58, 23] - [58, 29])))
|
|
value: (array [58, 34] - [58, 36])))
|
|
(if_statement [59, 2] - [75, 3]
|
|
condition: (parenthesized_expression [59, 5] - [59, 46]
|
|
(binary_expression [59, 6] - [59, 45]
|
|
left: (binary_expression [59, 6] - [59, 26]
|
|
left: (identifier [59, 6] - [59, 10])
|
|
right: (string [59, 15] - [59, 26]
|
|
(string_fragment [59, 16] - [59, 25])))
|
|
right: (binary_expression [59, 30] - [59, 45]
|
|
left: (identifier [59, 30] - [59, 34])
|
|
right: (string [59, 39] - [59, 45]
|
|
(string_fragment [59, 40] - [59, 44])))))
|
|
consequence: (statement_block [59, 47] - [67, 3]
|
|
(expression_statement [60, 4] - [66, 6]
|
|
(assignment_expression [60, 4] - [66, 5]
|
|
left: (identifier [60, 4] - [60, 19])
|
|
right: (array [60, 22] - [66, 5]
|
|
(string [61, 6] - [61, 18]
|
|
(string_fragment [61, 7] - [61, 17]))
|
|
(string [62, 6] - [62, 18]
|
|
(string_fragment [62, 7] - [62, 17]))
|
|
(string [63, 6] - [63, 17]
|
|
(string_fragment [63, 7] - [63, 16]))
|
|
(string [64, 6] - [64, 18]
|
|
(string_fragment [64, 7] - [64, 17]))
|
|
(string [65, 6] - [65, 21]
|
|
(string_fragment [65, 7] - [65, 20]))))))
|
|
alternative: (else_clause [67, 4] - [75, 3]
|
|
(if_statement [67, 9] - [75, 3]
|
|
condition: (parenthesized_expression [67, 12] - [67, 56]
|
|
(binary_expression [67, 13] - [67, 55]
|
|
left: (binary_expression [67, 13] - [67, 32]
|
|
left: (identifier [67, 13] - [67, 17])
|
|
right: (string [67, 22] - [67, 32]
|
|
(string_fragment [67, 23] - [67, 31])))
|
|
right: (binary_expression [67, 36] - [67, 55]
|
|
left: (identifier [67, 36] - [67, 40])
|
|
right: (string [67, 45] - [67, 55]
|
|
(string_fragment [67, 46] - [67, 54])))))
|
|
consequence: (statement_block [67, 57] - [69, 3]
|
|
(expression_statement [68, 4] - [68, 76]
|
|
(assignment_expression [68, 4] - [68, 75]
|
|
left: (identifier [68, 4] - [68, 19])
|
|
right: (array [68, 22] - [68, 75]
|
|
(string [68, 23] - [68, 33]
|
|
(string_fragment [68, 24] - [68, 32]))
|
|
(string [68, 35] - [68, 47]
|
|
(string_fragment [68, 36] - [68, 46]))
|
|
(string [68, 49] - [68, 61]
|
|
(string_fragment [68, 50] - [68, 60]))
|
|
(string [68, 63] - [68, 74]
|
|
(string_fragment [68, 64] - [68, 73]))))))
|
|
alternative: (else_clause [69, 4] - [75, 3]
|
|
(if_statement [69, 9] - [75, 3]
|
|
condition: (parenthesized_expression [69, 12] - [69, 30]
|
|
(binary_expression [69, 13] - [69, 29]
|
|
left: (identifier [69, 13] - [69, 17])
|
|
right: (string [69, 22] - [69, 29]
|
|
(string_fragment [69, 23] - [69, 28]))))
|
|
consequence: (statement_block [69, 31] - [71, 3]
|
|
(expression_statement [70, 4] - [70, 28]
|
|
(assignment_expression [70, 4] - [70, 27]
|
|
left: (identifier [70, 4] - [70, 19])
|
|
right: (array [70, 22] - [70, 27]
|
|
(string [70, 23] - [70, 26]
|
|
(string_fragment [70, 24] - [70, 25]))))))
|
|
alternative: (else_clause [71, 4] - [75, 3]
|
|
(if_statement [71, 9] - [75, 3]
|
|
condition: (parenthesized_expression [71, 12] - [71, 62]
|
|
(binary_expression [71, 13] - [71, 61]
|
|
left: (binary_expression [71, 13] - [71, 30]
|
|
left: (identifier [71, 13] - [71, 17])
|
|
right: (string [71, 22] - [71, 30]
|
|
(string_fragment [71, 23] - [71, 29])))
|
|
right: (call_expression [71, 34] - [71, 61]
|
|
function: (member_expression [71, 34] - [71, 47]
|
|
object: (identifier [71, 34] - [71, 39])
|
|
property: (property_identifier [71, 40] - [71, 47]))
|
|
arguments: (arguments [71, 47] - [71, 61]
|
|
(identifier [71, 48] - [71, 60])))))
|
|
consequence: (statement_block [71, 63] - [75, 3]
|
|
(expression_statement [72, 4] - [74, 6]
|
|
(assignment_expression [72, 4] - [74, 5]
|
|
left: (identifier [72, 4] - [72, 19])
|
|
right: (call_expression [72, 22] - [74, 5]
|
|
function: (member_expression [72, 22] - [72, 78]
|
|
object: (call_expression [72, 22] - [72, 71]
|
|
function: (member_expression [72, 22] - [72, 38]
|
|
object: (identifier [72, 22] - [72, 34])
|
|
property: (property_identifier [72, 35] - [72, 38]))
|
|
arguments: (arguments [72, 38] - [72, 71]
|
|
(arrow_function [72, 39] - [72, 70]
|
|
parameters: (formal_parameters [72, 39] - [72, 50]
|
|
(required_parameter [72, 40] - [72, 49]
|
|
pattern: (identifier [72, 40] - [72, 41])
|
|
type: (type_annotation [72, 41] - [72, 49]
|
|
(predefined_type [72, 43] - [72, 49]))))
|
|
body: (call_expression [72, 54] - [72, 70]
|
|
function: (member_expression [72, 54] - [72, 68]
|
|
object: (call_expression [72, 54] - [72, 63]
|
|
function: (identifier [72, 54] - [72, 60])
|
|
arguments: (arguments [72, 60] - [72, 63]
|
|
(identifier [72, 61] - [72, 62])))
|
|
property: (property_identifier [72, 64] - [72, 68]))
|
|
arguments: (arguments [72, 68] - [72, 70])))))
|
|
property: (property_identifier [72, 72] - [72, 78]))
|
|
arguments: (arguments [72, 78] - [74, 5]
|
|
(identifier [73, 6] - [73, 13])))))))))))))
|
|
(lexical_declaration [77, 2] - [77, 38]
|
|
(variable_declarator [77, 8] - [77, 37]
|
|
name: (identifier [77, 8] - [77, 16])
|
|
value: (new_expression [77, 19] - [77, 37]
|
|
constructor: (identifier [77, 23] - [77, 33])
|
|
arguments: (arguments [77, 33] - [77, 37]
|
|
(number [77, 34] - [77, 36])))))
|
|
(expression_statement [78, 2] - [78, 35]
|
|
(call_expression [78, 2] - [78, 34]
|
|
function: (member_expression [78, 2] - [78, 24]
|
|
object: (identifier [78, 2] - [78, 8])
|
|
property: (property_identifier [78, 9] - [78, 24]))
|
|
arguments: (arguments [78, 24] - [78, 34]
|
|
(identifier [78, 25] - [78, 33]))))
|
|
(lexical_declaration [79, 2] - [81, 13]
|
|
(variable_declarator [79, 8] - [81, 12]
|
|
name: (identifier [79, 8] - [79, 16])
|
|
value: (call_expression [79, 19] - [81, 12]
|
|
function: (member_expression [79, 19] - [81, 8]
|
|
object: (call_expression [79, 19] - [81, 3]
|
|
function: (member_expression [79, 19] - [79, 43]
|
|
object: (call_expression [79, 19] - [79, 39]
|
|
function: (member_expression [79, 19] - [79, 29]
|
|
object: (identifier [79, 19] - [79, 24])
|
|
property: (property_identifier [79, 25] - [79, 29]))
|
|
arguments: (arguments [79, 29] - [79, 39]
|
|
(identifier [79, 30] - [79, 38])))
|
|
property: (property_identifier [79, 40] - [79, 43]))
|
|
arguments: (arguments [79, 43] - [81, 3]
|
|
(arrow_function [79, 44] - [80, 35]
|
|
parameters: (formal_parameters [79, 44] - [79, 47]
|
|
(required_parameter [79, 45] - [79, 46]
|
|
pattern: (identifier [79, 45] - [79, 46])))
|
|
body: (call_expression [80, 4] - [80, 35]
|
|
function: (member_expression [80, 4] - [80, 27]
|
|
object: (call_expression [80, 4] - [80, 18]
|
|
function: (member_expression [80, 4] - [80, 14]
|
|
object: (identifier [80, 4] - [80, 5])
|
|
property: (property_identifier [80, 6] - [80, 14]))
|
|
arguments: (arguments [80, 14] - [80, 18]
|
|
(number [80, 15] - [80, 17])))
|
|
property: (property_identifier [80, 19] - [80, 27]))
|
|
arguments: (arguments [80, 27] - [80, 35]
|
|
(number [80, 28] - [80, 29])
|
|
(string [80, 31] - [80, 34]
|
|
(string_fragment [80, 32] - [80, 33])))))))
|
|
property: (property_identifier [81, 4] - [81, 8]))
|
|
arguments: (arguments [81, 8] - [81, 12]
|
|
(string [81, 9] - [81, 11])))))
|
|
(lexical_declaration [82, 2] - [82, 42]
|
|
(variable_declarator [82, 8] - [82, 41]
|
|
name: (identifier [82, 8] - [82, 17])
|
|
value: (template_string [82, 20] - [82, 41]
|
|
(string_fragment [82, 21] - [82, 29])
|
|
(template_substitution [82, 29] - [82, 40]
|
|
(identifier [82, 31] - [82, 39])))))
|
|
(expression_statement [84, 2] - [90, 4]
|
|
(await_expression [84, 2] - [90, 3]
|
|
(call_expression [84, 8] - [90, 3]
|
|
function: (identifier [84, 8] - [84, 23])
|
|
arguments: (arguments [84, 23] - [90, 3]
|
|
(identifier [85, 4] - [85, 13])
|
|
(member_expression [86, 4] - [86, 15]
|
|
object: (identifier [86, 4] - [86, 8])
|
|
property: (property_identifier [86, 9] - [86, 15]))
|
|
(identifier [87, 4] - [87, 14])
|
|
(identifier [88, 4] - [88, 19])
|
|
(identifier [89, 4] - [89, 13])))))
|
|
(try_statement [92, 2] - [107, 3]
|
|
body: (statement_block [92, 6] - [105, 3]
|
|
(lexical_declaration [93, 4] - [99, 6]
|
|
(variable_declarator [93, 10] - [99, 5]
|
|
name: (identifier [93, 10] - [93, 21])
|
|
value: (object [93, 24] - [99, 5]
|
|
(pair [94, 6] - [94, 23]
|
|
key: (property_identifier [94, 6] - [94, 10])
|
|
value: (member_expression [94, 12] - [94, 23]
|
|
object: (identifier [94, 12] - [94, 16])
|
|
property: (property_identifier [94, 17] - [94, 23])))
|
|
(pair [95, 6] - [95, 29]
|
|
key: (property_identifier [95, 6] - [95, 14])
|
|
value: (member_expression [95, 16] - [95, 29]
|
|
object: (identifier [95, 16] - [95, 20])
|
|
property: (property_identifier [95, 21] - [95, 29])))
|
|
(pair [96, 6] - [96, 23]
|
|
key: (property_identifier [96, 6] - [96, 11])
|
|
value: (identifier [96, 13] - [96, 23]))
|
|
(pair [97, 6] - [97, 19]
|
|
key: (property_identifier [97, 6] - [97, 13])
|
|
value: (true [97, 15] - [97, 19]))
|
|
(pair [98, 6] - [98, 35]
|
|
key: (property_identifier [98, 6] - [98, 18])
|
|
value: (identifier [98, 20] - [98, 35])))))
|
|
(expression_statement [100, 4] - [104, 6]
|
|
(await_expression [100, 4] - [104, 5]
|
|
(call_expression [100, 10] - [104, 5]
|
|
function: (member_expression [100, 10] - [100, 22]
|
|
object: (identifier [100, 10] - [100, 16])
|
|
property: (property_identifier [100, 17] - [100, 22]))
|
|
arguments: (arguments [100, 22] - [104, 5]
|
|
(identifier [101, 6] - [101, 15])
|
|
(call_expression [102, 6] - [102, 30]
|
|
function: (member_expression [102, 6] - [102, 16]
|
|
object: (identifier [102, 6] - [102, 10])
|
|
property: (property_identifier [102, 11] - [102, 16]))
|
|
arguments: (arguments [102, 16] - [102, 30]
|
|
(binary_expression [102, 17] - [102, 29]
|
|
left: (identifier [102, 17] - [102, 22])
|
|
right: (number [102, 25] - [102, 29]))))
|
|
(call_expression [103, 6] - [103, 33]
|
|
function: (member_expression [103, 6] - [103, 20]
|
|
object: (identifier [103, 6] - [103, 10])
|
|
property: (property_identifier [103, 11] - [103, 20]))
|
|
arguments: (arguments [103, 20] - [103, 33]
|
|
(identifier [103, 21] - [103, 32]))))))))
|
|
handler: (catch_clause [105, 4] - [107, 3]
|
|
parameter: (identifier [105, 11] - [105, 14])
|
|
body: (statement_block [105, 16] - [107, 3]
|
|
(expression_statement [106, 4] - [106, 70]
|
|
(call_expression [106, 4] - [106, 69]
|
|
function: (member_expression [106, 4] - [106, 17]
|
|
object: (identifier [106, 4] - [106, 11])
|
|
property: (property_identifier [106, 12] - [106, 17]))
|
|
arguments: (arguments [106, 17] - [106, 69]
|
|
(string [106, 18] - [106, 63]
|
|
(string_fragment [106, 19] - [106, 62]))
|
|
(identifier [106, 65] - [106, 68])))))))
|
|
(expression_statement [109, 2] - [114, 21]
|
|
(call_expression [109, 2] - [114, 20]
|
|
function: (member_expression [109, 2] - [109, 23]
|
|
object: (identifier [109, 2] - [109, 14])
|
|
property: (property_identifier [109, 15] - [109, 23]))
|
|
arguments: (arguments [109, 23] - [114, 20]
|
|
(member_expression [109, 24] - [109, 35]
|
|
object: (identifier [109, 24] - [109, 28])
|
|
property: (property_identifier [109, 29] - [109, 35]))
|
|
(string [109, 37] - [109, 56]
|
|
(string_fragment [109, 38] - [109, 55]))
|
|
(identifier [109, 58] - [109, 67])
|
|
(object [109, 69] - [114, 3]
|
|
(pair [110, 4] - [110, 21]
|
|
key: (property_identifier [110, 4] - [110, 9])
|
|
value: (identifier [110, 11] - [110, 21]))
|
|
(pair [111, 4] - [111, 25]
|
|
key: (property_identifier [111, 4] - [111, 18])
|
|
value: (identifier [111, 20] - [111, 25]))
|
|
(shorthand_property_identifier [112, 4] - [112, 8])
|
|
(pair [113, 4] - [113, 27]
|
|
key: (property_identifier [113, 4] - [113, 10])
|
|
value: (identifier [113, 12] - [113, 27])))
|
|
(call_expression [114, 5] - [114, 19]
|
|
function: (identifier [114, 5] - [114, 16])
|
|
arguments: (arguments [114, 16] - [114, 19]
|
|
(identifier [114, 17] - [114, 18]))))))
|
|
(return_statement [116, 2] - [123, 5]
|
|
(call_expression [116, 9] - [123, 4]
|
|
function: (member_expression [116, 9] - [116, 15]
|
|
object: (identifier [116, 9] - [116, 10])
|
|
property: (property_identifier [116, 11] - [116, 15]))
|
|
arguments: (arguments [116, 15] - [123, 4]
|
|
(object [116, 16] - [123, 3]
|
|
(pair [117, 4] - [117, 17]
|
|
key: (property_identifier [117, 4] - [117, 11])
|
|
value: (true [117, 13] - [117, 17]))
|
|
(shorthand_property_identifier [118, 4] - [118, 13])
|
|
(pair [119, 4] - [119, 20]
|
|
key: (property_identifier [119, 4] - [119, 9])
|
|
value: (identifier [119, 11] - [119, 20]))
|
|
(pair [120, 4] - [120, 21]
|
|
key: (property_identifier [120, 4] - [120, 9])
|
|
value: (identifier [120, 11] - [120, 21]))
|
|
(pair [121, 4] - [121, 38]
|
|
key: (property_identifier [121, 4] - [121, 13])
|
|
value: (call_expression [121, 15] - [121, 38]
|
|
function: (member_expression [121, 15] - [121, 36]
|
|
object: (identifier [121, 15] - [121, 24])
|
|
property: (property_identifier [121, 25] - [121, 36]))
|
|
arguments: (arguments [121, 36] - [121, 38])))
|
|
(pair [122, 4] - [122, 27]
|
|
key: (property_identifier [122, 4] - [122, 10])
|
|
value: (identifier [122, 12] - [122, 27])))))))))))
|
|
(comment [126, 0] - [126, 60])
|
|
(comment [127, 0] - [127, 42])
|
|
(comment [128, 0] - [128, 60])
|
|
(expression_statement [129, 0] - [169, 3]
|
|
(call_expression [129, 0] - [169, 2]
|
|
function: (member_expression [129, 0] - [129, 24]
|
|
object: (identifier [129, 0] - [129, 20])
|
|
property: (property_identifier [129, 21] - [129, 24]))
|
|
arguments: (arguments [129, 24] - [169, 2]
|
|
(string [129, 25] - [129, 51]
|
|
(string_fragment [129, 26] - [129, 50]))
|
|
(arrow_function [129, 53] - [169, 1]
|
|
parameters: (formal_parameters [129, 59] - [129, 62]
|
|
(required_parameter [129, 60] - [129, 61]
|
|
pattern: (identifier [129, 60] - [129, 61])))
|
|
body: (statement_block [129, 66] - [169, 1]
|
|
(lexical_declaration [130, 2] - [130, 45]
|
|
(variable_declarator [130, 8] - [130, 44]
|
|
name: (identifier [130, 8] - [130, 12])
|
|
value: (await_expression [130, 15] - [130, 44]
|
|
(call_expression [130, 21] - [130, 44]
|
|
function: (identifier [130, 21] - [130, 41])
|
|
arguments: (arguments [130, 41] - [130, 44]
|
|
(identifier [130, 42] - [130, 43]))))))
|
|
(if_statement [131, 2] - [131, 59]
|
|
condition: (parenthesized_expression [131, 5] - [131, 12]
|
|
(unary_expression [131, 6] - [131, 11]
|
|
argument: (identifier [131, 7] - [131, 11])))
|
|
consequence: (return_statement [131, 13] - [131, 59]
|
|
(call_expression [131, 20] - [131, 58]
|
|
function: (member_expression [131, 20] - [131, 26]
|
|
object: (identifier [131, 20] - [131, 21])
|
|
property: (property_identifier [131, 22] - [131, 26]))
|
|
arguments: (arguments [131, 26] - [131, 58]
|
|
(object [131, 27] - [131, 52]
|
|
(pair [131, 29] - [131, 50]
|
|
key: (property_identifier [131, 29] - [131, 34])
|
|
value: (string [131, 36] - [131, 50]
|
|
(string_fragment [131, 37] - [131, 49]))))
|
|
(number [131, 54] - [131, 57])))))
|
|
(if_statement [133, 2] - [135, 3]
|
|
condition: (parenthesized_expression [133, 5] - [133, 40]
|
|
(unary_expression [133, 6] - [133, 39]
|
|
argument: (call_expression [133, 7] - [133, 39]
|
|
function: (identifier [133, 7] - [133, 15])
|
|
arguments: (arguments [133, 15] - [133, 39]
|
|
(identifier [133, 16] - [133, 20])
|
|
(string [133, 22] - [133, 38]
|
|
(string_fragment [133, 23] - [133, 37]))))))
|
|
consequence: (statement_block [133, 41] - [135, 3]
|
|
(return_statement [134, 4] - [134, 68]
|
|
(call_expression [134, 11] - [134, 67]
|
|
function: (member_expression [134, 11] - [134, 17]
|
|
object: (identifier [134, 11] - [134, 12])
|
|
property: (property_identifier [134, 13] - [134, 17]))
|
|
arguments: (arguments [134, 17] - [134, 67]
|
|
(object [134, 18] - [134, 61]
|
|
(pair [134, 20] - [134, 59]
|
|
key: (property_identifier [134, 20] - [134, 25])
|
|
value: (string [134, 27] - [134, 59]
|
|
(string_fragment [134, 28] - [134, 58]))))
|
|
(number [134, 63] - [134, 66]))))))
|
|
(lexical_declaration [137, 2] - [137, 44]
|
|
(variable_declarator [137, 8] - [137, 43]
|
|
name: (identifier [137, 8] - [137, 23])
|
|
value: (call_expression [137, 26] - [137, 43]
|
|
function: (member_expression [137, 26] - [137, 37]
|
|
object: (member_expression [137, 26] - [137, 31]
|
|
object: (identifier [137, 26] - [137, 27])
|
|
property: (property_identifier [137, 28] - [137, 31]))
|
|
property: (property_identifier [137, 32] - [137, 37]))
|
|
arguments: (arguments [137, 37] - [137, 43]
|
|
(string [137, 38] - [137, 42]
|
|
(string_fragment [137, 39] - [137, 41]))))))
|
|
(lexical_declaration [138, 2] - [138, 51]
|
|
(variable_declarator [138, 8] - [138, 50]
|
|
name: (object_pattern [138, 8] - [138, 29]
|
|
(object_assignment_pattern [138, 10] - [138, 27]
|
|
left: (shorthand_property_identifier_pattern [138, 10] - [138, 22])
|
|
right: (array [138, 25] - [138, 27])))
|
|
value: (await_expression [138, 32] - [138, 50]
|
|
(call_expression [138, 38] - [138, 50]
|
|
function: (member_expression [138, 38] - [138, 48]
|
|
object: (member_expression [138, 38] - [138, 43]
|
|
object: (identifier [138, 38] - [138, 39])
|
|
property: (property_identifier [138, 40] - [138, 43]))
|
|
property: (property_identifier [138, 44] - [138, 48]))
|
|
arguments: (arguments [138, 48] - [138, 50])))))
|
|
(lexical_declaration [140, 2] - [140, 78]
|
|
(variable_declarator [140, 8] - [140, 77]
|
|
name: (identifier [140, 8] - [140, 15])
|
|
value: (await_expression [140, 18] - [140, 77]
|
|
(call_expression [140, 24] - [140, 77]
|
|
function: (identifier [140, 24] - [140, 47])
|
|
arguments: (arguments [140, 47] - [140, 77]
|
|
(identifier [140, 48] - [140, 63])
|
|
(member_expression [140, 65] - [140, 76]
|
|
object: (identifier [140, 65] - [140, 69])
|
|
property: (property_identifier [140, 70] - [140, 76])))))))
|
|
(if_statement [141, 2] - [143, 3]
|
|
condition: (parenthesized_expression [141, 5] - [141, 15]
|
|
(unary_expression [141, 6] - [141, 14]
|
|
argument: (identifier [141, 7] - [141, 14])))
|
|
consequence: (statement_block [141, 16] - [143, 3]
|
|
(return_statement [142, 4] - [142, 72]
|
|
(call_expression [142, 11] - [142, 71]
|
|
function: (member_expression [142, 11] - [142, 17]
|
|
object: (identifier [142, 11] - [142, 12])
|
|
property: (property_identifier [142, 13] - [142, 17]))
|
|
arguments: (arguments [142, 17] - [142, 71]
|
|
(object [142, 18] - [142, 65]
|
|
(pair [142, 20] - [142, 63]
|
|
key: (property_identifier [142, 20] - [142, 25])
|
|
value: (string [142, 27] - [142, 63]
|
|
(string_fragment [142, 28] - [142, 62]))))
|
|
(number [142, 67] - [142, 70]))))))
|
|
(lexical_declaration [145, 2] - [147, 9]
|
|
(variable_declarator [145, 8] - [147, 8]
|
|
name: (identifier [145, 8] - [145, 23])
|
|
value: (ternary_expression [145, 26] - [147, 8]
|
|
condition: (call_expression [145, 26] - [145, 53]
|
|
function: (member_expression [145, 26] - [145, 39]
|
|
object: (identifier [145, 26] - [145, 31])
|
|
property: (property_identifier [145, 32] - [145, 39]))
|
|
arguments: (arguments [145, 39] - [145, 53]
|
|
(identifier [145, 40] - [145, 52])))
|
|
consequence: (call_expression [146, 6] - [146, 71]
|
|
function: (member_expression [146, 6] - [146, 62]
|
|
object: (call_expression [146, 6] - [146, 55]
|
|
function: (member_expression [146, 6] - [146, 22]
|
|
object: (identifier [146, 6] - [146, 18])
|
|
property: (property_identifier [146, 19] - [146, 22]))
|
|
arguments: (arguments [146, 22] - [146, 55]
|
|
(arrow_function [146, 23] - [146, 54]
|
|
parameters: (formal_parameters [146, 23] - [146, 34]
|
|
(required_parameter [146, 24] - [146, 33]
|
|
pattern: (identifier [146, 24] - [146, 25])
|
|
type: (type_annotation [146, 25] - [146, 33]
|
|
(predefined_type [146, 27] - [146, 33]))))
|
|
body: (call_expression [146, 38] - [146, 54]
|
|
function: (member_expression [146, 38] - [146, 52]
|
|
object: (call_expression [146, 38] - [146, 47]
|
|
function: (identifier [146, 38] - [146, 44])
|
|
arguments: (arguments [146, 44] - [146, 47]
|
|
(identifier [146, 45] - [146, 46])))
|
|
property: (property_identifier [146, 48] - [146, 52]))
|
|
arguments: (arguments [146, 52] - [146, 54])))))
|
|
property: (property_identifier [146, 56] - [146, 62]))
|
|
arguments: (arguments [146, 62] - [146, 71]
|
|
(identifier [146, 63] - [146, 70])))
|
|
alternative: (array [147, 6] - [147, 8]))))
|
|
(expression_statement [149, 2] - [149, 62]
|
|
(await_expression [149, 2] - [149, 61]
|
|
(call_expression [149, 8] - [149, 61]
|
|
function: (identifier [149, 8] - [149, 27])
|
|
arguments: (arguments [149, 27] - [149, 61]
|
|
(identifier [149, 28] - [149, 43])
|
|
(identifier [149, 45] - [149, 60])))))
|
|
(try_statement [151, 2] - [158, 17]
|
|
body: (statement_block [151, 6] - [158, 3]
|
|
(lexical_declaration [152, 4] - [152, 61]
|
|
(variable_declarator [152, 10] - [152, 60]
|
|
name: (identifier [152, 10] - [152, 24])
|
|
value: (await_expression [152, 27] - [152, 60]
|
|
(call_expression [152, 33] - [152, 60]
|
|
function: (member_expression [152, 33] - [152, 43]
|
|
object: (identifier [152, 33] - [152, 39])
|
|
property: (property_identifier [152, 40] - [152, 43]))
|
|
arguments: (arguments [152, 43] - [152, 60]
|
|
(identifier [152, 44] - [152, 59]))))))
|
|
(if_statement [153, 4] - [157, 5]
|
|
condition: (parenthesized_expression [153, 7] - [153, 23]
|
|
(identifier [153, 8] - [153, 22]))
|
|
consequence: (statement_block [153, 24] - [157, 5]
|
|
(lexical_declaration [154, 6] - [154, 48]
|
|
(variable_declarator [154, 12] - [154, 47]
|
|
name: (identifier [154, 12] - [154, 18])
|
|
value: (call_expression [154, 21] - [154, 47]
|
|
function: (member_expression [154, 21] - [154, 31]
|
|
object: (identifier [154, 21] - [154, 25])
|
|
property: (property_identifier [154, 26] - [154, 31]))
|
|
arguments: (arguments [154, 31] - [154, 47]
|
|
(identifier [154, 32] - [154, 46])))))
|
|
(expression_statement [155, 6] - [155, 44]
|
|
(assignment_expression [155, 6] - [155, 43]
|
|
left: (member_expression [155, 6] - [155, 25]
|
|
object: (identifier [155, 6] - [155, 12])
|
|
property: (property_identifier [155, 13] - [155, 25]))
|
|
right: (identifier [155, 28] - [155, 43])))
|
|
(expression_statement [156, 6] - [156, 64]
|
|
(await_expression [156, 6] - [156, 63]
|
|
(call_expression [156, 12] - [156, 63]
|
|
function: (member_expression [156, 12] - [156, 22]
|
|
object: (identifier [156, 12] - [156, 18])
|
|
property: (property_identifier [156, 19] - [156, 22]))
|
|
arguments: (arguments [156, 22] - [156, 63]
|
|
(identifier [156, 23] - [156, 38])
|
|
(call_expression [156, 40] - [156, 62]
|
|
function: (member_expression [156, 40] - [156, 54]
|
|
object: (identifier [156, 40] - [156, 44])
|
|
property: (property_identifier [156, 45] - [156, 54]))
|
|
arguments: (arguments [156, 54] - [156, 62]
|
|
(identifier [156, 55] - [156, 61]))))))))))
|
|
handler: (catch_clause [158, 4] - [158, 17]
|
|
parameter: (identifier [158, 11] - [158, 13])
|
|
body: (statement_block [158, 15] - [158, 17])))
|
|
(expression_statement [160, 2] - [166, 4]
|
|
(call_expression [160, 2] - [166, 3]
|
|
function: (member_expression [160, 2] - [160, 23]
|
|
object: (identifier [160, 2] - [160, 14])
|
|
property: (property_identifier [160, 15] - [160, 23]))
|
|
arguments: (arguments [160, 23] - [166, 3]
|
|
(member_expression [161, 4] - [161, 15]
|
|
object: (identifier [161, 4] - [161, 8])
|
|
property: (property_identifier [161, 9] - [161, 15]))
|
|
(string [162, 4] - [162, 28]
|
|
(string_fragment [162, 5] - [162, 27]))
|
|
(identifier [163, 4] - [163, 19])
|
|
(object [164, 4] - [164, 31]
|
|
(pair [164, 6] - [164, 29]
|
|
key: (property_identifier [164, 6] - [164, 12])
|
|
value: (identifier [164, 14] - [164, 29])))
|
|
(call_expression [165, 4] - [165, 18]
|
|
function: (identifier [165, 4] - [165, 15])
|
|
arguments: (arguments [165, 15] - [165, 18]
|
|
(identifier [165, 16] - [165, 17]))))))
|
|
(return_statement [168, 2] - [168, 60]
|
|
(call_expression [168, 9] - [168, 59]
|
|
function: (member_expression [168, 9] - [168, 15]
|
|
object: (identifier [168, 9] - [168, 10])
|
|
property: (property_identifier [168, 11] - [168, 15]))
|
|
arguments: (arguments [168, 15] - [168, 59]
|
|
(object [168, 16] - [168, 58]
|
|
(pair [168, 18] - [168, 31]
|
|
key: (property_identifier [168, 18] - [168, 25])
|
|
value: (true [168, 27] - [168, 31]))
|
|
(pair [168, 33] - [168, 56]
|
|
key: (property_identifier [168, 33] - [168, 39])
|
|
value: (identifier [168, 41] - [168, 56])))))))))))
|
|
(comment [171, 0] - [171, 60])
|
|
(comment [172, 0] - [172, 26])
|
|
(comment [173, 0] - [173, 60])
|
|
(expression_statement [174, 0] - [218, 3]
|
|
(call_expression [174, 0] - [218, 2]
|
|
function: (member_expression [174, 0] - [174, 25]
|
|
object: (identifier [174, 0] - [174, 20])
|
|
property: (property_identifier [174, 21] - [174, 25]))
|
|
arguments: (arguments [174, 25] - [218, 2]
|
|
(string [174, 26] - [174, 51]
|
|
(string_fragment [174, 27] - [174, 50]))
|
|
(arrow_function [174, 53] - [218, 1]
|
|
parameters: (formal_parameters [174, 59] - [174, 62]
|
|
(required_parameter [174, 60] - [174, 61]
|
|
pattern: (identifier [174, 60] - [174, 61])))
|
|
body: (statement_block [174, 66] - [218, 1]
|
|
(lexical_declaration [175, 2] - [175, 45]
|
|
(variable_declarator [175, 8] - [175, 44]
|
|
name: (identifier [175, 8] - [175, 12])
|
|
value: (await_expression [175, 15] - [175, 44]
|
|
(call_expression [175, 21] - [175, 44]
|
|
function: (identifier [175, 21] - [175, 41])
|
|
arguments: (arguments [175, 41] - [175, 44]
|
|
(identifier [175, 42] - [175, 43]))))))
|
|
(if_statement [176, 2] - [176, 59]
|
|
condition: (parenthesized_expression [176, 5] - [176, 12]
|
|
(unary_expression [176, 6] - [176, 11]
|
|
argument: (identifier [176, 7] - [176, 11])))
|
|
consequence: (return_statement [176, 13] - [176, 59]
|
|
(call_expression [176, 20] - [176, 58]
|
|
function: (member_expression [176, 20] - [176, 26]
|
|
object: (identifier [176, 20] - [176, 21])
|
|
property: (property_identifier [176, 22] - [176, 26]))
|
|
arguments: (arguments [176, 26] - [176, 58]
|
|
(object [176, 27] - [176, 52]
|
|
(pair [176, 29] - [176, 50]
|
|
key: (property_identifier [176, 29] - [176, 34])
|
|
value: (string [176, 36] - [176, 50]
|
|
(string_fragment [176, 37] - [176, 49]))))
|
|
(number [176, 54] - [176, 57])))))
|
|
(if_statement [178, 2] - [180, 3]
|
|
condition: (parenthesized_expression [178, 5] - [178, 40]
|
|
(unary_expression [178, 6] - [178, 39]
|
|
argument: (call_expression [178, 7] - [178, 39]
|
|
function: (identifier [178, 7] - [178, 15])
|
|
arguments: (arguments [178, 15] - [178, 39]
|
|
(identifier [178, 16] - [178, 20])
|
|
(string [178, 22] - [178, 38]
|
|
(string_fragment [178, 23] - [178, 37]))))))
|
|
consequence: (statement_block [178, 41] - [180, 3]
|
|
(return_statement [179, 4] - [179, 68]
|
|
(call_expression [179, 11] - [179, 67]
|
|
function: (member_expression [179, 11] - [179, 17]
|
|
object: (identifier [179, 11] - [179, 12])
|
|
property: (property_identifier [179, 13] - [179, 17]))
|
|
arguments: (arguments [179, 17] - [179, 67]
|
|
(object [179, 18] - [179, 61]
|
|
(pair [179, 20] - [179, 59]
|
|
key: (property_identifier [179, 20] - [179, 25])
|
|
value: (string [179, 27] - [179, 59]
|
|
(string_fragment [179, 28] - [179, 58]))))
|
|
(number [179, 63] - [179, 66]))))))
|
|
(lexical_declaration [182, 2] - [182, 44]
|
|
(variable_declarator [182, 8] - [182, 43]
|
|
name: (identifier [182, 8] - [182, 23])
|
|
value: (call_expression [182, 26] - [182, 43]
|
|
function: (member_expression [182, 26] - [182, 37]
|
|
object: (member_expression [182, 26] - [182, 31]
|
|
object: (identifier [182, 26] - [182, 27])
|
|
property: (property_identifier [182, 28] - [182, 31]))
|
|
property: (property_identifier [182, 32] - [182, 37]))
|
|
arguments: (arguments [182, 37] - [182, 43]
|
|
(string [182, 38] - [182, 42]
|
|
(string_fragment [182, 39] - [182, 41]))))))
|
|
(lexical_declaration [183, 2] - [183, 43]
|
|
(variable_declarator [183, 8] - [183, 42]
|
|
name: (object_pattern [183, 8] - [183, 21]
|
|
(shorthand_property_identifier_pattern [183, 10] - [183, 19]))
|
|
value: (await_expression [183, 24] - [183, 42]
|
|
(call_expression [183, 30] - [183, 42]
|
|
function: (member_expression [183, 30] - [183, 40]
|
|
object: (member_expression [183, 30] - [183, 35]
|
|
object: (identifier [183, 30] - [183, 31])
|
|
property: (property_identifier [183, 32] - [183, 35]))
|
|
property: (property_identifier [183, 36] - [183, 40]))
|
|
arguments: (arguments [183, 40] - [183, 42])))))
|
|
(lexical_declaration [184, 2] - [184, 41]
|
|
(variable_declarator [184, 8] - [184, 40]
|
|
name: (identifier [184, 8] - [184, 19])
|
|
value: (call_expression [184, 22] - [184, 40]
|
|
function: (identifier [184, 22] - [184, 29])
|
|
arguments: (arguments [184, 29] - [184, 40]
|
|
(identifier [184, 30] - [184, 39])))))
|
|
(lexical_declaration [186, 2] - [186, 56]
|
|
(variable_declarator [186, 8] - [186, 55]
|
|
name: (identifier [186, 8] - [186, 15])
|
|
value: (await_expression [186, 18] - [186, 55]
|
|
(call_expression [186, 24] - [186, 55]
|
|
function: (identifier [186, 24] - [186, 38])
|
|
arguments: (arguments [186, 38] - [186, 55]
|
|
(identifier [186, 39] - [186, 54]))))))
|
|
(if_statement [187, 2] - [189, 3]
|
|
condition: (parenthesized_expression [187, 5] - [187, 15]
|
|
(unary_expression [187, 6] - [187, 14]
|
|
argument: (identifier [187, 7] - [187, 14])))
|
|
consequence: (statement_block [187, 16] - [189, 3]
|
|
(return_statement [188, 4] - [188, 55]
|
|
(call_expression [188, 11] - [188, 54]
|
|
function: (member_expression [188, 11] - [188, 17]
|
|
object: (identifier [188, 11] - [188, 12])
|
|
property: (property_identifier [188, 13] - [188, 17]))
|
|
arguments: (arguments [188, 17] - [188, 54]
|
|
(object [188, 18] - [188, 48]
|
|
(pair [188, 20] - [188, 46]
|
|
key: (property_identifier [188, 20] - [188, 25])
|
|
value: (string [188, 27] - [188, 46]
|
|
(string_fragment [188, 28] - [188, 45]))))
|
|
(number [188, 50] - [188, 53]))))))
|
|
(expression_statement [191, 2] - [191, 55]
|
|
(await_expression [191, 2] - [191, 54]
|
|
(call_expression [191, 8] - [191, 54]
|
|
function: (identifier [191, 8] - [191, 24])
|
|
arguments: (arguments [191, 24] - [191, 54]
|
|
(identifier [191, 25] - [191, 40])
|
|
(identifier [191, 42] - [191, 53])))))
|
|
(try_statement [193, 2] - [207, 3]
|
|
body: (statement_block [193, 6] - [205, 3]
|
|
(lexical_declaration [194, 4] - [194, 61]
|
|
(variable_declarator [194, 10] - [194, 60]
|
|
name: (identifier [194, 10] - [194, 24])
|
|
value: (await_expression [194, 27] - [194, 60]
|
|
(call_expression [194, 33] - [194, 60]
|
|
function: (member_expression [194, 33] - [194, 43]
|
|
object: (identifier [194, 33] - [194, 39])
|
|
property: (property_identifier [194, 40] - [194, 43]))
|
|
arguments: (arguments [194, 43] - [194, 60]
|
|
(identifier [194, 44] - [194, 59]))))))
|
|
(if_statement [195, 4] - [204, 5]
|
|
condition: (parenthesized_expression [195, 7] - [195, 23]
|
|
(identifier [195, 8] - [195, 22]))
|
|
consequence: (statement_block [195, 24] - [204, 5]
|
|
(lexical_declaration [196, 6] - [196, 48]
|
|
(variable_declarator [196, 12] - [196, 47]
|
|
name: (identifier [196, 12] - [196, 18])
|
|
value: (call_expression [196, 21] - [196, 47]
|
|
function: (member_expression [196, 21] - [196, 31]
|
|
object: (identifier [196, 21] - [196, 25])
|
|
property: (property_identifier [196, 26] - [196, 31]))
|
|
arguments: (arguments [196, 31] - [196, 47]
|
|
(identifier [196, 32] - [196, 46])))))
|
|
(expression_statement [197, 6] - [197, 37]
|
|
(assignment_expression [197, 6] - [197, 36]
|
|
left: (member_expression [197, 6] - [197, 22]
|
|
object: (identifier [197, 6] - [197, 12])
|
|
property: (property_identifier [197, 13] - [197, 22]))
|
|
right: (identifier [197, 25] - [197, 36])))
|
|
(lexical_declaration [198, 6] - [198, 52]
|
|
(variable_declarator [198, 12] - [198, 51]
|
|
name: (identifier [198, 12] - [198, 15])
|
|
value: (await_expression [198, 18] - [198, 51]
|
|
(call_expression [198, 24] - [198, 51]
|
|
function: (member_expression [198, 24] - [198, 34]
|
|
object: (identifier [198, 24] - [198, 30])
|
|
property: (property_identifier [198, 31] - [198, 34]))
|
|
arguments: (arguments [198, 34] - [198, 51]
|
|
(identifier [198, 35] - [198, 50]))))))
|
|
(if_statement [199, 6] - [203, 7]
|
|
condition: (parenthesized_expression [199, 9] - [199, 18]
|
|
(binary_expression [199, 10] - [199, 17]
|
|
left: (identifier [199, 10] - [199, 13])
|
|
right: (number [199, 16] - [199, 17])))
|
|
consequence: (statement_block [199, 19] - [201, 7]
|
|
(expression_statement [200, 8] - [200, 73]
|
|
(await_expression [200, 8] - [200, 72]
|
|
(call_expression [200, 14] - [200, 72]
|
|
function: (member_expression [200, 14] - [200, 26]
|
|
object: (identifier [200, 14] - [200, 20])
|
|
property: (property_identifier [200, 21] - [200, 26]))
|
|
arguments: (arguments [200, 26] - [200, 72]
|
|
(identifier [200, 27] - [200, 42])
|
|
(identifier [200, 44] - [200, 47])
|
|
(call_expression [200, 49] - [200, 71]
|
|
function: (member_expression [200, 49] - [200, 63]
|
|
object: (identifier [200, 49] - [200, 53])
|
|
property: (property_identifier [200, 54] - [200, 63]))
|
|
arguments: (arguments [200, 63] - [200, 71]
|
|
(identifier [200, 64] - [200, 70]))))))))
|
|
alternative: (else_clause [201, 8] - [203, 7]
|
|
(statement_block [201, 13] - [203, 7]
|
|
(expression_statement [202, 8] - [202, 66]
|
|
(await_expression [202, 8] - [202, 65]
|
|
(call_expression [202, 14] - [202, 65]
|
|
function: (member_expression [202, 14] - [202, 24]
|
|
object: (identifier [202, 14] - [202, 20])
|
|
property: (property_identifier [202, 21] - [202, 24]))
|
|
arguments: (arguments [202, 24] - [202, 65]
|
|
(identifier [202, 25] - [202, 40])
|
|
(call_expression [202, 42] - [202, 64]
|
|
function: (member_expression [202, 42] - [202, 56]
|
|
object: (identifier [202, 42] - [202, 46])
|
|
property: (property_identifier [202, 47] - [202, 56]))
|
|
arguments: (arguments [202, 56] - [202, 64]
|
|
(identifier [202, 57] - [202, 63])))))))))))))
|
|
handler: (catch_clause [205, 4] - [207, 3]
|
|
parameter: (identifier [205, 11] - [205, 14])
|
|
body: (statement_block [205, 16] - [207, 3]
|
|
(expression_statement [206, 4] - [206, 73]
|
|
(call_expression [206, 4] - [206, 72]
|
|
function: (member_expression [206, 4] - [206, 17]
|
|
object: (identifier [206, 4] - [206, 11])
|
|
property: (property_identifier [206, 12] - [206, 17]))
|
|
arguments: (arguments [206, 17] - [206, 72]
|
|
(string [206, 18] - [206, 66]
|
|
(string_fragment [206, 19] - [206, 65]))
|
|
(identifier [206, 68] - [206, 71])))))))
|
|
(expression_statement [209, 2] - [215, 4]
|
|
(call_expression [209, 2] - [215, 3]
|
|
function: (member_expression [209, 2] - [209, 23]
|
|
object: (identifier [209, 2] - [209, 14])
|
|
property: (property_identifier [209, 15] - [209, 23]))
|
|
arguments: (arguments [209, 23] - [215, 3]
|
|
(member_expression [210, 4] - [210, 15]
|
|
object: (identifier [210, 4] - [210, 8])
|
|
property: (property_identifier [210, 9] - [210, 15]))
|
|
(ternary_expression [211, 4] - [211, 55]
|
|
condition: (identifier [211, 4] - [211, 15])
|
|
consequence: (string [211, 18] - [211, 34]
|
|
(string_fragment [211, 19] - [211, 33]))
|
|
alternative: (string [211, 37] - [211, 55]
|
|
(string_fragment [211, 38] - [211, 54])))
|
|
(identifier [212, 4] - [212, 19])
|
|
(object [213, 4] - [213, 6])
|
|
(call_expression [214, 4] - [214, 18]
|
|
function: (identifier [214, 4] - [214, 15])
|
|
arguments: (arguments [214, 15] - [214, 18]
|
|
(identifier [214, 16] - [214, 17]))))))
|
|
(return_statement [217, 2] - [217, 59]
|
|
(call_expression [217, 9] - [217, 58]
|
|
function: (member_expression [217, 9] - [217, 15]
|
|
object: (identifier [217, 9] - [217, 10])
|
|
property: (property_identifier [217, 11] - [217, 15]))
|
|
arguments: (arguments [217, 15] - [217, 58]
|
|
(object [217, 16] - [217, 57]
|
|
(pair [217, 18] - [217, 31]
|
|
key: (property_identifier [217, 18] - [217, 25])
|
|
value: (true [217, 27] - [217, 31]))
|
|
(pair [217, 33] - [217, 55]
|
|
key: (property_identifier [217, 33] - [217, 42])
|
|
value: (identifier [217, 44] - [217, 55])))))))))))
|
|
(comment [220, 0] - [220, 60])
|
|
(comment [221, 0] - [221, 21])
|
|
(comment [222, 0] - [222, 60])
|
|
(expression_statement [223, 0] - [261, 3]
|
|
(call_expression [223, 0] - [261, 2]
|
|
function: (member_expression [223, 0] - [223, 25]
|
|
object: (identifier [223, 0] - [223, 20])
|
|
property: (property_identifier [223, 21] - [223, 25]))
|
|
arguments: (arguments [223, 25] - [261, 2]
|
|
(string [223, 26] - [223, 52]
|
|
(string_fragment [223, 27] - [223, 51]))
|
|
(arrow_function [223, 54] - [261, 1]
|
|
parameters: (formal_parameters [223, 60] - [223, 63]
|
|
(required_parameter [223, 61] - [223, 62]
|
|
pattern: (identifier [223, 61] - [223, 62])))
|
|
body: (statement_block [223, 67] - [261, 1]
|
|
(lexical_declaration [224, 2] - [224, 45]
|
|
(variable_declarator [224, 8] - [224, 44]
|
|
name: (identifier [224, 8] - [224, 12])
|
|
value: (await_expression [224, 15] - [224, 44]
|
|
(call_expression [224, 21] - [224, 44]
|
|
function: (identifier [224, 21] - [224, 41])
|
|
arguments: (arguments [224, 41] - [224, 44]
|
|
(identifier [224, 42] - [224, 43]))))))
|
|
(if_statement [225, 2] - [225, 59]
|
|
condition: (parenthesized_expression [225, 5] - [225, 12]
|
|
(unary_expression [225, 6] - [225, 11]
|
|
argument: (identifier [225, 7] - [225, 11])))
|
|
consequence: (return_statement [225, 13] - [225, 59]
|
|
(call_expression [225, 20] - [225, 58]
|
|
function: (member_expression [225, 20] - [225, 26]
|
|
object: (identifier [225, 20] - [225, 21])
|
|
property: (property_identifier [225, 22] - [225, 26]))
|
|
arguments: (arguments [225, 26] - [225, 58]
|
|
(object [225, 27] - [225, 52]
|
|
(pair [225, 29] - [225, 50]
|
|
key: (property_identifier [225, 29] - [225, 34])
|
|
value: (string [225, 36] - [225, 50]
|
|
(string_fragment [225, 37] - [225, 49]))))
|
|
(number [225, 54] - [225, 57])))))
|
|
(if_statement [227, 2] - [229, 3]
|
|
condition: (parenthesized_expression [227, 5] - [227, 40]
|
|
(unary_expression [227, 6] - [227, 39]
|
|
argument: (call_expression [227, 7] - [227, 39]
|
|
function: (identifier [227, 7] - [227, 15])
|
|
arguments: (arguments [227, 15] - [227, 39]
|
|
(identifier [227, 16] - [227, 20])
|
|
(string [227, 22] - [227, 38]
|
|
(string_fragment [227, 23] - [227, 37]))))))
|
|
consequence: (statement_block [227, 41] - [229, 3]
|
|
(return_statement [228, 4] - [228, 68]
|
|
(call_expression [228, 11] - [228, 67]
|
|
function: (member_expression [228, 11] - [228, 17]
|
|
object: (identifier [228, 11] - [228, 12])
|
|
property: (property_identifier [228, 13] - [228, 17]))
|
|
arguments: (arguments [228, 17] - [228, 67]
|
|
(object [228, 18] - [228, 61]
|
|
(pair [228, 20] - [228, 59]
|
|
key: (property_identifier [228, 20] - [228, 25])
|
|
value: (string [228, 27] - [228, 59]
|
|
(string_fragment [228, 28] - [228, 58]))))
|
|
(number [228, 63] - [228, 66]))))))
|
|
(lexical_declaration [231, 2] - [231, 44]
|
|
(variable_declarator [231, 8] - [231, 43]
|
|
name: (identifier [231, 8] - [231, 23])
|
|
value: (call_expression [231, 26] - [231, 43]
|
|
function: (member_expression [231, 26] - [231, 37]
|
|
object: (member_expression [231, 26] - [231, 31]
|
|
object: (identifier [231, 26] - [231, 27])
|
|
property: (property_identifier [231, 28] - [231, 31]))
|
|
property: (property_identifier [231, 32] - [231, 37]))
|
|
arguments: (arguments [231, 37] - [231, 43]
|
|
(string [231, 38] - [231, 42]
|
|
(string_fragment [231, 39] - [231, 41]))))))
|
|
(lexical_declaration [232, 2] - [232, 67]
|
|
(variable_declarator [232, 8] - [232, 66]
|
|
name: (object_pattern [232, 8] - [232, 27]
|
|
(object_assignment_pattern [232, 10] - [232, 25]
|
|
left: (shorthand_property_identifier_pattern [232, 10] - [232, 21])
|
|
right: (number [232, 24] - [232, 25])))
|
|
value: (await_expression [232, 30] - [232, 66]
|
|
(call_expression [232, 36] - [232, 66]
|
|
function: (member_expression [232, 36] - [232, 54]
|
|
object: (call_expression [232, 36] - [232, 48]
|
|
function: (member_expression [232, 36] - [232, 46]
|
|
object: (member_expression [232, 36] - [232, 41]
|
|
object: (identifier [232, 36] - [232, 37])
|
|
property: (property_identifier [232, 38] - [232, 41]))
|
|
property: (property_identifier [232, 42] - [232, 46]))
|
|
arguments: (arguments [232, 46] - [232, 48]))
|
|
property: (property_identifier [232, 49] - [232, 54]))
|
|
arguments: (arguments [232, 54] - [232, 66]
|
|
(arrow_function [232, 55] - [232, 65]
|
|
parameters: (formal_parameters [232, 55] - [232, 57])
|
|
body: (parenthesized_expression [232, 61] - [232, 65]
|
|
(object [232, 62] - [232, 64]))))))))
|
|
(lexical_declaration [233, 2] - [233, 64]
|
|
(variable_declarator [233, 8] - [233, 63]
|
|
name: (identifier [233, 8] - [233, 23])
|
|
value: (call_expression [233, 26] - [233, 63]
|
|
function: (member_expression [233, 26] - [233, 34]
|
|
object: (identifier [233, 26] - [233, 30])
|
|
property: (property_identifier [233, 31] - [233, 34]))
|
|
arguments: (arguments [233, 34] - [233, 63]
|
|
(binary_expression [233, 35] - [233, 59]
|
|
left: (call_expression [233, 35] - [233, 54]
|
|
function: (identifier [233, 35] - [233, 41])
|
|
arguments: (arguments [233, 41] - [233, 54]
|
|
(identifier [233, 42] - [233, 53])))
|
|
right: (number [233, 58] - [233, 59]))
|
|
(number [233, 61] - [233, 62])))))
|
|
(lexical_declaration [235, 2] - [235, 78]
|
|
(variable_declarator [235, 8] - [235, 77]
|
|
name: (identifier [235, 8] - [235, 15])
|
|
value: (await_expression [235, 18] - [235, 77]
|
|
(call_expression [235, 24] - [235, 77]
|
|
function: (identifier [235, 24] - [235, 47])
|
|
arguments: (arguments [235, 47] - [235, 77]
|
|
(identifier [235, 48] - [235, 63])
|
|
(member_expression [235, 65] - [235, 76]
|
|
object: (identifier [235, 65] - [235, 69])
|
|
property: (property_identifier [235, 70] - [235, 76])))))))
|
|
(if_statement [236, 2] - [238, 3]
|
|
condition: (parenthesized_expression [236, 5] - [236, 15]
|
|
(unary_expression [236, 6] - [236, 14]
|
|
argument: (identifier [236, 7] - [236, 14])))
|
|
consequence: (statement_block [236, 16] - [238, 3]
|
|
(return_statement [237, 4] - [237, 72]
|
|
(call_expression [237, 11] - [237, 71]
|
|
function: (member_expression [237, 11] - [237, 17]
|
|
object: (identifier [237, 11] - [237, 12])
|
|
property: (property_identifier [237, 13] - [237, 17]))
|
|
arguments: (arguments [237, 17] - [237, 71]
|
|
(object [237, 18] - [237, 65]
|
|
(pair [237, 20] - [237, 63]
|
|
key: (property_identifier [237, 20] - [237, 25])
|
|
value: (string [237, 27] - [237, 63]
|
|
(string_fragment [237, 28] - [237, 62]))))
|
|
(number [237, 67] - [237, 70]))))))
|
|
(lexical_declaration [240, 2] - [240, 63]
|
|
(variable_declarator [240, 8] - [240, 62]
|
|
name: (identifier [240, 8] - [240, 21])
|
|
value: (call_expression [240, 24] - [240, 62]
|
|
function: (member_expression [240, 24] - [240, 60]
|
|
object: (new_expression [240, 24] - [240, 52]
|
|
constructor: (identifier [240, 28] - [240, 32])
|
|
arguments: (arguments [240, 32] - [240, 52]
|
|
(member_expression [240, 33] - [240, 51]
|
|
object: (identifier [240, 33] - [240, 40])
|
|
property: (property_identifier [240, 41] - [240, 51]))))
|
|
property: (property_identifier [240, 53] - [240, 60]))
|
|
arguments: (arguments [240, 60] - [240, 62]))))
|
|
(lexical_declaration [241, 2] - [243, 4]
|
|
(variable_declarator [241, 8] - [243, 3]
|
|
name: (identifier [241, 8] - [241, 17])
|
|
value: (new_expression [241, 20] - [243, 3]
|
|
constructor: (identifier [241, 24] - [241, 28])
|
|
arguments: (arguments [241, 28] - [243, 3]
|
|
(binary_expression [242, 4] - [242, 71]
|
|
left: (call_expression [242, 4] - [242, 39]
|
|
function: (member_expression [242, 4] - [242, 12]
|
|
object: (identifier [242, 4] - [242, 8])
|
|
property: (property_identifier [242, 9] - [242, 12]))
|
|
arguments: (arguments [242, 12] - [242, 39]
|
|
(call_expression [242, 13] - [242, 23]
|
|
function: (member_expression [242, 13] - [242, 21]
|
|
object: (identifier [242, 13] - [242, 17])
|
|
property: (property_identifier [242, 18] - [242, 21]))
|
|
arguments: (arguments [242, 21] - [242, 23]))
|
|
(identifier [242, 25] - [242, 38])))
|
|
right: (binary_expression [242, 42] - [242, 71]
|
|
left: (binary_expression [242, 42] - [242, 64]
|
|
left: (identifier [242, 42] - [242, 57])
|
|
right: (number [242, 60] - [242, 64]))
|
|
right: (number [242, 67] - [242, 71])))))))
|
|
(expression_statement [245, 2] - [245, 56]
|
|
(await_expression [245, 2] - [245, 55]
|
|
(call_expression [245, 8] - [245, 55]
|
|
function: (identifier [245, 8] - [245, 27])
|
|
arguments: (arguments [245, 27] - [245, 55]
|
|
(identifier [245, 28] - [245, 43])
|
|
(identifier [245, 45] - [245, 54])))))
|
|
(try_statement [247, 2] - [253, 17]
|
|
body: (statement_block [247, 6] - [253, 3]
|
|
(lexical_declaration [248, 4] - [251, 6]
|
|
(variable_declarator [248, 10] - [251, 5]
|
|
name: (identifier [248, 10] - [248, 20])
|
|
value: (call_expression [248, 23] - [251, 5]
|
|
function: (member_expression [248, 23] - [248, 31]
|
|
object: (identifier [248, 23] - [248, 27])
|
|
property: (property_identifier [248, 28] - [248, 31]))
|
|
arguments: (arguments [248, 31] - [251, 5]
|
|
(number [249, 6] - [249, 7])
|
|
(call_expression [250, 6] - [250, 59]
|
|
function: (member_expression [250, 6] - [250, 16]
|
|
object: (identifier [250, 6] - [250, 10])
|
|
property: (property_identifier [250, 11] - [250, 16]))
|
|
arguments: (arguments [250, 16] - [250, 59]
|
|
(binary_expression [250, 17] - [250, 58]
|
|
left: (parenthesized_expression [250, 17] - [250, 51]
|
|
(binary_expression [250, 18] - [250, 50]
|
|
left: (call_expression [250, 18] - [250, 37]
|
|
function: (member_expression [250, 18] - [250, 35]
|
|
object: (identifier [250, 18] - [250, 27])
|
|
property: (property_identifier [250, 28] - [250, 35]))
|
|
arguments: (arguments [250, 35] - [250, 37]))
|
|
right: (call_expression [250, 40] - [250, 50]
|
|
function: (member_expression [250, 40] - [250, 48]
|
|
object: (identifier [250, 40] - [250, 44])
|
|
property: (property_identifier [250, 45] - [250, 48]))
|
|
arguments: (arguments [250, 48] - [250, 50]))))
|
|
right: (number [250, 54] - [250, 58]))))))))
|
|
(expression_statement [252, 4] - [252, 53]
|
|
(await_expression [252, 4] - [252, 52]
|
|
(call_expression [252, 10] - [252, 52]
|
|
function: (member_expression [252, 10] - [252, 23]
|
|
object: (identifier [252, 10] - [252, 16])
|
|
property: (property_identifier [252, 17] - [252, 23]))
|
|
arguments: (arguments [252, 23] - [252, 52]
|
|
(identifier [252, 24] - [252, 39])
|
|
(identifier [252, 41] - [252, 51]))))))
|
|
handler: (catch_clause [253, 4] - [253, 17]
|
|
parameter: (identifier [253, 11] - [253, 13])
|
|
body: (statement_block [253, 15] - [253, 17])))
|
|
(expression_statement [255, 2] - [258, 21]
|
|
(call_expression [255, 2] - [258, 20]
|
|
function: (member_expression [255, 2] - [255, 23]
|
|
object: (identifier [255, 2] - [255, 14])
|
|
property: (property_identifier [255, 15] - [255, 23]))
|
|
arguments: (arguments [255, 23] - [258, 20]
|
|
(member_expression [255, 24] - [255, 35]
|
|
object: (identifier [255, 24] - [255, 28])
|
|
property: (property_identifier [255, 29] - [255, 35]))
|
|
(string [255, 37] - [255, 55]
|
|
(string_fragment [255, 38] - [255, 54]))
|
|
(identifier [255, 57] - [255, 72])
|
|
(object [255, 74] - [258, 3]
|
|
(pair [256, 4] - [256, 38]
|
|
key: (property_identifier [256, 4] - [256, 21])
|
|
value: (identifier [256, 23] - [256, 38]))
|
|
(pair [257, 4] - [257, 43]
|
|
key: (property_identifier [257, 4] - [257, 18])
|
|
value: (call_expression [257, 20] - [257, 43]
|
|
function: (member_expression [257, 20] - [257, 41]
|
|
object: (identifier [257, 20] - [257, 29])
|
|
property: (property_identifier [257, 30] - [257, 41]))
|
|
arguments: (arguments [257, 41] - [257, 43]))))
|
|
(call_expression [258, 5] - [258, 19]
|
|
function: (identifier [258, 5] - [258, 16])
|
|
arguments: (arguments [258, 16] - [258, 19]
|
|
(identifier [258, 17] - [258, 18]))))))
|
|
(return_statement [260, 2] - [260, 74]
|
|
(call_expression [260, 9] - [260, 73]
|
|
function: (member_expression [260, 9] - [260, 15]
|
|
object: (identifier [260, 9] - [260, 10])
|
|
property: (property_identifier [260, 11] - [260, 15]))
|
|
arguments: (arguments [260, 15] - [260, 73]
|
|
(object [260, 16] - [260, 72]
|
|
(pair [260, 18] - [260, 31]
|
|
key: (property_identifier [260, 18] - [260, 25])
|
|
value: (true [260, 27] - [260, 31]))
|
|
(pair [260, 33] - [260, 70]
|
|
key: (property_identifier [260, 33] - [260, 45])
|
|
value: (call_expression [260, 47] - [260, 70]
|
|
function: (member_expression [260, 47] - [260, 68]
|
|
object: (identifier [260, 47] - [260, 56])
|
|
property: (property_identifier [260, 57] - [260, 68]))
|
|
arguments: (arguments [260, 68] - [260, 70]))))))))))))
|
|
(comment [263, 0] - [263, 60])
|
|
(comment [264, 0] - [264, 28])
|
|
(comment [265, 0] - [265, 60])
|
|
(expression_statement [266, 0] - [306, 3]
|
|
(call_expression [266, 0] - [306, 2]
|
|
function: (member_expression [266, 0] - [266, 27]
|
|
object: (identifier [266, 0] - [266, 20])
|
|
property: (property_identifier [266, 21] - [266, 27]))
|
|
arguments: (arguments [266, 27] - [306, 2]
|
|
(string [266, 28] - [266, 47]
|
|
(string_fragment [266, 29] - [266, 46]))
|
|
(arrow_function [266, 49] - [306, 1]
|
|
parameters: (formal_parameters [266, 55] - [266, 58]
|
|
(required_parameter [266, 56] - [266, 57]
|
|
pattern: (identifier [266, 56] - [266, 57])))
|
|
body: (statement_block [266, 62] - [306, 1]
|
|
(lexical_declaration [267, 2] - [267, 45]
|
|
(variable_declarator [267, 8] - [267, 44]
|
|
name: (identifier [267, 8] - [267, 12])
|
|
value: (await_expression [267, 15] - [267, 44]
|
|
(call_expression [267, 21] - [267, 44]
|
|
function: (identifier [267, 21] - [267, 41])
|
|
arguments: (arguments [267, 41] - [267, 44]
|
|
(identifier [267, 42] - [267, 43]))))))
|
|
(if_statement [268, 2] - [268, 59]
|
|
condition: (parenthesized_expression [268, 5] - [268, 12]
|
|
(unary_expression [268, 6] - [268, 11]
|
|
argument: (identifier [268, 7] - [268, 11])))
|
|
consequence: (return_statement [268, 13] - [268, 59]
|
|
(call_expression [268, 20] - [268, 58]
|
|
function: (member_expression [268, 20] - [268, 26]
|
|
object: (identifier [268, 20] - [268, 21])
|
|
property: (property_identifier [268, 22] - [268, 26]))
|
|
arguments: (arguments [268, 26] - [268, 58]
|
|
(object [268, 27] - [268, 52]
|
|
(pair [268, 29] - [268, 50]
|
|
key: (property_identifier [268, 29] - [268, 34])
|
|
value: (string [268, 36] - [268, 50]
|
|
(string_fragment [268, 37] - [268, 49]))))
|
|
(number [268, 54] - [268, 57])))))
|
|
(lexical_declaration [270, 2] - [270, 44]
|
|
(variable_declarator [270, 8] - [270, 43]
|
|
name: (identifier [270, 8] - [270, 23])
|
|
value: (call_expression [270, 26] - [270, 43]
|
|
function: (member_expression [270, 26] - [270, 37]
|
|
object: (member_expression [270, 26] - [270, 31]
|
|
object: (identifier [270, 26] - [270, 27])
|
|
property: (property_identifier [270, 28] - [270, 31]))
|
|
property: (property_identifier [270, 32] - [270, 37]))
|
|
arguments: (arguments [270, 37] - [270, 43]
|
|
(string [270, 38] - [270, 42]
|
|
(string_fragment [270, 39] - [270, 41]))))))
|
|
(if_statement [272, 2] - [276, 3]
|
|
condition: (parenthesized_expression [272, 5] - [272, 41]
|
|
(binary_expression [272, 6] - [272, 40]
|
|
left: (identifier [272, 6] - [272, 21])
|
|
right: (member_expression [272, 26] - [272, 40]
|
|
object: (identifier [272, 26] - [272, 30])
|
|
property: (property_identifier [272, 31] - [272, 40]))))
|
|
consequence: (statement_block [272, 42] - [276, 3]
|
|
(if_statement [273, 4] - [275, 5]
|
|
condition: (parenthesized_expression [273, 7] - [273, 42]
|
|
(unary_expression [273, 8] - [273, 41]
|
|
argument: (call_expression [273, 9] - [273, 41]
|
|
function: (identifier [273, 9] - [273, 17])
|
|
arguments: (arguments [273, 17] - [273, 41]
|
|
(identifier [273, 18] - [273, 22])
|
|
(string [273, 24] - [273, 40]
|
|
(string_fragment [273, 25] - [273, 39]))))))
|
|
consequence: (statement_block [273, 43] - [275, 5]
|
|
(return_statement [274, 6] - [274, 70]
|
|
(call_expression [274, 13] - [274, 69]
|
|
function: (member_expression [274, 13] - [274, 19]
|
|
object: (identifier [274, 13] - [274, 14])
|
|
property: (property_identifier [274, 15] - [274, 19]))
|
|
arguments: (arguments [274, 19] - [274, 69]
|
|
(object [274, 20] - [274, 63]
|
|
(pair [274, 22] - [274, 61]
|
|
key: (property_identifier [274, 22] - [274, 27])
|
|
value: (string [274, 29] - [274, 61]
|
|
(string_fragment [274, 30] - [274, 60]))))
|
|
(number [274, 65] - [274, 68]))))))))
|
|
(lexical_declaration [278, 2] - [278, 65]
|
|
(variable_declarator [278, 8] - [278, 64]
|
|
name: (identifier [278, 8] - [278, 15])
|
|
value: (binary_expression [278, 18] - [278, 64]
|
|
left: (call_expression [278, 18] - [278, 41]
|
|
function: (identifier [278, 18] - [278, 26])
|
|
arguments: (arguments [278, 26] - [278, 41]
|
|
(identifier [278, 27] - [278, 31])
|
|
(string [278, 33] - [278, 40]
|
|
(string_fragment [278, 34] - [278, 39]))))
|
|
right: (call_expression [278, 45] - [278, 64]
|
|
function: (identifier [278, 45] - [278, 53])
|
|
arguments: (arguments [278, 53] - [278, 64]
|
|
(identifier [278, 54] - [278, 58])
|
|
(string [278, 60] - [278, 63]
|
|
(string_fragment [278, 61] - [278, 62])))))))
|
|
(lexical_declaration [279, 2] - [283, 4]
|
|
(variable_declarator [279, 8] - [283, 3]
|
|
name: (identifier [279, 8] - [279, 15])
|
|
value: (await_expression [279, 18] - [283, 3]
|
|
(call_expression [279, 24] - [283, 3]
|
|
function: (identifier [279, 24] - [279, 52])
|
|
arguments: (arguments [279, 52] - [283, 3]
|
|
(identifier [280, 4] - [280, 19])
|
|
(member_expression [281, 4] - [281, 15]
|
|
object: (identifier [281, 4] - [281, 8])
|
|
property: (property_identifier [281, 9] - [281, 15]))
|
|
(identifier [282, 4] - [282, 11]))))))
|
|
(if_statement [285, 2] - [287, 3]
|
|
condition: (parenthesized_expression [285, 5] - [285, 15]
|
|
(unary_expression [285, 6] - [285, 14]
|
|
argument: (identifier [285, 7] - [285, 14])))
|
|
consequence: (statement_block [285, 16] - [287, 3]
|
|
(return_statement [286, 4] - [286, 72]
|
|
(call_expression [286, 11] - [286, 71]
|
|
function: (member_expression [286, 11] - [286, 17]
|
|
object: (identifier [286, 11] - [286, 12])
|
|
property: (property_identifier [286, 13] - [286, 17]))
|
|
arguments: (arguments [286, 17] - [286, 71]
|
|
(object [286, 18] - [286, 65]
|
|
(pair [286, 20] - [286, 63]
|
|
key: (property_identifier [286, 20] - [286, 25])
|
|
value: (string [286, 27] - [286, 63]
|
|
(string_fragment [286, 28] - [286, 62]))))
|
|
(number [286, 67] - [286, 70]))))))
|
|
(try_statement [289, 2] - [297, 3]
|
|
body: (statement_block [289, 6] - [295, 3]
|
|
(expression_statement [290, 4] - [290, 38]
|
|
(await_expression [290, 4] - [290, 37]
|
|
(call_expression [290, 10] - [290, 37]
|
|
function: (member_expression [290, 10] - [290, 20]
|
|
object: (identifier [290, 10] - [290, 16])
|
|
property: (property_identifier [290, 17] - [290, 20]))
|
|
arguments: (arguments [290, 20] - [290, 37]
|
|
(identifier [290, 21] - [290, 36])))))
|
|
(expression_statement [291, 4] - [294, 6]
|
|
(await_expression [291, 4] - [294, 5]
|
|
(call_expression [291, 10] - [294, 5]
|
|
function: (member_expression [291, 10] - [291, 24]
|
|
object: (identifier [291, 10] - [291, 16])
|
|
property: (property_identifier [291, 17] - [291, 24]))
|
|
arguments: (arguments [291, 24] - [294, 5]
|
|
(template_string [292, 6] - [292, 43]
|
|
(string_fragment [292, 7] - [292, 24])
|
|
(template_substitution [292, 24] - [292, 42]
|
|
(identifier [292, 26] - [292, 41])))
|
|
(call_expression [293, 6] - [293, 76]
|
|
function: (member_expression [293, 6] - [293, 20]
|
|
object: (identifier [293, 6] - [293, 10])
|
|
property: (property_identifier [293, 11] - [293, 20]))
|
|
arguments: (arguments [293, 20] - [293, 76]
|
|
(object [293, 21] - [293, 75]
|
|
(pair [293, 23] - [293, 49]
|
|
key: (property_identifier [293, 23] - [293, 32])
|
|
value: (identifier [293, 34] - [293, 49]))
|
|
(pair [293, 51] - [293, 73]
|
|
key: (property_identifier [293, 51] - [293, 60])
|
|
value: (member_expression [293, 62] - [293, 73]
|
|
object: (identifier [293, 62] - [293, 66])
|
|
property: (property_identifier [293, 67] - [293, 73])))))))))))
|
|
handler: (catch_clause [295, 4] - [297, 3]
|
|
parameter: (identifier [295, 11] - [295, 14])
|
|
body: (statement_block [295, 16] - [297, 3]
|
|
(expression_statement [296, 4] - [296, 63]
|
|
(call_expression [296, 4] - [296, 62]
|
|
function: (member_expression [296, 4] - [296, 17]
|
|
object: (identifier [296, 4] - [296, 11])
|
|
property: (property_identifier [296, 12] - [296, 17]))
|
|
arguments: (arguments [296, 17] - [296, 62]
|
|
(string [296, 18] - [296, 56]
|
|
(string_fragment [296, 19] - [296, 55]))
|
|
(identifier [296, 58] - [296, 61])))))))
|
|
(expression_statement [299, 2] - [299, 39]
|
|
(await_expression [299, 2] - [299, 38]
|
|
(call_expression [299, 8] - [299, 38]
|
|
function: (identifier [299, 8] - [299, 21])
|
|
arguments: (arguments [299, 21] - [299, 38]
|
|
(identifier [299, 22] - [299, 37])))))
|
|
(expression_statement [301, 2] - [303, 21]
|
|
(call_expression [301, 2] - [303, 20]
|
|
function: (member_expression [301, 2] - [301, 23]
|
|
object: (identifier [301, 2] - [301, 14])
|
|
property: (property_identifier [301, 15] - [301, 23]))
|
|
arguments: (arguments [301, 23] - [303, 20]
|
|
(member_expression [301, 24] - [301, 35]
|
|
object: (identifier [301, 24] - [301, 28])
|
|
property: (property_identifier [301, 29] - [301, 35]))
|
|
(string [301, 37] - [301, 54]
|
|
(string_fragment [301, 38] - [301, 53]))
|
|
(null [301, 56] - [301, 60])
|
|
(object [301, 62] - [303, 3]
|
|
(pair [302, 4] - [302, 39]
|
|
key: (property_identifier [302, 4] - [302, 22])
|
|
value: (identifier [302, 24] - [302, 39])))
|
|
(call_expression [303, 5] - [303, 19]
|
|
function: (identifier [303, 5] - [303, 16])
|
|
arguments: (arguments [303, 16] - [303, 19]
|
|
(identifier [303, 17] - [303, 18]))))))
|
|
(return_statement [305, 2] - [305, 35]
|
|
(call_expression [305, 9] - [305, 34]
|
|
function: (member_expression [305, 9] - [305, 15]
|
|
object: (identifier [305, 9] - [305, 10])
|
|
property: (property_identifier [305, 11] - [305, 15]))
|
|
arguments: (arguments [305, 15] - [305, 34]
|
|
(object [305, 16] - [305, 33]
|
|
(pair [305, 18] - [305, 31]
|
|
key: (property_identifier [305, 18] - [305, 25])
|
|
value: (true [305, 27] - [305, 31]))))))))))))
|