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