425 lines
25 KiB
Plaintext
425 lines
25 KiB
Plaintext
(program [0, 0] - [98, 0]
|
|
(comment [0, 0] - [2, 3])
|
|
(export_statement [3, 0] - [20, 1]
|
|
declaration: (function_declaration [3, 7] - [20, 1]
|
|
name: (identifier [3, 16] - [3, 30])
|
|
parameters: (formal_parameters [3, 30] - [6, 1]
|
|
(required_parameter [4, 2] - [4, 21]
|
|
pattern: (identifier [4, 2] - [4, 13])
|
|
type: (type_annotation [4, 13] - [4, 21]
|
|
(predefined_type [4, 15] - [4, 21])))
|
|
(optional_parameter [5, 2] - [5, 24]
|
|
pattern: (identifier [5, 2] - [5, 13])
|
|
type: (type_annotation [5, 14] - [5, 24]
|
|
(array_type [5, 16] - [5, 24]
|
|
(predefined_type [5, 16] - [5, 22])))))
|
|
return_type: (type_annotation [6, 1] - [6, 10]
|
|
(predefined_type [6, 3] - [6, 10]))
|
|
body: (statement_block [6, 11] - [20, 1]
|
|
(if_statement [7, 2] - [7, 61]
|
|
condition: (parenthesized_expression [7, 5] - [7, 47]
|
|
(binary_expression [7, 6] - [7, 46]
|
|
left: (unary_expression [7, 6] - [7, 18]
|
|
argument: (identifier [7, 7] - [7, 18]))
|
|
right: (binary_expression [7, 22] - [7, 46]
|
|
left: (member_expression [7, 22] - [7, 40]
|
|
object: (identifier [7, 22] - [7, 33])
|
|
property: (property_identifier [7, 34] - [7, 40]))
|
|
right: (number [7, 45] - [7, 46]))))
|
|
consequence: (return_statement [7, 48] - [7, 61]
|
|
(false [7, 55] - [7, 60])))
|
|
(for_in_statement [9, 2] - [17, 3]
|
|
left: (identifier [9, 13] - [9, 20])
|
|
right: (identifier [9, 24] - [9, 35])
|
|
body: (statement_block [9, 37] - [17, 3]
|
|
(if_statement [10, 4] - [10, 45]
|
|
condition: (parenthesized_expression [10, 7] - [10, 32]
|
|
(binary_expression [10, 8] - [10, 31]
|
|
left: (identifier [10, 8] - [10, 15])
|
|
right: (identifier [10, 20] - [10, 31])))
|
|
consequence: (return_statement [10, 33] - [10, 45]
|
|
(true [10, 40] - [10, 44])))
|
|
(if_statement [11, 4] - [16, 5]
|
|
condition: (parenthesized_expression [11, 7] - [11, 31]
|
|
(call_expression [11, 8] - [11, 30]
|
|
function: (member_expression [11, 8] - [11, 24]
|
|
object: (identifier [11, 8] - [11, 15])
|
|
property: (property_identifier [11, 16] - [11, 24]))
|
|
arguments: (arguments [11, 24] - [11, 30]
|
|
(string [11, 25] - [11, 29]
|
|
(string_fragment [11, 26] - [11, 28])))))
|
|
consequence: (statement_block [11, 32] - [16, 5]
|
|
(lexical_declaration [12, 6] - [12, 42]
|
|
(variable_declarator [12, 12] - [12, 41]
|
|
name: (identifier [12, 12] - [12, 18])
|
|
value: (call_expression [12, 21] - [12, 41]
|
|
function: (member_expression [12, 21] - [12, 34]
|
|
object: (identifier [12, 21] - [12, 28])
|
|
property: (property_identifier [12, 29] - [12, 34]))
|
|
arguments: (arguments [12, 34] - [12, 41]
|
|
(number [12, 35] - [12, 36])
|
|
(unary_expression [12, 38] - [12, 40]
|
|
argument: (number [12, 39] - [12, 40]))))))
|
|
(if_statement [13, 6] - [15, 7]
|
|
condition: (parenthesized_expression [13, 9] - [13, 73]
|
|
(binary_expression [13, 10] - [13, 72]
|
|
left: (binary_expression [13, 10] - [13, 32]
|
|
left: (identifier [13, 10] - [13, 21])
|
|
right: (identifier [13, 26] - [13, 32]))
|
|
right: (call_expression [13, 36] - [13, 72]
|
|
function: (member_expression [13, 36] - [13, 58]
|
|
object: (identifier [13, 36] - [13, 47])
|
|
property: (property_identifier [13, 48] - [13, 58]))
|
|
arguments: (arguments [13, 58] - [13, 72]
|
|
(binary_expression [13, 59] - [13, 71]
|
|
left: (identifier [13, 59] - [13, 65])
|
|
right: (string [13, 68] - [13, 71]
|
|
(string_fragment [13, 69] - [13, 70])))))))
|
|
consequence: (statement_block [13, 74] - [15, 7]
|
|
(return_statement [14, 8] - [14, 20]
|
|
(true [14, 15] - [14, 19]))))))))
|
|
(return_statement [19, 2] - [19, 15]
|
|
(false [19, 9] - [19, 14])))))
|
|
(comment [22, 0] - [24, 3])
|
|
(export_statement [25, 0] - [65, 1]
|
|
declaration: (function_declaration [25, 7] - [65, 1]
|
|
name: (identifier [25, 16] - [25, 27])
|
|
parameters: (formal_parameters [25, 27] - [28, 1]
|
|
(required_parameter [26, 2] - [26, 18]
|
|
pattern: (identifier [26, 2] - [26, 10])
|
|
type: (type_annotation [26, 10] - [26, 18]
|
|
(predefined_type [26, 12] - [26, 18])))
|
|
(optional_parameter [27, 2] - [27, 25]
|
|
pattern: (identifier [27, 2] - [27, 14])
|
|
type: (type_annotation [27, 15] - [27, 25]
|
|
(array_type [27, 17] - [27, 25]
|
|
(predefined_type [27, 17] - [27, 23])))))
|
|
return_type: (type_annotation [28, 1] - [28, 10]
|
|
(predefined_type [28, 3] - [28, 10]))
|
|
body: (statement_block [28, 11] - [65, 1]
|
|
(if_statement [29, 2] - [29, 63]
|
|
condition: (parenthesized_expression [29, 5] - [29, 49]
|
|
(binary_expression [29, 6] - [29, 48]
|
|
left: (unary_expression [29, 6] - [29, 19]
|
|
argument: (identifier [29, 7] - [29, 19]))
|
|
right: (binary_expression [29, 23] - [29, 48]
|
|
left: (member_expression [29, 23] - [29, 42]
|
|
object: (identifier [29, 23] - [29, 35])
|
|
property: (property_identifier [29, 36] - [29, 42]))
|
|
right: (number [29, 47] - [29, 48]))))
|
|
consequence: (return_statement [29, 50] - [29, 63]
|
|
(false [29, 57] - [29, 62])))
|
|
(lexical_declaration [31, 2] - [36, 4]
|
|
(variable_declarator [31, 8] - [36, 3]
|
|
name: (identifier [31, 8] - [31, 16])
|
|
value: (arrow_function [31, 19] - [36, 3]
|
|
parameters: (formal_parameters [31, 19] - [31, 31]
|
|
(required_parameter [31, 20] - [31, 30]
|
|
pattern: (identifier [31, 20] - [31, 22])
|
|
type: (type_annotation [31, 22] - [31, 30]
|
|
(predefined_type [31, 24] - [31, 30]))))
|
|
body: (statement_block [31, 35] - [36, 3]
|
|
(lexical_declaration [32, 4] - [32, 32]
|
|
(variable_declarator [32, 10] - [32, 31]
|
|
name: (identifier [32, 10] - [32, 15])
|
|
value: (call_expression [32, 18] - [32, 31]
|
|
function: (member_expression [32, 18] - [32, 26]
|
|
object: (identifier [32, 18] - [32, 20])
|
|
property: (property_identifier [32, 21] - [32, 26]))
|
|
arguments: (arguments [32, 26] - [32, 31]
|
|
(string [32, 27] - [32, 30]
|
|
(string_fragment [32, 28] - [32, 29]))))))
|
|
(if_statement [33, 4] - [33, 40]
|
|
condition: (parenthesized_expression [33, 7] - [33, 27]
|
|
(binary_expression [33, 8] - [33, 26]
|
|
left: (member_expression [33, 8] - [33, 20]
|
|
object: (identifier [33, 8] - [33, 13])
|
|
property: (property_identifier [33, 14] - [33, 20]))
|
|
right: (number [33, 25] - [33, 26])))
|
|
consequence: (return_statement [33, 28] - [33, 40]
|
|
(null [33, 35] - [33, 39])))
|
|
(return_statement [34, 4] - [35, 8]
|
|
(binary_expression [34, 11] - [35, 7]
|
|
left: (call_expression [34, 11] - [34, 76]
|
|
function: (member_expression [34, 11] - [34, 23]
|
|
object: (identifier [34, 11] - [34, 16])
|
|
property: (property_identifier [34, 17] - [34, 23]))
|
|
arguments: (arguments [34, 23] - [34, 76]
|
|
(arrow_function [34, 24] - [34, 72]
|
|
parameters: (formal_parameters [34, 24] - [34, 36]
|
|
(required_parameter [34, 25] - [34, 28]
|
|
pattern: (identifier [34, 25] - [34, 28]))
|
|
(required_parameter [34, 30] - [34, 35]
|
|
pattern: (identifier [34, 30] - [34, 35])))
|
|
body: (binary_expression [34, 40] - [34, 72]
|
|
left: (parenthesized_expression [34, 40] - [34, 50]
|
|
(binary_expression [34, 41] - [34, 49]
|
|
left: (identifier [34, 41] - [34, 44])
|
|
right: (number [34, 48] - [34, 49])))
|
|
right: (call_expression [34, 53] - [34, 72]
|
|
function: (identifier [34, 53] - [34, 61])
|
|
arguments: (arguments [34, 61] - [34, 72]
|
|
(identifier [34, 62] - [34, 67])
|
|
(number [34, 69] - [34, 71])))))
|
|
(number [34, 74] - [34, 75])))
|
|
right: (number [35, 6] - [35, 7])))))))
|
|
(lexical_declaration [38, 2] - [38, 50]
|
|
(variable_declarator [38, 8] - [38, 49]
|
|
name: (identifier [38, 8] - [38, 17])
|
|
value: (call_expression [38, 20] - [38, 49]
|
|
function: (member_expression [38, 20] - [38, 47]
|
|
object: (subscript_expression [38, 20] - [38, 42]
|
|
object: (call_expression [38, 20] - [38, 39]
|
|
function: (member_expression [38, 20] - [38, 34]
|
|
object: (identifier [38, 20] - [38, 28])
|
|
property: (property_identifier [38, 29] - [38, 34]))
|
|
arguments: (arguments [38, 34] - [38, 39]
|
|
(string [38, 35] - [38, 38]
|
|
(string_fragment [38, 36] - [38, 37]))))
|
|
index: (number [38, 40] - [38, 41]))
|
|
property: (property_identifier [38, 43] - [38, 47]))
|
|
arguments: (arguments [38, 47] - [38, 49]))))
|
|
(lexical_declaration [39, 2] - [39, 36]
|
|
(variable_declarator [39, 8] - [39, 35]
|
|
name: (identifier [39, 8] - [39, 13])
|
|
value: (call_expression [39, 16] - [39, 35]
|
|
function: (identifier [39, 16] - [39, 24])
|
|
arguments: (arguments [39, 24] - [39, 35]
|
|
(identifier [39, 25] - [39, 34])))))
|
|
(for_in_statement [41, 2] - [62, 3]
|
|
left: (identifier [41, 13] - [41, 17])
|
|
right: (identifier [41, 21] - [41, 33])
|
|
body: (statement_block [41, 35] - [62, 3]
|
|
(lexical_declaration [42, 4] - [42, 46]
|
|
(variable_declarator [42, 10] - [42, 45]
|
|
name: (array_pattern [42, 10] - [42, 27]
|
|
(identifier [42, 11] - [42, 17])
|
|
(identifier [42, 19] - [42, 26]))
|
|
value: (call_expression [42, 30] - [42, 45]
|
|
function: (member_expression [42, 30] - [42, 40]
|
|
object: (identifier [42, 30] - [42, 34])
|
|
property: (property_identifier [42, 35] - [42, 40]))
|
|
arguments: (arguments [42, 40] - [42, 45]
|
|
(string [42, 41] - [42, 44]
|
|
(string_fragment [42, 42] - [42, 43]))))))
|
|
(if_statement [43, 4] - [46, 5]
|
|
condition: (parenthesized_expression [43, 7] - [43, 17]
|
|
(unary_expression [43, 8] - [43, 16]
|
|
argument: (identifier [43, 9] - [43, 16])))
|
|
consequence: (statement_block [43, 18] - [46, 5]
|
|
(if_statement [44, 6] - [44, 44]
|
|
condition: (parenthesized_expression [44, 9] - [44, 31]
|
|
(binary_expression [44, 10] - [44, 30]
|
|
left: (identifier [44, 10] - [44, 16])
|
|
right: (identifier [44, 21] - [44, 30])))
|
|
consequence: (return_statement [44, 32] - [44, 44]
|
|
(true [44, 39] - [44, 43])))
|
|
(continue_statement [45, 6] - [45, 15])))
|
|
(if_statement [48, 4] - [61, 5]
|
|
condition: (parenthesized_expression [48, 7] - [48, 47]
|
|
(binary_expression [48, 8] - [48, 46]
|
|
left: (binary_expression [48, 8] - [48, 22]
|
|
left: (identifier [48, 8] - [48, 13])
|
|
right: (null [48, 18] - [48, 22]))
|
|
right: (call_expression [48, 26] - [48, 46]
|
|
function: (member_expression [48, 26] - [48, 41]
|
|
object: (identifier [48, 26] - [48, 32])
|
|
property: (property_identifier [48, 33] - [48, 41]))
|
|
arguments: (arguments [48, 41] - [48, 46]
|
|
(string [48, 42] - [48, 45]
|
|
(string_fragment [48, 43] - [48, 44]))))))
|
|
consequence: (statement_block [48, 48] - [59, 5]
|
|
(lexical_declaration [49, 6] - [49, 41]
|
|
(variable_declarator [49, 12] - [49, 40]
|
|
name: (identifier [49, 12] - [49, 21])
|
|
value: (call_expression [49, 24] - [49, 40]
|
|
function: (identifier [49, 24] - [49, 32])
|
|
arguments: (arguments [49, 32] - [49, 40]
|
|
(identifier [49, 33] - [49, 39])))))
|
|
(if_statement [50, 6] - [58, 7]
|
|
condition: (parenthesized_expression [50, 9] - [50, 29]
|
|
(binary_expression [50, 10] - [50, 28]
|
|
left: (identifier [50, 10] - [50, 19])
|
|
right: (null [50, 24] - [50, 28])))
|
|
consequence: (statement_block [50, 30] - [58, 7]
|
|
(lexical_declaration [51, 8] - [51, 47]
|
|
(variable_declarator [51, 14] - [51, 46]
|
|
name: (identifier [51, 14] - [51, 22])
|
|
value: (call_expression [51, 25] - [51, 46]
|
|
function: (identifier [51, 25] - [51, 33])
|
|
arguments: (arguments [51, 33] - [51, 46]
|
|
(identifier [51, 34] - [51, 41])
|
|
(number [51, 43] - [51, 45])))))
|
|
(lexical_declaration [52, 8] - [54, 52]
|
|
(variable_declarator [52, 14] - [54, 51]
|
|
name: (identifier [52, 14] - [52, 18])
|
|
value: (ternary_expression [52, 21] - [54, 51]
|
|
condition: (binary_expression [52, 21] - [52, 35]
|
|
left: (identifier [52, 21] - [52, 29])
|
|
right: (number [52, 34] - [52, 35]))
|
|
consequence: (number [53, 12] - [53, 13])
|
|
alternative: (parenthesized_expression [54, 12] - [54, 51]
|
|
(binary_expression [54, 13] - [54, 50]
|
|
left: (parenthesized_expression [54, 13] - [54, 44]
|
|
(binary_expression [54, 14] - [54, 43]
|
|
left: (number [54, 14] - [54, 24])
|
|
right: (parenthesized_expression [54, 28] - [54, 43]
|
|
(binary_expression [54, 29] - [54, 42]
|
|
left: (number [54, 29] - [54, 31])
|
|
right: (identifier [54, 34] - [54, 42])))))
|
|
right: (number [54, 49] - [54, 50]))))))
|
|
(if_statement [55, 8] - [57, 9]
|
|
condition: (parenthesized_expression [55, 11] - [55, 50]
|
|
(binary_expression [55, 12] - [55, 49]
|
|
left: (parenthesized_expression [55, 12] - [55, 26]
|
|
(binary_expression [55, 13] - [55, 25]
|
|
left: (identifier [55, 13] - [55, 18])
|
|
right: (identifier [55, 21] - [55, 25])))
|
|
right: (parenthesized_expression [55, 31] - [55, 49]
|
|
(binary_expression [55, 32] - [55, 48]
|
|
left: (identifier [55, 32] - [55, 41])
|
|
right: (identifier [55, 44] - [55, 48])))))
|
|
consequence: (statement_block [55, 51] - [57, 9]
|
|
(return_statement [56, 10] - [56, 22]
|
|
(true [56, 17] - [56, 21])))))))
|
|
alternative: (else_clause [59, 6] - [61, 5]
|
|
(if_statement [59, 11] - [61, 5]
|
|
condition: (parenthesized_expression [59, 14] - [59, 35]
|
|
(binary_expression [59, 15] - [59, 34]
|
|
left: (identifier [59, 15] - [59, 21])
|
|
right: (identifier [59, 26] - [59, 34])))
|
|
consequence: (statement_block [59, 36] - [61, 5]
|
|
(return_statement [60, 6] - [60, 18]
|
|
(true [60, 13] - [60, 17]))))))))
|
|
(return_statement [64, 2] - [64, 15]
|
|
(false [64, 9] - [64, 14])))))
|
|
(comment [67, 0] - [69, 3])
|
|
(export_statement [70, 0] - [97, 1]
|
|
declaration: (function_declaration [70, 7] - [97, 1]
|
|
name: (identifier [70, 16] - [70, 33])
|
|
parameters: (formal_parameters [70, 33] - [73, 1]
|
|
(required_parameter [71, 2] - [71, 16]
|
|
pattern: (identifier [71, 2] - [71, 8])
|
|
type: (type_annotation [71, 8] - [71, 16]
|
|
(predefined_type [71, 10] - [71, 16])))
|
|
(optional_parameter [72, 2] - [72, 23]
|
|
pattern: (identifier [72, 2] - [72, 14])
|
|
type: (type_annotation [72, 15] - [72, 23]
|
|
(predefined_type [72, 17] - [72, 23]))))
|
|
return_type: (type_annotation [73, 1] - [73, 10]
|
|
(predefined_type [73, 3] - [73, 10]))
|
|
body: (statement_block [73, 11] - [97, 1]
|
|
(if_statement [74, 2] - [74, 28]
|
|
condition: (parenthesized_expression [74, 5] - [74, 14]
|
|
(unary_expression [74, 6] - [74, 13]
|
|
argument: (identifier [74, 7] - [74, 13])))
|
|
consequence: (return_statement [74, 15] - [74, 28]
|
|
(false [74, 22] - [74, 27])))
|
|
(if_statement [75, 2] - [77, 3]
|
|
condition: (parenthesized_expression [75, 5] - [75, 57]
|
|
(binary_expression [75, 6] - [75, 56]
|
|
left: (call_expression [75, 6] - [75, 28]
|
|
function: (member_expression [75, 6] - [75, 23]
|
|
object: (identifier [75, 6] - [75, 12])
|
|
property: (property_identifier [75, 13] - [75, 23]))
|
|
arguments: (arguments [75, 23] - [75, 28]
|
|
(string [75, 24] - [75, 27]
|
|
(string_fragment [75, 25] - [75, 26]))))
|
|
right: (unary_expression [75, 32] - [75, 56]
|
|
argument: (call_expression [75, 33] - [75, 56]
|
|
function: (member_expression [75, 33] - [75, 50]
|
|
object: (identifier [75, 33] - [75, 39])
|
|
property: (property_identifier [75, 40] - [75, 50]))
|
|
arguments: (arguments [75, 50] - [75, 56]
|
|
(string [75, 51] - [75, 55]
|
|
(string_fragment [75, 52] - [75, 54])))))))
|
|
consequence: (statement_block [75, 58] - [77, 3]
|
|
(return_statement [76, 4] - [76, 16]
|
|
(true [76, 11] - [76, 15]))))
|
|
(try_statement [78, 2] - [95, 3]
|
|
body: (statement_block [78, 6] - [93, 3]
|
|
(lexical_declaration [79, 4] - [79, 35]
|
|
(variable_declarator [79, 10] - [79, 34]
|
|
name: (identifier [79, 10] - [79, 16])
|
|
value: (new_expression [79, 19] - [79, 34]
|
|
constructor: (identifier [79, 23] - [79, 26])
|
|
arguments: (arguments [79, 26] - [79, 34]
|
|
(identifier [79, 27] - [79, 33])))))
|
|
(lexical_declaration [80, 4] - [80, 33]
|
|
(variable_declarator [80, 10] - [80, 32]
|
|
name: (identifier [80, 10] - [80, 14])
|
|
value: (member_expression [80, 17] - [80, 32]
|
|
object: (identifier [80, 17] - [80, 23])
|
|
property: (property_identifier [80, 24] - [80, 32]))))
|
|
(lexical_declaration [81, 4] - [81, 69]
|
|
(variable_declarator [81, 10] - [81, 68]
|
|
name: (identifier [81, 10] - [81, 14])
|
|
value: (binary_expression [81, 17] - [81, 68]
|
|
left: (binary_expression [81, 17] - [81, 54]
|
|
left: (identifier [81, 17] - [81, 29])
|
|
right: (call_expression [81, 33] - [81, 54]
|
|
function: (member_expression [81, 33] - [81, 45]
|
|
object: (member_expression [81, 33] - [81, 41]
|
|
object: (identifier [81, 33] - [81, 37])
|
|
property: (property_identifier [81, 38] - [81, 41]))
|
|
property: (property_identifier [81, 42] - [81, 45]))
|
|
arguments: (arguments [81, 45] - [81, 54]
|
|
(string [81, 46] - [81, 53]
|
|
(string_fragment [81, 47] - [81, 52])))))
|
|
right: (string [81, 58] - [81, 68]
|
|
(string_fragment [81, 59] - [81, 67])))))
|
|
(lexical_declaration [82, 4] - [82, 46]
|
|
(variable_declarator [82, 10] - [82, 45]
|
|
name: (identifier [82, 10] - [82, 19])
|
|
value: (call_expression [82, 22] - [82, 45]
|
|
function: (member_expression [82, 22] - [82, 34]
|
|
object: (identifier [82, 22] - [82, 26])
|
|
property: (property_identifier [82, 27] - [82, 34]))
|
|
arguments: (arguments [82, 34] - [82, 45]
|
|
(regex [82, 35] - [82, 40]
|
|
pattern: (regex_pattern [82, 36] - [82, 39]))
|
|
(string [82, 42] - [82, 44])))))
|
|
(if_statement [84, 4] - [92, 5]
|
|
condition: (parenthesized_expression [84, 7] - [90, 5]
|
|
(binary_expression [85, 6] - [89, 36]
|
|
left: (binary_expression [85, 6] - [88, 24]
|
|
left: (binary_expression [85, 6] - [87, 32]
|
|
left: (binary_expression [85, 6] - [86, 25]
|
|
left: (binary_expression [85, 6] - [85, 26]
|
|
left: (identifier [85, 6] - [85, 10])
|
|
right: (string [85, 15] - [85, 26]
|
|
(string_fragment [85, 16] - [85, 25])))
|
|
right: (binary_expression [86, 6] - [86, 25]
|
|
left: (identifier [86, 6] - [86, 10])
|
|
right: (string [86, 15] - [86, 25]
|
|
(string_fragment [86, 16] - [86, 24]))))
|
|
right: (call_expression [87, 6] - [87, 32]
|
|
function: (member_expression [87, 6] - [87, 19]
|
|
object: (identifier [87, 6] - [87, 10])
|
|
property: (property_identifier [87, 11] - [87, 19]))
|
|
arguments: (arguments [87, 19] - [87, 32]
|
|
(string [87, 20] - [87, 31]
|
|
(string_fragment [87, 21] - [87, 30])))))
|
|
right: (binary_expression [88, 6] - [88, 24]
|
|
left: (identifier [88, 6] - [88, 10])
|
|
right: (identifier [88, 15] - [88, 24])))
|
|
right: (call_expression [89, 6] - [89, 36]
|
|
function: (member_expression [89, 6] - [89, 19]
|
|
object: (identifier [89, 6] - [89, 10])
|
|
property: (property_identifier [89, 11] - [89, 19]))
|
|
arguments: (arguments [89, 19] - [89, 36]
|
|
(template_string [89, 20] - [89, 35]
|
|
(string_fragment [89, 21] - [89, 22])
|
|
(template_substitution [89, 22] - [89, 34]
|
|
(identifier [89, 24] - [89, 33])))))))
|
|
consequence: (statement_block [90, 6] - [92, 5]
|
|
(return_statement [91, 6] - [91, 18]
|
|
(true [91, 13] - [91, 17])))))
|
|
handler: (catch_clause [93, 4] - [95, 3]
|
|
parameter: (identifier [93, 11] - [93, 13])
|
|
body: (statement_block [93, 15] - [95, 3]
|
|
(return_statement [94, 4] - [94, 17]
|
|
(false [94, 11] - [94, 16])))))
|
|
(return_statement [96, 2] - [96, 15]
|
|
(false [96, 9] - [96, 14]))))))
|