1010 lines
57 KiB
Plaintext
1010 lines
57 KiB
Plaintext
(program [0, 0] - [263, 0]
|
|
(import_statement [0, 0] - [0, 53]
|
|
(import_clause [0, 7] - [0, 26]
|
|
(named_imports [0, 7] - [0, 26]
|
|
(import_specifier [0, 9] - [0, 24]
|
|
name: (identifier [0, 9] - [0, 24]))))
|
|
source: (string [0, 32] - [0, 52]
|
|
(string_fragment [0, 33] - [0, 51])))
|
|
(import_statement [1, 0] - [1, 54]
|
|
(import_clause [1, 7] - [1, 20]
|
|
(named_imports [1, 7] - [1, 20]
|
|
(import_specifier [1, 9] - [1, 18]
|
|
name: (identifier [1, 9] - [1, 18]))))
|
|
source: (string [1, 26] - [1, 53]
|
|
(string_fragment [1, 27] - [1, 52])))
|
|
(import_statement [2, 0] - [2, 65]
|
|
(import_clause [2, 7] - [2, 33]
|
|
(named_imports [2, 7] - [2, 33]
|
|
(import_specifier [2, 9] - [2, 31]
|
|
name: (identifier [2, 9] - [2, 31]))))
|
|
source: (string [2, 39] - [2, 64]
|
|
(string_fragment [2, 40] - [2, 63])))
|
|
(comment [4, 0] - [4, 44])
|
|
(if_statement [6, 0] - [8, 1]
|
|
condition: (parenthesized_expression [6, 3] - [6, 66]
|
|
(binary_expression [6, 4] - [6, 65]
|
|
left: (binary_expression [6, 4] - [6, 32]
|
|
left: (member_expression [6, 4] - [6, 19]
|
|
object: (member_expression [6, 4] - [6, 14]
|
|
object: (identifier [6, 4] - [6, 8])
|
|
property: (property_identifier [6, 9] - [6, 14]))
|
|
property: (property_identifier [6, 15] - [6, 19]))
|
|
right: (string [6, 24] - [6, 32]
|
|
(string_fragment [6, 25] - [6, 31])))
|
|
right: (binary_expression [6, 36] - [6, 65]
|
|
left: (member_expression [6, 36] - [6, 51]
|
|
object: (member_expression [6, 36] - [6, 46]
|
|
object: (identifier [6, 36] - [6, 40])
|
|
property: (property_identifier [6, 41] - [6, 46]))
|
|
property: (property_identifier [6, 47] - [6, 51]))
|
|
right: (string [6, 56] - [6, 65]
|
|
(string_fragment [6, 57] - [6, 64])))))
|
|
consequence: (statement_block [6, 67] - [8, 1]
|
|
(throw_statement [7, 2] - [7, 46]
|
|
(new_expression [7, 8] - [7, 45]
|
|
constructor: (identifier [7, 12] - [7, 17])
|
|
arguments: (arguments [7, 17] - [7, 45]
|
|
(string [7, 18] - [7, 44]
|
|
(string_fragment [7, 19] - [7, 43])))))))
|
|
(lexical_declaration [10, 0] - [18, 5]
|
|
(variable_declarator [10, 6] - [18, 4]
|
|
name: (identifier [10, 6] - [10, 13])
|
|
value: (call_expression [10, 16] - [18, 4]
|
|
function: (parenthesized_expression [10, 16] - [18, 2]
|
|
(arrow_function [10, 17] - [18, 1]
|
|
parameters: (formal_parameters [10, 17] - [10, 19])
|
|
body: (statement_block [10, 23] - [18, 1]
|
|
(if_statement [11, 2] - [13, 3]
|
|
condition: (parenthesized_expression [11, 5] - [11, 34]
|
|
(binary_expression [11, 6] - [11, 33]
|
|
left: (member_expression [11, 6] - [11, 19]
|
|
object: (member_expression [11, 6] - [11, 16]
|
|
object: (identifier [11, 6] - [11, 10])
|
|
property: (property_identifier [11, 11] - [11, 16]))
|
|
property: (property_identifier [11, 17] - [11, 19]))
|
|
right: (string [11, 24] - [11, 33]
|
|
(string_fragment [11, 25] - [11, 32]))))
|
|
consequence: (statement_block [11, 35] - [13, 3]
|
|
(return_statement [12, 4] - [12, 55]
|
|
(string [12, 11] - [12, 54]
|
|
(string_fragment [12, 12] - [12, 53])))))
|
|
(if_statement [14, 2] - [16, 3]
|
|
condition: (parenthesized_expression [14, 5] - [14, 33]
|
|
(binary_expression [14, 6] - [14, 32]
|
|
left: (member_expression [14, 6] - [14, 19]
|
|
object: (member_expression [14, 6] - [14, 16]
|
|
object: (identifier [14, 6] - [14, 10])
|
|
property: (property_identifier [14, 11] - [14, 16]))
|
|
property: (property_identifier [14, 17] - [14, 19]))
|
|
right: (string [14, 24] - [14, 32]
|
|
(string_fragment [14, 25] - [14, 31]))))
|
|
consequence: (statement_block [14, 34] - [16, 3]
|
|
(return_statement [15, 4] - [15, 60]
|
|
(string [15, 11] - [15, 59]
|
|
(string_fragment [15, 12] - [15, 58])))))
|
|
(return_statement [17, 2] - [17, 55]
|
|
(string [17, 9] - [17, 54]
|
|
(string_fragment [17, 10] - [17, 53]))))))
|
|
arguments: (arguments [18, 2] - [18, 4]))))
|
|
(lexical_declaration [20, 0] - [20, 50]
|
|
(variable_declarator [20, 4] - [20, 49]
|
|
name: (identifier [20, 4] - [20, 9])
|
|
type: (type_annotation [20, 9] - [20, 42]
|
|
(union_type [20, 11] - [20, 42]
|
|
(generic_type [20, 11] - [20, 35]
|
|
name: (nested_type_identifier [20, 11] - [20, 30]
|
|
module: (identifier [20, 11] - [20, 15])
|
|
name: (type_identifier [20, 16] - [20, 30]))
|
|
type_arguments: (type_arguments [20, 30] - [20, 35]
|
|
(predefined_type [20, 31] - [20, 34])))
|
|
(literal_type [20, 38] - [20, 42]
|
|
(null [20, 38] - [20, 42]))))
|
|
value: (null [20, 45] - [20, 49])))
|
|
(try_statement [22, 0] - [52, 1]
|
|
body: (statement_block [22, 4] - [48, 1]
|
|
(expression_statement [23, 2] - [47, 5]
|
|
(assignment_expression [23, 2] - [47, 4]
|
|
left: (identifier [23, 2] - [23, 7])
|
|
right: (call_expression [23, 10] - [47, 4]
|
|
function: (member_expression [23, 10] - [23, 21]
|
|
object: (identifier [23, 10] - [23, 14])
|
|
property: (property_identifier [23, 15] - [23, 21]))
|
|
arguments: (arguments [23, 21] - [47, 4]
|
|
(identifier [23, 22] - [23, 29])
|
|
(object [23, 31] - [47, 3]
|
|
(pair [24, 4] - [28, 5]
|
|
key: (property_identifier [24, 4] - [24, 14])
|
|
value: (object [24, 16] - [28, 5]
|
|
(pair [25, 6] - [25, 29]
|
|
key: (property_identifier [25, 6] - [25, 16])
|
|
value: (array [25, 18] - [25, 29]
|
|
(string [25, 19] - [25, 28]
|
|
(string_fragment [25, 20] - [25, 27]))))
|
|
(pair [26, 6] - [26, 23]
|
|
key: (property_identifier [26, 6] - [26, 12])
|
|
value: (string [26, 14] - [26, 23]
|
|
(string_fragment [26, 15] - [26, 22])))
|
|
(pair [27, 6] - [27, 23]
|
|
key: (property_identifier [27, 6] - [27, 17])
|
|
value: (true [27, 19] - [27, 23]))))
|
|
(pair [29, 4] - [32, 5]
|
|
key: (property_identifier [29, 4] - [29, 13])
|
|
value: (object [29, 15] - [32, 5]
|
|
(pair [30, 6] - [30, 29]
|
|
key: (property_identifier [30, 6] - [30, 16])
|
|
value: (array [30, 18] - [30, 29]
|
|
(string [30, 19] - [30, 28]
|
|
(string_fragment [30, 20] - [30, 27]))))
|
|
(pair [31, 6] - [31, 20]
|
|
key: (property_identifier [31, 6] - [31, 12])
|
|
value: (string [31, 14] - [31, 20]
|
|
(string_fragment [31, 15] - [31, 19])))))
|
|
(pair [33, 4] - [46, 5]
|
|
key: (property_identifier [33, 4] - [33, 19])
|
|
value: (object [33, 21] - [46, 5]
|
|
(pair [34, 6] - [43, 7]
|
|
key: (property_identifier [34, 6] - [34, 16])
|
|
value: (array [34, 18] - [43, 7]
|
|
(string [35, 8] - [35, 17]
|
|
(string_fragment [35, 9] - [35, 16]))
|
|
(string [36, 8] - [36, 15]
|
|
(string_fragment [36, 9] - [36, 14]))
|
|
(string [37, 8] - [37, 17]
|
|
(string_fragment [37, 9] - [37, 16]))
|
|
(string [38, 8] - [38, 15]
|
|
(string_fragment [38, 9] - [38, 14]))
|
|
(string [39, 8] - [39, 13]
|
|
(string_fragment [39, 9] - [39, 12]))
|
|
(string [40, 8] - [40, 13]
|
|
(string_fragment [40, 9] - [40, 12]))
|
|
(string [41, 8] - [41, 17]
|
|
(string_fragment [41, 9] - [41, 16]))
|
|
(string [42, 8] - [42, 15]
|
|
(string_fragment [42, 9] - [42, 14]))))
|
|
(pair [44, 6] - [44, 19]
|
|
key: (property_identifier [44, 6] - [44, 12])
|
|
value: (string [44, 14] - [44, 19]
|
|
(string_fragment [44, 15] - [44, 18])))
|
|
(pair [45, 6] - [45, 23]
|
|
key: (property_identifier [45, 6] - [45, 17])
|
|
value: (true [45, 19] - [45, 23]))))))))))
|
|
handler: (catch_clause [48, 2] - [52, 1]
|
|
parameter: (identifier [48, 9] - [48, 11])
|
|
body: (statement_block [48, 13] - [52, 1]
|
|
(expression_statement [49, 2] - [51, 4]
|
|
(call_expression [49, 2] - [51, 3]
|
|
function: (member_expression [49, 2] - [49, 14]
|
|
object: (identifier [49, 2] - [49, 9])
|
|
property: (property_identifier [49, 10] - [49, 14]))
|
|
arguments: (arguments [49, 14] - [51, 3]
|
|
(template_string [50, 4] - [50, 87]
|
|
(string_fragment [50, 5] - [50, 20])
|
|
(template_substitution [50, 20] - [50, 30]
|
|
(identifier [50, 22] - [50, 29]))
|
|
(string_fragment [50, 30] - [50, 86]))))))))
|
|
(export_statement [54, 0] - [59, 1]
|
|
declaration: (interface_declaration [54, 7] - [59, 1]
|
|
name: (type_identifier [54, 17] - [54, 29])
|
|
body: (interface_body [54, 30] - [59, 1]
|
|
(property_signature [55, 2] - [55, 19]
|
|
name: (property_identifier [55, 2] - [55, 11])
|
|
type: (type_annotation [55, 11] - [55, 19]
|
|
(predefined_type [55, 13] - [55, 19])))
|
|
(property_signature [56, 2] - [56, 23]
|
|
name: (property_identifier [56, 2] - [56, 11])
|
|
type: (type_annotation [56, 11] - [56, 23]
|
|
(type_identifier [56, 13] - [56, 23])))
|
|
(property_signature [57, 2] - [57, 27]
|
|
name: (property_identifier [57, 2] - [57, 15])
|
|
type: (type_annotation [57, 15] - [57, 27]
|
|
(type_identifier [57, 17] - [57, 27])))
|
|
(property_signature [58, 2] - [58, 20]
|
|
name: (property_identifier [58, 2] - [58, 8])
|
|
type: (type_annotation [58, 8] - [58, 20]
|
|
(type_identifier [58, 10] - [58, 20]))))))
|
|
(export_statement [61, 0] - [166, 1]
|
|
declaration: (function_declaration [61, 7] - [166, 1]
|
|
name: (identifier [61, 22] - [61, 41])
|
|
parameters: (formal_parameters [61, 41] - [63, 1]
|
|
(required_parameter [62, 2] - [62, 50]
|
|
pattern: (identifier [62, 2] - [62, 12])
|
|
type: (type_annotation [62, 12] - [62, 20]
|
|
(predefined_type [62, 14] - [62, 20]))
|
|
value: (string [62, 23] - [62, 50]
|
|
(string_fragment [62, 24] - [62, 49]))))
|
|
return_type: (type_annotation [63, 1] - [63, 24]
|
|
(generic_type [63, 3] - [63, 24]
|
|
name: (type_identifier [63, 3] - [63, 10])
|
|
type_arguments: (type_arguments [63, 10] - [63, 24]
|
|
(type_identifier [63, 11] - [63, 23]))))
|
|
body: (statement_block [63, 25] - [166, 1]
|
|
(if_statement [64, 2] - [74, 3]
|
|
condition: (parenthesized_expression [64, 5] - [64, 13]
|
|
(unary_expression [64, 6] - [64, 12]
|
|
argument: (identifier [64, 7] - [64, 12])))
|
|
consequence: (statement_block [64, 14] - [74, 3]
|
|
(expression_statement [65, 4] - [67, 6]
|
|
(call_expression [65, 4] - [67, 5]
|
|
function: (member_expression [65, 4] - [65, 16]
|
|
object: (identifier [65, 4] - [65, 11])
|
|
property: (property_identifier [65, 12] - [65, 16]))
|
|
arguments: (arguments [65, 16] - [67, 5]
|
|
(template_string [66, 6] - [66, 108]
|
|
(string_fragment [66, 7] - [66, 36])
|
|
(template_substitution [66, 36] - [66, 46]
|
|
(identifier [66, 38] - [66, 45]))
|
|
(string_fragment [66, 46] - [66, 107])))))
|
|
(return_statement [68, 4] - [73, 6]
|
|
(object [68, 11] - [73, 5]
|
|
(pair [69, 6] - [69, 42]
|
|
key: (property_identifier [69, 6] - [69, 15])
|
|
value: (string [69, 17] - [69, 42]
|
|
(string_fragment [69, 18] - [69, 41])))
|
|
(pair [70, 6] - [70, 33]
|
|
key: (property_identifier [70, 6] - [70, 15])
|
|
value: (new_expression [70, 17] - [70, 33]
|
|
constructor: (identifier [70, 21] - [70, 31])
|
|
arguments: (arguments [70, 31] - [70, 33])))
|
|
(pair [71, 6] - [71, 37]
|
|
key: (property_identifier [71, 6] - [71, 19])
|
|
value: (new_expression [71, 21] - [71, 37]
|
|
constructor: (identifier [71, 25] - [71, 35])
|
|
arguments: (arguments [71, 35] - [71, 37])))
|
|
(pair [72, 6] - [72, 30]
|
|
key: (property_identifier [72, 6] - [72, 12])
|
|
value: (new_expression [72, 14] - [72, 30]
|
|
constructor: (identifier [72, 18] - [72, 28])
|
|
arguments: (arguments [72, 28] - [72, 30])))))))
|
|
(lexical_declaration [76, 2] - [76, 36]
|
|
(variable_declarator [76, 8] - [76, 35]
|
|
name: (identifier [76, 8] - [76, 15])
|
|
value: (new_expression [76, 18] - [76, 35]
|
|
constructor: (identifier [76, 22] - [76, 33])
|
|
arguments: (arguments [76, 33] - [76, 35]))))
|
|
(lexical_declaration [77, 2] - [77, 56]
|
|
(variable_declarator [77, 8] - [77, 55]
|
|
name: (identifier [77, 8] - [77, 19])
|
|
value: (call_expression [77, 22] - [77, 55]
|
|
function: (member_expression [77, 22] - [77, 36]
|
|
object: (identifier [77, 22] - [77, 29])
|
|
property: (property_identifier [77, 30] - [77, 36]))
|
|
arguments: (arguments [77, 36] - [77, 55]
|
|
(binary_expression [77, 37] - [77, 54]
|
|
left: (identifier [77, 37] - [77, 47])
|
|
right: (string [77, 50] - [77, 54]
|
|
(escape_sequence [77, 51] - [77, 53])))))))
|
|
(lexical_declaration [78, 2] - [78, 53]
|
|
(variable_declarator [78, 8] - [78, 52]
|
|
name: (identifier [78, 8] - [78, 15])
|
|
value: (call_expression [78, 18] - [78, 52]
|
|
function: (member_expression [78, 18] - [78, 39]
|
|
object: (member_expression [78, 18] - [78, 36]
|
|
object: (identifier [78, 18] - [78, 22])
|
|
property: (property_identifier [78, 23] - [78, 36]))
|
|
property: (property_identifier [78, 37] - [78, 39]))
|
|
arguments: (arguments [78, 39] - [78, 52]
|
|
(identifier [78, 40] - [78, 51])))))
|
|
(lexical_declaration [80, 2] - [83, 37]
|
|
(variable_declarator [80, 8] - [83, 36]
|
|
name: (identifier [80, 8] - [80, 18])
|
|
value: (as_expression [80, 21] - [83, 36]
|
|
(as_expression [80, 21] - [81, 26]
|
|
(member_expression [80, 21] - [81, 15]
|
|
object: (member_expression [80, 21] - [80, 34]
|
|
object: (identifier [80, 21] - [80, 26])
|
|
property: (property_identifier [80, 27] - [80, 34]))
|
|
property: (property_identifier [81, 5] - [81, 15]))
|
|
(predefined_type [81, 19] - [81, 26]))
|
|
(parenthesized_type [81, 30] - [83, 36]
|
|
(function_type [81, 31] - [83, 35]
|
|
parameters: (formal_parameters [81, 31] - [83, 5]
|
|
(required_parameter [82, 6] - [82, 28]
|
|
pattern: (identifier [82, 6] - [82, 9])
|
|
type: (type_annotation [82, 9] - [82, 28]
|
|
(nested_type_identifier [82, 11] - [82, 28]
|
|
module: (identifier [82, 11] - [82, 15])
|
|
name: (type_identifier [82, 16] - [82, 28])))))
|
|
return_type: (generic_type [83, 9] - [83, 35]
|
|
name: (type_identifier [83, 9] - [83, 16])
|
|
type_arguments: (type_arguments [83, 16] - [83, 35]
|
|
(nested_type_identifier [83, 17] - [83, 34]
|
|
module: (identifier [83, 17] - [83, 21])
|
|
name: (type_identifier [83, 22] - [83, 34])))))))))
|
|
(lexical_declaration [84, 2] - [85, 64]
|
|
(variable_declarator [84, 8] - [85, 63]
|
|
name: (identifier [84, 8] - [84, 17])
|
|
value: (as_expression [84, 20] - [85, 63]
|
|
(as_expression [84, 20] - [85, 25]
|
|
(member_expression [84, 20] - [85, 14]
|
|
object: (member_expression [84, 20] - [84, 33]
|
|
object: (identifier [84, 20] - [84, 25])
|
|
property: (property_identifier [84, 26] - [84, 33]))
|
|
property: (property_identifier [85, 5] - [85, 14]))
|
|
(predefined_type [85, 18] - [85, 25]))
|
|
(parenthesized_type [85, 29] - [85, 63]
|
|
(function_type [85, 30] - [85, 62]
|
|
parameters: (formal_parameters [85, 30] - [85, 54]
|
|
(required_parameter [85, 31] - [85, 53]
|
|
pattern: (identifier [85, 31] - [85, 34])
|
|
type: (type_annotation [85, 34] - [85, 53]
|
|
(nested_type_identifier [85, 36] - [85, 53]
|
|
module: (identifier [85, 36] - [85, 40])
|
|
name: (type_identifier [85, 41] - [85, 53])))))
|
|
return_type: (predefined_type [85, 58] - [85, 62]))))))
|
|
(lexical_declaration [87, 2] - [87, 43]
|
|
(variable_declarator [87, 8] - [87, 42]
|
|
name: (identifier [87, 8] - [87, 14])
|
|
value: (await_expression [87, 17] - [87, 42]
|
|
(call_expression [87, 23] - [87, 42]
|
|
function: (identifier [87, 23] - [87, 33])
|
|
arguments: (arguments [87, 33] - [87, 42]
|
|
(identifier [87, 34] - [87, 41]))))))
|
|
(if_statement [89, 2] - [91, 3]
|
|
condition: (parenthesized_expression [89, 5] - [89, 22]
|
|
(binary_expression [89, 6] - [89, 21]
|
|
left: (identifier [89, 6] - [89, 12])
|
|
right: (null [89, 17] - [89, 21])))
|
|
consequence: (statement_block [89, 23] - [91, 3]
|
|
(throw_statement [90, 4] - [90, 58]
|
|
(new_expression [90, 10] - [90, 57]
|
|
constructor: (identifier [90, 14] - [90, 19])
|
|
arguments: (arguments [90, 19] - [90, 57]
|
|
(string [90, 20] - [90, 56]
|
|
(string_fragment [90, 21] - [90, 55])))))))
|
|
(lexical_declaration [93, 2] - [93, 53]
|
|
(variable_declarator [93, 8] - [93, 52]
|
|
name: (identifier [93, 8] - [93, 15])
|
|
value: (new_expression [93, 18] - [93, 52]
|
|
constructor: (member_expression [93, 22] - [93, 44]
|
|
object: (identifier [93, 22] - [93, 26])
|
|
property: (property_identifier [93, 27] - [93, 44]))
|
|
arguments: (arguments [93, 44] - [93, 52]
|
|
(identifier [93, 45] - [93, 51])))))
|
|
(lexical_declaration [94, 2] - [94, 37]
|
|
(variable_declarator [94, 6] - [94, 36]
|
|
name: (identifier [94, 6] - [94, 14])
|
|
type: (type_annotation [94, 14] - [94, 29]
|
|
(union_type [94, 16] - [94, 29]
|
|
(predefined_type [94, 16] - [94, 22])
|
|
(literal_type [94, 25] - [94, 29]
|
|
(null [94, 25] - [94, 29]))))
|
|
value: (null [94, 32] - [94, 36])))
|
|
(lexical_declaration [95, 2] - [95, 38]
|
|
(variable_declarator [95, 6] - [95, 37]
|
|
name: (identifier [95, 6] - [95, 15])
|
|
type: (type_annotation [95, 15] - [95, 30]
|
|
(union_type [95, 17] - [95, 30]
|
|
(predefined_type [95, 17] - [95, 23])
|
|
(literal_type [95, 26] - [95, 30]
|
|
(null [95, 26] - [95, 30]))))
|
|
value: (null [95, 33] - [95, 37])))
|
|
(lexical_declaration [97, 2] - [97, 17]
|
|
(variable_declarator [97, 6] - [97, 16]
|
|
name: (identifier [97, 6] - [97, 12])
|
|
value: (number [97, 15] - [97, 16])))
|
|
(lexical_declaration [98, 2] - [98, 20]
|
|
(variable_declarator [98, 8] - [98, 19]
|
|
name: (identifier [98, 8] - [98, 15])
|
|
value: (number [98, 18] - [98, 19])))
|
|
(comment [98, 21] - [98, 39])
|
|
(lexical_declaration [100, 2] - [100, 51]
|
|
(variable_declarator [100, 8] - [100, 50]
|
|
name: (identifier [100, 8] - [100, 21])
|
|
value: (call_expression [100, 24] - [100, 50]
|
|
function: (member_expression [100, 24] - [100, 42]
|
|
object: (identifier [100, 24] - [100, 31])
|
|
property: (property_identifier [100, 32] - [100, 42]))
|
|
arguments: (arguments [100, 42] - [100, 50]
|
|
(identifier [100, 43] - [100, 49])))))
|
|
(expression_statement [101, 2] - [101, 20]
|
|
(augmented_assignment_expression [101, 2] - [101, 19]
|
|
left: (identifier [101, 2] - [101, 8])
|
|
right: (identifier [101, 12] - [101, 19])))
|
|
(lexical_declaration [102, 2] - [102, 51]
|
|
(variable_declarator [102, 8] - [102, 50]
|
|
name: (identifier [102, 8] - [102, 21])
|
|
value: (call_expression [102, 24] - [102, 50]
|
|
function: (member_expression [102, 24] - [102, 42]
|
|
object: (identifier [102, 24] - [102, 31])
|
|
property: (property_identifier [102, 32] - [102, 42]))
|
|
arguments: (arguments [102, 42] - [102, 50]
|
|
(identifier [102, 43] - [102, 49])))))
|
|
(expression_statement [103, 2] - [103, 20]
|
|
(augmented_assignment_expression [103, 2] - [103, 19]
|
|
left: (identifier [103, 2] - [103, 8])
|
|
right: (identifier [103, 12] - [103, 19])))
|
|
(lexical_declaration [104, 2] - [104, 61]
|
|
(variable_declarator [104, 8] - [104, 60]
|
|
name: (identifier [104, 8] - [104, 21])
|
|
value: (call_expression [104, 24] - [104, 60]
|
|
function: (identifier [104, 24] - [104, 30])
|
|
arguments: (arguments [104, 30] - [104, 60]
|
|
(call_expression [104, 31] - [104, 59]
|
|
function: (member_expression [104, 31] - [104, 51]
|
|
object: (identifier [104, 31] - [104, 38])
|
|
property: (property_identifier [104, 39] - [104, 51]))
|
|
arguments: (arguments [104, 51] - [104, 59]
|
|
(identifier [104, 52] - [104, 58])))))))
|
|
(expression_statement [105, 2] - [105, 20]
|
|
(augmented_assignment_expression [105, 2] - [105, 19]
|
|
left: (identifier [105, 2] - [105, 8])
|
|
right: (identifier [105, 12] - [105, 19])))
|
|
(lexical_declaration [106, 2] - [106, 55]
|
|
(variable_declarator [106, 8] - [106, 54]
|
|
name: (identifier [106, 8] - [106, 25])
|
|
value: (call_expression [106, 28] - [106, 54]
|
|
function: (member_expression [106, 28] - [106, 46]
|
|
object: (identifier [106, 28] - [106, 35])
|
|
property: (property_identifier [106, 36] - [106, 46]))
|
|
arguments: (arguments [106, 46] - [106, 54]
|
|
(identifier [106, 47] - [106, 53])))))
|
|
(expression_statement [107, 2] - [107, 20]
|
|
(augmented_assignment_expression [107, 2] - [107, 19]
|
|
left: (identifier [107, 2] - [107, 8])
|
|
right: (identifier [107, 12] - [107, 19])))
|
|
(lexical_declaration [108, 2] - [108, 65]
|
|
(variable_declarator [108, 8] - [108, 64]
|
|
name: (identifier [108, 8] - [108, 25])
|
|
value: (call_expression [108, 28] - [108, 64]
|
|
function: (identifier [108, 28] - [108, 34])
|
|
arguments: (arguments [108, 34] - [108, 64]
|
|
(call_expression [108, 35] - [108, 63]
|
|
function: (member_expression [108, 35] - [108, 55]
|
|
object: (identifier [108, 35] - [108, 42])
|
|
property: (property_identifier [108, 43] - [108, 55]))
|
|
arguments: (arguments [108, 55] - [108, 63]
|
|
(identifier [108, 56] - [108, 62])))))))
|
|
(expression_statement [109, 2] - [109, 20]
|
|
(augmented_assignment_expression [109, 2] - [109, 19]
|
|
left: (identifier [109, 2] - [109, 8])
|
|
right: (identifier [109, 12] - [109, 19])))
|
|
(lexical_declaration [110, 2] - [110, 48]
|
|
(variable_declarator [110, 8] - [110, 47]
|
|
name: (identifier [110, 8] - [110, 18])
|
|
value: (call_expression [110, 21] - [110, 47]
|
|
function: (member_expression [110, 21] - [110, 39]
|
|
object: (identifier [110, 21] - [110, 28])
|
|
property: (property_identifier [110, 29] - [110, 39]))
|
|
arguments: (arguments [110, 39] - [110, 47]
|
|
(identifier [110, 40] - [110, 46])))))
|
|
(expression_statement [111, 2] - [111, 20]
|
|
(augmented_assignment_expression [111, 2] - [111, 19]
|
|
left: (identifier [111, 2] - [111, 8])
|
|
right: (identifier [111, 12] - [111, 19])))
|
|
(lexical_declaration [112, 2] - [112, 58]
|
|
(variable_declarator [112, 8] - [112, 57]
|
|
name: (identifier [112, 8] - [112, 18])
|
|
value: (call_expression [112, 21] - [112, 57]
|
|
function: (identifier [112, 21] - [112, 27])
|
|
arguments: (arguments [112, 27] - [112, 57]
|
|
(call_expression [112, 28] - [112, 56]
|
|
function: (member_expression [112, 28] - [112, 48]
|
|
object: (identifier [112, 28] - [112, 35])
|
|
property: (property_identifier [112, 36] - [112, 48]))
|
|
arguments: (arguments [112, 48] - [112, 56]
|
|
(identifier [112, 49] - [112, 55])))))))
|
|
(expression_statement [113, 2] - [113, 20]
|
|
(augmented_assignment_expression [113, 2] - [113, 19]
|
|
left: (identifier [113, 2] - [113, 8])
|
|
right: (identifier [113, 12] - [113, 19])))
|
|
(lexical_declaration [114, 2] - [114, 47]
|
|
(variable_declarator [114, 8] - [114, 46]
|
|
name: (identifier [114, 8] - [114, 17])
|
|
value: (call_expression [114, 20] - [114, 46]
|
|
function: (member_expression [114, 20] - [114, 38]
|
|
object: (identifier [114, 20] - [114, 27])
|
|
property: (property_identifier [114, 28] - [114, 38]))
|
|
arguments: (arguments [114, 38] - [114, 46]
|
|
(identifier [114, 39] - [114, 45])))))
|
|
(if_statement [116, 2] - [118, 3]
|
|
condition: (parenthesized_expression [116, 5] - [116, 25]
|
|
(binary_expression [116, 6] - [116, 24]
|
|
left: (identifier [116, 6] - [116, 15])
|
|
right: (null [116, 20] - [116, 24])))
|
|
consequence: (statement_block [116, 26] - [118, 3]
|
|
(expression_statement [117, 4] - [117, 66]
|
|
(assignment_expression [117, 4] - [117, 65]
|
|
left: (identifier [117, 4] - [117, 12])
|
|
right: (call_expression [117, 15] - [117, 65]
|
|
function: (member_expression [117, 15] - [117, 63]
|
|
object: (new_expression [117, 15] - [117, 52]
|
|
constructor: (member_expression [117, 19] - [117, 41]
|
|
object: (identifier [117, 19] - [117, 23])
|
|
property: (property_identifier [117, 24] - [117, 41]))
|
|
arguments: (arguments [117, 41] - [117, 52]
|
|
(identifier [117, 42] - [117, 51])))
|
|
property: (property_identifier [117, 53] - [117, 63]))
|
|
arguments: (arguments [117, 63] - [117, 65]))))))
|
|
(if_statement [120, 2] - [123, 3]
|
|
condition: (parenthesized_expression [120, 5] - [120, 24]
|
|
(binary_expression [120, 6] - [120, 23]
|
|
left: (identifier [120, 6] - [120, 14])
|
|
right: (null [120, 19] - [120, 23])))
|
|
consequence: (statement_block [120, 25] - [123, 3]
|
|
(expression_statement [121, 4] - [121, 22]
|
|
(call_expression [121, 4] - [121, 21]
|
|
function: (identifier [121, 4] - [121, 13])
|
|
arguments: (arguments [121, 13] - [121, 21]
|
|
(identifier [121, 14] - [121, 20]))))
|
|
(throw_statement [122, 4] - [122, 30]
|
|
(new_expression [122, 10] - [122, 29]
|
|
constructor: (identifier [122, 14] - [122, 19])
|
|
arguments: (arguments [122, 19] - [122, 29]
|
|
(identifier [122, 20] - [122, 28]))))))
|
|
(if_statement [125, 2] - [127, 3]
|
|
condition: (parenthesized_expression [125, 5] - [125, 29]
|
|
(binary_expression [125, 6] - [125, 28]
|
|
left: (identifier [125, 6] - [125, 19])
|
|
right: (null [125, 24] - [125, 28])))
|
|
consequence: (statement_block [125, 30] - [127, 3]
|
|
(expression_statement [126, 4] - [126, 71]
|
|
(assignment_expression [126, 4] - [126, 70]
|
|
left: (identifier [126, 4] - [126, 13])
|
|
right: (call_expression [126, 16] - [126, 70]
|
|
function: (member_expression [126, 16] - [126, 68]
|
|
object: (new_expression [126, 16] - [126, 57]
|
|
constructor: (member_expression [126, 20] - [126, 42]
|
|
object: (identifier [126, 20] - [126, 24])
|
|
property: (property_identifier [126, 25] - [126, 42]))
|
|
arguments: (arguments [126, 42] - [126, 57]
|
|
(identifier [126, 43] - [126, 56])))
|
|
property: (property_identifier [126, 58] - [126, 68]))
|
|
arguments: (arguments [126, 68] - [126, 70]))))))
|
|
(if_statement [129, 2] - [132, 3]
|
|
condition: (parenthesized_expression [129, 5] - [129, 17]
|
|
(unary_expression [129, 6] - [129, 16]
|
|
argument: (identifier [129, 7] - [129, 16])))
|
|
consequence: (statement_block [129, 18] - [132, 3]
|
|
(expression_statement [130, 4] - [130, 22]
|
|
(call_expression [130, 4] - [130, 21]
|
|
function: (identifier [130, 4] - [130, 13])
|
|
arguments: (arguments [130, 13] - [130, 21]
|
|
(identifier [130, 14] - [130, 20]))))
|
|
(throw_statement [131, 4] - [131, 41]
|
|
(new_expression [131, 10] - [131, 40]
|
|
constructor: (identifier [131, 14] - [131, 19])
|
|
arguments: (arguments [131, 19] - [131, 40]
|
|
(string [131, 20] - [131, 39]
|
|
(string_fragment [131, 21] - [131, 38])))))))
|
|
(lexical_declaration [134, 2] - [138, 23]
|
|
(variable_declarator [134, 8] - [138, 22]
|
|
name: (identifier [134, 8] - [134, 17])
|
|
value: (ternary_expression [134, 20] - [138, 22]
|
|
condition: (binary_expression [134, 20] - [134, 63]
|
|
left: (binary_expression [134, 20] - [134, 42]
|
|
left: (identifier [134, 20] - [134, 33])
|
|
right: (null [134, 38] - [134, 42]))
|
|
right: (binary_expression [134, 46] - [134, 63]
|
|
left: (identifier [134, 46] - [134, 59])
|
|
right: (number [134, 62] - [134, 63])))
|
|
consequence: (new_expression [135, 6] - [137, 5]
|
|
constructor: (identifier [135, 10] - [135, 20])
|
|
arguments: (arguments [135, 20] - [137, 5]
|
|
(call_expression [136, 6] - [136, 77]
|
|
function: (member_expression [136, 6] - [136, 62]
|
|
object: (new_expression [136, 6] - [136, 47]
|
|
constructor: (member_expression [136, 10] - [136, 32]
|
|
object: (identifier [136, 10] - [136, 14])
|
|
property: (property_identifier [136, 15] - [136, 32]))
|
|
arguments: (arguments [136, 32] - [136, 47]
|
|
(identifier [136, 33] - [136, 46])))
|
|
property: (property_identifier [136, 48] - [136, 62]))
|
|
arguments: (arguments [136, 62] - [136, 77]
|
|
(identifier [136, 63] - [136, 76])))))
|
|
alternative: (new_expression [138, 6] - [138, 22]
|
|
constructor: (identifier [138, 10] - [138, 20])
|
|
arguments: (arguments [138, 20] - [138, 22])))))
|
|
(lexical_declaration [140, 2] - [146, 23]
|
|
(variable_declarator [140, 8] - [146, 22]
|
|
name: (identifier [140, 8] - [140, 21])
|
|
value: (ternary_expression [140, 24] - [146, 22]
|
|
condition: (binary_expression [140, 24] - [140, 75]
|
|
left: (binary_expression [140, 24] - [140, 50]
|
|
left: (identifier [140, 24] - [140, 41])
|
|
right: (null [140, 46] - [140, 50]))
|
|
right: (binary_expression [140, 54] - [140, 75]
|
|
left: (identifier [140, 54] - [140, 71])
|
|
right: (number [140, 74] - [140, 75])))
|
|
consequence: (new_expression [141, 6] - [145, 5]
|
|
constructor: (identifier [141, 10] - [141, 20])
|
|
arguments: (arguments [141, 20] - [145, 5]
|
|
(call_expression [142, 6] - [144, 7]
|
|
function: (member_expression [142, 6] - [142, 66]
|
|
object: (new_expression [142, 6] - [142, 51]
|
|
constructor: (member_expression [142, 10] - [142, 32]
|
|
object: (identifier [142, 10] - [142, 14])
|
|
property: (property_identifier [142, 15] - [142, 32]))
|
|
arguments: (arguments [142, 32] - [142, 51]
|
|
(identifier [142, 33] - [142, 50])))
|
|
property: (property_identifier [142, 52] - [142, 66]))
|
|
arguments: (arguments [142, 66] - [144, 7]
|
|
(identifier [143, 8] - [143, 25])))))
|
|
alternative: (new_expression [146, 6] - [146, 22]
|
|
constructor: (identifier [146, 10] - [146, 20])
|
|
arguments: (arguments [146, 20] - [146, 22])))))
|
|
(lexical_declaration [148, 2] - [152, 23]
|
|
(variable_declarator [148, 8] - [152, 22]
|
|
name: (identifier [148, 8] - [148, 14])
|
|
value: (ternary_expression [148, 17] - [152, 22]
|
|
condition: (binary_expression [148, 17] - [148, 54]
|
|
left: (binary_expression [148, 17] - [148, 36]
|
|
left: (identifier [148, 17] - [148, 27])
|
|
right: (null [148, 32] - [148, 36]))
|
|
right: (binary_expression [148, 40] - [148, 54]
|
|
left: (identifier [148, 40] - [148, 50])
|
|
right: (number [148, 53] - [148, 54])))
|
|
consequence: (new_expression [149, 6] - [151, 5]
|
|
constructor: (identifier [149, 10] - [149, 20])
|
|
arguments: (arguments [149, 20] - [151, 5]
|
|
(call_expression [150, 6] - [150, 71]
|
|
function: (member_expression [150, 6] - [150, 59]
|
|
object: (new_expression [150, 6] - [150, 44]
|
|
constructor: (member_expression [150, 10] - [150, 32]
|
|
object: (identifier [150, 10] - [150, 14])
|
|
property: (property_identifier [150, 15] - [150, 32]))
|
|
arguments: (arguments [150, 32] - [150, 44]
|
|
(identifier [150, 33] - [150, 43])))
|
|
property: (property_identifier [150, 45] - [150, 59]))
|
|
arguments: (arguments [150, 59] - [150, 71]
|
|
(identifier [150, 60] - [150, 70])))))
|
|
alternative: (new_expression [152, 6] - [152, 22]
|
|
constructor: (identifier [152, 10] - [152, 20])
|
|
arguments: (arguments [152, 20] - [152, 22])))))
|
|
(comment [154, 2] - [154, 64])
|
|
(lexical_declaration [155, 2] - [160, 4]
|
|
(variable_declarator [155, 8] - [160, 3]
|
|
name: (identifier [155, 8] - [155, 16])
|
|
value: (object [155, 19] - [160, 3]
|
|
(shorthand_property_identifier [156, 4] - [156, 13])
|
|
(pair [157, 4] - [157, 40]
|
|
key: (property_identifier [157, 4] - [157, 13])
|
|
value: (new_expression [157, 15] - [157, 40]
|
|
constructor: (identifier [157, 19] - [157, 29])
|
|
arguments: (arguments [157, 29] - [157, 40]
|
|
(identifier [157, 30] - [157, 39]))))
|
|
(pair [158, 4] - [158, 48]
|
|
key: (property_identifier [158, 4] - [158, 17])
|
|
value: (new_expression [158, 19] - [158, 48]
|
|
constructor: (identifier [158, 23] - [158, 33])
|
|
arguments: (arguments [158, 33] - [158, 48]
|
|
(identifier [158, 34] - [158, 47]))))
|
|
(pair [159, 4] - [159, 34]
|
|
key: (property_identifier [159, 4] - [159, 10])
|
|
value: (new_expression [159, 12] - [159, 34]
|
|
constructor: (identifier [159, 16] - [159, 26])
|
|
arguments: (arguments [159, 26] - [159, 34]
|
|
(identifier [159, 27] - [159, 33])))))))
|
|
(comment [162, 2] - [162, 37])
|
|
(expression_statement [163, 2] - [163, 20]
|
|
(call_expression [163, 2] - [163, 19]
|
|
function: (identifier [163, 2] - [163, 11])
|
|
arguments: (arguments [163, 11] - [163, 19]
|
|
(identifier [163, 12] - [163, 18]))))
|
|
(return_statement [165, 2] - [165, 18]
|
|
(identifier [165, 9] - [165, 17])))))
|
|
(comment [168, 0] - [170, 3])
|
|
(export_statement [171, 0] - [202, 2]
|
|
declaration: (lexical_declaration [171, 7] - [202, 2]
|
|
(variable_declarator [171, 11] - [202, 1]
|
|
name: (identifier [171, 11] - [171, 34])
|
|
value: (function_expression [171, 37] - [202, 1]
|
|
name: (identifier [171, 46] - [171, 69])
|
|
parameters: (formal_parameters [171, 69] - [173, 1]
|
|
(required_parameter [172, 2] - [172, 20]
|
|
pattern: (identifier [172, 2] - [172, 12])
|
|
type: (type_annotation [172, 12] - [172, 20]
|
|
(predefined_type [172, 14] - [172, 20]))))
|
|
return_type: (type_annotation [173, 1] - [173, 16]
|
|
(union_type [173, 3] - [173, 16]
|
|
(predefined_type [173, 3] - [173, 9])
|
|
(literal_type [173, 12] - [173, 16]
|
|
(null [173, 12] - [173, 16]))))
|
|
body: (statement_block [173, 17] - [202, 1]
|
|
(if_statement [174, 2] - [176, 3]
|
|
condition: (parenthesized_expression [174, 5] - [174, 52]
|
|
(binary_expression [174, 6] - [174, 51]
|
|
left: (unary_expression [174, 6] - [174, 17]
|
|
argument: (identifier [174, 7] - [174, 17]))
|
|
right: (binary_expression [174, 21] - [174, 51]
|
|
left: (unary_expression [174, 21] - [174, 38]
|
|
argument: (identifier [174, 28] - [174, 38]))
|
|
right: (string [174, 43] - [174, 51]
|
|
(string_fragment [174, 44] - [174, 50])))))
|
|
consequence: (statement_block [174, 53] - [176, 3]
|
|
(return_statement [175, 4] - [175, 16]
|
|
(null [175, 11] - [175, 15]))))
|
|
(try_statement [178, 2] - [199, 3]
|
|
body: (statement_block [178, 6] - [197, 3]
|
|
(lexical_declaration [179, 4] - [179, 49]
|
|
(variable_declarator [179, 10] - [179, 48]
|
|
name: (identifier [179, 10] - [179, 14])
|
|
value: (new_expression [179, 17] - [179, 48]
|
|
constructor: (identifier [179, 21] - [179, 36])
|
|
arguments: (arguments [179, 36] - [179, 48]
|
|
(identifier [179, 37] - [179, 47])))))
|
|
(lexical_declaration [180, 4] - [182, 6]
|
|
(variable_declarator [180, 10] - [182, 5]
|
|
name: (identifier [180, 10] - [180, 22])
|
|
value: (call_expression [180, 25] - [182, 5]
|
|
function: (member_expression [180, 25] - [180, 45]
|
|
object: (member_expression [180, 25] - [180, 40]
|
|
object: (identifier [180, 25] - [180, 29])
|
|
property: (property_identifier [180, 30] - [180, 40]))
|
|
property: (property_identifier [180, 41] - [180, 45]))
|
|
arguments: (arguments [180, 45] - [182, 5]
|
|
(arrow_function [180, 46] - [181, 30]
|
|
parameters: (formal_parameters [180, 46] - [180, 51]
|
|
(required_parameter [180, 47] - [180, 50]
|
|
pattern: (identifier [180, 47] - [180, 50])))
|
|
body: (binary_expression [181, 6] - [181, 30]
|
|
left: (member_expression [181, 6] - [181, 14]
|
|
object: (identifier [181, 6] - [181, 9])
|
|
property: (property_identifier [181, 10] - [181, 14]))
|
|
right: (string [181, 19] - [181, 30]
|
|
(string_fragment [181, 20] - [181, 29]))))))))
|
|
(comment [182, 7] - [182, 34])
|
|
(if_statement [184, 4] - [186, 5]
|
|
condition: (parenthesized_expression [184, 7] - [184, 22]
|
|
(unary_expression [184, 8] - [184, 21]
|
|
argument: (identifier [184, 9] - [184, 21])))
|
|
consequence: (statement_block [184, 23] - [186, 5]
|
|
(return_statement [185, 6] - [185, 18]
|
|
(null [185, 13] - [185, 17]))))
|
|
(lexical_declaration [188, 4] - [188, 76]
|
|
(variable_declarator [188, 10] - [188, 75]
|
|
name: (identifier [188, 10] - [188, 13])
|
|
value: (call_expression [188, 16] - [188, 75]
|
|
function: (member_expression [188, 16] - [188, 31]
|
|
object: (identifier [188, 16] - [188, 25])
|
|
property: (property_identifier [188, 26] - [188, 31]))
|
|
arguments: (arguments [188, 31] - [188, 75]
|
|
(member_expression [188, 32] - [188, 50]
|
|
object: (identifier [188, 32] - [188, 44])
|
|
property: (property_identifier [188, 45] - [188, 50]))
|
|
(identifier [188, 52] - [188, 74])))))
|
|
(for_in_statement [189, 4] - [196, 5]
|
|
left: (identifier [189, 15] - [189, 19])
|
|
right: (identifier [189, 23] - [189, 26])
|
|
body: (statement_block [189, 28] - [196, 5]
|
|
(if_statement [190, 6] - [195, 7]
|
|
condition: (parenthesized_expression [190, 9] - [193, 7]
|
|
(binary_expression [191, 8] - [192, 62]
|
|
left: (member_expression [191, 8] - [191, 38]
|
|
object: (identifier [191, 8] - [191, 12])
|
|
property: (property_identifier [191, 13] - [191, 38]))
|
|
right: (call_expression [192, 8] - [192, 62]
|
|
function: (member_expression [192, 8] - [192, 49]
|
|
object: (member_expression [192, 8] - [192, 38]
|
|
object: (identifier [192, 8] - [192, 12])
|
|
property: (property_identifier [192, 13] - [192, 38]))
|
|
property: (property_identifier [192, 39] - [192, 49]))
|
|
arguments: (arguments [192, 49] - [192, 62]
|
|
(string [192, 50] - [192, 61]
|
|
(string_fragment [192, 51] - [192, 60]))))))
|
|
consequence: (statement_block [193, 8] - [195, 7]
|
|
(return_statement [194, 8] - [194, 46]
|
|
(member_expression [194, 15] - [194, 45]
|
|
object: (identifier [194, 15] - [194, 19])
|
|
property: (property_identifier [194, 20] - [194, 45]))))))))
|
|
handler: (catch_clause [197, 4] - [199, 3]
|
|
parameter: (identifier [197, 11] - [197, 13])
|
|
body: (statement_block [197, 15] - [199, 3]
|
|
(return_statement [198, 4] - [198, 16]
|
|
(null [198, 11] - [198, 15])))))
|
|
(return_statement [201, 2] - [201, 14]
|
|
(null [201, 9] - [201, 13])))))))
|
|
(export_statement [204, 0] - [253, 1]
|
|
declaration: (function_declaration [204, 7] - [253, 1]
|
|
name: (identifier [204, 22] - [204, 39])
|
|
parameters: (formal_parameters [204, 39] - [207, 1]
|
|
(required_parameter [205, 2] - [205, 22]
|
|
pattern: (identifier [205, 2] - [205, 10])
|
|
type: (type_annotation [205, 10] - [205, 22]
|
|
(type_identifier [205, 12] - [205, 22])))
|
|
(required_parameter [206, 2] - [206, 18]
|
|
pattern: (identifier [206, 2] - [206, 6])
|
|
type: (type_annotation [206, 6] - [206, 18]
|
|
(type_identifier [206, 8] - [206, 18]))))
|
|
return_type: (type_annotation [207, 1] - [207, 22]
|
|
(generic_type [207, 3] - [207, 22]
|
|
name: (type_identifier [207, 3] - [207, 10])
|
|
type_arguments: (type_arguments [207, 10] - [207, 22]
|
|
(type_identifier [207, 11] - [207, 21]))))
|
|
body: (statement_block [207, 23] - [253, 1]
|
|
(lexical_declaration [208, 2] - [208, 36]
|
|
(variable_declarator [208, 8] - [208, 35]
|
|
name: (identifier [208, 8] - [208, 14])
|
|
value: (new_expression [208, 17] - [208, 35]
|
|
constructor: (identifier [208, 21] - [208, 31])
|
|
arguments: (arguments [208, 31] - [208, 35]
|
|
(number [208, 32] - [208, 34])))))
|
|
(if_statement [210, 2] - [216, 3]
|
|
condition: (parenthesized_expression [210, 5] - [210, 13]
|
|
(unary_expression [210, 6] - [210, 12]
|
|
argument: (identifier [210, 7] - [210, 12])))
|
|
consequence: (statement_block [210, 14] - [216, 3]
|
|
(expression_statement [211, 4] - [213, 6]
|
|
(call_expression [211, 4] - [213, 5]
|
|
function: (member_expression [211, 4] - [211, 16]
|
|
object: (identifier [211, 4] - [211, 11])
|
|
property: (property_identifier [211, 12] - [211, 16]))
|
|
arguments: (arguments [211, 16] - [213, 5]
|
|
(template_string [212, 6] - [212, 114]
|
|
(string_fragment [212, 7] - [212, 36])
|
|
(template_substitution [212, 36] - [212, 46]
|
|
(identifier [212, 38] - [212, 45]))
|
|
(string_fragment [212, 46] - [212, 113])))))
|
|
(expression_statement [214, 4] - [214, 22]
|
|
(call_expression [214, 4] - [214, 21]
|
|
function: (member_expression [214, 4] - [214, 15]
|
|
object: (identifier [214, 4] - [214, 10])
|
|
property: (property_identifier [214, 11] - [214, 15]))
|
|
arguments: (arguments [214, 15] - [214, 21]
|
|
(number [214, 16] - [214, 20]))))
|
|
(return_statement [215, 4] - [215, 18]
|
|
(identifier [215, 11] - [215, 17]))))
|
|
(lexical_declaration [218, 2] - [218, 24]
|
|
(variable_declarator [218, 8] - [218, 23]
|
|
name: (identifier [218, 8] - [218, 18])
|
|
value: (number [218, 21] - [218, 23])))
|
|
(lexical_declaration [219, 2] - [219, 25]
|
|
(variable_declarator [219, 8] - [219, 24]
|
|
name: (identifier [219, 8] - [219, 16])
|
|
value: (number [219, 19] - [219, 24])))
|
|
(lexical_declaration [221, 2] - [221, 54]
|
|
(variable_declarator [221, 8] - [221, 53]
|
|
name: (identifier [221, 8] - [221, 19])
|
|
value: (call_expression [221, 22] - [221, 53]
|
|
function: (member_expression [221, 22] - [221, 43]
|
|
object: (member_expression [221, 22] - [221, 40]
|
|
object: (identifier [221, 22] - [221, 26])
|
|
property: (property_identifier [221, 27] - [221, 40]))
|
|
property: (property_identifier [221, 41] - [221, 43]))
|
|
arguments: (arguments [221, 43] - [221, 53]
|
|
(identifier [221, 44] - [221, 52])))))
|
|
(lexical_declaration [222, 2] - [222, 46]
|
|
(variable_declarator [222, 8] - [222, 45]
|
|
name: (identifier [222, 8] - [222, 15])
|
|
value: (call_expression [222, 18] - [222, 45]
|
|
function: (member_expression [222, 18] - [222, 39]
|
|
object: (member_expression [222, 18] - [222, 36]
|
|
object: (identifier [222, 18] - [222, 22])
|
|
property: (property_identifier [222, 23] - [222, 36]))
|
|
property: (property_identifier [222, 37] - [222, 39]))
|
|
arguments: (arguments [222, 39] - [222, 45]
|
|
(identifier [222, 40] - [222, 44])))))
|
|
(lexical_declaration [223, 2] - [223, 47]
|
|
(variable_declarator [223, 8] - [223, 46]
|
|
name: (identifier [223, 8] - [223, 14])
|
|
value: (call_expression [223, 17] - [223, 46]
|
|
function: (member_expression [223, 17] - [223, 38]
|
|
object: (member_expression [223, 17] - [223, 35]
|
|
object: (identifier [223, 17] - [223, 21])
|
|
property: (property_identifier [223, 22] - [223, 35]))
|
|
property: (property_identifier [223, 36] - [223, 38]))
|
|
arguments: (arguments [223, 38] - [223, 46]
|
|
(identifier [223, 39] - [223, 45])))))
|
|
(lexical_declaration [225, 2] - [235, 26]
|
|
(variable_declarator [225, 8] - [235, 25]
|
|
name: (identifier [225, 8] - [225, 23])
|
|
value: (as_expression [225, 26] - [235, 25]
|
|
(as_expression [225, 26] - [226, 31]
|
|
(member_expression [225, 26] - [226, 20]
|
|
object: (member_expression [225, 26] - [225, 39]
|
|
object: (identifier [225, 26] - [225, 31])
|
|
property: (property_identifier [225, 32] - [225, 39]))
|
|
property: (property_identifier [226, 5] - [226, 20]))
|
|
(predefined_type [226, 24] - [226, 31]))
|
|
(parenthesized_type [226, 35] - [235, 25]
|
|
(function_type [226, 36] - [235, 24]
|
|
parameters: (formal_parameters [226, 36] - [235, 5]
|
|
(required_parameter [227, 6] - [227, 36]
|
|
pattern: (identifier [227, 6] - [227, 17])
|
|
type: (type_annotation [227, 17] - [227, 36]
|
|
(nested_type_identifier [227, 19] - [227, 36]
|
|
module: (identifier [227, 19] - [227, 23])
|
|
name: (type_identifier [227, 24] - [227, 36]))))
|
|
(required_parameter [228, 6] - [228, 34]
|
|
pattern: (identifier [228, 6] - [228, 17])
|
|
type: (type_annotation [228, 17] - [228, 34]
|
|
(union_type [228, 19] - [228, 34]
|
|
(predefined_type [228, 19] - [228, 25])
|
|
(type_identifier [228, 28] - [228, 34]))))
|
|
(required_parameter [229, 6] - [229, 32]
|
|
pattern: (identifier [229, 6] - [229, 13])
|
|
type: (type_annotation [229, 13] - [229, 32]
|
|
(nested_type_identifier [229, 15] - [229, 32]
|
|
module: (identifier [229, 15] - [229, 19])
|
|
name: (type_identifier [229, 20] - [229, 32]))))
|
|
(required_parameter [230, 6] - [230, 30]
|
|
pattern: (identifier [230, 6] - [230, 13])
|
|
type: (type_annotation [230, 13] - [230, 30]
|
|
(union_type [230, 15] - [230, 30]
|
|
(predefined_type [230, 15] - [230, 21])
|
|
(type_identifier [230, 24] - [230, 30]))))
|
|
(required_parameter [231, 6] - [231, 24]
|
|
pattern: (identifier [231, 6] - [231, 16])
|
|
type: (type_annotation [231, 16] - [231, 24]
|
|
(predefined_type [231, 18] - [231, 24])))
|
|
(required_parameter [232, 6] - [232, 22]
|
|
pattern: (identifier [232, 6] - [232, 14])
|
|
type: (type_annotation [232, 14] - [232, 22]
|
|
(predefined_type [232, 16] - [232, 22])))
|
|
(required_parameter [233, 6] - [233, 31]
|
|
pattern: (identifier [233, 6] - [233, 12])
|
|
type: (type_annotation [233, 12] - [233, 31]
|
|
(nested_type_identifier [233, 14] - [233, 31]
|
|
module: (identifier [233, 14] - [233, 18])
|
|
name: (type_identifier [233, 19] - [233, 31]))))
|
|
(required_parameter [234, 6] - [234, 29]
|
|
pattern: (identifier [234, 6] - [234, 12])
|
|
type: (type_annotation [234, 12] - [234, 29]
|
|
(union_type [234, 14] - [234, 29]
|
|
(predefined_type [234, 14] - [234, 20])
|
|
(type_identifier [234, 23] - [234, 29])))))
|
|
return_type: (generic_type [235, 9] - [235, 24]
|
|
name: (type_identifier [235, 9] - [235, 16])
|
|
type_arguments: (type_arguments [235, 16] - [235, 24]
|
|
(predefined_type [235, 17] - [235, 23]))))))))
|
|
(lexical_declaration [237, 2] - [246, 4]
|
|
(variable_declarator [237, 8] - [246, 3]
|
|
name: (identifier [237, 8] - [237, 11])
|
|
value: (await_expression [237, 14] - [246, 3]
|
|
(call_expression [237, 20] - [246, 3]
|
|
function: (identifier [237, 20] - [237, 35])
|
|
arguments: (arguments [237, 35] - [246, 3]
|
|
(identifier [238, 4] - [238, 15])
|
|
(member_expression [239, 4] - [239, 19]
|
|
object: (identifier [239, 4] - [239, 12])
|
|
property: (property_identifier [239, 13] - [239, 19]))
|
|
(identifier [240, 4] - [240, 11])
|
|
(member_expression [241, 4] - [241, 15]
|
|
object: (identifier [241, 4] - [241, 8])
|
|
property: (property_identifier [241, 9] - [241, 15]))
|
|
(identifier [242, 4] - [242, 14])
|
|
(identifier [243, 4] - [243, 12])
|
|
(identifier [244, 4] - [244, 10])
|
|
(member_expression [245, 4] - [245, 17]
|
|
object: (identifier [245, 4] - [245, 10])
|
|
property: (property_identifier [245, 11] - [245, 17])))))))
|
|
(if_statement [248, 2] - [250, 3]
|
|
condition: (parenthesized_expression [248, 5] - [248, 16]
|
|
(binary_expression [248, 6] - [248, 15]
|
|
left: (identifier [248, 6] - [248, 9])
|
|
right: (number [248, 14] - [248, 15])))
|
|
consequence: (statement_block [248, 17] - [250, 3]
|
|
(throw_statement [249, 4] - [249, 58]
|
|
(new_expression [249, 10] - [249, 57]
|
|
constructor: (identifier [249, 14] - [249, 19])
|
|
arguments: (arguments [249, 19] - [249, 57]
|
|
(template_string [249, 20] - [249, 56]
|
|
(string_fragment [249, 21] - [249, 49])
|
|
(template_substitution [249, 49] - [249, 55]
|
|
(identifier [249, 51] - [249, 54]))))))))
|
|
(return_statement [252, 2] - [252, 16]
|
|
(identifier [252, 9] - [252, 15])))))
|
|
(export_statement [255, 0] - [262, 2]
|
|
declaration: (lexical_declaration [255, 7] - [262, 2]
|
|
(variable_declarator [255, 13] - [262, 1]
|
|
name: (identifier [255, 13] - [255, 25])
|
|
value: (object [255, 28] - [262, 1]
|
|
(method_definition [256, 2] - [258, 3]
|
|
name: (property_identifier [256, 6] - [256, 29])
|
|
parameters: (formal_parameters [256, 29] - [256, 31])
|
|
body: (statement_block [256, 32] - [258, 3]
|
|
(return_statement [257, 4] - [257, 35]
|
|
(identifier [257, 11] - [257, 34]))))
|
|
(method_definition [259, 2] - [261, 3]
|
|
name: (property_identifier [259, 6] - [259, 29])
|
|
parameters: (formal_parameters [259, 29] - [259, 39]
|
|
(required_parameter [259, 30] - [259, 38]
|
|
pattern: (identifier [259, 30] - [259, 33])
|
|
type: (type_annotation [259, 33] - [259, 38]
|
|
(predefined_type [259, 35] - [259, 38]))))
|
|
body: (statement_block [259, 40] - [261, 3]
|
|
(expression_statement [260, 4] - [260, 34]
|
|
(assignment_expression [260, 4] - [260, 33]
|
|
left: (identifier [260, 4] - [260, 27])
|
|
right: (identifier [260, 30] - [260, 33]))))))))))
|