(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]))))))