1301 lines
78 KiB
Plaintext
1301 lines
78 KiB
Plaintext
(program [0, 0] - [309, 0]
|
|
(import_statement [0, 0] - [0, 48]
|
|
(import_clause [0, 12] - [0, 23]
|
|
(named_imports [0, 12] - [0, 23]
|
|
(import_specifier [0, 14] - [0, 21]
|
|
name: (identifier [0, 14] - [0, 21]))))
|
|
source: (string [0, 29] - [0, 47]
|
|
(string_fragment [0, 30] - [0, 46])))
|
|
(import_statement [1, 0] - [1, 55]
|
|
(import_clause [1, 7] - [1, 23]
|
|
(named_imports [1, 7] - [1, 23]
|
|
(import_specifier [1, 9] - [1, 21]
|
|
name: (identifier [1, 9] - [1, 21]))))
|
|
source: (string [1, 29] - [1, 54]
|
|
(string_fragment [1, 30] - [1, 53])))
|
|
(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, 37]
|
|
(import_clause [3, 7] - [3, 17]
|
|
(named_imports [3, 7] - [3, 17]
|
|
(import_specifier [3, 9] - [3, 15]
|
|
name: (identifier [3, 9] - [3, 15]))))
|
|
source: (string [3, 23] - [3, 36]
|
|
(string_fragment [3, 24] - [3, 35])))
|
|
(export_statement [5, 0] - [13, 1]
|
|
declaration: (interface_declaration [5, 7] - [13, 1]
|
|
name: (type_identifier [5, 17] - [5, 34])
|
|
body: (interface_body [5, 35] - [13, 1]
|
|
(property_signature [6, 2] - [6, 16]
|
|
name: (property_identifier [6, 2] - [6, 8])
|
|
type: (type_annotation [6, 8] - [6, 16]
|
|
(predefined_type [6, 10] - [6, 16])))
|
|
(property_signature [7, 2] - [7, 19]
|
|
name: (property_identifier [7, 2] - [7, 11])
|
|
type: (type_annotation [7, 11] - [7, 19]
|
|
(predefined_type [7, 13] - [7, 19])))
|
|
(property_signature [8, 2] - [8, 18]
|
|
name: (property_identifier [8, 2] - [8, 10])
|
|
type: (type_annotation [8, 10] - [8, 18]
|
|
(predefined_type [8, 12] - [8, 18])))
|
|
(property_signature [9, 2] - [9, 16]
|
|
name: (property_identifier [9, 2] - [9, 7])
|
|
type: (type_annotation [9, 8] - [9, 16]
|
|
(predefined_type [9, 10] - [9, 16])))
|
|
(property_signature [10, 2] - [10, 19]
|
|
name: (property_identifier [10, 2] - [10, 9])
|
|
type: (type_annotation [10, 10] - [10, 19]
|
|
(predefined_type [10, 12] - [10, 19])))
|
|
(property_signature [11, 2] - [11, 20]
|
|
name: (property_identifier [11, 2] - [11, 10])
|
|
type: (type_annotation [11, 11] - [11, 20]
|
|
(predefined_type [11, 13] - [11, 20])))
|
|
(property_signature [12, 2] - [12, 25]
|
|
name: (property_identifier [12, 2] - [12, 14])
|
|
type: (type_annotation [12, 15] - [12, 25]
|
|
(array_type [12, 17] - [12, 25]
|
|
(predefined_type [12, 17] - [12, 23])))))))
|
|
(export_statement [15, 0] - [22, 1]
|
|
declaration: (interface_declaration [15, 7] - [22, 1]
|
|
name: (type_identifier [15, 17] - [15, 26])
|
|
body: (interface_body [15, 27] - [22, 1]
|
|
(property_signature [16, 2] - [16, 12]
|
|
name: (property_identifier [16, 2] - [16, 4])
|
|
type: (type_annotation [16, 4] - [16, 12]
|
|
(predefined_type [16, 6] - [16, 12])))
|
|
(property_signature [17, 2] - [17, 14]
|
|
name: (property_identifier [17, 2] - [17, 6])
|
|
type: (type_annotation [17, 6] - [17, 14]
|
|
(predefined_type [17, 8] - [17, 14])))
|
|
(property_signature [18, 2] - [18, 17]
|
|
name: (property_identifier [18, 2] - [18, 8])
|
|
type: (type_annotation [18, 9] - [18, 17]
|
|
(predefined_type [18, 11] - [18, 17])))
|
|
(property_signature [19, 2] - [19, 21]
|
|
name: (property_identifier [19, 2] - [19, 11])
|
|
type: (type_annotation [19, 12] - [19, 21]
|
|
(predefined_type [19, 14] - [19, 21])))
|
|
(property_signature [20, 2] - [20, 25]
|
|
name: (property_identifier [20, 2] - [20, 14])
|
|
type: (type_annotation [20, 15] - [20, 25]
|
|
(array_type [20, 17] - [20, 25]
|
|
(predefined_type [20, 17] - [20, 23]))))
|
|
(property_signature [21, 2] - [21, 26]
|
|
name: (property_identifier [21, 2] - [21, 15])
|
|
type: (type_annotation [21, 16] - [21, 26]
|
|
(array_type [21, 18] - [21, 26]
|
|
(predefined_type [21, 18] - [21, 24])))))))
|
|
(comment [24, 0] - [26, 3])
|
|
(export_statement [27, 0] - [47, 1]
|
|
declaration: (function_declaration [27, 7] - [47, 1]
|
|
name: (identifier [27, 16] - [27, 36])
|
|
parameters: (formal_parameters [27, 36] - [27, 48]
|
|
(required_parameter [27, 37] - [27, 47]
|
|
pattern: (identifier [27, 37] - [27, 38])
|
|
type: (type_annotation [27, 38] - [27, 47]
|
|
(type_identifier [27, 40] - [27, 47]))))
|
|
return_type: (type_annotation [27, 48] - [27, 58]
|
|
(array_type [27, 50] - [27, 58]
|
|
(predefined_type [27, 50] - [27, 56])))
|
|
body: (statement_block [27, 59] - [47, 1]
|
|
(lexical_declaration [28, 2] - [28, 34]
|
|
(variable_declarator [28, 8] - [28, 33]
|
|
name: (identifier [28, 8] - [28, 18])
|
|
type: (type_annotation [28, 18] - [28, 28]
|
|
(array_type [28, 20] - [28, 28]
|
|
(predefined_type [28, 20] - [28, 26])))
|
|
value: (array [28, 31] - [28, 33])))
|
|
(lexical_declaration [30, 2] - [30, 57]
|
|
(variable_declarator [30, 8] - [30, 56]
|
|
name: (identifier [30, 8] - [30, 18])
|
|
value: (binary_expression [30, 21] - [30, 56]
|
|
left: (call_expression [30, 21] - [30, 50]
|
|
function: (member_expression [30, 21] - [30, 33]
|
|
object: (member_expression [30, 21] - [30, 26]
|
|
object: (identifier [30, 21] - [30, 22])
|
|
property: (property_identifier [30, 23] - [30, 26]))
|
|
property: (property_identifier [30, 27] - [30, 33]))
|
|
arguments: (arguments [30, 33] - [30, 50]
|
|
(string [30, 34] - [30, 49]
|
|
(string_fragment [30, 35] - [30, 48]))))
|
|
right: (string [30, 54] - [30, 56]))))
|
|
(if_statement [31, 2] - [34, 3]
|
|
condition: (parenthesized_expression [31, 5] - [31, 39]
|
|
(call_expression [31, 6] - [31, 38]
|
|
function: (member_expression [31, 6] - [31, 27]
|
|
object: (identifier [31, 6] - [31, 16])
|
|
property: (property_identifier [31, 17] - [31, 27]))
|
|
arguments: (arguments [31, 27] - [31, 38]
|
|
(string [31, 28] - [31, 37]
|
|
(string_fragment [31, 29] - [31, 36])))))
|
|
consequence: (statement_block [31, 40] - [34, 3]
|
|
(lexical_declaration [32, 4] - [32, 55]
|
|
(variable_declarator [32, 10] - [32, 54]
|
|
name: (identifier [32, 10] - [32, 21])
|
|
value: (call_expression [32, 24] - [32, 54]
|
|
function: (member_expression [32, 24] - [32, 52]
|
|
object: (call_expression [32, 24] - [32, 47]
|
|
function: (member_expression [32, 24] - [32, 44]
|
|
object: (identifier [32, 24] - [32, 34])
|
|
property: (property_identifier [32, 35] - [32, 44]))
|
|
arguments: (arguments [32, 44] - [32, 47]
|
|
(number [32, 45] - [32, 46])))
|
|
property: (property_identifier [32, 48] - [32, 52]))
|
|
arguments: (arguments [32, 52] - [32, 54]))))
|
|
(if_statement [33, 4] - [33, 50]
|
|
condition: (parenthesized_expression [33, 7] - [33, 20]
|
|
(identifier [33, 8] - [33, 19]))
|
|
consequence: (expression_statement [33, 21] - [33, 50]
|
|
(call_expression [33, 21] - [33, 49]
|
|
function: (member_expression [33, 21] - [33, 36]
|
|
object: (identifier [33, 21] - [33, 31])
|
|
property: (property_identifier [33, 32] - [33, 36]))
|
|
arguments: (arguments [33, 36] - [33, 49]
|
|
(identifier [33, 37] - [33, 48])))))))
|
|
(lexical_declaration [36, 2] - [36, 52]
|
|
(variable_declarator [36, 8] - [36, 51]
|
|
name: (identifier [36, 8] - [36, 20])
|
|
value: (binary_expression [36, 23] - [36, 51]
|
|
left: (call_expression [36, 23] - [36, 45]
|
|
function: (member_expression [36, 23] - [36, 35]
|
|
object: (member_expression [36, 23] - [36, 28]
|
|
object: (identifier [36, 23] - [36, 24])
|
|
property: (property_identifier [36, 25] - [36, 28]))
|
|
property: (property_identifier [36, 29] - [36, 35]))
|
|
arguments: (arguments [36, 35] - [36, 45]
|
|
(string [36, 36] - [36, 44]
|
|
(string_fragment [36, 37] - [36, 43]))))
|
|
right: (string [36, 49] - [36, 51]))))
|
|
(if_statement [37, 2] - [44, 3]
|
|
condition: (parenthesized_expression [37, 5] - [37, 19]
|
|
(identifier [37, 6] - [37, 18]))
|
|
consequence: (statement_block [37, 20] - [44, 3]
|
|
(lexical_declaration [38, 4] - [42, 23]
|
|
(variable_declarator [38, 10] - [42, 22]
|
|
name: (identifier [38, 10] - [38, 23])
|
|
value: (call_expression [38, 26] - [42, 22]
|
|
function: (member_expression [38, 26] - [42, 13]
|
|
object: (call_expression [38, 26] - [41, 50]
|
|
function: (member_expression [38, 26] - [41, 10]
|
|
object: (array [38, 26] - [40, 5]
|
|
(spread_element [39, 6] - [39, 63]
|
|
(call_expression [39, 9] - [39, 63]
|
|
function: (member_expression [39, 9] - [39, 30]
|
|
object: (identifier [39, 9] - [39, 21])
|
|
property: (property_identifier [39, 22] - [39, 30]))
|
|
arguments: (arguments [39, 30] - [39, 63]
|
|
(regex [39, 31] - [39, 62]
|
|
pattern: (regex_pattern [39, 32] - [39, 60])
|
|
flags: (regex_flags [39, 61] - [39, 62]))))))
|
|
property: (property_identifier [41, 7] - [41, 10]))
|
|
arguments: (arguments [41, 10] - [41, 50]
|
|
(arrow_function [41, 11] - [41, 49]
|
|
parameters: (formal_parameters [41, 11] - [41, 14]
|
|
(required_parameter [41, 12] - [41, 13]
|
|
pattern: (identifier [41, 12] - [41, 13])))
|
|
body: (call_expression [41, 18] - [41, 49]
|
|
function: (identifier [41, 18] - [41, 36])
|
|
arguments: (arguments [41, 36] - [41, 49]
|
|
(call_expression [41, 37] - [41, 48]
|
|
function: (member_expression [41, 37] - [41, 46]
|
|
object: (subscript_expression [41, 37] - [41, 41]
|
|
object: (identifier [41, 37] - [41, 38])
|
|
index: (number [41, 39] - [41, 40]))
|
|
property: (property_identifier [41, 42] - [41, 46]))
|
|
arguments: (arguments [41, 46] - [41, 48])))))))
|
|
property: (property_identifier [42, 7] - [42, 13]))
|
|
arguments: (arguments [42, 13] - [42, 22]
|
|
(identifier [42, 14] - [42, 21])))))
|
|
(expression_statement [43, 4] - [43, 38]
|
|
(call_expression [43, 4] - [43, 37]
|
|
function: (member_expression [43, 4] - [43, 19]
|
|
object: (identifier [43, 4] - [43, 14])
|
|
property: (property_identifier [43, 15] - [43, 19]))
|
|
arguments: (arguments [43, 19] - [43, 37]
|
|
(spread_element [43, 20] - [43, 36]
|
|
(identifier [43, 23] - [43, 36])))))))
|
|
(return_statement [46, 2] - [46, 20]
|
|
(identifier [46, 9] - [46, 19])))))
|
|
(comment [49, 0] - [51, 3])
|
|
(export_statement [52, 0] - [139, 1]
|
|
declaration: (function_declaration [52, 7] - [139, 1]
|
|
name: (identifier [52, 22] - [52, 42])
|
|
parameters: (formal_parameters [52, 42] - [54, 1]
|
|
(required_parameter [53, 2] - [53, 12]
|
|
pattern: (identifier [53, 2] - [53, 3])
|
|
type: (type_annotation [53, 3] - [53, 12]
|
|
(type_identifier [53, 5] - [53, 12]))))
|
|
return_type: (type_annotation [54, 1] - [54, 36]
|
|
(generic_type [54, 3] - [54, 36]
|
|
name: (type_identifier [54, 3] - [54, 10])
|
|
type_arguments: (type_arguments [54, 10] - [54, 36]
|
|
(union_type [54, 11] - [54, 35]
|
|
(type_identifier [54, 11] - [54, 28])
|
|
(literal_type [54, 31] - [54, 35]
|
|
(null [54, 31] - [54, 35]))))))
|
|
body: (statement_block [54, 37] - [139, 1]
|
|
(lexical_declaration [55, 2] - [55, 49]
|
|
(variable_declarator [55, 8] - [55, 48]
|
|
name: (identifier [55, 8] - [55, 22])
|
|
value: (call_expression [55, 25] - [55, 48]
|
|
function: (identifier [55, 25] - [55, 45])
|
|
arguments: (arguments [55, 45] - [55, 48]
|
|
(identifier [55, 46] - [55, 47])))))
|
|
(if_statement [56, 2] - [56, 47]
|
|
condition: (parenthesized_expression [56, 5] - [56, 34]
|
|
(binary_expression [56, 6] - [56, 33]
|
|
left: (member_expression [56, 6] - [56, 27]
|
|
object: (identifier [56, 6] - [56, 20])
|
|
property: (property_identifier [56, 21] - [56, 27]))
|
|
right: (number [56, 32] - [56, 33])))
|
|
consequence: (return_statement [56, 35] - [56, 47]
|
|
(null [56, 42] - [56, 46])))
|
|
(for_statement [58, 2] - [136, 3]
|
|
initializer: (lexical_declaration [58, 7] - [58, 17]
|
|
(variable_declarator [58, 11] - [58, 16]
|
|
name: (identifier [58, 11] - [58, 12])
|
|
value: (number [58, 15] - [58, 16])))
|
|
condition: (binary_expression [58, 18] - [58, 43]
|
|
left: (identifier [58, 18] - [58, 19])
|
|
right: (member_expression [58, 22] - [58, 43]
|
|
object: (identifier [58, 22] - [58, 36])
|
|
property: (property_identifier [58, 37] - [58, 43])))
|
|
increment: (update_expression [58, 45] - [58, 48]
|
|
argument: (identifier [58, 45] - [58, 46]))
|
|
body: (statement_block [58, 50] - [136, 3]
|
|
(lexical_declaration [59, 4] - [59, 42]
|
|
(variable_declarator [59, 10] - [59, 41]
|
|
name: (identifier [59, 10] - [59, 21])
|
|
value: (subscript_expression [59, 24] - [59, 41]
|
|
object: (identifier [59, 24] - [59, 38])
|
|
index: (identifier [59, 39] - [59, 40]))))
|
|
(comment [61, 4] - [61, 26])
|
|
(try_statement [62, 4] - [84, 5]
|
|
body: (statement_block [62, 8] - [82, 5]
|
|
(lexical_declaration [63, 6] - [63, 59]
|
|
(variable_declarator [63, 12] - [63, 58]
|
|
name: (identifier [63, 12] - [63, 26])
|
|
value: (await_expression [63, 29] - [63, 58]
|
|
(call_expression [63, 35] - [63, 58]
|
|
function: (member_expression [63, 35] - [63, 45]
|
|
object: (identifier [63, 35] - [63, 41])
|
|
property: (property_identifier [63, 42] - [63, 45]))
|
|
arguments: (arguments [63, 45] - [63, 58]
|
|
(identifier [63, 46] - [63, 57]))))))
|
|
(if_statement [64, 6] - [81, 7]
|
|
condition: (parenthesized_expression [64, 9] - [64, 25]
|
|
(identifier [64, 10] - [64, 24]))
|
|
consequence: (statement_block [64, 26] - [81, 7]
|
|
(lexical_declaration [65, 8] - [65, 55]
|
|
(variable_declarator [65, 14] - [65, 54]
|
|
name: (identifier [65, 14] - [65, 25])
|
|
value: (call_expression [65, 28] - [65, 54]
|
|
function: (member_expression [65, 28] - [65, 38]
|
|
object: (identifier [65, 28] - [65, 32])
|
|
property: (property_identifier [65, 33] - [65, 38]))
|
|
arguments: (arguments [65, 38] - [65, 54]
|
|
(identifier [65, 39] - [65, 53])))))
|
|
(if_statement [66, 8] - [80, 9]
|
|
condition: (parenthesized_expression [66, 11] - [66, 44]
|
|
(binary_expression [66, 12] - [66, 43]
|
|
left: (identifier [66, 12] - [66, 23])
|
|
right: (member_expression [66, 27] - [66, 43]
|
|
object: (identifier [66, 27] - [66, 38])
|
|
property: (property_identifier [66, 39] - [66, 43]))))
|
|
consequence: (statement_block [66, 45] - [80, 9]
|
|
(if_statement [67, 10] - [69, 11]
|
|
condition: (parenthesized_expression [67, 13] - [67, 20]
|
|
(binary_expression [67, 14] - [67, 19]
|
|
left: (identifier [67, 14] - [67, 15])
|
|
right: (number [67, 18] - [67, 19])))
|
|
consequence: (statement_block [67, 21] - [69, 11]
|
|
(expression_statement [68, 12] - [68, 57]
|
|
(call_expression [68, 12] - [68, 56]
|
|
function: (identifier [68, 12] - [68, 24])
|
|
arguments: (arguments [68, 24] - [68, 56]
|
|
(identifier [68, 25] - [68, 26])
|
|
(string [68, 28] - [68, 40]
|
|
(string_fragment [68, 29] - [68, 39]))
|
|
(object [68, 42] - [68, 55]
|
|
(pair [68, 44] - [68, 53]
|
|
key: (property_identifier [68, 44] - [68, 48])
|
|
value: (string [68, 50] - [68, 53]
|
|
(string_fragment [68, 51] - [68, 52])))))))))
|
|
(return_statement [71, 10] - [79, 12]
|
|
(object [71, 17] - [79, 11]
|
|
(pair [72, 12] - [72, 36]
|
|
key: (property_identifier [72, 12] - [72, 18])
|
|
value: (member_expression [72, 20] - [72, 36]
|
|
object: (identifier [72, 20] - [72, 31])
|
|
property: (property_identifier [72, 32] - [72, 36])))
|
|
(pair [73, 12] - [73, 34]
|
|
key: (property_identifier [73, 12] - [73, 21])
|
|
value: (identifier [73, 23] - [73, 34]))
|
|
(pair [74, 12] - [74, 48]
|
|
key: (property_identifier [74, 12] - [74, 20])
|
|
value: (binary_expression [74, 22] - [74, 48]
|
|
left: (member_expression [74, 22] - [74, 42]
|
|
object: (identifier [74, 22] - [74, 33])
|
|
property: (property_identifier [74, 34] - [74, 42]))
|
|
right: (string [74, 46] - [74, 48])))
|
|
(pair [75, 12] - [75, 36]
|
|
key: (property_identifier [75, 12] - [75, 17])
|
|
value: (member_expression [75, 19] - [75, 36]
|
|
object: (identifier [75, 19] - [75, 30])
|
|
property: (property_identifier [75, 31] - [75, 36])))
|
|
(pair [76, 12] - [76, 40]
|
|
key: (property_identifier [76, 12] - [76, 19])
|
|
value: (member_expression [76, 21] - [76, 40]
|
|
object: (identifier [76, 21] - [76, 32])
|
|
property: (property_identifier [76, 33] - [76, 40])))
|
|
(pair [77, 12] - [77, 43]
|
|
key: (property_identifier [77, 12] - [77, 20])
|
|
value: (member_expression [77, 22] - [77, 43]
|
|
object: (identifier [77, 22] - [77, 33])
|
|
property: (property_identifier [77, 34] - [77, 43])))
|
|
(pair [78, 12] - [78, 50]
|
|
key: (property_identifier [78, 12] - [78, 24])
|
|
value: (member_expression [78, 26] - [78, 50]
|
|
object: (identifier [78, 26] - [78, 37])
|
|
property: (property_identifier [78, 38] - [78, 50]))))))))))
|
|
handler: (catch_clause [82, 6] - [84, 5]
|
|
parameter: (identifier [82, 13] - [82, 17])
|
|
body: (statement_block [82, 19] - [84, 5]
|
|
(comment [83, 6] - [83, 64]))))
|
|
(comment [86, 4] - [86, 47])
|
|
(try_statement [87, 4] - [135, 5]
|
|
body: (statement_block [87, 8] - [133, 5]
|
|
(lexical_declaration [88, 6] - [88, 46]
|
|
(variable_declarator [88, 12] - [88, 45]
|
|
name: (identifier [88, 12] - [88, 18])
|
|
value: (call_expression [88, 21] - [88, 45]
|
|
function: (member_expression [88, 21] - [88, 43]
|
|
object: (new_expression [88, 21] - [88, 31]
|
|
constructor: (identifier [88, 25] - [88, 29])
|
|
arguments: (arguments [88, 29] - [88, 31]))
|
|
property: (property_identifier [88, 32] - [88, 43]))
|
|
arguments: (arguments [88, 43] - [88, 45]))))
|
|
(lexical_declaration [89, 6] - [94, 35]
|
|
(variable_declarator [89, 12] - [94, 34]
|
|
name: (identifier [89, 12] - [89, 19])
|
|
value: (await_expression [89, 22] - [94, 34]
|
|
(call_expression [89, 28] - [94, 34]
|
|
function: (member_expression [89, 28] - [94, 12]
|
|
object: (call_expression [89, 28] - [94, 7]
|
|
function: (member_expression [89, 28] - [89, 42]
|
|
object: (identifier [89, 28] - [89, 38])
|
|
property: (property_identifier [89, 39] - [89, 42]))
|
|
arguments: (template_string [89, 42] - [94, 7]
|
|
(string_fragment [89, 43] - [93, 21])
|
|
(template_substitution [93, 21] - [93, 35]
|
|
(identifier [93, 23] - [93, 34]))
|
|
(string_fragment [93, 35] - [93, 55])
|
|
(template_substitution [93, 55] - [93, 64]
|
|
(identifier [93, 57] - [93, 63]))
|
|
(string_fragment [93, 64] - [94, 6])))
|
|
property: (property_identifier [94, 8] - [94, 12]))
|
|
arguments: (arguments [94, 12] - [94, 34]
|
|
(arrow_function [94, 13] - [94, 33]
|
|
parameters: (formal_parameters [94, 13] - [94, 23]
|
|
(required_parameter [94, 14] - [94, 22]
|
|
pattern: (identifier [94, 14] - [94, 17])
|
|
type: (type_annotation [94, 17] - [94, 22]
|
|
(predefined_type [94, 19] - [94, 22]))))
|
|
body: (subscript_expression [94, 27] - [94, 33]
|
|
object: (identifier [94, 27] - [94, 30])
|
|
index: (number [94, 31] - [94, 32]))))))))
|
|
(if_statement [96, 6] - [132, 7]
|
|
condition: (parenthesized_expression [96, 9] - [96, 18]
|
|
(identifier [96, 10] - [96, 17]))
|
|
consequence: (statement_block [96, 19] - [132, 7]
|
|
(lexical_declaration [97, 8] - [97, 48]
|
|
(variable_declarator [97, 14] - [97, 47]
|
|
name: (identifier [97, 14] - [97, 22])
|
|
value: (binary_expression [97, 25] - [97, 47]
|
|
left: (member_expression [97, 25] - [97, 41]
|
|
object: (identifier [97, 25] - [97, 32])
|
|
property: (property_identifier [97, 33] - [97, 41]))
|
|
right: (string [97, 45] - [97, 47]))))
|
|
(try_statement [98, 8] - [117, 23]
|
|
body: (statement_block [98, 12] - [117, 9]
|
|
(lexical_declaration [99, 10] - [104, 12]
|
|
(variable_declarator [99, 16] - [104, 11]
|
|
name: (identifier [99, 16] - [99, 26])
|
|
value: (call_expression [99, 29] - [104, 11]
|
|
function: (member_expression [99, 29] - [99, 37]
|
|
object: (identifier [99, 29] - [99, 33])
|
|
property: (property_identifier [99, 34] - [99, 37]))
|
|
arguments: (arguments [99, 37] - [104, 11]
|
|
(number [100, 12] - [100, 13])
|
|
(call_expression [101, 12] - [103, 13]
|
|
function: (member_expression [101, 12] - [101, 22]
|
|
object: (identifier [101, 12] - [101, 16])
|
|
property: (property_identifier [101, 17] - [101, 22]))
|
|
arguments: (arguments [101, 22] - [103, 13]
|
|
(binary_expression [102, 14] - [102, 74]
|
|
left: (parenthesized_expression [102, 14] - [102, 67]
|
|
(binary_expression [102, 15] - [102, 66]
|
|
left: (call_expression [102, 15] - [102, 53]
|
|
function: (member_expression [102, 15] - [102, 51]
|
|
object: (new_expression [102, 15] - [102, 43]
|
|
constructor: (identifier [102, 19] - [102, 23])
|
|
arguments: (arguments [102, 23] - [102, 43]
|
|
(member_expression [102, 24] - [102, 42]
|
|
object: (identifier [102, 24] - [102, 31])
|
|
property: (property_identifier [102, 32] - [102, 42]))))
|
|
property: (property_identifier [102, 44] - [102, 51]))
|
|
arguments: (arguments [102, 51] - [102, 53]))
|
|
right: (call_expression [102, 56] - [102, 66]
|
|
function: (member_expression [102, 56] - [102, 64]
|
|
object: (identifier [102, 56] - [102, 60])
|
|
property: (property_identifier [102, 61] - [102, 64]))
|
|
arguments: (arguments [102, 64] - [102, 66]))))
|
|
right: (number [102, 70] - [102, 74]))))))))
|
|
(expression_statement [105, 10] - [116, 12]
|
|
(await_expression [105, 10] - [116, 11]
|
|
(call_expression [105, 16] - [116, 11]
|
|
function: (member_expression [105, 16] - [105, 28]
|
|
object: (identifier [105, 16] - [105, 22])
|
|
property: (property_identifier [105, 23] - [105, 28]))
|
|
arguments: (arguments [105, 28] - [116, 11]
|
|
(identifier [106, 12] - [106, 23])
|
|
(identifier [107, 12] - [107, 22])
|
|
(call_expression [108, 12] - [115, 14]
|
|
function: (member_expression [108, 12] - [108, 26]
|
|
object: (identifier [108, 12] - [108, 16])
|
|
property: (property_identifier [108, 17] - [108, 26]))
|
|
arguments: (arguments [108, 26] - [115, 14]
|
|
(object [108, 27] - [115, 13]
|
|
(pair [109, 14] - [109, 35]
|
|
key: (property_identifier [109, 14] - [109, 18])
|
|
value: (member_expression [109, 20] - [109, 35]
|
|
object: (identifier [109, 20] - [109, 27])
|
|
property: (property_identifier [109, 28] - [109, 35])))
|
|
(shorthand_property_identifier [110, 14] - [110, 22])
|
|
(pair [111, 14] - [111, 34]
|
|
key: (property_identifier [111, 14] - [111, 19])
|
|
value: (member_expression [111, 21] - [111, 34]
|
|
object: (identifier [111, 21] - [111, 28])
|
|
property: (property_identifier [111, 29] - [111, 34])))
|
|
(pair [112, 14] - [112, 39]
|
|
key: (property_identifier [112, 14] - [112, 21])
|
|
value: (member_expression [112, 23] - [112, 39]
|
|
object: (identifier [112, 23] - [112, 30])
|
|
property: (property_identifier [112, 31] - [112, 39])))
|
|
(pair [113, 14] - [113, 42]
|
|
key: (property_identifier [113, 14] - [113, 23])
|
|
value: (member_expression [113, 25] - [113, 42]
|
|
object: (identifier [113, 25] - [113, 32])
|
|
property: (property_identifier [113, 33] - [113, 42])))
|
|
(pair [114, 14] - [114, 49]
|
|
key: (property_identifier [114, 14] - [114, 26])
|
|
value: (member_expression [114, 28] - [114, 49]
|
|
object: (identifier [114, 28] - [114, 35])
|
|
property: (property_identifier [114, 36] - [114, 49])))))))))))
|
|
handler: (catch_clause [117, 10] - [117, 23]
|
|
parameter: (identifier [117, 17] - [117, 19])
|
|
body: (statement_block [117, 21] - [117, 23])))
|
|
(if_statement [119, 8] - [121, 9]
|
|
condition: (parenthesized_expression [119, 11] - [119, 18]
|
|
(binary_expression [119, 12] - [119, 17]
|
|
left: (identifier [119, 12] - [119, 13])
|
|
right: (number [119, 16] - [119, 17])))
|
|
consequence: (statement_block [119, 19] - [121, 9]
|
|
(expression_statement [120, 10] - [120, 55]
|
|
(call_expression [120, 10] - [120, 54]
|
|
function: (identifier [120, 10] - [120, 22])
|
|
arguments: (arguments [120, 22] - [120, 54]
|
|
(identifier [120, 23] - [120, 24])
|
|
(string [120, 26] - [120, 38]
|
|
(string_fragment [120, 27] - [120, 37]))
|
|
(object [120, 40] - [120, 53]
|
|
(pair [120, 42] - [120, 51]
|
|
key: (property_identifier [120, 42] - [120, 46])
|
|
value: (string [120, 48] - [120, 51]
|
|
(string_fragment [120, 49] - [120, 50])))))))))
|
|
(return_statement [123, 8] - [131, 10]
|
|
(object [123, 15] - [131, 9]
|
|
(pair [124, 10] - [124, 33]
|
|
key: (property_identifier [124, 10] - [124, 16])
|
|
value: (member_expression [124, 18] - [124, 33]
|
|
object: (identifier [124, 18] - [124, 25])
|
|
property: (property_identifier [124, 26] - [124, 33])))
|
|
(pair [125, 10] - [125, 32]
|
|
key: (property_identifier [125, 10] - [125, 19])
|
|
value: (identifier [125, 21] - [125, 32]))
|
|
(shorthand_property_identifier [126, 10] - [126, 18])
|
|
(pair [127, 10] - [127, 30]
|
|
key: (property_identifier [127, 10] - [127, 15])
|
|
value: (member_expression [127, 17] - [127, 30]
|
|
object: (identifier [127, 17] - [127, 24])
|
|
property: (property_identifier [127, 25] - [127, 30])))
|
|
(pair [128, 10] - [128, 35]
|
|
key: (property_identifier [128, 10] - [128, 17])
|
|
value: (member_expression [128, 19] - [128, 35]
|
|
object: (identifier [128, 19] - [128, 26])
|
|
property: (property_identifier [128, 27] - [128, 35])))
|
|
(pair [129, 10] - [129, 37]
|
|
key: (property_identifier [129, 10] - [129, 18])
|
|
value: (member_expression [129, 20] - [129, 37]
|
|
object: (identifier [129, 20] - [129, 27])
|
|
property: (property_identifier [129, 28] - [129, 37])))
|
|
(pair [130, 10] - [130, 45]
|
|
key: (property_identifier [130, 10] - [130, 22])
|
|
value: (member_expression [130, 24] - [130, 45]
|
|
object: (identifier [130, 24] - [130, 31])
|
|
property: (property_identifier [130, 32] - [130, 45]))))))))
|
|
handler: (catch_clause [133, 6] - [135, 5]
|
|
parameter: (identifier [133, 13] - [133, 17])
|
|
body: (statement_block [133, 19] - [135, 5]
|
|
(comment [134, 6] - [134, 35]))))))
|
|
(return_statement [138, 2] - [138, 14]
|
|
(null [138, 9] - [138, 13])))))
|
|
(comment [141, 0] - [143, 3])
|
|
(export_statement [144, 0] - [175, 1]
|
|
declaration: (function_declaration [144, 7] - [175, 1]
|
|
name: (identifier [144, 22] - [144, 35])
|
|
parameters: (formal_parameters [144, 35] - [144, 51]
|
|
(required_parameter [144, 36] - [144, 50]
|
|
pattern: (identifier [144, 36] - [144, 42])
|
|
type: (type_annotation [144, 42] - [144, 50]
|
|
(predefined_type [144, 44] - [144, 50]))))
|
|
return_type: (type_annotation [144, 51] - [144, 69]
|
|
(generic_type [144, 53] - [144, 69]
|
|
name: (type_identifier [144, 53] - [144, 60])
|
|
type_arguments: (type_arguments [144, 60] - [144, 69]
|
|
(predefined_type [144, 61] - [144, 68]))))
|
|
body: (statement_block [144, 70] - [175, 1]
|
|
(try_statement [145, 2] - [172, 3]
|
|
body: (statement_block [145, 6] - [170, 3]
|
|
(comment [146, 4] - [146, 50])
|
|
(lexical_declaration [147, 4] - [158, 33]
|
|
(variable_declarator [147, 10] - [158, 32]
|
|
name: (identifier [147, 10] - [147, 20])
|
|
value: (await_expression [147, 23] - [158, 32]
|
|
(call_expression [147, 29] - [158, 32]
|
|
function: (member_expression [147, 29] - [158, 10]
|
|
object: (call_expression [147, 29] - [158, 5]
|
|
function: (member_expression [147, 29] - [147, 43]
|
|
object: (identifier [147, 29] - [147, 39])
|
|
property: (property_identifier [147, 40] - [147, 43]))
|
|
arguments: (template_string [147, 43] - [158, 5]
|
|
(string_fragment [147, 44] - [151, 24])
|
|
(template_substitution [151, 24] - [151, 33]
|
|
(identifier [151, 26] - [151, 32]))
|
|
(string_fragment [151, 33] - [158, 4])))
|
|
property: (property_identifier [158, 6] - [158, 10]))
|
|
arguments: (arguments [158, 10] - [158, 32]
|
|
(arrow_function [158, 11] - [158, 31]
|
|
parameters: (formal_parameters [158, 11] - [158, 21]
|
|
(required_parameter [158, 12] - [158, 20]
|
|
pattern: (identifier [158, 12] - [158, 15])
|
|
type: (type_annotation [158, 15] - [158, 20]
|
|
(predefined_type [158, 17] - [158, 20]))))
|
|
body: (subscript_expression [158, 25] - [158, 31]
|
|
object: (identifier [158, 25] - [158, 28])
|
|
index: (number [158, 29] - [158, 30]))))))))
|
|
(if_statement [160, 4] - [160, 32]
|
|
condition: (parenthesized_expression [160, 7] - [160, 19]
|
|
(identifier [160, 8] - [160, 18]))
|
|
consequence: (return_statement [160, 20] - [160, 32]
|
|
(true [160, 27] - [160, 31])))
|
|
(comment [162, 4] - [162, 56])
|
|
(lexical_declaration [163, 4] - [165, 33]
|
|
(variable_declarator [163, 10] - [165, 32]
|
|
name: (identifier [163, 10] - [163, 19])
|
|
value: (await_expression [163, 22] - [165, 32]
|
|
(call_expression [163, 28] - [165, 32]
|
|
function: (member_expression [163, 28] - [165, 10]
|
|
object: (call_expression [163, 28] - [165, 5]
|
|
function: (member_expression [163, 28] - [163, 42]
|
|
object: (identifier [163, 28] - [163, 38])
|
|
property: (property_identifier [163, 39] - [163, 42]))
|
|
arguments: (template_string [163, 42] - [165, 5]
|
|
(string_fragment [163, 43] - [165, 4])))
|
|
property: (property_identifier [165, 6] - [165, 10]))
|
|
arguments: (arguments [165, 10] - [165, 32]
|
|
(arrow_function [165, 11] - [165, 31]
|
|
parameters: (formal_parameters [165, 11] - [165, 21]
|
|
(required_parameter [165, 12] - [165, 20]
|
|
pattern: (identifier [165, 12] - [165, 15])
|
|
type: (type_annotation [165, 15] - [165, 20]
|
|
(predefined_type [165, 17] - [165, 20]))))
|
|
body: (subscript_expression [165, 25] - [165, 31]
|
|
object: (identifier [165, 25] - [165, 28])
|
|
index: (number [165, 29] - [165, 30]))))))))
|
|
(if_statement [167, 4] - [169, 5]
|
|
condition: (parenthesized_expression [167, 7] - [167, 45]
|
|
(binary_expression [167, 8] - [167, 44]
|
|
left: (identifier [167, 8] - [167, 17])
|
|
right: (binary_expression [167, 21] - [167, 44]
|
|
left: (member_expression [167, 21] - [167, 33]
|
|
object: (identifier [167, 21] - [167, 30])
|
|
property: (property_identifier [167, 31] - [167, 33]))
|
|
right: (identifier [167, 38] - [167, 44]))))
|
|
consequence: (statement_block [167, 46] - [169, 5]
|
|
(return_statement [168, 6] - [168, 18]
|
|
(true [168, 13] - [168, 17])))))
|
|
handler: (catch_clause [170, 4] - [172, 3]
|
|
parameter: (identifier [170, 11] - [170, 14])
|
|
body: (statement_block [170, 16] - [172, 3]
|
|
(expression_statement [171, 4] - [171, 58]
|
|
(call_expression [171, 4] - [171, 57]
|
|
function: (member_expression [171, 4] - [171, 17]
|
|
object: (identifier [171, 4] - [171, 11])
|
|
property: (property_identifier [171, 12] - [171, 17]))
|
|
arguments: (arguments [171, 17] - [171, 57]
|
|
(string [171, 18] - [171, 51]
|
|
(string_fragment [171, 19] - [171, 50]))
|
|
(identifier [171, 53] - [171, 56])))))))
|
|
(return_statement [174, 2] - [174, 15]
|
|
(false [174, 9] - [174, 14])))))
|
|
(comment [177, 0] - [179, 3])
|
|
(export_statement [180, 0] - [188, 1]
|
|
declaration: (function_declaration [180, 7] - [188, 1]
|
|
name: (identifier [180, 16] - [180, 24])
|
|
parameters: (formal_parameters [180, 24] - [183, 1]
|
|
(required_parameter [181, 2] - [181, 25]
|
|
pattern: (identifier [181, 2] - [181, 6])
|
|
type: (type_annotation [181, 6] - [181, 25]
|
|
(type_identifier [181, 8] - [181, 25])))
|
|
(required_parameter [182, 2] - [182, 23]
|
|
pattern: (identifier [182, 2] - [182, 15])
|
|
type: (type_annotation [182, 15] - [182, 23]
|
|
(predefined_type [182, 17] - [182, 23]))))
|
|
return_type: (type_annotation [183, 1] - [183, 10]
|
|
(predefined_type [183, 3] - [183, 10]))
|
|
body: (statement_block [183, 11] - [188, 1]
|
|
(if_statement [184, 2] - [184, 33]
|
|
condition: (parenthesized_expression [184, 5] - [184, 20]
|
|
(unary_expression [184, 6] - [184, 19]
|
|
argument: (member_expression [184, 7] - [184, 19]
|
|
object: (identifier [184, 7] - [184, 11])
|
|
property: (property_identifier [184, 12] - [184, 19]))))
|
|
consequence: (return_statement [184, 21] - [184, 33]
|
|
(true [184, 28] - [184, 32])))
|
|
(if_statement [185, 2] - [185, 54]
|
|
condition: (parenthesized_expression [185, 5] - [185, 40]
|
|
(unary_expression [185, 6] - [185, 39]
|
|
argument: (call_expression [185, 7] - [185, 39]
|
|
function: (member_expression [185, 7] - [185, 20]
|
|
object: (identifier [185, 7] - [185, 12])
|
|
property: (property_identifier [185, 13] - [185, 20]))
|
|
arguments: (arguments [185, 20] - [185, 39]
|
|
(member_expression [185, 21] - [185, 38]
|
|
object: (identifier [185, 21] - [185, 25])
|
|
property: (property_identifier [185, 26] - [185, 38]))))))
|
|
consequence: (return_statement [185, 41] - [185, 54]
|
|
(false [185, 48] - [185, 53])))
|
|
(return_statement [186, 2] - [187, 46]
|
|
(binary_expression [186, 9] - [187, 45]
|
|
left: (call_expression [186, 9] - [186, 40]
|
|
function: (member_expression [186, 9] - [186, 35]
|
|
object: (member_expression [186, 9] - [186, 26]
|
|
object: (identifier [186, 9] - [186, 13])
|
|
property: (property_identifier [186, 14] - [186, 26]))
|
|
property: (property_identifier [186, 27] - [186, 35]))
|
|
arguments: (arguments [186, 35] - [186, 40]
|
|
(string [186, 36] - [186, 39]
|
|
(string_fragment [186, 37] - [186, 38]))))
|
|
right: (call_expression [187, 4] - [187, 45]
|
|
function: (member_expression [187, 4] - [187, 30]
|
|
object: (member_expression [187, 4] - [187, 21]
|
|
object: (identifier [187, 4] - [187, 8])
|
|
property: (property_identifier [187, 9] - [187, 21]))
|
|
property: (property_identifier [187, 22] - [187, 30]))
|
|
arguments: (arguments [187, 30] - [187, 45]
|
|
(identifier [187, 31] - [187, 44]))))))))
|
|
(comment [190, 0] - [192, 3])
|
|
(export_statement [193, 0] - [200, 1]
|
|
declaration: (function_declaration [193, 7] - [200, 1]
|
|
name: (identifier [193, 22] - [193, 36])
|
|
parameters: (formal_parameters [193, 36] - [195, 1]
|
|
(required_parameter [194, 2] - [194, 25]
|
|
pattern: (identifier [194, 2] - [194, 6])
|
|
type: (type_annotation [194, 6] - [194, 25]
|
|
(type_identifier [194, 8] - [194, 25]))))
|
|
return_type: (type_annotation [195, 1] - [195, 19]
|
|
(generic_type [195, 3] - [195, 19]
|
|
name: (type_identifier [195, 3] - [195, 10])
|
|
type_arguments: (type_arguments [195, 10] - [195, 19]
|
|
(predefined_type [195, 11] - [195, 18]))))
|
|
body: (statement_block [195, 20] - [200, 1]
|
|
(lexical_declaration [196, 2] - [196, 55]
|
|
(variable_declarator [196, 8] - [196, 54]
|
|
name: (identifier [196, 8] - [196, 19])
|
|
value: (await_expression [196, 22] - [196, 54]
|
|
(call_expression [196, 28] - [196, 54]
|
|
function: (identifier [196, 28] - [196, 41])
|
|
arguments: (arguments [196, 41] - [196, 54]
|
|
(member_expression [196, 42] - [196, 53]
|
|
object: (identifier [196, 42] - [196, 46])
|
|
property: (property_identifier [196, 47] - [196, 53])))))))
|
|
(if_statement [197, 2] - [197, 33]
|
|
condition: (parenthesized_expression [197, 5] - [197, 19]
|
|
(unary_expression [197, 6] - [197, 18]
|
|
argument: (identifier [197, 7] - [197, 18])))
|
|
consequence: (return_statement [197, 20] - [197, 33]
|
|
(false [197, 27] - [197, 32])))
|
|
(if_statement [198, 2] - [198, 33]
|
|
condition: (parenthesized_expression [198, 5] - [198, 20]
|
|
(unary_expression [198, 6] - [198, 19]
|
|
argument: (member_expression [198, 7] - [198, 19]
|
|
object: (identifier [198, 7] - [198, 11])
|
|
property: (property_identifier [198, 12] - [198, 19]))))
|
|
consequence: (return_statement [198, 21] - [198, 33]
|
|
(true [198, 28] - [198, 32])))
|
|
(return_statement [199, 2] - [199, 77]
|
|
(binary_expression [199, 9] - [199, 76]
|
|
left: (call_expression [199, 9] - [199, 41]
|
|
function: (member_expression [199, 9] - [199, 22]
|
|
object: (identifier [199, 9] - [199, 14])
|
|
property: (property_identifier [199, 15] - [199, 22]))
|
|
arguments: (arguments [199, 22] - [199, 41]
|
|
(member_expression [199, 23] - [199, 40]
|
|
object: (identifier [199, 23] - [199, 27])
|
|
property: (property_identifier [199, 28] - [199, 40]))))
|
|
right: (call_expression [199, 45] - [199, 76]
|
|
function: (member_expression [199, 45] - [199, 71]
|
|
object: (member_expression [199, 45] - [199, 62]
|
|
object: (identifier [199, 45] - [199, 49])
|
|
property: (property_identifier [199, 50] - [199, 62]))
|
|
property: (property_identifier [199, 63] - [199, 71]))
|
|
arguments: (arguments [199, 71] - [199, 76]
|
|
(string [199, 72] - [199, 75]
|
|
(string_fragment [199, 73] - [199, 74])))))))))
|
|
(comment [202, 0] - [205, 3])
|
|
(export_statement [206, 0] - [225, 1]
|
|
declaration: (function_declaration [206, 7] - [225, 1]
|
|
name: (identifier [206, 16] - [206, 31])
|
|
parameters: (formal_parameters [206, 31] - [206, 52]
|
|
(optional_parameter [206, 32] - [206, 51]
|
|
pattern: (identifier [206, 32] - [206, 42])
|
|
type: (type_annotation [206, 43] - [206, 51]
|
|
(predefined_type [206, 45] - [206, 51]))))
|
|
return_type: (type_annotation [206, 52] - [206, 72]
|
|
(union_type [206, 54] - [206, 72]
|
|
(predefined_type [206, 54] - [206, 60])
|
|
(literal_type [206, 63] - [206, 72]
|
|
(undefined [206, 63] - [206, 72]))))
|
|
body: (statement_block [206, 73] - [225, 1]
|
|
(lexical_declaration [207, 2] - [207, 50]
|
|
(variable_declarator [207, 8] - [207, 49]
|
|
name: (identifier [207, 8] - [207, 17])
|
|
value: (call_expression [207, 20] - [207, 49]
|
|
function: (member_expression [207, 20] - [207, 32]
|
|
object: (member_expression [207, 20] - [207, 28]
|
|
object: (identifier [207, 20] - [207, 24])
|
|
property: (property_identifier [207, 25] - [207, 28]))
|
|
property: (property_identifier [207, 29] - [207, 32]))
|
|
arguments: (arguments [207, 32] - [207, 49]
|
|
(string [207, 33] - [207, 48]
|
|
(string_fragment [207, 34] - [207, 47]))))))
|
|
(if_statement [208, 2] - [210, 3]
|
|
condition: (parenthesized_expression [208, 5] - [208, 16]
|
|
(identifier [208, 6] - [208, 15]))
|
|
consequence: (statement_block [208, 17] - [210, 3]
|
|
(return_statement [209, 4] - [209, 67]
|
|
(ternary_expression [209, 11] - [209, 66]
|
|
condition: (call_expression [209, 11] - [209, 36]
|
|
function: (member_expression [209, 11] - [209, 31]
|
|
object: (identifier [209, 11] - [209, 20])
|
|
property: (property_identifier [209, 21] - [209, 31]))
|
|
arguments: (arguments [209, 31] - [209, 36]
|
|
(string [209, 32] - [209, 35]
|
|
(string_fragment [209, 33] - [209, 34]))))
|
|
consequence: (identifier [209, 39] - [209, 48])
|
|
alternative: (template_string [209, 51] - [209, 66]
|
|
(string_fragment [209, 52] - [209, 53])
|
|
(template_substitution [209, 53] - [209, 65]
|
|
(identifier [209, 55] - [209, 64])))))))
|
|
(lexical_declaration [211, 2] - [211, 61]
|
|
(variable_declarator [211, 8] - [211, 60]
|
|
name: (identifier [211, 8] - [211, 16])
|
|
value: (binary_expression [211, 19] - [211, 60]
|
|
left: (binary_expression [211, 19] - [211, 54]
|
|
left: (identifier [211, 19] - [211, 29])
|
|
right: (call_expression [211, 33] - [211, 54]
|
|
function: (member_expression [211, 33] - [211, 45]
|
|
object: (member_expression [211, 33] - [211, 41]
|
|
object: (identifier [211, 33] - [211, 37])
|
|
property: (property_identifier [211, 38] - [211, 41]))
|
|
property: (property_identifier [211, 42] - [211, 45]))
|
|
arguments: (arguments [211, 45] - [211, 54]
|
|
(string [211, 46] - [211, 53]
|
|
(string_fragment [211, 47] - [211, 52])))))
|
|
right: (string [211, 58] - [211, 60]))))
|
|
(if_statement [212, 2] - [219, 3]
|
|
condition: (parenthesized_expression [212, 5] - [217, 3]
|
|
(binary_expression [213, 4] - [216, 34]
|
|
left: (binary_expression [213, 4] - [215, 34]
|
|
left: (binary_expression [213, 4] - [214, 27]
|
|
left: (unary_expression [213, 4] - [213, 13]
|
|
argument: (identifier [213, 5] - [213, 13]))
|
|
right: (unary_expression [214, 4] - [214, 27]
|
|
argument: (call_expression [214, 5] - [214, 27]
|
|
function: (member_expression [214, 5] - [214, 22]
|
|
object: (identifier [214, 5] - [214, 13])
|
|
property: (property_identifier [214, 14] - [214, 22]))
|
|
arguments: (arguments [214, 22] - [214, 27]
|
|
(string [214, 23] - [214, 26]
|
|
(string_fragment [214, 24] - [214, 25]))))))
|
|
right: (call_expression [215, 4] - [215, 34]
|
|
function: (member_expression [215, 4] - [215, 21]
|
|
object: (identifier [215, 4] - [215, 12])
|
|
property: (property_identifier [215, 13] - [215, 21]))
|
|
arguments: (arguments [215, 21] - [215, 34]
|
|
(string [215, 22] - [215, 33]
|
|
(string_fragment [215, 23] - [215, 32])))))
|
|
right: (call_expression [216, 4] - [216, 34]
|
|
function: (member_expression [216, 4] - [216, 21]
|
|
object: (identifier [216, 4] - [216, 12])
|
|
property: (property_identifier [216, 13] - [216, 21]))
|
|
arguments: (arguments [216, 21] - [216, 34]
|
|
(string [216, 22] - [216, 33]
|
|
(string_fragment [216, 23] - [216, 32]))))))
|
|
consequence: (statement_block [217, 4] - [219, 3]
|
|
(return_statement [218, 4] - [218, 21]
|
|
(undefined [218, 11] - [218, 20]))))
|
|
(lexical_declaration [220, 2] - [220, 52]
|
|
(variable_declarator [220, 8] - [220, 51]
|
|
name: (identifier [220, 8] - [220, 13])
|
|
value: (call_expression [220, 16] - [220, 51]
|
|
function: (member_expression [220, 16] - [220, 42]
|
|
object: (call_expression [220, 16] - [220, 35]
|
|
function: (member_expression [220, 16] - [220, 30]
|
|
object: (identifier [220, 16] - [220, 24])
|
|
property: (property_identifier [220, 25] - [220, 30]))
|
|
arguments: (arguments [220, 30] - [220, 35]
|
|
(string [220, 31] - [220, 34]
|
|
(string_fragment [220, 32] - [220, 33]))))
|
|
property: (property_identifier [220, 36] - [220, 42]))
|
|
arguments: (arguments [220, 42] - [220, 51]
|
|
(identifier [220, 43] - [220, 50])))))
|
|
(if_statement [221, 2] - [223, 3]
|
|
condition: (parenthesized_expression [221, 5] - [221, 24]
|
|
(binary_expression [221, 6] - [221, 23]
|
|
left: (member_expression [221, 6] - [221, 18]
|
|
object: (identifier [221, 6] - [221, 11])
|
|
property: (property_identifier [221, 12] - [221, 18]))
|
|
right: (number [221, 22] - [221, 23])))
|
|
consequence: (statement_block [221, 25] - [223, 3]
|
|
(return_statement [222, 4] - [222, 43]
|
|
(template_string [222, 11] - [222, 42]
|
|
(string_fragment [222, 12] - [222, 13])
|
|
(template_substitution [222, 13] - [222, 41]
|
|
(call_expression [222, 15] - [222, 40]
|
|
function: (member_expression [222, 15] - [222, 35]
|
|
object: (call_expression [222, 15] - [222, 30]
|
|
function: (member_expression [222, 15] - [222, 26]
|
|
object: (identifier [222, 15] - [222, 20])
|
|
property: (property_identifier [222, 21] - [222, 26]))
|
|
arguments: (arguments [222, 26] - [222, 30]
|
|
(unary_expression [222, 27] - [222, 29]
|
|
argument: (number [222, 28] - [222, 29]))))
|
|
property: (property_identifier [222, 31] - [222, 35]))
|
|
arguments: (arguments [222, 35] - [222, 40]
|
|
(string [222, 36] - [222, 39]
|
|
(string_fragment [222, 37] - [222, 38])))))))))
|
|
(return_statement [224, 2] - [224, 24]
|
|
(template_string [224, 9] - [224, 23]
|
|
(string_fragment [224, 10] - [224, 11])
|
|
(template_substitution [224, 11] - [224, 22]
|
|
(identifier [224, 13] - [224, 21])))))))
|
|
(comment [227, 0] - [229, 3])
|
|
(export_statement [230, 0] - [240, 1]
|
|
declaration: (function_declaration [230, 7] - [240, 1]
|
|
name: (identifier [230, 22] - [230, 43])
|
|
parameters: (formal_parameters [230, 43] - [233, 1]
|
|
(required_parameter [231, 2] - [231, 12]
|
|
pattern: (identifier [231, 2] - [231, 3])
|
|
type: (type_annotation [231, 3] - [231, 12]
|
|
(type_identifier [231, 5] - [231, 12])))
|
|
(required_parameter [232, 2] - [232, 27]
|
|
pattern: (identifier [232, 2] - [232, 6])
|
|
type: (type_annotation [232, 6] - [232, 27]
|
|
(function_type [232, 8] - [232, 27]
|
|
parameters: (formal_parameters [232, 8] - [232, 10])
|
|
return_type: (generic_type [232, 14] - [232, 27]
|
|
name: (type_identifier [232, 14] - [232, 21])
|
|
type_arguments: (type_arguments [232, 21] - [232, 27]
|
|
(predefined_type [232, 22] - [232, 26])))))))
|
|
body: (statement_block [233, 2] - [240, 1]
|
|
(lexical_declaration [234, 2] - [234, 45]
|
|
(variable_declarator [234, 8] - [234, 44]
|
|
name: (identifier [234, 8] - [234, 12])
|
|
value: (await_expression [234, 15] - [234, 44]
|
|
(call_expression [234, 21] - [234, 44]
|
|
function: (identifier [234, 21] - [234, 41])
|
|
arguments: (arguments [234, 41] - [234, 44]
|
|
(identifier [234, 42] - [234, 43]))))))
|
|
(if_statement [235, 2] - [235, 59]
|
|
condition: (parenthesized_expression [235, 5] - [235, 12]
|
|
(unary_expression [235, 6] - [235, 11]
|
|
argument: (identifier [235, 7] - [235, 11])))
|
|
consequence: (return_statement [235, 13] - [235, 59]
|
|
(call_expression [235, 20] - [235, 58]
|
|
function: (member_expression [235, 20] - [235, 26]
|
|
object: (identifier [235, 20] - [235, 21])
|
|
property: (property_identifier [235, 22] - [235, 26]))
|
|
arguments: (arguments [235, 26] - [235, 58]
|
|
(object [235, 27] - [235, 52]
|
|
(pair [235, 29] - [235, 50]
|
|
key: (property_identifier [235, 29] - [235, 34])
|
|
value: (string [235, 36] - [235, 50]
|
|
(string_fragment [235, 37] - [235, 49]))))
|
|
(number [235, 54] - [235, 57])))))
|
|
(if_statement [236, 2] - [238, 3]
|
|
condition: (parenthesized_expression [236, 5] - [236, 19]
|
|
(member_expression [236, 6] - [236, 18]
|
|
object: (identifier [236, 6] - [236, 10])
|
|
property: (property_identifier [236, 11] - [236, 18])))
|
|
consequence: (statement_block [236, 20] - [238, 3]
|
|
(return_statement [237, 4] - [237, 73]
|
|
(call_expression [237, 11] - [237, 72]
|
|
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, 72]
|
|
(object [237, 18] - [237, 66]
|
|
(pair [237, 20] - [237, 64]
|
|
key: (property_identifier [237, 20] - [237, 25])
|
|
value: (string [237, 27] - [237, 64]
|
|
(string_fragment [237, 28] - [237, 63]))))
|
|
(number [237, 68] - [237, 71]))))))
|
|
(expression_statement [239, 2] - [239, 15]
|
|
(await_expression [239, 2] - [239, 14]
|
|
(call_expression [239, 8] - [239, 14]
|
|
function: (identifier [239, 8] - [239, 12])
|
|
arguments: (arguments [239, 12] - [239, 14])))))))
|
|
(comment [242, 0] - [244, 3])
|
|
(export_statement [245, 0] - [254, 1]
|
|
declaration: (function_declaration [245, 7] - [254, 1]
|
|
name: (identifier [245, 16] - [245, 28])
|
|
parameters: (formal_parameters [245, 28] - [245, 43]
|
|
(required_parameter [245, 29] - [245, 42]
|
|
pattern: (identifier [245, 29] - [245, 34])
|
|
type: (type_annotation [245, 34] - [245, 42]
|
|
(predefined_type [245, 36] - [245, 42]))))
|
|
body: (statement_block [245, 44] - [254, 1]
|
|
(return_statement [246, 2] - [253, 4]
|
|
(arrow_function [246, 9] - [253, 3]
|
|
parameters: (formal_parameters [246, 15] - [246, 54]
|
|
(required_parameter [246, 16] - [246, 26]
|
|
pattern: (identifier [246, 16] - [246, 17])
|
|
type: (type_annotation [246, 17] - [246, 26]
|
|
(type_identifier [246, 19] - [246, 26])))
|
|
(required_parameter [246, 28] - [246, 53]
|
|
pattern: (identifier [246, 28] - [246, 32])
|
|
type: (type_annotation [246, 32] - [246, 53]
|
|
(function_type [246, 34] - [246, 53]
|
|
parameters: (formal_parameters [246, 34] - [246, 36])
|
|
return_type: (generic_type [246, 40] - [246, 53]
|
|
name: (type_identifier [246, 40] - [246, 47])
|
|
type_arguments: (type_arguments [246, 47] - [246, 53]
|
|
(predefined_type [246, 48] - [246, 52])))))))
|
|
body: (statement_block [246, 58] - [253, 3]
|
|
(lexical_declaration [247, 4] - [247, 47]
|
|
(variable_declarator [247, 10] - [247, 46]
|
|
name: (identifier [247, 10] - [247, 14])
|
|
value: (await_expression [247, 17] - [247, 46]
|
|
(call_expression [247, 23] - [247, 46]
|
|
function: (identifier [247, 23] - [247, 43])
|
|
arguments: (arguments [247, 43] - [247, 46]
|
|
(identifier [247, 44] - [247, 45]))))))
|
|
(if_statement [248, 4] - [248, 61]
|
|
condition: (parenthesized_expression [248, 7] - [248, 14]
|
|
(unary_expression [248, 8] - [248, 13]
|
|
argument: (identifier [248, 9] - [248, 13])))
|
|
consequence: (return_statement [248, 15] - [248, 61]
|
|
(call_expression [248, 22] - [248, 60]
|
|
function: (member_expression [248, 22] - [248, 28]
|
|
object: (identifier [248, 22] - [248, 23])
|
|
property: (property_identifier [248, 24] - [248, 28]))
|
|
arguments: (arguments [248, 28] - [248, 60]
|
|
(object [248, 29] - [248, 54]
|
|
(pair [248, 31] - [248, 52]
|
|
key: (property_identifier [248, 31] - [248, 36])
|
|
value: (string [248, 38] - [248, 52]
|
|
(string_fragment [248, 39] - [248, 51]))))
|
|
(number [248, 56] - [248, 59])))))
|
|
(if_statement [249, 4] - [251, 5]
|
|
condition: (parenthesized_expression [249, 7] - [249, 31]
|
|
(unary_expression [249, 8] - [249, 30]
|
|
argument: (call_expression [249, 9] - [249, 30]
|
|
function: (identifier [249, 9] - [249, 17])
|
|
arguments: (arguments [249, 17] - [249, 30]
|
|
(identifier [249, 18] - [249, 22])
|
|
(identifier [249, 24] - [249, 29])))))
|
|
consequence: (statement_block [249, 32] - [251, 5]
|
|
(return_statement [250, 6] - [250, 70]
|
|
(call_expression [250, 13] - [250, 69]
|
|
function: (member_expression [250, 13] - [250, 19]
|
|
object: (identifier [250, 13] - [250, 14])
|
|
property: (property_identifier [250, 15] - [250, 19]))
|
|
arguments: (arguments [250, 19] - [250, 69]
|
|
(object [250, 20] - [250, 63]
|
|
(pair [250, 22] - [250, 61]
|
|
key: (property_identifier [250, 22] - [250, 27])
|
|
value: (string [250, 29] - [250, 61]
|
|
(string_fragment [250, 30] - [250, 60]))))
|
|
(number [250, 65] - [250, 68]))))))
|
|
(expression_statement [252, 4] - [252, 17]
|
|
(await_expression [252, 4] - [252, 16]
|
|
(call_expression [252, 10] - [252, 16]
|
|
function: (identifier [252, 10] - [252, 14])
|
|
arguments: (arguments [252, 14] - [252, 16]))))))))))
|
|
(comment [256, 0] - [258, 3])
|
|
(export_statement [259, 0] - [267, 1]
|
|
declaration: (function_declaration [259, 7] - [267, 1]
|
|
name: (identifier [259, 22] - [259, 34])
|
|
parameters: (formal_parameters [259, 34] - [259, 73]
|
|
(required_parameter [259, 35] - [259, 45]
|
|
pattern: (identifier [259, 35] - [259, 36])
|
|
type: (type_annotation [259, 36] - [259, 45]
|
|
(type_identifier [259, 38] - [259, 45])))
|
|
(required_parameter [259, 47] - [259, 72]
|
|
pattern: (identifier [259, 47] - [259, 51])
|
|
type: (type_annotation [259, 51] - [259, 72]
|
|
(function_type [259, 53] - [259, 72]
|
|
parameters: (formal_parameters [259, 53] - [259, 55])
|
|
return_type: (generic_type [259, 59] - [259, 72]
|
|
name: (type_identifier [259, 59] - [259, 66])
|
|
type_arguments: (type_arguments [259, 66] - [259, 72]
|
|
(predefined_type [259, 67] - [259, 71])))))))
|
|
body: (statement_block [259, 74] - [267, 1]
|
|
(lexical_declaration [260, 2] - [260, 45]
|
|
(variable_declarator [260, 8] - [260, 44]
|
|
name: (identifier [260, 8] - [260, 12])
|
|
value: (await_expression [260, 15] - [260, 44]
|
|
(call_expression [260, 21] - [260, 44]
|
|
function: (identifier [260, 21] - [260, 41])
|
|
arguments: (arguments [260, 41] - [260, 44]
|
|
(identifier [260, 42] - [260, 43]))))))
|
|
(if_statement [261, 2] - [261, 59]
|
|
condition: (parenthesized_expression [261, 5] - [261, 12]
|
|
(unary_expression [261, 6] - [261, 11]
|
|
argument: (identifier [261, 7] - [261, 11])))
|
|
consequence: (return_statement [261, 13] - [261, 59]
|
|
(call_expression [261, 20] - [261, 58]
|
|
function: (member_expression [261, 20] - [261, 26]
|
|
object: (identifier [261, 20] - [261, 21])
|
|
property: (property_identifier [261, 22] - [261, 26]))
|
|
arguments: (arguments [261, 26] - [261, 58]
|
|
(object [261, 27] - [261, 52]
|
|
(pair [261, 29] - [261, 50]
|
|
key: (property_identifier [261, 29] - [261, 34])
|
|
value: (string [261, 36] - [261, 50]
|
|
(string_fragment [261, 37] - [261, 49]))))
|
|
(number [261, 54] - [261, 57])))))
|
|
(lexical_declaration [262, 2] - [262, 45]
|
|
(variable_declarator [262, 8] - [262, 44]
|
|
name: (identifier [262, 8] - [262, 15])
|
|
value: (await_expression [262, 18] - [262, 44]
|
|
(call_expression [262, 24] - [262, 44]
|
|
function: (identifier [262, 24] - [262, 38])
|
|
arguments: (arguments [262, 38] - [262, 44]
|
|
(identifier [262, 39] - [262, 43]))))))
|
|
(if_statement [263, 2] - [265, 3]
|
|
condition: (parenthesized_expression [263, 5] - [263, 15]
|
|
(unary_expression [263, 6] - [263, 14]
|
|
argument: (identifier [263, 7] - [263, 14])))
|
|
consequence: (statement_block [263, 16] - [265, 3]
|
|
(return_statement [264, 4] - [264, 77]
|
|
(call_expression [264, 11] - [264, 76]
|
|
function: (member_expression [264, 11] - [264, 17]
|
|
object: (identifier [264, 11] - [264, 12])
|
|
property: (property_identifier [264, 13] - [264, 17]))
|
|
arguments: (arguments [264, 17] - [264, 76]
|
|
(object [264, 18] - [264, 70]
|
|
(pair [264, 20] - [264, 68]
|
|
key: (property_identifier [264, 20] - [264, 25])
|
|
value: (string [264, 27] - [264, 68]
|
|
(string_fragment [264, 28] - [264, 67]))))
|
|
(number [264, 72] - [264, 75]))))))
|
|
(expression_statement [266, 2] - [266, 15]
|
|
(await_expression [266, 2] - [266, 14]
|
|
(call_expression [266, 8] - [266, 14]
|
|
function: (identifier [266, 8] - [266, 12])
|
|
arguments: (arguments [266, 12] - [266, 14])))))))
|
|
(comment [269, 0] - [271, 3])
|
|
(export_statement [272, 0] - [291, 1]
|
|
declaration: (function_declaration [272, 7] - [291, 1]
|
|
name: (identifier [272, 22] - [272, 34])
|
|
parameters: (formal_parameters [272, 34] - [272, 48]
|
|
(required_parameter [272, 35] - [272, 47]
|
|
pattern: (identifier [272, 35] - [272, 39])
|
|
type: (type_annotation [272, 39] - [272, 47]
|
|
(predefined_type [272, 41] - [272, 47]))))
|
|
return_type: (type_annotation [272, 48] - [272, 75]
|
|
(generic_type [272, 50] - [272, 75]
|
|
name: (type_identifier [272, 50] - [272, 57])
|
|
type_arguments: (type_arguments [272, 57] - [272, 75]
|
|
(union_type [272, 58] - [272, 74]
|
|
(type_identifier [272, 58] - [272, 67])
|
|
(literal_type [272, 70] - [272, 74]
|
|
(null [272, 70] - [272, 74]))))))
|
|
body: (statement_block [272, 76] - [291, 1]
|
|
(lexical_declaration [273, 2] - [273, 46]
|
|
(variable_declarator [273, 8] - [273, 45]
|
|
name: (identifier [273, 8] - [273, 16])
|
|
value: (template_string [273, 19] - [273, 45]
|
|
(string_fragment [273, 20] - [273, 37])
|
|
(template_substitution [273, 37] - [273, 44]
|
|
(identifier [273, 39] - [273, 43])))))
|
|
(try_statement [274, 2] - [277, 17]
|
|
body: (statement_block [274, 6] - [277, 3]
|
|
(lexical_declaration [275, 4] - [275, 46]
|
|
(variable_declarator [275, 10] - [275, 45]
|
|
name: (identifier [275, 10] - [275, 16])
|
|
value: (await_expression [275, 19] - [275, 45]
|
|
(call_expression [275, 25] - [275, 45]
|
|
function: (member_expression [275, 25] - [275, 35]
|
|
object: (identifier [275, 25] - [275, 31])
|
|
property: (property_identifier [275, 32] - [275, 35]))
|
|
arguments: (arguments [275, 35] - [275, 45]
|
|
(identifier [275, 36] - [275, 44]))))))
|
|
(if_statement [276, 4] - [276, 42]
|
|
condition: (parenthesized_expression [276, 7] - [276, 15]
|
|
(identifier [276, 8] - [276, 14]))
|
|
consequence: (return_statement [276, 16] - [276, 42]
|
|
(call_expression [276, 23] - [276, 41]
|
|
function: (member_expression [276, 23] - [276, 33]
|
|
object: (identifier [276, 23] - [276, 27])
|
|
property: (property_identifier [276, 28] - [276, 33]))
|
|
arguments: (arguments [276, 33] - [276, 41]
|
|
(identifier [276, 34] - [276, 40]))))))
|
|
handler: (catch_clause [277, 4] - [277, 17]
|
|
parameter: (identifier [277, 11] - [277, 13])
|
|
body: (statement_block [277, 15] - [277, 17])))
|
|
(try_statement [279, 2] - [289, 17]
|
|
body: (statement_block [279, 6] - [289, 3]
|
|
(lexical_declaration [280, 4] - [283, 33]
|
|
(variable_declarator [280, 10] - [283, 32]
|
|
name: (identifier [280, 10] - [280, 13])
|
|
value: (await_expression [280, 16] - [283, 32]
|
|
(call_expression [280, 22] - [283, 32]
|
|
function: (member_expression [280, 22] - [283, 10]
|
|
object: (call_expression [280, 22] - [283, 5]
|
|
function: (member_expression [280, 22] - [280, 36]
|
|
object: (identifier [280, 22] - [280, 32])
|
|
property: (property_identifier [280, 33] - [280, 36]))
|
|
arguments: (template_string [280, 36] - [283, 5]
|
|
(string_fragment [280, 37] - [282, 31])
|
|
(template_substitution [282, 31] - [282, 38]
|
|
(identifier [282, 33] - [282, 37]))
|
|
(string_fragment [282, 38] - [283, 4])))
|
|
property: (property_identifier [283, 6] - [283, 10]))
|
|
arguments: (arguments [283, 10] - [283, 32]
|
|
(arrow_function [283, 11] - [283, 31]
|
|
parameters: (formal_parameters [283, 11] - [283, 21]
|
|
(required_parameter [283, 12] - [283, 20]
|
|
pattern: (identifier [283, 12] - [283, 15])
|
|
type: (type_annotation [283, 15] - [283, 20]
|
|
(predefined_type [283, 17] - [283, 20]))))
|
|
body: (subscript_expression [283, 25] - [283, 31]
|
|
object: (identifier [283, 25] - [283, 28])
|
|
index: (number [283, 29] - [283, 30]))))))))
|
|
(if_statement [285, 4] - [288, 5]
|
|
condition: (parenthesized_expression [285, 7] - [285, 12]
|
|
(identifier [285, 8] - [285, 11]))
|
|
consequence: (statement_block [285, 13] - [288, 5]
|
|
(expression_statement [286, 6] - [286, 77]
|
|
(await_expression [286, 6] - [286, 76]
|
|
(call_expression [286, 12] - [286, 76]
|
|
function: (member_expression [286, 12] - [286, 66]
|
|
object: (call_expression [286, 12] - [286, 60]
|
|
function: (member_expression [286, 12] - [286, 24]
|
|
object: (identifier [286, 12] - [286, 18])
|
|
property: (property_identifier [286, 19] - [286, 24]))
|
|
arguments: (arguments [286, 24] - [286, 60]
|
|
(identifier [286, 25] - [286, 33])
|
|
(number [286, 35] - [286, 38])
|
|
(call_expression [286, 40] - [286, 59]
|
|
function: (member_expression [286, 40] - [286, 54]
|
|
object: (identifier [286, 40] - [286, 44])
|
|
property: (property_identifier [286, 45] - [286, 54]))
|
|
arguments: (arguments [286, 54] - [286, 59]
|
|
(identifier [286, 55] - [286, 58])))))
|
|
property: (property_identifier [286, 61] - [286, 66]))
|
|
arguments: (arguments [286, 66] - [286, 76]
|
|
(arrow_function [286, 67] - [286, 75]
|
|
parameters: (formal_parameters [286, 67] - [286, 69])
|
|
body: (statement_block [286, 73] - [286, 75]))))))
|
|
(return_statement [287, 6] - [287, 17]
|
|
(identifier [287, 13] - [287, 16])))))
|
|
handler: (catch_clause [289, 4] - [289, 17]
|
|
parameter: (identifier [289, 11] - [289, 13])
|
|
body: (statement_block [289, 15] - [289, 17])))
|
|
(return_statement [290, 2] - [290, 14]
|
|
(null [290, 9] - [290, 13])))))
|
|
(comment [293, 0] - [295, 3])
|
|
(export_statement [296, 0] - [308, 1]
|
|
declaration: (function_declaration [296, 7] - [308, 1]
|
|
name: (identifier [296, 22] - [296, 34])
|
|
parameters: (formal_parameters [296, 34] - [299, 1]
|
|
(required_parameter [297, 2] - [297, 16]
|
|
pattern: (identifier [297, 2] - [297, 8])
|
|
type: (type_annotation [297, 8] - [297, 16]
|
|
(predefined_type [297, 10] - [297, 16])))
|
|
(required_parameter [298, 2] - [298, 15]
|
|
pattern: (identifier [298, 2] - [298, 7])
|
|
type: (type_annotation [298, 7] - [298, 15]
|
|
(predefined_type [298, 9] - [298, 15]))))
|
|
return_type: (type_annotation [299, 1] - [299, 25]
|
|
(generic_type [299, 3] - [299, 25]
|
|
name: (type_identifier [299, 3] - [299, 10])
|
|
type_arguments: (type_arguments [299, 10] - [299, 25]
|
|
(union_type [299, 11] - [299, 24]
|
|
(predefined_type [299, 11] - [299, 17])
|
|
(literal_type [299, 20] - [299, 24]
|
|
(null [299, 20] - [299, 24]))))))
|
|
body: (statement_block [299, 26] - [308, 1]
|
|
(try_statement [300, 2] - [307, 3]
|
|
body: (statement_block [300, 6] - [305, 3]
|
|
(lexical_declaration [301, 4] - [303, 33]
|
|
(variable_declarator [301, 10] - [303, 32]
|
|
name: (identifier [301, 10] - [301, 15])
|
|
value: (await_expression [301, 18] - [303, 32]
|
|
(call_expression [301, 24] - [303, 32]
|
|
function: (member_expression [301, 24] - [303, 10]
|
|
object: (call_expression [301, 24] - [303, 5]
|
|
function: (member_expression [301, 24] - [301, 38]
|
|
object: (identifier [301, 24] - [301, 34])
|
|
property: (property_identifier [301, 35] - [301, 38]))
|
|
arguments: (template_string [301, 38] - [303, 5]
|
|
(string_fragment [301, 39] - [302, 51])
|
|
(template_substitution [302, 51] - [302, 60]
|
|
(identifier [302, 53] - [302, 59]))
|
|
(string_fragment [302, 60] - [302, 74])
|
|
(template_substitution [302, 74] - [302, 82]
|
|
(identifier [302, 76] - [302, 81]))
|
|
(string_fragment [302, 82] - [303, 4])))
|
|
property: (property_identifier [303, 6] - [303, 10]))
|
|
arguments: (arguments [303, 10] - [303, 32]
|
|
(arrow_function [303, 11] - [303, 31]
|
|
parameters: (formal_parameters [303, 11] - [303, 21]
|
|
(required_parameter [303, 12] - [303, 20]
|
|
pattern: (identifier [303, 12] - [303, 15])
|
|
type: (type_annotation [303, 15] - [303, 20]
|
|
(predefined_type [303, 17] - [303, 20]))))
|
|
body: (subscript_expression [303, 25] - [303, 31]
|
|
object: (identifier [303, 25] - [303, 28])
|
|
index: (number [303, 29] - [303, 30]))))))))
|
|
(return_statement [304, 4] - [304, 31]
|
|
(binary_expression [304, 11] - [304, 30]
|
|
left: (member_expression [304, 11] - [304, 22]
|
|
object: (identifier [304, 11] - [304, 16])
|
|
optional_chain: (optional_chain [304, 16] - [304, 18])
|
|
property: (property_identifier [304, 18] - [304, 22]))
|
|
right: (null [304, 26] - [304, 30]))))
|
|
handler: (catch_clause [305, 4] - [307, 3]
|
|
parameter: (identifier [305, 11] - [305, 13])
|
|
body: (statement_block [305, 15] - [307, 3]
|
|
(return_statement [306, 4] - [306, 16]
|
|
(null [306, 11] - [306, 15])))))))))
|