618 lines
39 KiB
Plaintext
618 lines
39 KiB
Plaintext
(program [0, 0] - [129, 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, 66]
|
|
(import_clause [1, 7] - [1, 34]
|
|
(named_imports [1, 7] - [1, 34]
|
|
(import_specifier [1, 9] - [1, 21]
|
|
name: (identifier [1, 9] - [1, 21]))
|
|
(import_specifier [1, 23] - [1, 32]
|
|
name: (identifier [1, 23] - [1, 32]))))
|
|
source: (string [1, 40] - [1, 65]
|
|
(string_fragment [1, 41] - [1, 64])))
|
|
(import_statement [2, 0] - [2, 46]
|
|
(import_clause [2, 7] - [2, 17]
|
|
(named_imports [2, 7] - [2, 17]
|
|
(import_specifier [2, 9] - [2, 15]
|
|
name: (identifier [2, 9] - [2, 15]))))
|
|
source: (string [2, 23] - [2, 45]
|
|
(string_fragment [2, 24] - [2, 44])))
|
|
(import_statement [3, 0] - [3, 46]
|
|
(import_clause [3, 7] - [3, 21]
|
|
(named_imports [3, 7] - [3, 21]
|
|
(import_specifier [3, 9] - [3, 19]
|
|
name: (identifier [3, 9] - [3, 19]))))
|
|
source: (string [3, 27] - [3, 45]
|
|
(string_fragment [3, 28] - [3, 44])))
|
|
(import_statement [4, 0] - [4, 56]
|
|
(import_clause [4, 7] - [4, 26]
|
|
(named_imports [4, 7] - [4, 26]
|
|
(import_specifier [4, 9] - [4, 24]
|
|
name: (identifier [4, 9] - [4, 24]))))
|
|
source: (string [4, 32] - [4, 55]
|
|
(string_fragment [4, 33] - [4, 54])))
|
|
(export_statement [6, 0] - [6, 37]
|
|
declaration: (lexical_declaration [6, 7] - [6, 37]
|
|
(variable_declarator [6, 13] - [6, 36]
|
|
name: (identifier [6, 13] - [6, 23])
|
|
value: (new_expression [6, 26] - [6, 36]
|
|
constructor: (identifier [6, 30] - [6, 34])
|
|
arguments: (arguments [6, 34] - [6, 36])))))
|
|
(comment [8, 0] - [8, 60])
|
|
(comment [9, 0] - [9, 50])
|
|
(comment [10, 0] - [10, 60])
|
|
(expression_statement [12, 0] - [128, 3]
|
|
(call_expression [12, 0] - [128, 2]
|
|
function: (member_expression [12, 0] - [12, 14]
|
|
object: (identifier [12, 0] - [12, 10])
|
|
property: (property_identifier [12, 11] - [12, 14]))
|
|
arguments: (arguments [12, 14] - [128, 2]
|
|
(string [12, 15] - [12, 18]
|
|
(string_fragment [12, 16] - [12, 17]))
|
|
(arrow_function [12, 20] - [128, 1]
|
|
parameters: (formal_parameters [12, 26] - [12, 29]
|
|
(required_parameter [12, 27] - [12, 28]
|
|
pattern: (identifier [12, 27] - [12, 28])))
|
|
body: (statement_block [12, 33] - [128, 1]
|
|
(lexical_declaration [13, 2] - [13, 37]
|
|
(variable_declarator [13, 8] - [13, 36]
|
|
name: (identifier [13, 8] - [13, 13])
|
|
value: (call_expression [13, 16] - [13, 36]
|
|
function: (member_expression [13, 16] - [13, 27]
|
|
object: (member_expression [13, 16] - [13, 21]
|
|
object: (identifier [13, 16] - [13, 17])
|
|
property: (property_identifier [13, 18] - [13, 21]))
|
|
property: (property_identifier [13, 22] - [13, 27]))
|
|
arguments: (arguments [13, 27] - [13, 36]
|
|
(string [13, 28] - [13, 35]
|
|
(string_fragment [13, 29] - [13, 34]))))))
|
|
(if_statement [14, 2] - [16, 3]
|
|
condition: (parenthesized_expression [14, 5] - [14, 13]
|
|
(unary_expression [14, 6] - [14, 12]
|
|
argument: (identifier [14, 7] - [14, 12])))
|
|
consequence: (statement_block [14, 14] - [16, 3]
|
|
(return_statement [15, 4] - [15, 67]
|
|
(call_expression [15, 11] - [15, 66]
|
|
function: (member_expression [15, 11] - [15, 21]
|
|
object: (identifier [15, 11] - [15, 12])
|
|
property: (property_identifier [15, 13] - [15, 21]))
|
|
arguments: (arguments [15, 21] - [15, 66]
|
|
(string [15, 22] - [15, 60]
|
|
(string_fragment [15, 23] - [15, 59]))
|
|
(number [15, 62] - [15, 65]))))))
|
|
(comment [18, 2] - [18, 55])
|
|
(lexical_declaration [19, 2] - [19, 28]
|
|
(variable_declarator [19, 6] - [19, 27]
|
|
name: (identifier [19, 6] - [19, 20])
|
|
value: (null [19, 23] - [19, 27])))
|
|
(try_statement [20, 2] - [22, 19]
|
|
body: (statement_block [20, 6] - [22, 3]
|
|
(expression_statement [21, 4] - [21, 45]
|
|
(assignment_expression [21, 4] - [21, 44]
|
|
left: (identifier [21, 4] - [21, 18])
|
|
right: (await_expression [21, 21] - [21, 44]
|
|
(call_expression [21, 27] - [21, 44]
|
|
function: (member_expression [21, 27] - [21, 37]
|
|
object: (identifier [21, 27] - [21, 33])
|
|
property: (property_identifier [21, 34] - [21, 37]))
|
|
arguments: (arguments [21, 37] - [21, 44]
|
|
(identifier [21, 38] - [21, 43])))))))
|
|
handler: (catch_clause [22, 4] - [22, 19]
|
|
parameter: (identifier [22, 11] - [22, 15])
|
|
body: (statement_block [22, 17] - [22, 19])))
|
|
(lexical_declaration [24, 2] - [24, 30]
|
|
(variable_declarator [24, 6] - [24, 29]
|
|
name: (identifier [24, 6] - [24, 17])
|
|
type: (type_annotation [24, 17] - [24, 22]
|
|
(predefined_type [24, 19] - [24, 22]))
|
|
value: (null [24, 25] - [24, 29])))
|
|
(if_statement [25, 2] - [29, 3]
|
|
condition: (parenthesized_expression [25, 5] - [25, 21]
|
|
(identifier [25, 6] - [25, 20]))
|
|
consequence: (statement_block [25, 22] - [29, 3]
|
|
(try_statement [26, 4] - [28, 21]
|
|
body: (statement_block [26, 8] - [28, 5]
|
|
(expression_statement [27, 6] - [27, 47]
|
|
(assignment_expression [27, 6] - [27, 46]
|
|
left: (identifier [27, 6] - [27, 17])
|
|
right: (call_expression [27, 20] - [27, 46]
|
|
function: (member_expression [27, 20] - [27, 30]
|
|
object: (identifier [27, 20] - [27, 24])
|
|
property: (property_identifier [27, 25] - [27, 30]))
|
|
arguments: (arguments [27, 30] - [27, 46]
|
|
(identifier [27, 31] - [27, 45]))))))
|
|
handler: (catch_clause [28, 6] - [28, 21]
|
|
parameter: (identifier [28, 13] - [28, 17])
|
|
body: (statement_block [28, 19] - [28, 21])))))
|
|
(lexical_declaration [31, 2] - [31, 40]
|
|
(variable_declarator [31, 6] - [31, 39]
|
|
name: (identifier [31, 6] - [31, 19])
|
|
type: (type_annotation [31, 19] - [31, 32]
|
|
(union_type [31, 21] - [31, 32]
|
|
(type_identifier [31, 21] - [31, 25])
|
|
(literal_type [31, 28] - [31, 32]
|
|
(null [31, 28] - [31, 32]))))
|
|
value: (null [31, 35] - [31, 39])))
|
|
(lexical_declaration [32, 2] - [32, 34]
|
|
(variable_declarator [32, 6] - [32, 33]
|
|
name: (identifier [32, 6] - [32, 18])
|
|
type: (type_annotation [32, 18] - [32, 28]
|
|
(array_type [32, 20] - [32, 28]
|
|
(predefined_type [32, 20] - [32, 26])))
|
|
value: (array [32, 31] - [32, 33])))
|
|
(if_statement [34, 2] - [80, 3]
|
|
condition: (parenthesized_expression [34, 5] - [34, 40]
|
|
(binary_expression [34, 6] - [34, 39]
|
|
left: (unary_expression [34, 6] - [34, 18]
|
|
argument: (identifier [34, 7] - [34, 18]))
|
|
right: (unary_expression [34, 22] - [34, 39]
|
|
argument: (member_expression [34, 23] - [34, 39]
|
|
object: (identifier [34, 23] - [34, 34])
|
|
property: (property_identifier [34, 35] - [34, 39])))))
|
|
consequence: (statement_block [34, 41] - [68, 3]
|
|
(try_statement [35, 4] - [67, 5]
|
|
body: (statement_block [35, 8] - [65, 5]
|
|
(lexical_declaration [36, 6] - [36, 46]
|
|
(variable_declarator [36, 12] - [36, 45]
|
|
name: (identifier [36, 12] - [36, 18])
|
|
value: (call_expression [36, 21] - [36, 45]
|
|
function: (member_expression [36, 21] - [36, 43]
|
|
object: (new_expression [36, 21] - [36, 31]
|
|
constructor: (identifier [36, 25] - [36, 29])
|
|
arguments: (arguments [36, 29] - [36, 31]))
|
|
property: (property_identifier [36, 32] - [36, 43]))
|
|
arguments: (arguments [36, 43] - [36, 45]))))
|
|
(lexical_declaration [37, 6] - [42, 35]
|
|
(variable_declarator [37, 12] - [42, 34]
|
|
name: (identifier [37, 12] - [37, 19])
|
|
value: (await_expression [37, 22] - [42, 34]
|
|
(call_expression [37, 28] - [42, 34]
|
|
function: (member_expression [37, 28] - [42, 12]
|
|
object: (call_expression [37, 28] - [42, 7]
|
|
function: (member_expression [37, 28] - [37, 42]
|
|
object: (identifier [37, 28] - [37, 38])
|
|
property: (property_identifier [37, 39] - [37, 42]))
|
|
arguments: (template_string [37, 42] - [42, 7]
|
|
(string_fragment [37, 43] - [41, 21])
|
|
(template_substitution [41, 21] - [41, 29]
|
|
(identifier [41, 23] - [41, 28]))
|
|
(string_fragment [41, 29] - [41, 49])
|
|
(template_substitution [41, 49] - [41, 58]
|
|
(identifier [41, 51] - [41, 57]))
|
|
(string_fragment [41, 58] - [42, 6])))
|
|
property: (property_identifier [42, 8] - [42, 12]))
|
|
arguments: (arguments [42, 12] - [42, 34]
|
|
(arrow_function [42, 13] - [42, 33]
|
|
parameters: (formal_parameters [42, 13] - [42, 23]
|
|
(required_parameter [42, 14] - [42, 22]
|
|
pattern: (identifier [42, 14] - [42, 17])
|
|
type: (type_annotation [42, 17] - [42, 22]
|
|
(predefined_type [42, 19] - [42, 22]))))
|
|
body: (subscript_expression [42, 27] - [42, 33]
|
|
object: (identifier [42, 27] - [42, 30])
|
|
index: (number [42, 31] - [42, 32]))))))))
|
|
(if_statement [44, 6] - [46, 7]
|
|
condition: (parenthesized_expression [44, 9] - [44, 19]
|
|
(unary_expression [44, 10] - [44, 18]
|
|
argument: (identifier [44, 11] - [44, 18])))
|
|
consequence: (statement_block [44, 20] - [46, 7]
|
|
(return_statement [45, 8] - [45, 71]
|
|
(call_expression [45, 15] - [45, 70]
|
|
function: (member_expression [45, 15] - [45, 25]
|
|
object: (identifier [45, 15] - [45, 16])
|
|
property: (property_identifier [45, 17] - [45, 25]))
|
|
arguments: (arguments [45, 25] - [45, 70]
|
|
(string [45, 26] - [45, 64]
|
|
(string_fragment [45, 27] - [45, 63]))
|
|
(number [45, 66] - [45, 69]))))))
|
|
(expression_statement [48, 6] - [54, 8]
|
|
(assignment_expression [48, 6] - [54, 7]
|
|
left: (identifier [48, 6] - [48, 17])
|
|
right: (object [48, 20] - [54, 7]
|
|
(pair [49, 8] - [49, 29]
|
|
key: (property_identifier [49, 8] - [49, 12])
|
|
value: (member_expression [49, 14] - [49, 29]
|
|
object: (identifier [49, 14] - [49, 21])
|
|
property: (property_identifier [49, 22] - [49, 29])))
|
|
(pair [50, 8] - [50, 34]
|
|
key: (property_identifier [50, 8] - [50, 16])
|
|
value: (member_expression [50, 18] - [50, 34]
|
|
object: (identifier [50, 18] - [50, 25])
|
|
property: (property_identifier [50, 26] - [50, 34])))
|
|
(pair [51, 8] - [51, 28]
|
|
key: (property_identifier [51, 8] - [51, 13])
|
|
value: (member_expression [51, 15] - [51, 28]
|
|
object: (identifier [51, 15] - [51, 22])
|
|
property: (property_identifier [51, 23] - [51, 28])))
|
|
(pair [52, 8] - [52, 33]
|
|
key: (property_identifier [52, 8] - [52, 15])
|
|
value: (member_expression [52, 17] - [52, 33]
|
|
object: (identifier [52, 17] - [52, 24])
|
|
property: (property_identifier [52, 25] - [52, 33])))
|
|
(pair [53, 8] - [53, 43]
|
|
key: (property_identifier [53, 8] - [53, 20])
|
|
value: (member_expression [53, 22] - [53, 43]
|
|
object: (identifier [53, 22] - [53, 29])
|
|
property: (property_identifier [53, 30] - [53, 43]))))))
|
|
(expression_statement [55, 6] - [55, 51]
|
|
(assignment_expression [55, 6] - [55, 50]
|
|
left: (identifier [55, 6] - [55, 19])
|
|
right: (new_expression [55, 22] - [55, 50]
|
|
constructor: (identifier [55, 26] - [55, 30])
|
|
arguments: (arguments [55, 30] - [55, 50]
|
|
(member_expression [55, 31] - [55, 49]
|
|
object: (identifier [55, 31] - [55, 38])
|
|
property: (property_identifier [55, 39] - [55, 49]))))))
|
|
(expression_statement [56, 6] - [56, 49]
|
|
(assignment_expression [56, 6] - [56, 48]
|
|
left: (identifier [56, 6] - [56, 18])
|
|
right: (binary_expression [56, 21] - [56, 48]
|
|
left: (member_expression [56, 21] - [56, 42]
|
|
object: (identifier [56, 21] - [56, 28])
|
|
property: (property_identifier [56, 29] - [56, 42]))
|
|
right: (array [56, 46] - [56, 48]))))
|
|
(try_statement [58, 6] - [64, 21]
|
|
body: (statement_block [58, 10] - [64, 7]
|
|
(lexical_declaration [59, 8] - [62, 10]
|
|
(variable_declarator [59, 14] - [62, 9]
|
|
name: (identifier [59, 14] - [59, 24])
|
|
value: (call_expression [59, 27] - [62, 9]
|
|
function: (member_expression [59, 27] - [59, 35]
|
|
object: (identifier [59, 27] - [59, 31])
|
|
property: (property_identifier [59, 32] - [59, 35]))
|
|
arguments: (arguments [59, 35] - [62, 9]
|
|
(number [60, 10] - [60, 11])
|
|
(call_expression [61, 10] - [61, 67]
|
|
function: (member_expression [61, 10] - [61, 20]
|
|
object: (identifier [61, 10] - [61, 14])
|
|
property: (property_identifier [61, 15] - [61, 20]))
|
|
arguments: (arguments [61, 20] - [61, 67]
|
|
(binary_expression [61, 21] - [61, 66]
|
|
left: (parenthesized_expression [61, 21] - [61, 59]
|
|
(binary_expression [61, 22] - [61, 58]
|
|
left: (call_expression [61, 22] - [61, 45]
|
|
function: (member_expression [61, 22] - [61, 43]
|
|
object: (identifier [61, 22] - [61, 35])
|
|
property: (property_identifier [61, 36] - [61, 43]))
|
|
arguments: (arguments [61, 43] - [61, 45]))
|
|
right: (call_expression [61, 48] - [61, 58]
|
|
function: (member_expression [61, 48] - [61, 56]
|
|
object: (identifier [61, 48] - [61, 52])
|
|
property: (property_identifier [61, 53] - [61, 56]))
|
|
arguments: (arguments [61, 56] - [61, 58]))))
|
|
right: (number [61, 62] - [61, 66]))))))))
|
|
(expression_statement [63, 8] - [63, 75]
|
|
(await_expression [63, 8] - [63, 74]
|
|
(call_expression [63, 14] - [63, 74]
|
|
function: (member_expression [63, 14] - [63, 26]
|
|
object: (identifier [63, 14] - [63, 20])
|
|
property: (property_identifier [63, 21] - [63, 26]))
|
|
arguments: (arguments [63, 26] - [63, 74]
|
|
(identifier [63, 27] - [63, 32])
|
|
(identifier [63, 34] - [63, 44])
|
|
(call_expression [63, 46] - [63, 73]
|
|
function: (member_expression [63, 46] - [63, 60]
|
|
object: (identifier [63, 46] - [63, 50])
|
|
property: (property_identifier [63, 51] - [63, 60]))
|
|
arguments: (arguments [63, 60] - [63, 73]
|
|
(identifier [63, 61] - [63, 72]))))))))
|
|
handler: (catch_clause [64, 8] - [64, 21]
|
|
parameter: (identifier [64, 15] - [64, 17])
|
|
body: (statement_block [64, 19] - [64, 21]))))
|
|
handler: (catch_clause [65, 6] - [67, 5]
|
|
parameter: (identifier [65, 13] - [65, 17])
|
|
body: (statement_block [65, 19] - [67, 5]
|
|
(return_statement [66, 6] - [66, 69]
|
|
(call_expression [66, 13] - [66, 68]
|
|
function: (member_expression [66, 13] - [66, 23]
|
|
object: (identifier [66, 13] - [66, 14])
|
|
property: (property_identifier [66, 15] - [66, 23]))
|
|
arguments: (arguments [66, 23] - [66, 68]
|
|
(string [66, 24] - [66, 62]
|
|
(string_fragment [66, 25] - [66, 61]))
|
|
(number [66, 64] - [66, 67]))))))))
|
|
alternative: (else_clause [68, 4] - [80, 3]
|
|
(statement_block [68, 9] - [80, 3]
|
|
(try_statement [69, 4] - [79, 5]
|
|
body: (statement_block [69, 8] - [77, 5]
|
|
(lexical_declaration [70, 6] - [70, 42]
|
|
(variable_declarator [70, 12] - [70, 41]
|
|
name: (identifier [70, 12] - [70, 15])
|
|
value: (await_expression [70, 18] - [70, 41]
|
|
(call_expression [70, 24] - [70, 41]
|
|
function: (member_expression [70, 24] - [70, 34]
|
|
object: (identifier [70, 24] - [70, 30])
|
|
property: (property_identifier [70, 31] - [70, 34]))
|
|
arguments: (arguments [70, 34] - [70, 41]
|
|
(identifier [70, 35] - [70, 40]))))))
|
|
(if_statement [71, 6] - [73, 7]
|
|
condition: (parenthesized_expression [71, 9] - [71, 19]
|
|
(binary_expression [71, 10] - [71, 18]
|
|
left: (identifier [71, 10] - [71, 13])
|
|
right: (number [71, 17] - [71, 18])))
|
|
consequence: (statement_block [71, 20] - [73, 7]
|
|
(return_statement [72, 8] - [72, 71]
|
|
(call_expression [72, 15] - [72, 70]
|
|
function: (member_expression [72, 15] - [72, 25]
|
|
object: (identifier [72, 15] - [72, 16])
|
|
property: (property_identifier [72, 17] - [72, 25]))
|
|
arguments: (arguments [72, 25] - [72, 70]
|
|
(string [72, 26] - [72, 64]
|
|
(string_fragment [72, 27] - [72, 63]))
|
|
(number [72, 66] - [72, 69]))))))
|
|
(expression_statement [74, 6] - [74, 56]
|
|
(assignment_expression [74, 6] - [74, 55]
|
|
left: (identifier [74, 6] - [74, 19])
|
|
right: (new_expression [74, 22] - [74, 55]
|
|
constructor: (identifier [74, 26] - [74, 30])
|
|
arguments: (arguments [74, 30] - [74, 55]
|
|
(binary_expression [74, 31] - [74, 54]
|
|
left: (call_expression [74, 31] - [74, 41]
|
|
function: (member_expression [74, 31] - [74, 39]
|
|
object: (identifier [74, 31] - [74, 35])
|
|
property: (property_identifier [74, 36] - [74, 39]))
|
|
arguments: (arguments [74, 39] - [74, 41]))
|
|
right: (binary_expression [74, 44] - [74, 54]
|
|
left: (identifier [74, 44] - [74, 47])
|
|
right: (number [74, 50] - [74, 54])))))))
|
|
(expression_statement [75, 6] - [76, 11]
|
|
(assignment_expression [75, 6] - [76, 10]
|
|
left: (identifier [75, 6] - [75, 18])
|
|
right: (binary_expression [75, 21] - [76, 10]
|
|
left: (binary_expression [75, 21] - [75, 74]
|
|
left: (member_expression [75, 21] - [75, 45]
|
|
object: (identifier [75, 21] - [75, 32])
|
|
property: (property_identifier [75, 33] - [75, 45]))
|
|
right: (member_expression [75, 49] - [75, 74]
|
|
object: (identifier [75, 49] - [75, 60])
|
|
property: (property_identifier [75, 61] - [75, 74])))
|
|
right: (array [76, 8] - [76, 10])))))
|
|
handler: (catch_clause [77, 6] - [79, 5]
|
|
parameter: (identifier [77, 13] - [77, 17])
|
|
body: (statement_block [77, 19] - [79, 5]
|
|
(return_statement [78, 6] - [78, 69]
|
|
(call_expression [78, 13] - [78, 68]
|
|
function: (member_expression [78, 13] - [78, 23]
|
|
object: (identifier [78, 13] - [78, 14])
|
|
property: (property_identifier [78, 15] - [78, 23]))
|
|
arguments: (arguments [78, 23] - [78, 68]
|
|
(string [78, 24] - [78, 62]
|
|
(string_fragment [78, 25] - [78, 61]))
|
|
(number [78, 64] - [78, 67]))))))))))
|
|
(if_statement [82, 2] - [84, 3]
|
|
condition: (parenthesized_expression [82, 5] - [82, 37]
|
|
(binary_expression [82, 6] - [82, 36]
|
|
left: (unary_expression [82, 6] - [82, 18]
|
|
argument: (identifier [82, 7] - [82, 18]))
|
|
right: (unary_expression [82, 22] - [82, 36]
|
|
argument: (identifier [82, 23] - [82, 36]))))
|
|
consequence: (statement_block [82, 38] - [84, 3]
|
|
(return_statement [83, 4] - [83, 67]
|
|
(call_expression [83, 11] - [83, 66]
|
|
function: (member_expression [83, 11] - [83, 21]
|
|
object: (identifier [83, 11] - [83, 12])
|
|
property: (property_identifier [83, 13] - [83, 21]))
|
|
arguments: (arguments [83, 21] - [83, 66]
|
|
(string [83, 22] - [83, 60]
|
|
(string_fragment [83, 23] - [83, 59]))
|
|
(number [83, 62] - [83, 65]))))))
|
|
(comment [86, 2] - [86, 22])
|
|
(expression_statement [87, 2] - [87, 47]
|
|
(call_expression [87, 2] - [87, 46]
|
|
function: (identifier [87, 2] - [87, 14])
|
|
arguments: (arguments [87, 14] - [87, 46]
|
|
(identifier [87, 15] - [87, 16])
|
|
(string [87, 18] - [87, 30]
|
|
(string_fragment [87, 19] - [87, 29]))
|
|
(object [87, 32] - [87, 45]
|
|
(pair [87, 34] - [87, 43]
|
|
key: (property_identifier [87, 34] - [87, 38])
|
|
value: (string [87, 40] - [87, 43]
|
|
(string_fragment [87, 41] - [87, 42])))))))
|
|
(lexical_declaration [89, 2] - [89, 37]
|
|
(variable_declarator [89, 8] - [89, 36]
|
|
name: (identifier [89, 8] - [89, 12])
|
|
value: (call_expression [89, 15] - [89, 36]
|
|
function: (member_expression [89, 15] - [89, 27]
|
|
object: (member_expression [89, 15] - [89, 23]
|
|
object: (identifier [89, 15] - [89, 19])
|
|
property: (property_identifier [89, 20] - [89, 23]))
|
|
property: (property_identifier [89, 24] - [89, 27]))
|
|
arguments: (arguments [89, 27] - [89, 36]
|
|
(string [89, 28] - [89, 35]
|
|
(string_fragment [89, 29] - [89, 34]))))))
|
|
(lexical_declaration [90, 2] - [90, 45]
|
|
(variable_declarator [90, 8] - [90, 44]
|
|
name: (identifier [90, 8] - [90, 20])
|
|
value: (call_expression [90, 23] - [90, 44]
|
|
function: (identifier [90, 23] - [90, 38])
|
|
arguments: (arguments [90, 38] - [90, 44]
|
|
(identifier [90, 39] - [90, 43])))))
|
|
(lexical_declaration [91, 2] - [94, 4]
|
|
(variable_declarator [91, 8] - [94, 3]
|
|
name: (identifier [91, 8] - [91, 18])
|
|
value: (call_expression [91, 21] - [94, 3]
|
|
function: (member_expression [91, 21] - [91, 29]
|
|
object: (identifier [91, 21] - [91, 25])
|
|
property: (property_identifier [91, 26] - [91, 29]))
|
|
arguments: (arguments [91, 29] - [94, 3]
|
|
(number [92, 4] - [92, 5])
|
|
(call_expression [93, 4] - [93, 61]
|
|
function: (member_expression [93, 4] - [93, 14]
|
|
object: (identifier [93, 4] - [93, 8])
|
|
property: (property_identifier [93, 9] - [93, 14]))
|
|
arguments: (arguments [93, 14] - [93, 61]
|
|
(binary_expression [93, 15] - [93, 60]
|
|
left: (parenthesized_expression [93, 15] - [93, 53]
|
|
(binary_expression [93, 16] - [93, 52]
|
|
left: (call_expression [93, 16] - [93, 39]
|
|
function: (member_expression [93, 16] - [93, 37]
|
|
object: (identifier [93, 16] - [93, 29])
|
|
property: (property_identifier [93, 30] - [93, 37]))
|
|
arguments: (arguments [93, 37] - [93, 39]))
|
|
right: (call_expression [93, 42] - [93, 52]
|
|
function: (member_expression [93, 42] - [93, 50]
|
|
object: (identifier [93, 42] - [93, 46])
|
|
property: (property_identifier [93, 47] - [93, 50]))
|
|
arguments: (arguments [93, 50] - [93, 52]))))
|
|
right: (number [93, 56] - [93, 60]))))))))
|
|
(expression_statement [95, 2] - [102, 5]
|
|
(call_expression [95, 2] - [102, 4]
|
|
function: (identifier [95, 2] - [95, 11])
|
|
arguments: (arguments [95, 11] - [102, 4]
|
|
(identifier [95, 12] - [95, 13])
|
|
(string [95, 15] - [95, 27]
|
|
(string_fragment [95, 16] - [95, 26]))
|
|
(identifier [95, 29] - [95, 34])
|
|
(object [95, 36] - [102, 3]
|
|
(pair [96, 4] - [96, 13]
|
|
key: (property_identifier [96, 4] - [96, 8])
|
|
value: (string [96, 10] - [96, 13]
|
|
(string_fragment [96, 11] - [96, 12])))
|
|
(pair [97, 4] - [97, 24]
|
|
key: (property_identifier [97, 4] - [97, 10])
|
|
value: (identifier [97, 12] - [97, 24]))
|
|
(pair [98, 4] - [98, 18]
|
|
key: (property_identifier [98, 4] - [98, 12])
|
|
value: (true [98, 14] - [98, 18]))
|
|
(pair [99, 4] - [99, 16]
|
|
key: (property_identifier [99, 4] - [99, 10])
|
|
value: (true [99, 12] - [99, 16]))
|
|
(pair [100, 4] - [100, 19]
|
|
key: (property_identifier [100, 4] - [100, 12])
|
|
value: (string [100, 14] - [100, 19]
|
|
(string_fragment [100, 15] - [100, 18])))
|
|
(pair [101, 4] - [101, 22]
|
|
key: (property_identifier [101, 4] - [101, 10])
|
|
value: (identifier [101, 12] - [101, 22]))))))
|
|
(comment [104, 2] - [104, 31])
|
|
(lexical_declaration [105, 2] - [105, 26]
|
|
(variable_declarator [105, 6] - [105, 25]
|
|
name: (identifier [105, 6] - [105, 18])
|
|
value: (null [105, 21] - [105, 25])))
|
|
(if_statement [106, 2] - [121, 3]
|
|
condition: (parenthesized_expression [106, 5] - [106, 34]
|
|
(call_expression [106, 6] - [106, 33]
|
|
function: (member_expression [106, 6] - [106, 19]
|
|
object: (identifier [106, 6] - [106, 11])
|
|
property: (property_identifier [106, 12] - [106, 19]))
|
|
arguments: (arguments [106, 19] - [106, 33]
|
|
(identifier [106, 20] - [106, 32]))))
|
|
consequence: (statement_block [106, 35] - [121, 3]
|
|
(lexical_declaration [107, 4] - [109, 6]
|
|
(variable_declarator [107, 10] - [109, 5]
|
|
name: (identifier [107, 10] - [107, 18])
|
|
value: (call_expression [107, 21] - [109, 5]
|
|
function: (member_expression [107, 21] - [107, 38]
|
|
object: (identifier [107, 21] - [107, 33])
|
|
property: (property_identifier [107, 34] - [107, 38]))
|
|
arguments: (arguments [107, 38] - [109, 5]
|
|
(arrow_function [107, 39] - [108, 51]
|
|
parameters: (formal_parameters [107, 39] - [107, 50]
|
|
(required_parameter [107, 40] - [107, 49]
|
|
pattern: (identifier [107, 40] - [107, 41])
|
|
type: (type_annotation [107, 41] - [107, 49]
|
|
(predefined_type [107, 43] - [107, 49]))))
|
|
body: (binary_expression [108, 6] - [108, 51]
|
|
left: (binary_expression [108, 6] - [108, 27]
|
|
left: (unary_expression [108, 6] - [108, 14]
|
|
argument: (identifier [108, 13] - [108, 14]))
|
|
right: (string [108, 19] - [108, 27]
|
|
(string_fragment [108, 20] - [108, 26])))
|
|
right: (call_expression [108, 31] - [108, 51]
|
|
function: (member_expression [108, 31] - [108, 43]
|
|
object: (identifier [108, 31] - [108, 32])
|
|
property: (property_identifier [108, 33] - [108, 43]))
|
|
arguments: (arguments [108, 43] - [108, 51]
|
|
(string [108, 44] - [108, 50]
|
|
(string_fragment [108, 45] - [108, 49]))))))))))
|
|
(if_statement [110, 4] - [120, 5]
|
|
condition: (parenthesized_expression [110, 7] - [110, 17]
|
|
(identifier [110, 8] - [110, 16]))
|
|
consequence: (statement_block [110, 18] - [120, 5]
|
|
(lexical_declaration [111, 6] - [111, 44]
|
|
(variable_declarator [111, 12] - [111, 43]
|
|
name: (identifier [111, 12] - [111, 19])
|
|
value: (call_expression [111, 22] - [111, 43]
|
|
function: (member_expression [111, 22] - [111, 40]
|
|
object: (identifier [111, 22] - [111, 30])
|
|
property: (property_identifier [111, 31] - [111, 40]))
|
|
arguments: (arguments [111, 40] - [111, 43]
|
|
(number [111, 41] - [111, 42])))))
|
|
(try_statement [112, 6] - [119, 23]
|
|
body: (statement_block [112, 10] - [119, 7]
|
|
(lexical_declaration [113, 8] - [115, 37]
|
|
(variable_declarator [113, 14] - [115, 36]
|
|
name: (identifier [113, 14] - [113, 23])
|
|
value: (await_expression [113, 26] - [115, 36]
|
|
(call_expression [113, 32] - [115, 36]
|
|
function: (member_expression [113, 32] - [115, 14]
|
|
object: (call_expression [113, 32] - [115, 9]
|
|
function: (member_expression [113, 32] - [113, 46]
|
|
object: (identifier [113, 32] - [113, 42])
|
|
property: (property_identifier [113, 43] - [113, 46]))
|
|
arguments: (template_string [113, 46] - [115, 9]
|
|
(string_fragment [113, 47] - [114, 47])
|
|
(template_substitution [114, 47] - [114, 57]
|
|
(identifier [114, 49] - [114, 56]))
|
|
(string_fragment [114, 57] - [115, 8])))
|
|
property: (property_identifier [115, 10] - [115, 14]))
|
|
arguments: (arguments [115, 14] - [115, 36]
|
|
(arrow_function [115, 15] - [115, 35]
|
|
parameters: (formal_parameters [115, 15] - [115, 25]
|
|
(required_parameter [115, 16] - [115, 24]
|
|
pattern: (identifier [115, 16] - [115, 19])
|
|
type: (type_annotation [115, 19] - [115, 24]
|
|
(predefined_type [115, 21] - [115, 24]))))
|
|
body: (subscript_expression [115, 29] - [115, 35]
|
|
object: (identifier [115, 29] - [115, 32])
|
|
index: (number [115, 33] - [115, 34]))))))))
|
|
(if_statement [116, 8] - [118, 9]
|
|
condition: (parenthesized_expression [116, 11] - [116, 42]
|
|
(binary_expression [116, 12] - [116, 41]
|
|
left: (identifier [116, 12] - [116, 21])
|
|
right: (member_expression [116, 25] - [116, 41]
|
|
object: (identifier [116, 25] - [116, 34])
|
|
property: (property_identifier [116, 35] - [116, 41]))))
|
|
consequence: (statement_block [116, 43] - [118, 9]
|
|
(expression_statement [117, 10] - [117, 42]
|
|
(assignment_expression [117, 10] - [117, 41]
|
|
left: (identifier [117, 10] - [117, 22])
|
|
right: (member_expression [117, 25] - [117, 41]
|
|
object: (identifier [117, 25] - [117, 34])
|
|
property: (property_identifier [117, 35] - [117, 41])))))))
|
|
handler: (catch_clause [119, 8] - [119, 23]
|
|
parameter: (identifier [119, 15] - [119, 19])
|
|
body: (statement_block [119, 21] - [119, 23])))))))
|
|
(if_statement [123, 2] - [127, 3]
|
|
condition: (parenthesized_expression [123, 5] - [123, 19]
|
|
(identifier [123, 6] - [123, 18]))
|
|
consequence: (statement_block [123, 20] - [125, 3]
|
|
(return_statement [124, 4] - [124, 54]
|
|
(call_expression [124, 11] - [124, 53]
|
|
function: (member_expression [124, 11] - [124, 21]
|
|
object: (identifier [124, 11] - [124, 12])
|
|
property: (property_identifier [124, 13] - [124, 21]))
|
|
arguments: (arguments [124, 21] - [124, 53]
|
|
(template_string [124, 22] - [124, 47]
|
|
(string_fragment [124, 23] - [124, 31])
|
|
(template_substitution [124, 31] - [124, 46]
|
|
(identifier [124, 33] - [124, 45])))
|
|
(number [124, 49] - [124, 52])))))
|
|
alternative: (else_clause [125, 4] - [127, 3]
|
|
(statement_block [125, 9] - [127, 3]
|
|
(return_statement [126, 4] - [126, 41]
|
|
(call_expression [126, 11] - [126, 40]
|
|
function: (member_expression [126, 11] - [126, 21]
|
|
object: (identifier [126, 11] - [126, 12])
|
|
property: (property_identifier [126, 13] - [126, 21]))
|
|
arguments: (arguments [126, 21] - [126, 40]
|
|
(string [126, 22] - [126, 34]
|
|
(string_fragment [126, 23] - [126, 33]))
|
|
(number [126, 36] - [126, 39])))))))))))))
|