1064 lines
63 KiB
Plaintext
1064 lines
63 KiB
Plaintext
(program [0, 0] - [252, 0]
|
|
(import_statement [0, 0] - [0, 40]
|
|
(import_clause [0, 7] - [0, 15]
|
|
(named_imports [0, 7] - [0, 15]
|
|
(import_specifier [0, 9] - [0, 13]
|
|
name: (identifier [0, 9] - [0, 13]))))
|
|
source: (string [0, 21] - [0, 39]
|
|
(string_fragment [0, 22] - [0, 38])))
|
|
(import_statement [1, 0] - [1, 63]
|
|
(import_clause [1, 7] - [1, 31]
|
|
(named_imports [1, 7] - [1, 31]
|
|
(import_specifier [1, 9] - [1, 18]
|
|
name: (identifier [1, 9] - [1, 18]))
|
|
(import_specifier [1, 20] - [1, 29]
|
|
name: (identifier [1, 20] - [1, 29]))))
|
|
source: (string [1, 37] - [1, 62]
|
|
(string_fragment [1, 38] - [1, 61])))
|
|
(import_statement [2, 0] - [2, 64]
|
|
(import_clause [2, 7] - [2, 26]
|
|
(named_imports [2, 7] - [2, 26]
|
|
(import_specifier [2, 9] - [2, 24]
|
|
name: (identifier [2, 9] - [2, 24]))))
|
|
source: (string [2, 32] - [2, 63]
|
|
(string_fragment [2, 33] - [2, 62])))
|
|
(import_statement [3, 0] - [6, 39]
|
|
(import_clause [3, 7] - [6, 1]
|
|
(named_imports [3, 7] - [6, 1]
|
|
(import_specifier [4, 2] - [4, 31]
|
|
name: (identifier [4, 2] - [4, 31]))
|
|
(import_specifier [5, 2] - [5, 30]
|
|
name: (identifier [5, 2] - [5, 30]))))
|
|
source: (string [6, 7] - [6, 38]
|
|
(string_fragment [6, 8] - [6, 37])))
|
|
(import_statement [7, 0] - [7, 80]
|
|
(import_clause [7, 12] - [7, 42]
|
|
(named_imports [7, 12] - [7, 42]
|
|
(import_specifier [7, 14] - [7, 40]
|
|
name: (identifier [7, 14] - [7, 40]))))
|
|
source: (string [7, 48] - [7, 79]
|
|
(string_fragment [7, 49] - [7, 78])))
|
|
(import_statement [9, 0] - [9, 46]
|
|
(import_clause [9, 7] - [9, 17]
|
|
(named_imports [9, 7] - [9, 17]
|
|
(import_specifier [9, 9] - [9, 15]
|
|
name: (identifier [9, 9] - [9, 15]))))
|
|
source: (string [9, 23] - [9, 45]
|
|
(string_fragment [9, 24] - [9, 44])))
|
|
(import_statement [10, 0] - [10, 74]
|
|
(import_clause [10, 7] - [10, 41]
|
|
(named_imports [10, 7] - [10, 41]
|
|
(import_specifier [10, 9] - [10, 20]
|
|
name: (identifier [10, 9] - [10, 20]))
|
|
(import_specifier [10, 22] - [10, 39]
|
|
name: (identifier [10, 22] - [10, 39]))))
|
|
source: (string [10, 47] - [10, 73]
|
|
(string_fragment [10, 48] - [10, 72])))
|
|
(import_statement [11, 0] - [15, 31]
|
|
(import_clause [11, 7] - [15, 1]
|
|
(named_imports [11, 7] - [15, 1]
|
|
(import_specifier [12, 2] - [12, 22]
|
|
name: (identifier [12, 2] - [12, 22]))
|
|
(import_specifier [13, 2] - [13, 22]
|
|
name: (identifier [13, 2] - [13, 22]))
|
|
(import_specifier [14, 2] - [14, 17]
|
|
name: (identifier [14, 2] - [14, 17]))))
|
|
source: (string [15, 7] - [15, 30]
|
|
(string_fragment [15, 8] - [15, 29])))
|
|
(import_statement [16, 0] - [16, 63]
|
|
(import_clause [16, 7] - [16, 28]
|
|
(named_imports [16, 7] - [16, 28]
|
|
(import_specifier [16, 9] - [16, 26]
|
|
name: (identifier [16, 9] - [16, 26]))))
|
|
source: (string [16, 34] - [16, 62]
|
|
(string_fragment [16, 35] - [16, 61])))
|
|
(import_statement [17, 0] - [17, 51]
|
|
(import_clause [17, 7] - [17, 23]
|
|
(named_imports [17, 7] - [17, 23]
|
|
(import_specifier [17, 9] - [17, 21]
|
|
name: (identifier [17, 9] - [17, 21]))))
|
|
source: (string [17, 29] - [17, 50]
|
|
(string_fragment [17, 30] - [17, 49])))
|
|
(import_statement [19, 0] - [27, 22]
|
|
(import_clause [19, 7] - [27, 1]
|
|
(named_imports [19, 7] - [27, 1]
|
|
(import_specifier [20, 2] - [20, 15]
|
|
name: (identifier [20, 2] - [20, 15]))
|
|
(import_specifier [21, 2] - [21, 15]
|
|
name: (identifier [21, 2] - [21, 15]))
|
|
(import_specifier [22, 2] - [22, 26]
|
|
name: (identifier [22, 2] - [22, 26]))
|
|
(import_specifier [23, 2] - [23, 21]
|
|
name: (identifier [23, 2] - [23, 21]))
|
|
(import_specifier [24, 2] - [24, 13]
|
|
name: (identifier [24, 2] - [24, 13]))
|
|
(import_specifier [25, 2] - [25, 19]
|
|
name: (identifier [25, 2] - [25, 19]))
|
|
(import_specifier [26, 2] - [26, 22]
|
|
name: (identifier [26, 2] - [26, 22]))))
|
|
source: (string [27, 7] - [27, 21]
|
|
(string_fragment [27, 8] - [27, 20])))
|
|
(import_statement [28, 0] - [28, 58]
|
|
(import_clause [28, 7] - [28, 28]
|
|
(named_imports [28, 7] - [28, 28]
|
|
(import_specifier [28, 9] - [28, 26]
|
|
name: (identifier [28, 9] - [28, 26]))))
|
|
source: (string [28, 34] - [28, 57]
|
|
(string_fragment [28, 35] - [28, 56])))
|
|
(export_statement [30, 0] - [30, 38]
|
|
declaration: (lexical_declaration [30, 7] - [30, 38]
|
|
(variable_declarator [30, 13] - [30, 37]
|
|
name: (identifier [30, 13] - [30, 24])
|
|
value: (new_expression [30, 27] - [30, 37]
|
|
constructor: (identifier [30, 31] - [30, 35])
|
|
arguments: (arguments [30, 35] - [30, 37])))))
|
|
(lexical_declaration [32, 0] - [33, 47]
|
|
(variable_declarator [32, 6] - [33, 46]
|
|
name: (identifier [32, 6] - [32, 10])
|
|
value: (binary_expression [32, 13] - [33, 46]
|
|
left: (call_expression [32, 13] - [32, 34]
|
|
function: (member_expression [32, 13] - [32, 25]
|
|
object: (member_expression [32, 13] - [32, 21]
|
|
object: (identifier [32, 13] - [32, 17])
|
|
property: (property_identifier [32, 18] - [32, 21]))
|
|
property: (property_identifier [32, 22] - [32, 25]))
|
|
arguments: (arguments [32, 25] - [32, 34]
|
|
(string [32, 26] - [32, 33]
|
|
(string_fragment [32, 27] - [32, 32]))))
|
|
right: (parenthesized_expression [33, 2] - [33, 46]
|
|
(ternary_expression [33, 3] - [33, 45]
|
|
condition: (member_expression [33, 3] - [33, 19]
|
|
object: (meta_property [33, 3] - [33, 14])
|
|
property: (property_identifier [33, 15] - [33, 19]))
|
|
consequence: (undefined [33, 22] - [33, 31])
|
|
alternative: (string [33, 34] - [33, 45]
|
|
(string_fragment [33, 35] - [33, 44])))))))
|
|
(lexical_declaration [34, 0] - [35, 54]
|
|
(variable_declarator [34, 6] - [35, 53]
|
|
name: (identifier [34, 6] - [34, 12])
|
|
value: (binary_expression [34, 15] - [35, 53]
|
|
left: (call_expression [34, 15] - [34, 37]
|
|
function: (member_expression [34, 15] - [34, 27]
|
|
object: (member_expression [34, 15] - [34, 23]
|
|
object: (identifier [34, 15] - [34, 19])
|
|
property: (property_identifier [34, 20] - [34, 23]))
|
|
property: (property_identifier [34, 24] - [34, 27]))
|
|
arguments: (arguments [34, 27] - [34, 37]
|
|
(string [34, 28] - [34, 36]
|
|
(string_fragment [34, 29] - [34, 35]))))
|
|
right: (parenthesized_expression [35, 2] - [35, 53]
|
|
(ternary_expression [35, 3] - [35, 52]
|
|
condition: (member_expression [35, 3] - [35, 19]
|
|
object: (meta_property [35, 3] - [35, 14])
|
|
property: (property_identifier [35, 15] - [35, 19]))
|
|
consequence: (undefined [35, 22] - [35, 31])
|
|
alternative: (string [35, 34] - [35, 52]
|
|
(string_fragment [35, 35] - [35, 51])))))))
|
|
(comment [37, 0] - [37, 11])
|
|
(expression_statement [38, 0] - [48, 3]
|
|
(call_expression [38, 0] - [48, 2]
|
|
function: (member_expression [38, 0] - [38, 15]
|
|
object: (identifier [38, 0] - [38, 11])
|
|
property: (property_identifier [38, 12] - [38, 15]))
|
|
arguments: (arguments [38, 15] - [48, 2]
|
|
(string [38, 16] - [38, 24]
|
|
(string_fragment [38, 17] - [38, 23]))
|
|
(arrow_function [38, 26] - [48, 1]
|
|
parameters: (formal_parameters [38, 32] - [38, 35]
|
|
(required_parameter [38, 33] - [38, 34]
|
|
pattern: (identifier [38, 33] - [38, 34])))
|
|
body: (statement_block [38, 39] - [48, 1]
|
|
(lexical_declaration [39, 2] - [39, 45]
|
|
(variable_declarator [39, 8] - [39, 44]
|
|
name: (identifier [39, 8] - [39, 12])
|
|
value: (await_expression [39, 15] - [39, 44]
|
|
(call_expression [39, 21] - [39, 44]
|
|
function: (identifier [39, 21] - [39, 41])
|
|
arguments: (arguments [39, 41] - [39, 44]
|
|
(identifier [39, 42] - [39, 43]))))))
|
|
(if_statement [40, 2] - [46, 3]
|
|
condition: (parenthesized_expression [40, 5] - [40, 11]
|
|
(identifier [40, 6] - [40, 10]))
|
|
consequence: (statement_block [40, 12] - [46, 3]
|
|
(lexical_declaration [41, 4] - [41, 50]
|
|
(variable_declarator [41, 10] - [41, 49]
|
|
name: (identifier [41, 10] - [41, 23])
|
|
value: (call_expression [41, 26] - [41, 49]
|
|
function: (member_expression [41, 26] - [41, 37]
|
|
object: (member_expression [41, 26] - [41, 31]
|
|
object: (identifier [41, 26] - [41, 27])
|
|
property: (property_identifier [41, 28] - [41, 31]))
|
|
property: (property_identifier [41, 32] - [41, 37]))
|
|
arguments: (arguments [41, 37] - [41, 49]
|
|
(string [41, 38] - [41, 48]
|
|
(string_fragment [41, 39] - [41, 47]))))))
|
|
(if_statement [42, 4] - [44, 5]
|
|
condition: (parenthesized_expression [42, 7] - [42, 58]
|
|
(binary_expression [42, 8] - [42, 57]
|
|
left: (identifier [42, 8] - [42, 21])
|
|
right: (call_expression [42, 25] - [42, 57]
|
|
function: (identifier [42, 25] - [42, 42])
|
|
arguments: (arguments [42, 42] - [42, 57]
|
|
(identifier [42, 43] - [42, 56])))))
|
|
consequence: (statement_block [42, 59] - [44, 5]
|
|
(return_statement [43, 6] - [43, 39]
|
|
(call_expression [43, 13] - [43, 38]
|
|
function: (member_expression [43, 13] - [43, 23]
|
|
object: (identifier [43, 13] - [43, 14])
|
|
property: (property_identifier [43, 15] - [43, 23]))
|
|
arguments: (arguments [43, 23] - [43, 38]
|
|
(identifier [43, 24] - [43, 37]))))))
|
|
(return_statement [45, 4] - [45, 36]
|
|
(call_expression [45, 11] - [45, 35]
|
|
function: (member_expression [45, 11] - [45, 21]
|
|
object: (identifier [45, 11] - [45, 12])
|
|
property: (property_identifier [45, 13] - [45, 21]))
|
|
arguments: (arguments [45, 21] - [45, 35]
|
|
(string [45, 22] - [45, 34]
|
|
(string_fragment [45, 23] - [45, 33])))))))
|
|
(return_statement [47, 2] - [47, 37]
|
|
(call_expression [47, 9] - [47, 36]
|
|
function: (member_expression [47, 9] - [47, 15]
|
|
object: (identifier [47, 9] - [47, 10])
|
|
property: (property_identifier [47, 11] - [47, 15]))
|
|
arguments: (arguments [47, 15] - [47, 36]
|
|
(call_expression [47, 16] - [47, 35]
|
|
function: (identifier [47, 16] - [47, 33])
|
|
arguments: (arguments [47, 33] - [47, 35]))))))))))
|
|
(comment [50, 0] - [50, 13])
|
|
(expression_statement [51, 0] - [51, 51]
|
|
(call_expression [51, 0] - [51, 50]
|
|
function: (member_expression [51, 0] - [51, 15]
|
|
object: (identifier [51, 0] - [51, 11])
|
|
property: (property_identifier [51, 12] - [51, 15]))
|
|
arguments: (arguments [51, 15] - [51, 50]
|
|
(string [51, 16] - [51, 30]
|
|
(string_fragment [51, 17] - [51, 29]))
|
|
(identifier [51, 32] - [51, 49]))))
|
|
(comment [53, 0] - [53, 18])
|
|
(expression_statement [54, 0] - [111, 3]
|
|
(call_expression [54, 0] - [111, 2]
|
|
function: (member_expression [54, 0] - [54, 16]
|
|
object: (identifier [54, 0] - [54, 11])
|
|
property: (property_identifier [54, 12] - [54, 16]))
|
|
arguments: (arguments [54, 16] - [111, 2]
|
|
(string [54, 17] - [54, 39]
|
|
(string_fragment [54, 18] - [54, 38]))
|
|
(arrow_function [54, 41] - [111, 1]
|
|
parameters: (formal_parameters [54, 47] - [54, 50]
|
|
(required_parameter [54, 48] - [54, 49]
|
|
pattern: (identifier [54, 48] - [54, 49])))
|
|
body: (statement_block [54, 54] - [111, 1]
|
|
(lexical_declaration [55, 2] - [55, 11]
|
|
(variable_declarator [55, 6] - [55, 10]
|
|
name: (identifier [55, 6] - [55, 10])))
|
|
(try_statement [56, 2] - [60, 3]
|
|
body: (statement_block [56, 6] - [58, 3]
|
|
(expression_statement [57, 4] - [57, 30]
|
|
(assignment_expression [57, 4] - [57, 29]
|
|
left: (identifier [57, 4] - [57, 8])
|
|
right: (await_expression [57, 11] - [57, 29]
|
|
(call_expression [57, 17] - [57, 29]
|
|
function: (member_expression [57, 17] - [57, 27]
|
|
object: (member_expression [57, 17] - [57, 22]
|
|
object: (identifier [57, 17] - [57, 18])
|
|
property: (property_identifier [57, 19] - [57, 22]))
|
|
property: (property_identifier [57, 23] - [57, 27]))
|
|
arguments: (arguments [57, 27] - [57, 29]))))))
|
|
handler: (catch_clause [58, 4] - [60, 3]
|
|
parameter: (identifier [58, 11] - [58, 15])
|
|
body: (statement_block [58, 17] - [60, 3]
|
|
(expression_statement [59, 4] - [59, 14]
|
|
(assignment_expression [59, 4] - [59, 13]
|
|
left: (identifier [59, 4] - [59, 8])
|
|
right: (object [59, 11] - [59, 13]))))))
|
|
(lexical_declaration [61, 2] - [61, 33]
|
|
(variable_declarator [61, 8] - [61, 32]
|
|
name: (identifier [61, 8] - [61, 16])
|
|
value: (member_expression [61, 19] - [61, 32]
|
|
object: (identifier [61, 19] - [61, 23])
|
|
property: (property_identifier [61, 24] - [61, 32]))))
|
|
(lexical_declaration [62, 2] - [62, 34]
|
|
(variable_declarator [62, 6] - [62, 33]
|
|
name: (identifier [62, 6] - [62, 16])
|
|
type: (type_annotation [62, 16] - [62, 21]
|
|
(predefined_type [62, 18] - [62, 21]))
|
|
value: (undefined [62, 24] - [62, 33])))
|
|
(lexical_declaration [63, 2] - [63, 54]
|
|
(variable_declarator [63, 6] - [63, 53]
|
|
name: (identifier [63, 6] - [63, 22])
|
|
type: (type_annotation [63, 22] - [63, 41]
|
|
(union_type [63, 24] - [63, 41]
|
|
(array_type [63, 24] - [63, 29]
|
|
(predefined_type [63, 24] - [63, 27]))
|
|
(literal_type [63, 32] - [63, 41]
|
|
(undefined [63, 32] - [63, 41]))))
|
|
value: (undefined [63, 44] - [63, 53])))
|
|
(if_statement [65, 2] - [91, 3]
|
|
condition: (parenthesized_expression [65, 5] - [65, 15]
|
|
(identifier [65, 6] - [65, 14]))
|
|
consequence: (statement_block [65, 16] - [91, 3]
|
|
(lexical_declaration [66, 4] - [66, 51]
|
|
(variable_declarator [66, 10] - [66, 50]
|
|
name: (identifier [66, 10] - [66, 14])
|
|
value: (await_expression [66, 17] - [66, 50]
|
|
(call_expression [66, 23] - [66, 50]
|
|
function: (identifier [66, 23] - [66, 40])
|
|
arguments: (arguments [66, 40] - [66, 50]
|
|
(identifier [66, 41] - [66, 49]))))))
|
|
(if_statement [67, 4] - [90, 5]
|
|
condition: (parenthesized_expression [67, 7] - [67, 13]
|
|
(identifier [67, 8] - [67, 12]))
|
|
consequence: (statement_block [67, 14] - [90, 5]
|
|
(lexical_declaration [68, 6] - [68, 58]
|
|
(variable_declarator [68, 12] - [68, 57]
|
|
name: (identifier [68, 12] - [68, 20])
|
|
value: (await_expression [68, 23] - [68, 57]
|
|
(call_expression [68, 29] - [68, 57]
|
|
function: (identifier [68, 29] - [68, 48])
|
|
arguments: (arguments [68, 48] - [68, 57]
|
|
(member_expression [68, 49] - [68, 56]
|
|
object: (identifier [68, 49] - [68, 53])
|
|
property: (property_identifier [68, 54] - [68, 56])))))))
|
|
(if_statement [69, 6] - [89, 7]
|
|
condition: (parenthesized_expression [69, 9] - [69, 30]
|
|
(binary_expression [69, 10] - [69, 29]
|
|
left: (member_expression [69, 10] - [69, 25]
|
|
object: (identifier [69, 10] - [69, 18])
|
|
property: (property_identifier [69, 19] - [69, 25]))
|
|
right: (number [69, 28] - [69, 29])))
|
|
consequence: (statement_block [69, 31] - [89, 7]
|
|
(expression_statement [70, 8] - [73, 12]
|
|
(assignment_expression [70, 8] - [73, 11]
|
|
left: (identifier [70, 8] - [70, 24])
|
|
right: (call_expression [70, 27] - [73, 11]
|
|
function: (member_expression [70, 27] - [70, 39]
|
|
object: (identifier [70, 27] - [70, 35])
|
|
property: (property_identifier [70, 36] - [70, 39]))
|
|
arguments: (arguments [70, 39] - [73, 11]
|
|
(arrow_function [70, 40] - [73, 10]
|
|
parameters: (formal_parameters [70, 40] - [70, 49]
|
|
(required_parameter [70, 41] - [70, 48]
|
|
pattern: (identifier [70, 41] - [70, 43])
|
|
type: (type_annotation [70, 43] - [70, 48]
|
|
(predefined_type [70, 45] - [70, 48]))))
|
|
body: (parenthesized_expression [70, 53] - [73, 10]
|
|
(object [70, 54] - [73, 9]
|
|
(pair [71, 10] - [71, 30]
|
|
key: (property_identifier [71, 10] - [71, 12])
|
|
value: (member_expression [71, 14] - [71, 30]
|
|
object: (identifier [71, 14] - [71, 16])
|
|
property: (property_identifier [71, 17] - [71, 30])))
|
|
(pair [72, 10] - [72, 28]
|
|
key: (property_identifier [72, 10] - [72, 14])
|
|
value: (string [72, 16] - [72, 28]
|
|
(string_fragment [72, 17] - [72, 27]))))))))))
|
|
(lexical_declaration [75, 8] - [77, 10]
|
|
(variable_declarator [75, 14] - [77, 9]
|
|
name: (identifier [75, 14] - [75, 25])
|
|
value: (call_expression [75, 28] - [77, 9]
|
|
function: (member_expression [75, 28] - [75, 43]
|
|
object: (identifier [75, 28] - [75, 36])
|
|
property: (property_identifier [75, 37] - [75, 43]))
|
|
arguments: (arguments [75, 43] - [77, 9]
|
|
(arrow_function [75, 44] - [76, 39]
|
|
parameters: (formal_parameters [75, 44] - [75, 53]
|
|
(required_parameter [75, 45] - [75, 52]
|
|
pattern: (identifier [75, 45] - [75, 47])
|
|
type: (type_annotation [75, 47] - [75, 52]
|
|
(predefined_type [75, 49] - [75, 52]))))
|
|
body: (binary_expression [76, 10] - [76, 39]
|
|
left: (member_expression [76, 10] - [76, 24]
|
|
object: (identifier [76, 10] - [76, 12])
|
|
property: (property_identifier [76, 13] - [76, 24]))
|
|
right: (member_expression [76, 28] - [76, 39]
|
|
object: (identifier [76, 28] - [76, 30])
|
|
property: (property_identifier [76, 31] - [76, 39]))))))))
|
|
(if_statement [78, 8] - [88, 9]
|
|
condition: (parenthesized_expression [78, 11] - [78, 35]
|
|
(binary_expression [78, 12] - [78, 34]
|
|
left: (member_expression [78, 12] - [78, 30]
|
|
object: (identifier [78, 12] - [78, 23])
|
|
property: (property_identifier [78, 24] - [78, 30]))
|
|
right: (number [78, 33] - [78, 34])))
|
|
consequence: (statement_block [78, 36] - [88, 9]
|
|
(expression_statement [79, 10] - [81, 12]
|
|
(assignment_expression [79, 10] - [81, 11]
|
|
left: (identifier [79, 10] - [79, 20])
|
|
right: (object [79, 23] - [81, 11]
|
|
(pair [80, 12] - [80, 55]
|
|
key: (computed_property_name [80, 12] - [80, 29]
|
|
(as_expression [80, 13] - [80, 28]
|
|
(string [80, 13] - [80, 18]
|
|
(string_fragment [80, 14] - [80, 17]))
|
|
(predefined_type [80, 22] - [80, 28])))
|
|
value: (object [80, 31] - [80, 55]
|
|
(pair [80, 33] - [80, 53]
|
|
key: (property_identifier [80, 33] - [80, 49])
|
|
value: (object [80, 51] - [80, 53])))))))
|
|
(for_in_statement [82, 10] - [87, 11]
|
|
left: (identifier [82, 21] - [82, 23])
|
|
right: (identifier [82, 27] - [82, 38])
|
|
body: (statement_block [82, 40] - [87, 11]
|
|
(lexical_declaration [83, 12] - [83, 59]
|
|
(variable_declarator [83, 18] - [83, 58]
|
|
name: (identifier [83, 18] - [83, 27])
|
|
value: (call_expression [83, 30] - [83, 58]
|
|
function: (identifier [83, 30] - [83, 45])
|
|
arguments: (arguments [83, 45] - [83, 58]
|
|
(member_expression [83, 46] - [83, 57]
|
|
object: (identifier [83, 46] - [83, 48])
|
|
property: (property_identifier [83, 49] - [83, 57]))))))
|
|
(expression_statement [84, 12] - [86, 14]
|
|
(assignment_expression [84, 12] - [86, 13]
|
|
left: (subscript_expression [84, 12] - [84, 67]
|
|
object: (subscript_expression [84, 12] - [84, 49]
|
|
object: (subscript_expression [84, 12] - [84, 29]
|
|
object: (identifier [84, 12] - [84, 22])
|
|
index: (string [84, 23] - [84, 28]
|
|
(string_fragment [84, 24] - [84, 27])))
|
|
index: (string [84, 30] - [84, 48]
|
|
(string_fragment [84, 31] - [84, 47])))
|
|
index: (member_expression [84, 50] - [84, 66]
|
|
object: (identifier [84, 50] - [84, 52])
|
|
property: (property_identifier [84, 53] - [84, 66])))
|
|
right: (object [84, 70] - [86, 13]
|
|
(pair [85, 14] - [85, 30]
|
|
key: (property_identifier [85, 14] - [85, 19])
|
|
value: (identifier [85, 21] - [85, 30])))))))))))))))
|
|
(if_statement [93, 2] - [93, 48]
|
|
condition: (parenthesized_expression [93, 5] - [93, 12]
|
|
(unary_expression [93, 6] - [93, 11]
|
|
argument: (identifier [93, 7] - [93, 11])))
|
|
consequence: (throw_statement [93, 13] - [93, 48]
|
|
(new_expression [93, 19] - [93, 47]
|
|
constructor: (identifier [93, 23] - [93, 28])
|
|
arguments: (arguments [93, 28] - [93, 47]
|
|
(string [93, 29] - [93, 46]
|
|
(string_fragment [93, 30] - [93, 45]))))))
|
|
(lexical_declaration [95, 2] - [101, 5]
|
|
(variable_declarator [95, 8] - [101, 4]
|
|
name: (identifier [95, 8] - [95, 15])
|
|
value: (await_expression [95, 18] - [101, 4]
|
|
(call_expression [95, 24] - [101, 4]
|
|
function: (identifier [95, 24] - [95, 53])
|
|
arguments: (arguments [95, 53] - [101, 4]
|
|
(object [95, 54] - [101, 3]
|
|
(shorthand_property_identifier [96, 4] - [96, 8])
|
|
(pair [97, 4] - [97, 33]
|
|
key: (property_identifier [97, 4] - [97, 20])
|
|
value: (string [97, 22] - [97, 33]
|
|
(string_fragment [97, 23] - [97, 32])))
|
|
(pair [98, 4] - [98, 18]
|
|
key: (property_identifier [98, 4] - [98, 11])
|
|
value: (number [98, 13] - [98, 18]))
|
|
(shorthand_property_identifier [99, 4] - [99, 20])
|
|
(shorthand_property_identifier [100, 4] - [100, 14])))))))
|
|
(expression_statement [103, 2] - [108, 5]
|
|
(call_expression [103, 2] - [108, 4]
|
|
function: (identifier [103, 2] - [103, 11])
|
|
arguments: (arguments [103, 11] - [108, 4]
|
|
(identifier [103, 12] - [103, 13])
|
|
(string [103, 15] - [103, 50]
|
|
(string_fragment [103, 16] - [103, 49]))
|
|
(member_expression [103, 52] - [103, 69]
|
|
object: (identifier [103, 52] - [103, 59])
|
|
property: (property_identifier [103, 60] - [103, 69]))
|
|
(object [103, 71] - [108, 3]
|
|
(pair [104, 4] - [104, 18]
|
|
key: (property_identifier [104, 4] - [104, 12])
|
|
value: (true [104, 14] - [104, 18]))
|
|
(pair [105, 4] - [105, 16]
|
|
key: (property_identifier [105, 4] - [105, 10])
|
|
value: (true [105, 12] - [105, 16]))
|
|
(pair [106, 4] - [106, 19]
|
|
key: (property_identifier [106, 4] - [106, 12])
|
|
value: (string [106, 14] - [106, 19]
|
|
(string_fragment [106, 15] - [106, 18])))
|
|
(pair [107, 4] - [107, 15]
|
|
key: (property_identifier [107, 4] - [107, 10])
|
|
value: (number [107, 12] - [107, 15]))))))
|
|
(return_statement [110, 2] - [110, 29]
|
|
(call_expression [110, 9] - [110, 28]
|
|
function: (member_expression [110, 9] - [110, 15]
|
|
object: (identifier [110, 9] - [110, 10])
|
|
property: (property_identifier [110, 11] - [110, 15]))
|
|
arguments: (arguments [110, 15] - [110, 28]
|
|
(object [110, 16] - [110, 27]
|
|
(shorthand_property_identifier [110, 18] - [110, 25]))))))))))
|
|
(comment [113, 0] - [113, 15])
|
|
(expression_statement [114, 0] - [251, 3]
|
|
(call_expression [114, 0] - [251, 2]
|
|
function: (member_expression [114, 0] - [114, 16]
|
|
object: (identifier [114, 0] - [114, 11])
|
|
property: (property_identifier [114, 12] - [114, 16]))
|
|
arguments: (arguments [114, 16] - [251, 2]
|
|
(string [114, 17] - [114, 36]
|
|
(string_fragment [114, 18] - [114, 35]))
|
|
(arrow_function [114, 38] - [251, 1]
|
|
parameters: (formal_parameters [114, 44] - [114, 47]
|
|
(required_parameter [114, 45] - [114, 46]
|
|
pattern: (identifier [114, 45] - [114, 46])))
|
|
body: (statement_block [114, 51] - [251, 1]
|
|
(lexical_declaration [115, 2] - [115, 11]
|
|
(variable_declarator [115, 6] - [115, 10]
|
|
name: (identifier [115, 6] - [115, 10])))
|
|
(try_statement [116, 2] - [120, 3]
|
|
body: (statement_block [116, 6] - [118, 3]
|
|
(expression_statement [117, 4] - [117, 30]
|
|
(assignment_expression [117, 4] - [117, 29]
|
|
left: (identifier [117, 4] - [117, 8])
|
|
right: (await_expression [117, 11] - [117, 29]
|
|
(call_expression [117, 17] - [117, 29]
|
|
function: (member_expression [117, 17] - [117, 27]
|
|
object: (member_expression [117, 17] - [117, 22]
|
|
object: (identifier [117, 17] - [117, 18])
|
|
property: (property_identifier [117, 19] - [117, 22]))
|
|
property: (property_identifier [117, 23] - [117, 27]))
|
|
arguments: (arguments [117, 27] - [117, 29]))))))
|
|
handler: (catch_clause [118, 4] - [120, 3]
|
|
body: (statement_block [118, 10] - [120, 3]
|
|
(return_statement [119, 4] - [119, 53]
|
|
(call_expression [119, 11] - [119, 52]
|
|
function: (member_expression [119, 11] - [119, 17]
|
|
object: (identifier [119, 11] - [119, 12])
|
|
property: (property_identifier [119, 13] - [119, 17]))
|
|
arguments: (arguments [119, 17] - [119, 52]
|
|
(object [119, 18] - [119, 46]
|
|
(pair [119, 20] - [119, 44]
|
|
key: (property_identifier [119, 20] - [119, 25])
|
|
value: (string [119, 27] - [119, 44]
|
|
(string_fragment [119, 28] - [119, 43]))))
|
|
(number [119, 48] - [119, 51])))))))
|
|
(lexical_declaration [121, 2] - [121, 28]
|
|
(variable_declarator [121, 8] - [121, 27]
|
|
name: (object_pattern [121, 8] - [121, 20]
|
|
(shorthand_property_identifier_pattern [121, 10] - [121, 18]))
|
|
value: (identifier [121, 23] - [121, 27])))
|
|
(lexical_declaration [123, 2] - [123, 78]
|
|
(variable_declarator [123, 8] - [123, 77]
|
|
name: (identifier [123, 8] - [123, 25])
|
|
value: (call_expression [123, 28] - [123, 77]
|
|
function: (identifier [123, 28] - [123, 37])
|
|
arguments: (arguments [123, 37] - [123, 77]
|
|
(identifier [123, 38] - [123, 39])
|
|
(string [123, 41] - [123, 76]
|
|
(string_fragment [123, 42] - [123, 75]))))))
|
|
(if_statement [124, 2] - [129, 3]
|
|
condition: (parenthesized_expression [124, 5] - [124, 25]
|
|
(unary_expression [124, 6] - [124, 24]
|
|
argument: (identifier [124, 7] - [124, 24])))
|
|
consequence: (statement_block [124, 26] - [129, 3]
|
|
(return_statement [125, 4] - [128, 6]
|
|
(call_expression [125, 11] - [128, 5]
|
|
function: (member_expression [125, 11] - [125, 17]
|
|
object: (identifier [125, 11] - [125, 12])
|
|
property: (property_identifier [125, 13] - [125, 17]))
|
|
arguments: (arguments [125, 17] - [128, 5]
|
|
(object [126, 6] - [126, 62]
|
|
(pair [126, 8] - [126, 60]
|
|
key: (property_identifier [126, 8] - [126, 13])
|
|
value: (string [126, 15] - [126, 60]
|
|
(string_fragment [126, 16] - [126, 59]))))
|
|
(number [127, 6] - [127, 9]))))))
|
|
(lexical_declaration [131, 2] - [131, 41]
|
|
(variable_declarator [131, 8] - [131, 40]
|
|
name: (identifier [131, 8] - [131, 26])
|
|
value: (member_expression [131, 29] - [131, 40]
|
|
object: (identifier [131, 29] - [131, 37])
|
|
property: (property_identifier [131, 38] - [131, 40]))))
|
|
(lexical_declaration [132, 2] - [132, 69]
|
|
(variable_declarator [132, 8] - [132, 68]
|
|
name: (identifier [132, 8] - [132, 15])
|
|
value: (await_expression [132, 18] - [132, 68]
|
|
(call_expression [132, 24] - [132, 68]
|
|
function: (identifier [132, 24] - [132, 48])
|
|
arguments: (arguments [132, 48] - [132, 68]
|
|
(identifier [132, 49] - [132, 67]))))))
|
|
(if_statement [134, 2] - [139, 3]
|
|
condition: (parenthesized_expression [134, 5] - [134, 15]
|
|
(unary_expression [134, 6] - [134, 14]
|
|
argument: (identifier [134, 7] - [134, 14])))
|
|
consequence: (statement_block [134, 16] - [139, 3]
|
|
(return_statement [135, 4] - [138, 6]
|
|
(call_expression [135, 11] - [138, 5]
|
|
function: (member_expression [135, 11] - [135, 17]
|
|
object: (identifier [135, 11] - [135, 12])
|
|
property: (property_identifier [135, 13] - [135, 17]))
|
|
arguments: (arguments [135, 17] - [138, 5]
|
|
(object [136, 6] - [136, 73]
|
|
(pair [136, 8] - [136, 71]
|
|
key: (property_identifier [136, 8] - [136, 13])
|
|
value: (string [136, 15] - [136, 71]
|
|
(string_fragment [136, 16] - [136, 70]))))
|
|
(number [137, 6] - [137, 9]))))))
|
|
(lexical_declaration [141, 2] - [141, 50]
|
|
(variable_declarator [141, 8] - [141, 49]
|
|
name: (identifier [141, 8] - [141, 12])
|
|
value: (await_expression [141, 15] - [141, 49]
|
|
(call_expression [141, 21] - [141, 49]
|
|
function: (identifier [141, 21] - [141, 32])
|
|
arguments: (arguments [141, 32] - [141, 49]
|
|
(member_expression [141, 33] - [141, 48]
|
|
object: (identifier [141, 33] - [141, 40])
|
|
property: (property_identifier [141, 41] - [141, 48])))))))
|
|
(if_statement [142, 2] - [144, 3]
|
|
condition: (parenthesized_expression [142, 5] - [142, 12]
|
|
(unary_expression [142, 6] - [142, 11]
|
|
argument: (identifier [142, 7] - [142, 11])))
|
|
consequence: (statement_block [142, 13] - [144, 3]
|
|
(return_statement [143, 4] - [143, 52]
|
|
(call_expression [143, 11] - [143, 51]
|
|
function: (member_expression [143, 11] - [143, 17]
|
|
object: (identifier [143, 11] - [143, 12])
|
|
property: (property_identifier [143, 13] - [143, 17]))
|
|
arguments: (arguments [143, 17] - [143, 51]
|
|
(object [143, 18] - [143, 45]
|
|
(pair [143, 20] - [143, 43]
|
|
key: (property_identifier [143, 20] - [143, 25])
|
|
value: (string [143, 27] - [143, 43]
|
|
(string_fragment [143, 28] - [143, 42]))))
|
|
(number [143, 47] - [143, 50]))))))
|
|
(lexical_declaration [146, 2] - [146, 25]
|
|
(variable_declarator [146, 8] - [146, 24]
|
|
name: (identifier [146, 8] - [146, 14])
|
|
value: (member_expression [146, 17] - [146, 24]
|
|
object: (identifier [146, 17] - [146, 21])
|
|
property: (property_identifier [146, 22] - [146, 24]))))
|
|
(if_statement [148, 2] - [160, 3]
|
|
condition: (parenthesized_expression [148, 5] - [148, 39]
|
|
(binary_expression [148, 6] - [148, 38]
|
|
left: (member_expression [148, 6] - [148, 25]
|
|
object: (identifier [148, 6] - [148, 10])
|
|
property: (property_identifier [148, 11] - [148, 25]))
|
|
right: (string [148, 30] - [148, 38]
|
|
(string_fragment [148, 31] - [148, 37]))))
|
|
consequence: (statement_block [148, 40] - [160, 3]
|
|
(expression_statement [149, 4] - [155, 6]
|
|
(call_expression [149, 4] - [155, 5]
|
|
function: (member_expression [149, 4] - [149, 25]
|
|
object: (identifier [149, 4] - [149, 16])
|
|
property: (property_identifier [149, 17] - [149, 25]))
|
|
arguments: (arguments [149, 25] - [155, 5]
|
|
(identifier [150, 6] - [150, 12])
|
|
(string [151, 6] - [151, 20]
|
|
(string_fragment [151, 7] - [151, 19]))
|
|
(null [152, 6] - [152, 10])
|
|
(object [153, 6] - [153, 60]
|
|
(pair [153, 8] - [153, 58]
|
|
key: (property_identifier [153, 8] - [153, 14])
|
|
value: (template_string [153, 16] - [153, 58]
|
|
(string_fragment [153, 17] - [153, 35])
|
|
(template_substitution [153, 35] - [153, 57]
|
|
(member_expression [153, 37] - [153, 56]
|
|
object: (identifier [153, 37] - [153, 41])
|
|
property: (property_identifier [153, 42] - [153, 56]))))))
|
|
(call_expression [154, 6] - [154, 20]
|
|
function: (identifier [154, 6] - [154, 17])
|
|
arguments: (arguments [154, 17] - [154, 20]
|
|
(identifier [154, 18] - [154, 19]))))))
|
|
(return_statement [156, 4] - [159, 6]
|
|
(call_expression [156, 11] - [159, 5]
|
|
function: (member_expression [156, 11] - [156, 17]
|
|
object: (identifier [156, 11] - [156, 12])
|
|
property: (property_identifier [156, 13] - [156, 17]))
|
|
arguments: (arguments [156, 17] - [159, 5]
|
|
(object [157, 6] - [157, 74]
|
|
(pair [157, 8] - [157, 72]
|
|
key: (property_identifier [157, 8] - [157, 13])
|
|
value: (string [157, 15] - [157, 72]
|
|
(string_fragment [157, 16] - [157, 71]))))
|
|
(number [158, 6] - [158, 9]))))))
|
|
(lexical_declaration [162, 2] - [162, 61]
|
|
(variable_declarator [162, 8] - [162, 60]
|
|
name: (identifier [162, 8] - [162, 22])
|
|
value: (call_expression [162, 25] - [162, 60]
|
|
function: (identifier [162, 25] - [162, 40])
|
|
arguments: (arguments [162, 40] - [162, 60]
|
|
(member_expression [162, 41] - [162, 59]
|
|
object: (identifier [162, 41] - [162, 48])
|
|
property: (property_identifier [162, 49] - [162, 59]))))))
|
|
(if_statement [163, 2] - [163, 66]
|
|
condition: (parenthesized_expression [163, 5] - [163, 23]
|
|
(binary_expression [163, 6] - [163, 22]
|
|
left: (unary_expression [163, 6] - [163, 13]
|
|
argument: (identifier [163, 7] - [163, 13]))
|
|
right: (unary_expression [163, 17] - [163, 22]
|
|
argument: (identifier [163, 18] - [163, 22]))))
|
|
consequence: (throw_statement [163, 24] - [163, 66]
|
|
(new_expression [163, 30] - [163, 65]
|
|
constructor: (identifier [163, 34] - [163, 39])
|
|
arguments: (arguments [163, 39] - [163, 65]
|
|
(string [163, 40] - [163, 64]
|
|
(string_fragment [163, 41] - [163, 63]))))))
|
|
(lexical_declaration [165, 2] - [165, 19]
|
|
(variable_declarator [165, 6] - [165, 18]
|
|
name: (identifier [165, 6] - [165, 18])))
|
|
(try_statement [166, 2] - [181, 3]
|
|
body: (statement_block [166, 6] - [179, 3]
|
|
(expression_statement [167, 4] - [178, 7]
|
|
(assignment_expression [167, 4] - [178, 6]
|
|
left: (identifier [167, 4] - [167, 16])
|
|
right: (await_expression [167, 19] - [178, 6]
|
|
(call_expression [167, 25] - [178, 6]
|
|
function: (identifier [167, 25] - [167, 53])
|
|
arguments: (arguments [167, 53] - [178, 6]
|
|
(object [167, 54] - [178, 5]
|
|
(pair [168, 6] - [168, 54]
|
|
key: (property_identifier [168, 6] - [168, 14])
|
|
value: (as_expression [168, 16] - [168, 54]
|
|
(identifier [168, 16] - [168, 24])
|
|
(type_identifier [168, 28] - [168, 54])))
|
|
(shorthand_property_identifier [169, 6] - [169, 23])
|
|
(pair [170, 6] - [170, 28]
|
|
key: (property_identifier [170, 6] - [170, 20])
|
|
value: (identifier [170, 22] - [170, 28]))
|
|
(pair [171, 6] - [171, 24]
|
|
key: (property_identifier [171, 6] - [171, 18])
|
|
value: (identifier [171, 20] - [171, 24]))
|
|
(pair [172, 6] - [172, 36]
|
|
key: (property_identifier [172, 6] - [172, 29])
|
|
value: (false [172, 31] - [172, 36]))
|
|
(pair [173, 6] - [177, 7]
|
|
key: (property_identifier [173, 6] - [173, 16])
|
|
value: (object [173, 18] - [177, 7]
|
|
(pair [174, 8] - [174, 33]
|
|
key: (property_identifier [174, 8] - [174, 10])
|
|
value: (member_expression [174, 12] - [174, 33]
|
|
object: (identifier [174, 12] - [174, 19])
|
|
property: (property_identifier [174, 20] - [174, 33])))
|
|
(pair [175, 8] - [175, 33]
|
|
key: (property_identifier [175, 8] - [175, 17])
|
|
value: (identifier [175, 19] - [175, 33]))
|
|
(pair [176, 8] - [176, 40]
|
|
key: (property_identifier [176, 8] - [176, 15])
|
|
value: (call_expression [176, 17] - [176, 40]
|
|
function: (identifier [176, 17] - [176, 23])
|
|
arguments: (arguments [176, 23] - [176, 40]
|
|
(member_expression [176, 24] - [176, 39]
|
|
object: (identifier [176, 24] - [176, 31])
|
|
property: (property_identifier [176, 32] - [176, 39]))))))))))))))
|
|
handler: (catch_clause [179, 4] - [181, 3]
|
|
parameter: (identifier [179, 11] - [179, 16])
|
|
type: (type_annotation [179, 16] - [179, 21]
|
|
(predefined_type [179, 18] - [179, 21]))
|
|
body: (statement_block [179, 23] - [181, 3]
|
|
(return_statement [180, 4] - [180, 49]
|
|
(call_expression [180, 11] - [180, 48]
|
|
function: (member_expression [180, 11] - [180, 17]
|
|
object: (identifier [180, 11] - [180, 12])
|
|
property: (property_identifier [180, 13] - [180, 17]))
|
|
arguments: (arguments [180, 17] - [180, 48]
|
|
(object [180, 18] - [180, 42]
|
|
(pair [180, 20] - [180, 40]
|
|
key: (property_identifier [180, 20] - [180, 25])
|
|
value: (member_expression [180, 27] - [180, 40]
|
|
object: (identifier [180, 27] - [180, 32])
|
|
property: (property_identifier [180, 33] - [180, 40]))))
|
|
(number [180, 44] - [180, 47])))))))
|
|
(lexical_declaration [183, 2] - [183, 56]
|
|
(variable_declarator [183, 8] - [183, 55]
|
|
name: (object_pattern [183, 8] - [183, 40]
|
|
(shorthand_property_identifier_pattern [183, 10] - [183, 18])
|
|
(shorthand_property_identifier_pattern [183, 20] - [183, 38]))
|
|
value: (identifier [183, 43] - [183, 55])))
|
|
(if_statement [184, 2] - [193, 3]
|
|
condition: (parenthesized_expression [184, 5] - [184, 39]
|
|
(binary_expression [184, 6] - [184, 38]
|
|
left: (unary_expression [184, 6] - [184, 15]
|
|
argument: (identifier [184, 7] - [184, 15]))
|
|
right: (unary_expression [184, 19] - [184, 38]
|
|
argument: (identifier [184, 20] - [184, 38]))))
|
|
consequence: (statement_block [184, 40] - [193, 3]
|
|
(expression_statement [185, 4] - [191, 6]
|
|
(call_expression [185, 4] - [191, 5]
|
|
function: (member_expression [185, 4] - [185, 25]
|
|
object: (identifier [185, 4] - [185, 16])
|
|
property: (property_identifier [185, 17] - [185, 25]))
|
|
arguments: (arguments [185, 25] - [191, 5]
|
|
(identifier [186, 6] - [186, 12])
|
|
(string [187, 6] - [187, 20]
|
|
(string_fragment [187, 7] - [187, 19]))
|
|
(null [188, 6] - [188, 10])
|
|
(object [189, 6] - [189, 39]
|
|
(pair [189, 8] - [189, 37]
|
|
key: (property_identifier [189, 8] - [189, 14])
|
|
value: (string [189, 16] - [189, 37]
|
|
(string_fragment [189, 17] - [189, 36]))))
|
|
(call_expression [190, 6] - [190, 20]
|
|
function: (identifier [190, 6] - [190, 17])
|
|
arguments: (arguments [190, 17] - [190, 20]
|
|
(identifier [190, 18] - [190, 19]))))))
|
|
(return_statement [192, 4] - [192, 57]
|
|
(call_expression [192, 11] - [192, 56]
|
|
function: (member_expression [192, 11] - [192, 17]
|
|
object: (identifier [192, 11] - [192, 12])
|
|
property: (property_identifier [192, 13] - [192, 17]))
|
|
arguments: (arguments [192, 17] - [192, 56]
|
|
(object [192, 18] - [192, 50]
|
|
(pair [192, 20] - [192, 48]
|
|
key: (property_identifier [192, 20] - [192, 25])
|
|
value: (string [192, 27] - [192, 48]
|
|
(string_fragment [192, 28] - [192, 47]))))
|
|
(number [192, 52] - [192, 55]))))))
|
|
(expression_statement [195, 2] - [195, 72]
|
|
(await_expression [195, 2] - [195, 71]
|
|
(call_expression [195, 8] - [195, 71]
|
|
function: (identifier [195, 8] - [195, 28])
|
|
arguments: (arguments [195, 28] - [195, 71]
|
|
(member_expression [195, 29] - [195, 39]
|
|
object: (identifier [195, 29] - [195, 36])
|
|
property: (property_identifier [195, 37] - [195, 39]))
|
|
(member_expression [195, 41] - [195, 70]
|
|
object: (identifier [195, 41] - [195, 59])
|
|
property: (property_identifier [195, 60] - [195, 70]))))))
|
|
(lexical_declaration [197, 2] - [197, 40]
|
|
(variable_declarator [197, 8] - [197, 39]
|
|
name: (identifier [197, 8] - [197, 17])
|
|
value: (call_expression [197, 20] - [197, 39]
|
|
function: (member_expression [197, 20] - [197, 37]
|
|
object: (identifier [197, 20] - [197, 26])
|
|
property: (property_identifier [197, 27] - [197, 37]))
|
|
arguments: (arguments [197, 37] - [197, 39]))))
|
|
(lexical_declaration [198, 2] - [198, 31]
|
|
(variable_declarator [198, 8] - [198, 30]
|
|
name: (identifier [198, 8] - [198, 17])
|
|
value: (new_expression [198, 20] - [198, 30]
|
|
constructor: (identifier [198, 24] - [198, 28])
|
|
arguments: (arguments [198, 28] - [198, 30]))))
|
|
(expression_statement [199, 2] - [199, 45]
|
|
(call_expression [199, 2] - [199, 44]
|
|
function: (member_expression [199, 2] - [199, 19]
|
|
object: (identifier [199, 2] - [199, 11])
|
|
property: (property_identifier [199, 12] - [199, 19]))
|
|
arguments: (arguments [199, 19] - [199, 44]
|
|
(binary_expression [199, 20] - [199, 43]
|
|
left: (call_expression [199, 20] - [199, 39]
|
|
function: (member_expression [199, 20] - [199, 37]
|
|
object: (identifier [199, 20] - [199, 29])
|
|
property: (property_identifier [199, 30] - [199, 37]))
|
|
arguments: (arguments [199, 37] - [199, 39]))
|
|
right: (number [199, 42] - [199, 43])))))
|
|
(expression_statement [201, 2] - [201, 53]
|
|
(await_expression [201, 2] - [201, 52]
|
|
(call_expression [201, 8] - [201, 52]
|
|
function: (identifier [201, 8] - [201, 21])
|
|
arguments: (arguments [201, 21] - [201, 52]
|
|
(identifier [201, 22] - [201, 31])
|
|
(member_expression [201, 33] - [201, 40]
|
|
object: (identifier [201, 33] - [201, 37])
|
|
property: (property_identifier [201, 38] - [201, 40]))
|
|
(identifier [201, 42] - [201, 51])))))
|
|
(lexical_declaration [203, 2] - [203, 75]
|
|
(variable_declarator [203, 8] - [203, 74]
|
|
name: (identifier [203, 8] - [203, 18])
|
|
value: (call_expression [203, 21] - [203, 74]
|
|
function: (member_expression [203, 21] - [203, 31]
|
|
object: (identifier [203, 21] - [203, 25])
|
|
property: (property_identifier [203, 26] - [203, 31]))
|
|
arguments: (arguments [203, 31] - [203, 74]
|
|
(binary_expression [203, 32] - [203, 73]
|
|
left: (parenthesized_expression [203, 32] - [203, 66]
|
|
(binary_expression [203, 33] - [203, 65]
|
|
left: (call_expression [203, 33] - [203, 52]
|
|
function: (member_expression [203, 33] - [203, 50]
|
|
object: (identifier [203, 33] - [203, 42])
|
|
property: (property_identifier [203, 43] - [203, 50]))
|
|
arguments: (arguments [203, 50] - [203, 52]))
|
|
right: (call_expression [203, 55] - [203, 65]
|
|
function: (member_expression [203, 55] - [203, 63]
|
|
object: (identifier [203, 55] - [203, 59])
|
|
property: (property_identifier [203, 60] - [203, 63]))
|
|
arguments: (arguments [203, 63] - [203, 65]))))
|
|
right: (number [203, 69] - [203, 73]))))))
|
|
(try_statement [204, 2] - [219, 3]
|
|
body: (statement_block [204, 6] - [210, 3]
|
|
(lexical_declaration [205, 4] - [208, 7]
|
|
(variable_declarator [205, 10] - [208, 6]
|
|
name: (identifier [205, 10] - [205, 21])
|
|
value: (call_expression [205, 24] - [208, 6]
|
|
function: (member_expression [205, 24] - [205, 38]
|
|
object: (identifier [205, 24] - [205, 28])
|
|
property: (property_identifier [205, 29] - [205, 38]))
|
|
arguments: (arguments [205, 38] - [208, 6]
|
|
(object [205, 39] - [208, 5]
|
|
(pair [206, 6] - [206, 19]
|
|
key: (property_identifier [206, 6] - [206, 10])
|
|
value: (member_expression [206, 12] - [206, 19]
|
|
object: (identifier [206, 12] - [206, 16])
|
|
property: (property_identifier [206, 17] - [206, 19])))
|
|
(pair [207, 6] - [207, 29]
|
|
key: (property_identifier [207, 6] - [207, 14])
|
|
value: (member_expression [207, 16] - [207, 29]
|
|
object: (identifier [207, 16] - [207, 20])
|
|
property: (property_identifier [207, 21] - [207, 29]))))))))
|
|
(expression_statement [209, 4] - [209, 59]
|
|
(await_expression [209, 4] - [209, 58]
|
|
(call_expression [209, 10] - [209, 58]
|
|
function: (member_expression [209, 10] - [209, 22]
|
|
object: (identifier [209, 10] - [209, 16])
|
|
property: (property_identifier [209, 17] - [209, 22]))
|
|
arguments: (arguments [209, 22] - [209, 58]
|
|
(identifier [209, 23] - [209, 32])
|
|
(identifier [209, 34] - [209, 44])
|
|
(identifier [209, 46] - [209, 57]))))))
|
|
handler: (catch_clause [210, 4] - [219, 3]
|
|
parameter: (identifier [210, 11] - [210, 15])
|
|
type: (type_annotation [210, 15] - [210, 24]
|
|
(predefined_type [210, 17] - [210, 24]))
|
|
body: (statement_block [210, 26] - [219, 3]
|
|
(expression_statement [211, 4] - [217, 6]
|
|
(call_expression [211, 4] - [217, 5]
|
|
function: (member_expression [211, 4] - [211, 25]
|
|
object: (identifier [211, 4] - [211, 16])
|
|
property: (property_identifier [211, 17] - [211, 25]))
|
|
arguments: (arguments [211, 25] - [217, 5]
|
|
(member_expression [212, 6] - [212, 13]
|
|
object: (identifier [212, 6] - [212, 10])
|
|
property: (property_identifier [212, 11] - [212, 13]))
|
|
(string [213, 6] - [213, 20]
|
|
(string_fragment [213, 7] - [213, 19]))
|
|
(null [214, 6] - [214, 10])
|
|
(object [215, 6] - [215, 39]
|
|
(pair [215, 8] - [215, 37]
|
|
key: (property_identifier [215, 8] - [215, 14])
|
|
value: (string [215, 16] - [215, 37]
|
|
(string_fragment [215, 17] - [215, 36]))))
|
|
(call_expression [216, 6] - [216, 20]
|
|
function: (identifier [216, 6] - [216, 17])
|
|
arguments: (arguments [216, 17] - [216, 20]
|
|
(identifier [216, 18] - [216, 19]))))))
|
|
(return_statement [218, 4] - [218, 59]
|
|
(call_expression [218, 11] - [218, 58]
|
|
function: (member_expression [218, 11] - [218, 17]
|
|
object: (identifier [218, 11] - [218, 12])
|
|
property: (property_identifier [218, 13] - [218, 17]))
|
|
arguments: (arguments [218, 17] - [218, 58]
|
|
(object [218, 18] - [218, 52]
|
|
(pair [218, 20] - [218, 50]
|
|
key: (property_identifier [218, 20] - [218, 25])
|
|
value: (string [218, 27] - [218, 50]
|
|
(string_fragment [218, 28] - [218, 49]))))
|
|
(number [218, 54] - [218, 57])))))))
|
|
(lexical_declaration [221, 2] - [221, 48]
|
|
(variable_declarator [221, 8] - [221, 47]
|
|
name: (identifier [221, 8] - [221, 21])
|
|
value: (call_expression [221, 24] - [221, 47]
|
|
function: (identifier [221, 24] - [221, 44])
|
|
arguments: (arguments [221, 44] - [221, 47]
|
|
(identifier [221, 45] - [221, 46])))))
|
|
(if_statement [222, 2] - [229, 3]
|
|
condition: (parenthesized_expression [222, 5] - [222, 31]
|
|
(binary_expression [222, 6] - [222, 30]
|
|
left: (member_expression [222, 6] - [222, 26]
|
|
object: (identifier [222, 6] - [222, 19])
|
|
property: (property_identifier [222, 20] - [222, 26]))
|
|
right: (number [222, 29] - [222, 30])))
|
|
consequence: (statement_block [222, 32] - [229, 3]
|
|
(for_in_statement [223, 4] - [228, 5]
|
|
left: (identifier [223, 15] - [223, 18])
|
|
right: (identifier [223, 22] - [223, 35])
|
|
body: (statement_block [223, 37] - [228, 5]
|
|
(try_statement [224, 6] - [227, 21]
|
|
body: (statement_block [224, 10] - [227, 7]
|
|
(expression_statement [225, 8] - [225, 30]
|
|
(await_expression [225, 8] - [225, 29]
|
|
(call_expression [225, 14] - [225, 29]
|
|
function: (member_expression [225, 14] - [225, 24]
|
|
object: (identifier [225, 14] - [225, 20])
|
|
property: (property_identifier [225, 21] - [225, 24]))
|
|
arguments: (arguments [225, 24] - [225, 29]
|
|
(identifier [225, 25] - [225, 28])))))
|
|
(expression_statement [226, 8] - [226, 33]
|
|
(await_expression [226, 8] - [226, 32]
|
|
(call_expression [226, 14] - [226, 32]
|
|
function: (identifier [226, 14] - [226, 27])
|
|
arguments: (arguments [226, 27] - [226, 32]
|
|
(identifier [226, 28] - [226, 31]))))))
|
|
handler: (catch_clause [227, 8] - [227, 21]
|
|
parameter: (identifier [227, 15] - [227, 17])
|
|
body: (statement_block [227, 19] - [227, 21])))))))
|
|
(lexical_declaration [231, 2] - [231, 45]
|
|
(variable_declarator [231, 8] - [231, 44]
|
|
name: (identifier [231, 8] - [231, 20])
|
|
value: (call_expression [231, 23] - [231, 44]
|
|
function: (identifier [231, 23] - [231, 38])
|
|
arguments: (arguments [231, 38] - [231, 44]
|
|
(identifier [231, 39] - [231, 43])))))
|
|
(expression_statement [232, 2] - [239, 5]
|
|
(call_expression [232, 2] - [239, 4]
|
|
function: (identifier [232, 2] - [232, 11])
|
|
arguments: (arguments [232, 11] - [239, 4]
|
|
(identifier [232, 12] - [232, 13])
|
|
(string [232, 15] - [232, 27]
|
|
(string_fragment [232, 16] - [232, 26]))
|
|
(identifier [232, 29] - [232, 38])
|
|
(object [232, 40] - [239, 3]
|
|
(pair [233, 4] - [233, 24]
|
|
key: (property_identifier [233, 4] - [233, 10])
|
|
value: (identifier [233, 12] - [233, 24]))
|
|
(pair [234, 4] - [234, 13]
|
|
key: (property_identifier [234, 4] - [234, 8])
|
|
value: (string [234, 10] - [234, 13]
|
|
(string_fragment [234, 11] - [234, 12])))
|
|
(pair [235, 4] - [235, 18]
|
|
key: (property_identifier [235, 4] - [235, 12])
|
|
value: (true [235, 14] - [235, 18]))
|
|
(pair [236, 4] - [236, 16]
|
|
key: (property_identifier [236, 4] - [236, 10])
|
|
value: (true [236, 12] - [236, 16]))
|
|
(pair [237, 4] - [237, 19]
|
|
key: (property_identifier [237, 4] - [237, 12])
|
|
value: (string [237, 14] - [237, 19]
|
|
(string_fragment [237, 15] - [237, 18])))
|
|
(pair [238, 4] - [238, 22]
|
|
key: (property_identifier [238, 4] - [238, 11])
|
|
value: (identifier [238, 13] - [238, 22]))))))
|
|
(expression_statement [241, 2] - [246, 5]
|
|
(call_expression [241, 2] - [246, 4]
|
|
function: (identifier [241, 2] - [241, 11])
|
|
arguments: (arguments [241, 11] - [246, 4]
|
|
(identifier [241, 12] - [241, 13])
|
|
(string [241, 15] - [241, 50]
|
|
(string_fragment [241, 16] - [241, 49]))
|
|
(string [241, 52] - [241, 54])
|
|
(object [241, 56] - [246, 3]
|
|
(pair [242, 4] - [242, 18]
|
|
key: (property_identifier [242, 4] - [242, 12])
|
|
value: (true [242, 14] - [242, 18]))
|
|
(pair [243, 4] - [243, 16]
|
|
key: (property_identifier [243, 4] - [243, 10])
|
|
value: (true [243, 12] - [243, 16]))
|
|
(pair [244, 4] - [244, 19]
|
|
key: (property_identifier [244, 4] - [244, 12])
|
|
value: (string [244, 14] - [244, 19]
|
|
(string_fragment [244, 15] - [244, 18])))
|
|
(pair [245, 4] - [245, 13]
|
|
key: (property_identifier [245, 4] - [245, 10])
|
|
value: (number [245, 12] - [245, 13]))))))
|
|
(expression_statement [248, 2] - [248, 77]
|
|
(call_expression [248, 2] - [248, 76]
|
|
function: (member_expression [248, 2] - [248, 23]
|
|
object: (identifier [248, 2] - [248, 14])
|
|
property: (property_identifier [248, 15] - [248, 23]))
|
|
arguments: (arguments [248, 23] - [248, 76]
|
|
(identifier [248, 24] - [248, 30])
|
|
(string [248, 32] - [248, 47]
|
|
(string_fragment [248, 33] - [248, 46]))
|
|
(null [248, 49] - [248, 53])
|
|
(null [248, 55] - [248, 59])
|
|
(call_expression [248, 61] - [248, 75]
|
|
function: (identifier [248, 61] - [248, 72])
|
|
arguments: (arguments [248, 72] - [248, 75]
|
|
(identifier [248, 73] - [248, 74]))))))
|
|
(return_statement [250, 2] - [250, 35]
|
|
(call_expression [250, 9] - [250, 34]
|
|
function: (member_expression [250, 9] - [250, 15]
|
|
object: (identifier [250, 9] - [250, 10])
|
|
property: (property_identifier [250, 11] - [250, 15]))
|
|
arguments: (arguments [250, 15] - [250, 34]
|
|
(object [250, 16] - [250, 33]
|
|
(pair [250, 18] - [250, 31]
|
|
key: (property_identifier [250, 18] - [250, 25])
|
|
value: (true [250, 27] - [250, 31]))))))))))))
|