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