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