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