(program [0, 0] - [307, 0]
  (import_statement [0, 0] - [0, 40]
    (import_clause [0, 7] - [0, 15]
      (named_imports [0, 7] - [0, 15]
        (import_specifier [0, 9] - [0, 13]
          name: (identifier [0, 9] - [0, 13]))))
    source: (string [0, 21] - [0, 39]
      (string_fragment [0, 22] - [0, 38])))
  (import_statement [2, 0] - [2, 46]
    (import_clause [2, 7] - [2, 17]
      (named_imports [2, 7] - [2, 17]
        (import_specifier [2, 9] - [2, 15]
          name: (identifier [2, 9] - [2, 15]))))
    source: (string [2, 23] - [2, 45]
      (string_fragment [2, 24] - [2, 44])))
  (import_statement [3, 0] - [3, 51]
    (import_clause [3, 7] - [3, 23]
      (named_imports [3, 7] - [3, 23]
        (import_specifier [3, 9] - [3, 21]
          name: (identifier [3, 9] - [3, 21]))))
    source: (string [3, 29] - [3, 50]
      (string_fragment [3, 30] - [3, 49])))
  (import_statement [4, 0] - [4, 55]
    (import_clause [4, 7] - [4, 22]
      (named_imports [4, 7] - [4, 22]
        (import_specifier [4, 9] - [4, 20]
          name: (identifier [4, 9] - [4, 20]))))
    source: (string [4, 28] - [4, 54]
      (string_fragment [4, 29] - [4, 53])))
  (import_statement [5, 0] - [5, 71]
    (import_clause [5, 7] - [5, 41]
      (named_imports [5, 7] - [5, 41]
        (import_specifier [5, 9] - [5, 29]
          name: (identifier [5, 9] - [5, 29]))
        (import_specifier [5, 31] - [5, 39]
          name: (identifier [5, 31] - [5, 39]))))
    source: (string [5, 47] - [5, 70]
      (string_fragment [5, 48] - [5, 69])))
  (import_statement [7, 0] - [17, 22]
    (import_clause [7, 7] - [17, 1]
      (named_imports [7, 7] - [17, 1]
        (import_specifier [8, 2] - [8, 17]
          name: (identifier [8, 2] - [8, 17]))
        (import_specifier [9, 2] - [9, 21]
          name: (identifier [9, 2] - [9, 21]))
        (import_specifier [10, 2] - [10, 19]
          name: (identifier [10, 2] - [10, 19]))
        (import_specifier [11, 2] - [11, 16]
          name: (identifier [11, 2] - [11, 16]))
        (import_specifier [12, 2] - [12, 25]
          name: (identifier [12, 2] - [12, 25]))
        (import_specifier [13, 2] - [13, 30]
          name: (identifier [13, 2] - [13, 30]))
        (import_specifier [14, 2] - [14, 15]
          name: (identifier [14, 2] - [14, 15]))
        (import_specifier [15, 2] - [15, 18]
          name: (identifier [15, 2] - [15, 18]))
        (import_specifier [16, 2] - [16, 21]
          name: (identifier [16, 2] - [16, 21]))))
    source: (string [17, 7] - [17, 21]
      (string_fragment [17, 8] - [17, 20])))
  (export_statement [19, 0] - [19, 47]
    declaration: (lexical_declaration [19, 7] - [19, 47]
      (variable_declarator [19, 13] - [19, 46]
        name: (identifier [19, 13] - [19, 33])
        value: (new_expression [19, 36] - [19, 46]
          constructor: (identifier [19, 40] - [19, 44])
          arguments: (arguments [19, 44] - [19, 46])))))
  (comment [21, 0] - [21, 60])
  (comment [22, 0] - [22, 32])
  (comment [23, 0] - [23, 60])
  (expression_statement [24, 0] - [30, 3]
    (call_expression [24, 0] - [30, 2]
      function: (member_expression [24, 0] - [24, 24]
        object: (identifier [24, 0] - [24, 20])
        property: (property_identifier [24, 21] - [24, 24]))
      arguments: (arguments [24, 24] - [30, 2]
        (string [24, 25] - [24, 40]
          (string_fragment [24, 26] - [24, 39]))
        (arrow_function [24, 42] - [30, 1]
          parameters: (formal_parameters [24, 48] - [24, 51]
            (required_parameter [24, 49] - [24, 50]
              pattern: (identifier [24, 49] - [24, 50])))
          body: (statement_block [24, 55] - [30, 1]
            (lexical_declaration [25, 2] - [25, 45]
              (variable_declarator [25, 8] - [25, 44]
                name: (identifier [25, 8] - [25, 12])
                value: (await_expression [25, 15] - [25, 44]
                  (call_expression [25, 21] - [25, 44]
                    function: (identifier [25, 21] - [25, 41])
                    arguments: (arguments [25, 41] - [25, 44]
                      (identifier [25, 42] - [25, 43]))))))
            (if_statement [26, 2] - [26, 59]
              condition: (parenthesized_expression [26, 5] - [26, 12]
                (unary_expression [26, 6] - [26, 11]
                  argument: (identifier [26, 7] - [26, 11])))
              consequence: (return_statement [26, 13] - [26, 59]
                (call_expression [26, 20] - [26, 58]
                  function: (member_expression [26, 20] - [26, 26]
                    object: (identifier [26, 20] - [26, 21])
                    property: (property_identifier [26, 22] - [26, 26]))
                  arguments: (arguments [26, 26] - [26, 58]
                    (object [26, 27] - [26, 52]
                      (pair [26, 29] - [26, 50]
                        key: (property_identifier [26, 29] - [26, 34])
                        value: (string [26, 36] - [26, 50]
                          (string_fragment [26, 37] - [26, 49]))))
                    (number [26, 54] - [26, 57])))))
            (lexical_declaration [28, 2] - [28, 56]
              (variable_declarator [28, 8] - [28, 55]
                name: (identifier [28, 8] - [28, 16])
                value: (await_expression [28, 19] - [28, 55]
                  (call_expression [28, 25] - [28, 55]
                    function: (identifier [28, 25] - [28, 42])
                    arguments: (arguments [28, 42] - [28, 55]
                      (member_expression [28, 43] - [28, 54]
                        object: (identifier [28, 43] - [28, 47])
                        property: (property_identifier [28, 48] - [28, 54])))))))
            (return_statement [29, 2] - [29, 64]
              (call_expression [29, 9] - [29, 63]
                function: (member_expression [29, 9] - [29, 15]
                  object: (identifier [29, 9] - [29, 10])
                  property: (property_identifier [29, 11] - [29, 15]))
                arguments: (arguments [29, 15] - [29, 63]
                  (object [29, 16] - [29, 62]
                    (shorthand_property_identifier [29, 18] - [29, 26])
                    (pair [29, 28] - [29, 60]
                      key: (property_identifier [29, 28] - [29, 44])
                      value: (member_expression [29, 46] - [29, 60]
                        object: (identifier [29, 46] - [29, 50])
                        property: (property_identifier [29, 51] - [29, 60]))))))))))))
  (comment [32, 0] - [32, 60])
  (comment [33, 0] - [33, 65])
  (comment [34, 0] - [34, 60])
  (expression_statement [35, 0] - [124, 3]
    (call_expression [35, 0] - [124, 2]
      function: (member_expression [35, 0] - [35, 25]
        object: (identifier [35, 0] - [35, 20])
        property: (property_identifier [35, 21] - [35, 25]))
      arguments: (arguments [35, 25] - [124, 2]
        (string [35, 26] - [35, 50]
          (string_fragment [35, 27] - [35, 49]))
        (arrow_function [35, 52] - [124, 1]
          parameters: (formal_parameters [35, 58] - [35, 61]
            (required_parameter [35, 59] - [35, 60]
              pattern: (identifier [35, 59] - [35, 60])))
          body: (statement_block [35, 65] - [124, 1]
            (lexical_declaration [36, 2] - [36, 45]
              (variable_declarator [36, 8] - [36, 44]
                name: (identifier [36, 8] - [36, 12])
                value: (await_expression [36, 15] - [36, 44]
                  (call_expression [36, 21] - [36, 44]
                    function: (identifier [36, 21] - [36, 41])
                    arguments: (arguments [36, 41] - [36, 44]
                      (identifier [36, 42] - [36, 43]))))))
            (if_statement [37, 2] - [37, 59]
              condition: (parenthesized_expression [37, 5] - [37, 12]
                (unary_expression [37, 6] - [37, 11]
                  argument: (identifier [37, 7] - [37, 11])))
              consequence: (return_statement [37, 13] - [37, 59]
                (call_expression [37, 20] - [37, 58]
                  function: (member_expression [37, 20] - [37, 26]
                    object: (identifier [37, 20] - [37, 21])
                    property: (property_identifier [37, 22] - [37, 26]))
                  arguments: (arguments [37, 26] - [37, 58]
                    (object [37, 27] - [37, 52]
                      (pair [37, 29] - [37, 50]
                        key: (property_identifier [37, 29] - [37, 34])
                        value: (string [37, 36] - [37, 50]
                          (string_fragment [37, 37] - [37, 49]))))
                    (number [37, 54] - [37, 57])))))
            (if_statement [39, 2] - [43, 3]
              condition: (parenthesized_expression [39, 5] - [39, 19]
                (member_expression [39, 6] - [39, 18]
                  object: (identifier [39, 6] - [39, 10])
                  property: (property_identifier [39, 11] - [39, 18])))
              consequence: (statement_block [39, 20] - [43, 3]
                (if_statement [40, 4] - [42, 5]
                  condition: (parenthesized_expression [40, 7] - [40, 57]
                    (binary_expression [40, 8] - [40, 56]
                      left: (unary_expression [40, 8] - [40, 32]
                        argument: (call_expression [40, 9] - [40, 32]
                          function: (identifier [40, 9] - [40, 17])
                          arguments: (arguments [40, 17] - [40, 32]
                            (identifier [40, 18] - [40, 22])
                            (string [40, 24] - [40, 31]
                              (string_fragment [40, 25] - [40, 30])))))
                      right: (unary_expression [40, 36] - [40, 56]
                        argument: (call_expression [40, 37] - [40, 56]
                          function: (identifier [40, 37] - [40, 45])
                          arguments: (arguments [40, 45] - [40, 56]
                            (identifier [40, 46] - [40, 50])
                            (string [40, 52] - [40, 55]
                              (string_fragment [40, 53] - [40, 54])))))))
                  consequence: (statement_block [40, 58] - [42, 5]
                    (return_statement [41, 6] - [41, 70]
                      (call_expression [41, 13] - [41, 69]
                        function: (member_expression [41, 13] - [41, 19]
                          object: (identifier [41, 13] - [41, 14])
                          property: (property_identifier [41, 15] - [41, 19]))
                        arguments: (arguments [41, 19] - [41, 69]
                          (object [41, 20] - [41, 63]
                            (pair [41, 22] - [41, 61]
                              key: (property_identifier [41, 22] - [41, 27])
                              value: (string [41, 29] - [41, 61]
                                (string_fragment [41, 30] - [41, 60]))))
                          (number [41, 65] - [41, 68]))))))))
            (lexical_declaration [45, 2] - [50, 25]
              (variable_declarator [45, 8] - [50, 24]
                name: (object_pattern [45, 8] - [50, 3]
                  (shorthand_property_identifier_pattern [46, 4] - [46, 9])
                  (object_assignment_pattern [47, 4] - [47, 21]
                    left: (shorthand_property_identifier_pattern [47, 4] - [47, 17])
                    right: (number [47, 20] - [47, 21]))
                  (object_assignment_pattern [48, 4] - [48, 22]
                    left: (shorthand_property_identifier_pattern [48, 4] - [48, 8])
                    right: (string [48, 11] - [48, 22]
                      (string_fragment [48, 12] - [48, 21])))
                  (object_assignment_pattern [49, 4] - [49, 21]
                    left: (shorthand_property_identifier_pattern [49, 4] - [49, 16])
                    right: (array [49, 19] - [49, 21])))
                value: (await_expression [50, 6] - [50, 24]
                  (call_expression [50, 12] - [50, 24]
                    function: (member_expression [50, 12] - [50, 22]
                      object: (member_expression [50, 12] - [50, 17]
                        object: (identifier [50, 12] - [50, 13])
                        property: (property_identifier [50, 14] - [50, 17]))
                      property: (property_identifier [50, 18] - [50, 22]))
                    arguments: (arguments [50, 22] - [50, 24])))))
            (lexical_declaration [52, 2] - [54, 26]
              (variable_declarator [52, 8] - [54, 25]
                name: (identifier [52, 8] - [52, 18])
                value: (ternary_expression [52, 21] - [54, 25]
                  condition: (parenthesized_expression [52, 21] - [52, 73]
                    (binary_expression [52, 22] - [52, 72]
                      left: (binary_expression [52, 22] - [52, 56]
                        left: (identifier [52, 22] - [52, 27])
                        right: (binary_expression [52, 31] - [52, 56]
                          left: (unary_expression [52, 31] - [52, 43]
                            argument: (identifier [52, 38] - [52, 43]))
                          right: (string [52, 48] - [52, 56]
                            (string_fragment [52, 49] - [52, 55]))))
                      right: (call_expression [52, 60] - [52, 72]
                        function: (member_expression [52, 60] - [52, 70]
                          object: (identifier [52, 60] - [52, 65])
                          property: (property_identifier [52, 66] - [52, 70]))
                        arguments: (arguments [52, 70] - [52, 72]))))
                  consequence: (call_expression [53, 6] - [53, 18]
                    function: (member_expression [53, 6] - [53, 16]
                      object: (identifier [53, 6] - [53, 11])
                      property: (property_identifier [53, 12] - [53, 16]))
                    arguments: (arguments [53, 16] - [53, 18]))
                  alternative: (string [54, 6] - [54, 25]
                    (string_fragment [54, 7] - [54, 24])))))
            (lexical_declaration [55, 2] - [55, 71]
              (variable_declarator [55, 8] - [55, 70]
                name: (identifier [55, 8] - [55, 13])
                value: (call_expression [55, 16] - [55, 70]
                  function: (member_expression [55, 16] - [55, 24]
                    object: (identifier [55, 16] - [55, 20])
                    property: (property_identifier [55, 21] - [55, 24]))
                  arguments: (arguments [55, 24] - [55, 70]
                    (call_expression [55, 25] - [55, 64]
                      function: (member_expression [55, 25] - [55, 33]
                        object: (identifier [55, 25] - [55, 29])
                        property: (property_identifier [55, 30] - [55, 33]))
                      arguments: (arguments [55, 33] - [55, 64]
                        (binary_expression [55, 34] - [55, 60]
                          left: (call_expression [55, 34] - [55, 55]
                            function: (identifier [55, 34] - [55, 40])
                            arguments: (arguments [55, 40] - [55, 55]
                              (identifier [55, 41] - [55, 54])))
                          right: (number [55, 59] - [55, 60]))
                        (number [55, 62] - [55, 63])))
                    (number [55, 66] - [55, 69])))))
            (lexical_declaration [56, 2] - [56, 63]
              (variable_declarator [56, 8] - [56, 62]
                name: (identifier [56, 8] - [56, 17])
                value: (new_expression [56, 20] - [56, 62]
                  constructor: (identifier [56, 24] - [56, 28])
                  arguments: (arguments [56, 28] - [56, 62]
                    (binary_expression [56, 29] - [56, 61]
                      left: (call_expression [56, 29] - [56, 39]
                        function: (member_expression [56, 29] - [56, 37]
                          object: (identifier [56, 29] - [56, 33])
                          property: (property_identifier [56, 34] - [56, 37]))
                        arguments: (arguments [56, 37] - [56, 39]))
                      right: (binary_expression [56, 42] - [56, 61]
                        left: (binary_expression [56, 42] - [56, 54]
                          left: (identifier [56, 42] - [56, 47])
                          right: (number [56, 50] - [56, 54]))
                        right: (number [56, 57] - [56, 61])))))))
            (lexical_declaration [58, 2] - [58, 37]
              (variable_declarator [58, 6] - [58, 36]
                name: (identifier [58, 6] - [58, 21])
                type: (type_annotation [58, 21] - [58, 31]
                  (array_type [58, 23] - [58, 31]
                    (predefined_type [58, 23] - [58, 29])))
                value: (array [58, 34] - [58, 36])))
            (if_statement [59, 2] - [75, 3]
              condition: (parenthesized_expression [59, 5] - [59, 46]
                (binary_expression [59, 6] - [59, 45]
                  left: (binary_expression [59, 6] - [59, 26]
                    left: (identifier [59, 6] - [59, 10])
                    right: (string [59, 15] - [59, 26]
                      (string_fragment [59, 16] - [59, 25])))
                  right: (binary_expression [59, 30] - [59, 45]
                    left: (identifier [59, 30] - [59, 34])
                    right: (string [59, 39] - [59, 45]
                      (string_fragment [59, 40] - [59, 44])))))
              consequence: (statement_block [59, 47] - [67, 3]
                (expression_statement [60, 4] - [66, 6]
                  (assignment_expression [60, 4] - [66, 5]
                    left: (identifier [60, 4] - [60, 19])
                    right: (array [60, 22] - [66, 5]
                      (string [61, 6] - [61, 18]
                        (string_fragment [61, 7] - [61, 17]))
                      (string [62, 6] - [62, 18]
                        (string_fragment [62, 7] - [62, 17]))
                      (string [63, 6] - [63, 17]
                        (string_fragment [63, 7] - [63, 16]))
                      (string [64, 6] - [64, 18]
                        (string_fragment [64, 7] - [64, 17]))
                      (string [65, 6] - [65, 21]
                        (string_fragment [65, 7] - [65, 20]))))))
              alternative: (else_clause [67, 4] - [75, 3]
                (if_statement [67, 9] - [75, 3]
                  condition: (parenthesized_expression [67, 12] - [67, 56]
                    (binary_expression [67, 13] - [67, 55]
                      left: (binary_expression [67, 13] - [67, 32]
                        left: (identifier [67, 13] - [67, 17])
                        right: (string [67, 22] - [67, 32]
                          (string_fragment [67, 23] - [67, 31])))
                      right: (binary_expression [67, 36] - [67, 55]
                        left: (identifier [67, 36] - [67, 40])
                        right: (string [67, 45] - [67, 55]
                          (string_fragment [67, 46] - [67, 54])))))
                  consequence: (statement_block [67, 57] - [69, 3]
                    (expression_statement [68, 4] - [68, 76]
                      (assignment_expression [68, 4] - [68, 75]
                        left: (identifier [68, 4] - [68, 19])
                        right: (array [68, 22] - [68, 75]
                          (string [68, 23] - [68, 33]
                            (string_fragment [68, 24] - [68, 32]))
                          (string [68, 35] - [68, 47]
                            (string_fragment [68, 36] - [68, 46]))
                          (string [68, 49] - [68, 61]
                            (string_fragment [68, 50] - [68, 60]))
                          (string [68, 63] - [68, 74]
                            (string_fragment [68, 64] - [68, 73]))))))
                  alternative: (else_clause [69, 4] - [75, 3]
                    (if_statement [69, 9] - [75, 3]
                      condition: (parenthesized_expression [69, 12] - [69, 30]
                        (binary_expression [69, 13] - [69, 29]
                          left: (identifier [69, 13] - [69, 17])
                          right: (string [69, 22] - [69, 29]
                            (string_fragment [69, 23] - [69, 28]))))
                      consequence: (statement_block [69, 31] - [71, 3]
                        (expression_statement [70, 4] - [70, 28]
                          (assignment_expression [70, 4] - [70, 27]
                            left: (identifier [70, 4] - [70, 19])
                            right: (array [70, 22] - [70, 27]
                              (string [70, 23] - [70, 26]
                                (string_fragment [70, 24] - [70, 25]))))))
                      alternative: (else_clause [71, 4] - [75, 3]
                        (if_statement [71, 9] - [75, 3]
                          condition: (parenthesized_expression [71, 12] - [71, 62]
                            (binary_expression [71, 13] - [71, 61]
                              left: (binary_expression [71, 13] - [71, 30]
                                left: (identifier [71, 13] - [71, 17])
                                right: (string [71, 22] - [71, 30]
                                  (string_fragment [71, 23] - [71, 29])))
                              right: (call_expression [71, 34] - [71, 61]
                                function: (member_expression [71, 34] - [71, 47]
                                  object: (identifier [71, 34] - [71, 39])
                                  property: (property_identifier [71, 40] - [71, 47]))
                                arguments: (arguments [71, 47] - [71, 61]
                                  (identifier [71, 48] - [71, 60])))))
                          consequence: (statement_block [71, 63] - [75, 3]
                            (expression_statement [72, 4] - [74, 6]
                              (assignment_expression [72, 4] - [74, 5]
                                left: (identifier [72, 4] - [72, 19])
                                right: (call_expression [72, 22] - [74, 5]
                                  function: (member_expression [72, 22] - [72, 78]
                                    object: (call_expression [72, 22] - [72, 71]
                                      function: (member_expression [72, 22] - [72, 38]
                                        object: (identifier [72, 22] - [72, 34])
                                        property: (property_identifier [72, 35] - [72, 38]))
                                      arguments: (arguments [72, 38] - [72, 71]
                                        (arrow_function [72, 39] - [72, 70]
                                          parameters: (formal_parameters [72, 39] - [72, 50]
                                            (required_parameter [72, 40] - [72, 49]
                                              pattern: (identifier [72, 40] - [72, 41])
                                              type: (type_annotation [72, 41] - [72, 49]
                                                (predefined_type [72, 43] - [72, 49]))))
                                          body: (call_expression [72, 54] - [72, 70]
                                            function: (member_expression [72, 54] - [72, 68]
                                              object: (call_expression [72, 54] - [72, 63]
                                                function: (identifier [72, 54] - [72, 60])
                                                arguments: (arguments [72, 60] - [72, 63]
                                                  (identifier [72, 61] - [72, 62])))
                                              property: (property_identifier [72, 64] - [72, 68]))
                                            arguments: (arguments [72, 68] - [72, 70])))))
                                    property: (property_identifier [72, 72] - [72, 78]))
                                  arguments: (arguments [72, 78] - [74, 5]
                                    (identifier [73, 6] - [73, 13])))))))))))))
            (lexical_declaration [77, 2] - [77, 38]
              (variable_declarator [77, 8] - [77, 37]
                name: (identifier [77, 8] - [77, 16])
                value: (new_expression [77, 19] - [77, 37]
                  constructor: (identifier [77, 23] - [77, 33])
                  arguments: (arguments [77, 33] - [77, 37]
                    (number [77, 34] - [77, 36])))))
            (expression_statement [78, 2] - [78, 35]
              (call_expression [78, 2] - [78, 34]
                function: (member_expression [78, 2] - [78, 24]
                  object: (identifier [78, 2] - [78, 8])
                  property: (property_identifier [78, 9] - [78, 24]))
                arguments: (arguments [78, 24] - [78, 34]
                  (identifier [78, 25] - [78, 33]))))
            (lexical_declaration [79, 2] - [81, 13]
              (variable_declarator [79, 8] - [81, 12]
                name: (identifier [79, 8] - [79, 16])
                value: (call_expression [79, 19] - [81, 12]
                  function: (member_expression [79, 19] - [81, 8]
                    object: (call_expression [79, 19] - [81, 3]
                      function: (member_expression [79, 19] - [79, 43]
                        object: (call_expression [79, 19] - [79, 39]
                          function: (member_expression [79, 19] - [79, 29]
                            object: (identifier [79, 19] - [79, 24])
                            property: (property_identifier [79, 25] - [79, 29]))
                          arguments: (arguments [79, 29] - [79, 39]
                            (identifier [79, 30] - [79, 38])))
                        property: (property_identifier [79, 40] - [79, 43]))
                      arguments: (arguments [79, 43] - [81, 3]
                        (arrow_function [79, 44] - [80, 35]
                          parameters: (formal_parameters [79, 44] - [79, 47]
                            (required_parameter [79, 45] - [79, 46]
                              pattern: (identifier [79, 45] - [79, 46])))
                          body: (call_expression [80, 4] - [80, 35]
                            function: (member_expression [80, 4] - [80, 27]
                              object: (call_expression [80, 4] - [80, 18]
                                function: (member_expression [80, 4] - [80, 14]
                                  object: (identifier [80, 4] - [80, 5])
                                  property: (property_identifier [80, 6] - [80, 14]))
                                arguments: (arguments [80, 14] - [80, 18]
                                  (number [80, 15] - [80, 17])))
                              property: (property_identifier [80, 19] - [80, 27]))
                            arguments: (arguments [80, 27] - [80, 35]
                              (number [80, 28] - [80, 29])
                              (string [80, 31] - [80, 34]
                                (string_fragment [80, 32] - [80, 33])))))))
                    property: (property_identifier [81, 4] - [81, 8]))
                  arguments: (arguments [81, 8] - [81, 12]
                    (string [81, 9] - [81, 11])))))
            (lexical_declaration [82, 2] - [82, 42]
              (variable_declarator [82, 8] - [82, 41]
                name: (identifier [82, 8] - [82, 17])
                value: (template_string [82, 20] - [82, 41]
                  (string_fragment [82, 21] - [82, 29])
                  (template_substitution [82, 29] - [82, 40]
                    (identifier [82, 31] - [82, 39])))))
            (expression_statement [84, 2] - [90, 4]
              (await_expression [84, 2] - [90, 3]
                (call_expression [84, 8] - [90, 3]
                  function: (identifier [84, 8] - [84, 23])
                  arguments: (arguments [84, 23] - [90, 3]
                    (identifier [85, 4] - [85, 13])
                    (member_expression [86, 4] - [86, 15]
                      object: (identifier [86, 4] - [86, 8])
                      property: (property_identifier [86, 9] - [86, 15]))
                    (identifier [87, 4] - [87, 14])
                    (identifier [88, 4] - [88, 19])
                    (identifier [89, 4] - [89, 13])))))
            (try_statement [92, 2] - [107, 3]
              body: (statement_block [92, 6] - [105, 3]
                (lexical_declaration [93, 4] - [99, 6]
                  (variable_declarator [93, 10] - [99, 5]
                    name: (identifier [93, 10] - [93, 21])
                    value: (object [93, 24] - [99, 5]
                      (pair [94, 6] - [94, 23]
                        key: (property_identifier [94, 6] - [94, 10])
                        value: (member_expression [94, 12] - [94, 23]
                          object: (identifier [94, 12] - [94, 16])
                          property: (property_identifier [94, 17] - [94, 23])))
                      (pair [95, 6] - [95, 29]
                        key: (property_identifier [95, 6] - [95, 14])
                        value: (member_expression [95, 16] - [95, 29]
                          object: (identifier [95, 16] - [95, 20])
                          property: (property_identifier [95, 21] - [95, 29])))
                      (pair [96, 6] - [96, 23]
                        key: (property_identifier [96, 6] - [96, 11])
                        value: (identifier [96, 13] - [96, 23]))
                      (pair [97, 6] - [97, 19]
                        key: (property_identifier [97, 6] - [97, 13])
                        value: (true [97, 15] - [97, 19]))
                      (pair [98, 6] - [98, 35]
                        key: (property_identifier [98, 6] - [98, 18])
                        value: (identifier [98, 20] - [98, 35])))))
                (expression_statement [100, 4] - [104, 6]
                  (await_expression [100, 4] - [104, 5]
                    (call_expression [100, 10] - [104, 5]
                      function: (member_expression [100, 10] - [100, 22]
                        object: (identifier [100, 10] - [100, 16])
                        property: (property_identifier [100, 17] - [100, 22]))
                      arguments: (arguments [100, 22] - [104, 5]
                        (identifier [101, 6] - [101, 15])
                        (call_expression [102, 6] - [102, 30]
                          function: (member_expression [102, 6] - [102, 16]
                            object: (identifier [102, 6] - [102, 10])
                            property: (property_identifier [102, 11] - [102, 16]))
                          arguments: (arguments [102, 16] - [102, 30]
                            (binary_expression [102, 17] - [102, 29]
                              left: (identifier [102, 17] - [102, 22])
                              right: (number [102, 25] - [102, 29]))))
                        (call_expression [103, 6] - [103, 33]
                          function: (member_expression [103, 6] - [103, 20]
                            object: (identifier [103, 6] - [103, 10])
                            property: (property_identifier [103, 11] - [103, 20]))
                          arguments: (arguments [103, 20] - [103, 33]
                            (identifier [103, 21] - [103, 32]))))))))
              handler: (catch_clause [105, 4] - [107, 3]
                parameter: (identifier [105, 11] - [105, 14])
                body: (statement_block [105, 16] - [107, 3]
                  (expression_statement [106, 4] - [106, 70]
                    (call_expression [106, 4] - [106, 69]
                      function: (member_expression [106, 4] - [106, 17]
                        object: (identifier [106, 4] - [106, 11])
                        property: (property_identifier [106, 12] - [106, 17]))
                      arguments: (arguments [106, 17] - [106, 69]
                        (string [106, 18] - [106, 63]
                          (string_fragment [106, 19] - [106, 62]))
                        (identifier [106, 65] - [106, 68])))))))
            (expression_statement [109, 2] - [114, 21]
              (call_expression [109, 2] - [114, 20]
                function: (member_expression [109, 2] - [109, 23]
                  object: (identifier [109, 2] - [109, 14])
                  property: (property_identifier [109, 15] - [109, 23]))
                arguments: (arguments [109, 23] - [114, 20]
                  (member_expression [109, 24] - [109, 35]
                    object: (identifier [109, 24] - [109, 28])
                    property: (property_identifier [109, 29] - [109, 35]))
                  (string [109, 37] - [109, 56]
                    (string_fragment [109, 38] - [109, 55]))
                  (identifier [109, 58] - [109, 67])
                  (object [109, 69] - [114, 3]
                    (pair [110, 4] - [110, 21]
                      key: (property_identifier [110, 4] - [110, 9])
                      value: (identifier [110, 11] - [110, 21]))
                    (pair [111, 4] - [111, 25]
                      key: (property_identifier [111, 4] - [111, 18])
                      value: (identifier [111, 20] - [111, 25]))
                    (shorthand_property_identifier [112, 4] - [112, 8])
                    (pair [113, 4] - [113, 27]
                      key: (property_identifier [113, 4] - [113, 10])
                      value: (identifier [113, 12] - [113, 27])))
                  (call_expression [114, 5] - [114, 19]
                    function: (identifier [114, 5] - [114, 16])
                    arguments: (arguments [114, 16] - [114, 19]
                      (identifier [114, 17] - [114, 18]))))))
            (return_statement [116, 2] - [123, 5]
              (call_expression [116, 9] - [123, 4]
                function: (member_expression [116, 9] - [116, 15]
                  object: (identifier [116, 9] - [116, 10])
                  property: (property_identifier [116, 11] - [116, 15]))
                arguments: (arguments [116, 15] - [123, 4]
                  (object [116, 16] - [123, 3]
                    (pair [117, 4] - [117, 17]
                      key: (property_identifier [117, 4] - [117, 11])
                      value: (true [117, 13] - [117, 17]))
                    (shorthand_property_identifier [118, 4] - [118, 13])
                    (pair [119, 4] - [119, 20]
                      key: (property_identifier [119, 4] - [119, 9])
                      value: (identifier [119, 11] - [119, 20]))
                    (pair [120, 4] - [120, 21]
                      key: (property_identifier [120, 4] - [120, 9])
                      value: (identifier [120, 11] - [120, 21]))
                    (pair [121, 4] - [121, 38]
                      key: (property_identifier [121, 4] - [121, 13])
                      value: (call_expression [121, 15] - [121, 38]
                        function: (member_expression [121, 15] - [121, 36]
                          object: (identifier [121, 15] - [121, 24])
                          property: (property_identifier [121, 25] - [121, 36]))
                        arguments: (arguments [121, 36] - [121, 38])))
                    (pair [122, 4] - [122, 27]
                      key: (property_identifier [122, 4] - [122, 10])
                      value: (identifier [122, 12] - [122, 27])))))))))))
  (comment [126, 0] - [126, 60])
  (comment [127, 0] - [127, 42])
  (comment [128, 0] - [128, 60])
  (expression_statement [129, 0] - [169, 3]
    (call_expression [129, 0] - [169, 2]
      function: (member_expression [129, 0] - [129, 24]
        object: (identifier [129, 0] - [129, 20])
        property: (property_identifier [129, 21] - [129, 24]))
      arguments: (arguments [129, 24] - [169, 2]
        (string [129, 25] - [129, 51]
          (string_fragment [129, 26] - [129, 50]))
        (arrow_function [129, 53] - [169, 1]
          parameters: (formal_parameters [129, 59] - [129, 62]
            (required_parameter [129, 60] - [129, 61]
              pattern: (identifier [129, 60] - [129, 61])))
          body: (statement_block [129, 66] - [169, 1]
            (lexical_declaration [130, 2] - [130, 45]
              (variable_declarator [130, 8] - [130, 44]
                name: (identifier [130, 8] - [130, 12])
                value: (await_expression [130, 15] - [130, 44]
                  (call_expression [130, 21] - [130, 44]
                    function: (identifier [130, 21] - [130, 41])
                    arguments: (arguments [130, 41] - [130, 44]
                      (identifier [130, 42] - [130, 43]))))))
            (if_statement [131, 2] - [131, 59]
              condition: (parenthesized_expression [131, 5] - [131, 12]
                (unary_expression [131, 6] - [131, 11]
                  argument: (identifier [131, 7] - [131, 11])))
              consequence: (return_statement [131, 13] - [131, 59]
                (call_expression [131, 20] - [131, 58]
                  function: (member_expression [131, 20] - [131, 26]
                    object: (identifier [131, 20] - [131, 21])
                    property: (property_identifier [131, 22] - [131, 26]))
                  arguments: (arguments [131, 26] - [131, 58]
                    (object [131, 27] - [131, 52]
                      (pair [131, 29] - [131, 50]
                        key: (property_identifier [131, 29] - [131, 34])
                        value: (string [131, 36] - [131, 50]
                          (string_fragment [131, 37] - [131, 49]))))
                    (number [131, 54] - [131, 57])))))
            (if_statement [133, 2] - [135, 3]
              condition: (parenthesized_expression [133, 5] - [133, 40]
                (unary_expression [133, 6] - [133, 39]
                  argument: (call_expression [133, 7] - [133, 39]
                    function: (identifier [133, 7] - [133, 15])
                    arguments: (arguments [133, 15] - [133, 39]
                      (identifier [133, 16] - [133, 20])
                      (string [133, 22] - [133, 38]
                        (string_fragment [133, 23] - [133, 37]))))))
              consequence: (statement_block [133, 41] - [135, 3]
                (return_statement [134, 4] - [134, 68]
                  (call_expression [134, 11] - [134, 67]
                    function: (member_expression [134, 11] - [134, 17]
                      object: (identifier [134, 11] - [134, 12])
                      property: (property_identifier [134, 13] - [134, 17]))
                    arguments: (arguments [134, 17] - [134, 67]
                      (object [134, 18] - [134, 61]
                        (pair [134, 20] - [134, 59]
                          key: (property_identifier [134, 20] - [134, 25])
                          value: (string [134, 27] - [134, 59]
                            (string_fragment [134, 28] - [134, 58]))))
                      (number [134, 63] - [134, 66]))))))
            (lexical_declaration [137, 2] - [137, 44]
              (variable_declarator [137, 8] - [137, 43]
                name: (identifier [137, 8] - [137, 23])
                value: (call_expression [137, 26] - [137, 43]
                  function: (member_expression [137, 26] - [137, 37]
                    object: (member_expression [137, 26] - [137, 31]
                      object: (identifier [137, 26] - [137, 27])
                      property: (property_identifier [137, 28] - [137, 31]))
                    property: (property_identifier [137, 32] - [137, 37]))
                  arguments: (arguments [137, 37] - [137, 43]
                    (string [137, 38] - [137, 42]
                      (string_fragment [137, 39] - [137, 41]))))))
            (lexical_declaration [138, 2] - [138, 51]
              (variable_declarator [138, 8] - [138, 50]
                name: (object_pattern [138, 8] - [138, 29]
                  (object_assignment_pattern [138, 10] - [138, 27]
                    left: (shorthand_property_identifier_pattern [138, 10] - [138, 22])
                    right: (array [138, 25] - [138, 27])))
                value: (await_expression [138, 32] - [138, 50]
                  (call_expression [138, 38] - [138, 50]
                    function: (member_expression [138, 38] - [138, 48]
                      object: (member_expression [138, 38] - [138, 43]
                        object: (identifier [138, 38] - [138, 39])
                        property: (property_identifier [138, 40] - [138, 43]))
                      property: (property_identifier [138, 44] - [138, 48]))
                    arguments: (arguments [138, 48] - [138, 50])))))
            (lexical_declaration [140, 2] - [140, 78]
              (variable_declarator [140, 8] - [140, 77]
                name: (identifier [140, 8] - [140, 15])
                value: (await_expression [140, 18] - [140, 77]
                  (call_expression [140, 24] - [140, 77]
                    function: (identifier [140, 24] - [140, 47])
                    arguments: (arguments [140, 47] - [140, 77]
                      (identifier [140, 48] - [140, 63])
                      (member_expression [140, 65] - [140, 76]
                        object: (identifier [140, 65] - [140, 69])
                        property: (property_identifier [140, 70] - [140, 76])))))))
            (if_statement [141, 2] - [143, 3]
              condition: (parenthesized_expression [141, 5] - [141, 15]
                (unary_expression [141, 6] - [141, 14]
                  argument: (identifier [141, 7] - [141, 14])))
              consequence: (statement_block [141, 16] - [143, 3]
                (return_statement [142, 4] - [142, 72]
                  (call_expression [142, 11] - [142, 71]
                    function: (member_expression [142, 11] - [142, 17]
                      object: (identifier [142, 11] - [142, 12])
                      property: (property_identifier [142, 13] - [142, 17]))
                    arguments: (arguments [142, 17] - [142, 71]
                      (object [142, 18] - [142, 65]
                        (pair [142, 20] - [142, 63]
                          key: (property_identifier [142, 20] - [142, 25])
                          value: (string [142, 27] - [142, 63]
                            (string_fragment [142, 28] - [142, 62]))))
                      (number [142, 67] - [142, 70]))))))
            (lexical_declaration [145, 2] - [147, 9]
              (variable_declarator [145, 8] - [147, 8]
                name: (identifier [145, 8] - [145, 23])
                value: (ternary_expression [145, 26] - [147, 8]
                  condition: (call_expression [145, 26] - [145, 53]
                    function: (member_expression [145, 26] - [145, 39]
                      object: (identifier [145, 26] - [145, 31])
                      property: (property_identifier [145, 32] - [145, 39]))
                    arguments: (arguments [145, 39] - [145, 53]
                      (identifier [145, 40] - [145, 52])))
                  consequence: (call_expression [146, 6] - [146, 71]
                    function: (member_expression [146, 6] - [146, 62]
                      object: (call_expression [146, 6] - [146, 55]
                        function: (member_expression [146, 6] - [146, 22]
                          object: (identifier [146, 6] - [146, 18])
                          property: (property_identifier [146, 19] - [146, 22]))
                        arguments: (arguments [146, 22] - [146, 55]
                          (arrow_function [146, 23] - [146, 54]
                            parameters: (formal_parameters [146, 23] - [146, 34]
                              (required_parameter [146, 24] - [146, 33]
                                pattern: (identifier [146, 24] - [146, 25])
                                type: (type_annotation [146, 25] - [146, 33]
                                  (predefined_type [146, 27] - [146, 33]))))
                            body: (call_expression [146, 38] - [146, 54]
                              function: (member_expression [146, 38] - [146, 52]
                                object: (call_expression [146, 38] - [146, 47]
                                  function: (identifier [146, 38] - [146, 44])
                                  arguments: (arguments [146, 44] - [146, 47]
                                    (identifier [146, 45] - [146, 46])))
                                property: (property_identifier [146, 48] - [146, 52]))
                              arguments: (arguments [146, 52] - [146, 54])))))
                      property: (property_identifier [146, 56] - [146, 62]))
                    arguments: (arguments [146, 62] - [146, 71]
                      (identifier [146, 63] - [146, 70])))
                  alternative: (array [147, 6] - [147, 8]))))
            (expression_statement [149, 2] - [149, 62]
              (await_expression [149, 2] - [149, 61]
                (call_expression [149, 8] - [149, 61]
                  function: (identifier [149, 8] - [149, 27])
                  arguments: (arguments [149, 27] - [149, 61]
                    (identifier [149, 28] - [149, 43])
                    (identifier [149, 45] - [149, 60])))))
            (try_statement [151, 2] - [158, 17]
              body: (statement_block [151, 6] - [158, 3]
                (lexical_declaration [152, 4] - [152, 61]
                  (variable_declarator [152, 10] - [152, 60]
                    name: (identifier [152, 10] - [152, 24])
                    value: (await_expression [152, 27] - [152, 60]
                      (call_expression [152, 33] - [152, 60]
                        function: (member_expression [152, 33] - [152, 43]
                          object: (identifier [152, 33] - [152, 39])
                          property: (property_identifier [152, 40] - [152, 43]))
                        arguments: (arguments [152, 43] - [152, 60]
                          (identifier [152, 44] - [152, 59]))))))
                (if_statement [153, 4] - [157, 5]
                  condition: (parenthesized_expression [153, 7] - [153, 23]
                    (identifier [153, 8] - [153, 22]))
                  consequence: (statement_block [153, 24] - [157, 5]
                    (lexical_declaration [154, 6] - [154, 48]
                      (variable_declarator [154, 12] - [154, 47]
                        name: (identifier [154, 12] - [154, 18])
                        value: (call_expression [154, 21] - [154, 47]
                          function: (member_expression [154, 21] - [154, 31]
                            object: (identifier [154, 21] - [154, 25])
                            property: (property_identifier [154, 26] - [154, 31]))
                          arguments: (arguments [154, 31] - [154, 47]
                            (identifier [154, 32] - [154, 46])))))
                    (expression_statement [155, 6] - [155, 44]
                      (assignment_expression [155, 6] - [155, 43]
                        left: (member_expression [155, 6] - [155, 25]
                          object: (identifier [155, 6] - [155, 12])
                          property: (property_identifier [155, 13] - [155, 25]))
                        right: (identifier [155, 28] - [155, 43])))
                    (expression_statement [156, 6] - [156, 64]
                      (await_expression [156, 6] - [156, 63]
                        (call_expression [156, 12] - [156, 63]
                          function: (member_expression [156, 12] - [156, 22]
                            object: (identifier [156, 12] - [156, 18])
                            property: (property_identifier [156, 19] - [156, 22]))
                          arguments: (arguments [156, 22] - [156, 63]
                            (identifier [156, 23] - [156, 38])
                            (call_expression [156, 40] - [156, 62]
                              function: (member_expression [156, 40] - [156, 54]
                                object: (identifier [156, 40] - [156, 44])
                                property: (property_identifier [156, 45] - [156, 54]))
                              arguments: (arguments [156, 54] - [156, 62]
                                (identifier [156, 55] - [156, 61]))))))))))
              handler: (catch_clause [158, 4] - [158, 17]
                parameter: (identifier [158, 11] - [158, 13])
                body: (statement_block [158, 15] - [158, 17])))
            (expression_statement [160, 2] - [166, 4]
              (call_expression [160, 2] - [166, 3]
                function: (member_expression [160, 2] - [160, 23]
                  object: (identifier [160, 2] - [160, 14])
                  property: (property_identifier [160, 15] - [160, 23]))
                arguments: (arguments [160, 23] - [166, 3]
                  (member_expression [161, 4] - [161, 15]
                    object: (identifier [161, 4] - [161, 8])
                    property: (property_identifier [161, 9] - [161, 15]))
                  (string [162, 4] - [162, 28]
                    (string_fragment [162, 5] - [162, 27]))
                  (identifier [163, 4] - [163, 19])
                  (object [164, 4] - [164, 31]
                    (pair [164, 6] - [164, 29]
                      key: (property_identifier [164, 6] - [164, 12])
                      value: (identifier [164, 14] - [164, 29])))
                  (call_expression [165, 4] - [165, 18]
                    function: (identifier [165, 4] - [165, 15])
                    arguments: (arguments [165, 15] - [165, 18]
                      (identifier [165, 16] - [165, 17]))))))
            (return_statement [168, 2] - [168, 60]
              (call_expression [168, 9] - [168, 59]
                function: (member_expression [168, 9] - [168, 15]
                  object: (identifier [168, 9] - [168, 10])
                  property: (property_identifier [168, 11] - [168, 15]))
                arguments: (arguments [168, 15] - [168, 59]
                  (object [168, 16] - [168, 58]
                    (pair [168, 18] - [168, 31]
                      key: (property_identifier [168, 18] - [168, 25])
                      value: (true [168, 27] - [168, 31]))
                    (pair [168, 33] - [168, 56]
                      key: (property_identifier [168, 33] - [168, 39])
                      value: (identifier [168, 41] - [168, 56])))))))))))
  (comment [171, 0] - [171, 60])
  (comment [172, 0] - [172, 26])
  (comment [173, 0] - [173, 60])
  (expression_statement [174, 0] - [218, 3]
    (call_expression [174, 0] - [218, 2]
      function: (member_expression [174, 0] - [174, 25]
        object: (identifier [174, 0] - [174, 20])
        property: (property_identifier [174, 21] - [174, 25]))
      arguments: (arguments [174, 25] - [218, 2]
        (string [174, 26] - [174, 51]
          (string_fragment [174, 27] - [174, 50]))
        (arrow_function [174, 53] - [218, 1]
          parameters: (formal_parameters [174, 59] - [174, 62]
            (required_parameter [174, 60] - [174, 61]
              pattern: (identifier [174, 60] - [174, 61])))
          body: (statement_block [174, 66] - [218, 1]
            (lexical_declaration [175, 2] - [175, 45]
              (variable_declarator [175, 8] - [175, 44]
                name: (identifier [175, 8] - [175, 12])
                value: (await_expression [175, 15] - [175, 44]
                  (call_expression [175, 21] - [175, 44]
                    function: (identifier [175, 21] - [175, 41])
                    arguments: (arguments [175, 41] - [175, 44]
                      (identifier [175, 42] - [175, 43]))))))
            (if_statement [176, 2] - [176, 59]
              condition: (parenthesized_expression [176, 5] - [176, 12]
                (unary_expression [176, 6] - [176, 11]
                  argument: (identifier [176, 7] - [176, 11])))
              consequence: (return_statement [176, 13] - [176, 59]
                (call_expression [176, 20] - [176, 58]
                  function: (member_expression [176, 20] - [176, 26]
                    object: (identifier [176, 20] - [176, 21])
                    property: (property_identifier [176, 22] - [176, 26]))
                  arguments: (arguments [176, 26] - [176, 58]
                    (object [176, 27] - [176, 52]
                      (pair [176, 29] - [176, 50]
                        key: (property_identifier [176, 29] - [176, 34])
                        value: (string [176, 36] - [176, 50]
                          (string_fragment [176, 37] - [176, 49]))))
                    (number [176, 54] - [176, 57])))))
            (if_statement [178, 2] - [180, 3]
              condition: (parenthesized_expression [178, 5] - [178, 40]
                (unary_expression [178, 6] - [178, 39]
                  argument: (call_expression [178, 7] - [178, 39]
                    function: (identifier [178, 7] - [178, 15])
                    arguments: (arguments [178, 15] - [178, 39]
                      (identifier [178, 16] - [178, 20])
                      (string [178, 22] - [178, 38]
                        (string_fragment [178, 23] - [178, 37]))))))
              consequence: (statement_block [178, 41] - [180, 3]
                (return_statement [179, 4] - [179, 68]
                  (call_expression [179, 11] - [179, 67]
                    function: (member_expression [179, 11] - [179, 17]
                      object: (identifier [179, 11] - [179, 12])
                      property: (property_identifier [179, 13] - [179, 17]))
                    arguments: (arguments [179, 17] - [179, 67]
                      (object [179, 18] - [179, 61]
                        (pair [179, 20] - [179, 59]
                          key: (property_identifier [179, 20] - [179, 25])
                          value: (string [179, 27] - [179, 59]
                            (string_fragment [179, 28] - [179, 58]))))
                      (number [179, 63] - [179, 66]))))))
            (lexical_declaration [182, 2] - [182, 44]
              (variable_declarator [182, 8] - [182, 43]
                name: (identifier [182, 8] - [182, 23])
                value: (call_expression [182, 26] - [182, 43]
                  function: (member_expression [182, 26] - [182, 37]
                    object: (member_expression [182, 26] - [182, 31]
                      object: (identifier [182, 26] - [182, 27])
                      property: (property_identifier [182, 28] - [182, 31]))
                    property: (property_identifier [182, 32] - [182, 37]))
                  arguments: (arguments [182, 37] - [182, 43]
                    (string [182, 38] - [182, 42]
                      (string_fragment [182, 39] - [182, 41]))))))
            (lexical_declaration [183, 2] - [183, 43]
              (variable_declarator [183, 8] - [183, 42]
                name: (object_pattern [183, 8] - [183, 21]
                  (shorthand_property_identifier_pattern [183, 10] - [183, 19]))
                value: (await_expression [183, 24] - [183, 42]
                  (call_expression [183, 30] - [183, 42]
                    function: (member_expression [183, 30] - [183, 40]
                      object: (member_expression [183, 30] - [183, 35]
                        object: (identifier [183, 30] - [183, 31])
                        property: (property_identifier [183, 32] - [183, 35]))
                      property: (property_identifier [183, 36] - [183, 40]))
                    arguments: (arguments [183, 40] - [183, 42])))))
            (lexical_declaration [184, 2] - [184, 41]
              (variable_declarator [184, 8] - [184, 40]
                name: (identifier [184, 8] - [184, 19])
                value: (call_expression [184, 22] - [184, 40]
                  function: (identifier [184, 22] - [184, 29])
                  arguments: (arguments [184, 29] - [184, 40]
                    (identifier [184, 30] - [184, 39])))))
            (lexical_declaration [186, 2] - [186, 56]
              (variable_declarator [186, 8] - [186, 55]
                name: (identifier [186, 8] - [186, 15])
                value: (await_expression [186, 18] - [186, 55]
                  (call_expression [186, 24] - [186, 55]
                    function: (identifier [186, 24] - [186, 38])
                    arguments: (arguments [186, 38] - [186, 55]
                      (identifier [186, 39] - [186, 54]))))))
            (if_statement [187, 2] - [189, 3]
              condition: (parenthesized_expression [187, 5] - [187, 15]
                (unary_expression [187, 6] - [187, 14]
                  argument: (identifier [187, 7] - [187, 14])))
              consequence: (statement_block [187, 16] - [189, 3]
                (return_statement [188, 4] - [188, 55]
                  (call_expression [188, 11] - [188, 54]
                    function: (member_expression [188, 11] - [188, 17]
                      object: (identifier [188, 11] - [188, 12])
                      property: (property_identifier [188, 13] - [188, 17]))
                    arguments: (arguments [188, 17] - [188, 54]
                      (object [188, 18] - [188, 48]
                        (pair [188, 20] - [188, 46]
                          key: (property_identifier [188, 20] - [188, 25])
                          value: (string [188, 27] - [188, 46]
                            (string_fragment [188, 28] - [188, 45]))))
                      (number [188, 50] - [188, 53]))))))
            (expression_statement [191, 2] - [191, 55]
              (await_expression [191, 2] - [191, 54]
                (call_expression [191, 8] - [191, 54]
                  function: (identifier [191, 8] - [191, 24])
                  arguments: (arguments [191, 24] - [191, 54]
                    (identifier [191, 25] - [191, 40])
                    (identifier [191, 42] - [191, 53])))))
            (try_statement [193, 2] - [207, 3]
              body: (statement_block [193, 6] - [205, 3]
                (lexical_declaration [194, 4] - [194, 61]
                  (variable_declarator [194, 10] - [194, 60]
                    name: (identifier [194, 10] - [194, 24])
                    value: (await_expression [194, 27] - [194, 60]
                      (call_expression [194, 33] - [194, 60]
                        function: (member_expression [194, 33] - [194, 43]
                          object: (identifier [194, 33] - [194, 39])
                          property: (property_identifier [194, 40] - [194, 43]))
                        arguments: (arguments [194, 43] - [194, 60]
                          (identifier [194, 44] - [194, 59]))))))
                (if_statement [195, 4] - [204, 5]
                  condition: (parenthesized_expression [195, 7] - [195, 23]
                    (identifier [195, 8] - [195, 22]))
                  consequence: (statement_block [195, 24] - [204, 5]
                    (lexical_declaration [196, 6] - [196, 48]
                      (variable_declarator [196, 12] - [196, 47]
                        name: (identifier [196, 12] - [196, 18])
                        value: (call_expression [196, 21] - [196, 47]
                          function: (member_expression [196, 21] - [196, 31]
                            object: (identifier [196, 21] - [196, 25])
                            property: (property_identifier [196, 26] - [196, 31]))
                          arguments: (arguments [196, 31] - [196, 47]
                            (identifier [196, 32] - [196, 46])))))
                    (expression_statement [197, 6] - [197, 37]
                      (assignment_expression [197, 6] - [197, 36]
                        left: (member_expression [197, 6] - [197, 22]
                          object: (identifier [197, 6] - [197, 12])
                          property: (property_identifier [197, 13] - [197, 22]))
                        right: (identifier [197, 25] - [197, 36])))
                    (lexical_declaration [198, 6] - [198, 52]
                      (variable_declarator [198, 12] - [198, 51]
                        name: (identifier [198, 12] - [198, 15])
                        value: (await_expression [198, 18] - [198, 51]
                          (call_expression [198, 24] - [198, 51]
                            function: (member_expression [198, 24] - [198, 34]
                              object: (identifier [198, 24] - [198, 30])
                              property: (property_identifier [198, 31] - [198, 34]))
                            arguments: (arguments [198, 34] - [198, 51]
                              (identifier [198, 35] - [198, 50]))))))
                    (if_statement [199, 6] - [203, 7]
                      condition: (parenthesized_expression [199, 9] - [199, 18]
                        (binary_expression [199, 10] - [199, 17]
                          left: (identifier [199, 10] - [199, 13])
                          right: (number [199, 16] - [199, 17])))
                      consequence: (statement_block [199, 19] - [201, 7]
                        (expression_statement [200, 8] - [200, 73]
                          (await_expression [200, 8] - [200, 72]
                            (call_expression [200, 14] - [200, 72]
                              function: (member_expression [200, 14] - [200, 26]
                                object: (identifier [200, 14] - [200, 20])
                                property: (property_identifier [200, 21] - [200, 26]))
                              arguments: (arguments [200, 26] - [200, 72]
                                (identifier [200, 27] - [200, 42])
                                (identifier [200, 44] - [200, 47])
                                (call_expression [200, 49] - [200, 71]
                                  function: (member_expression [200, 49] - [200, 63]
                                    object: (identifier [200, 49] - [200, 53])
                                    property: (property_identifier [200, 54] - [200, 63]))
                                  arguments: (arguments [200, 63] - [200, 71]
                                    (identifier [200, 64] - [200, 70]))))))))
                      alternative: (else_clause [201, 8] - [203, 7]
                        (statement_block [201, 13] - [203, 7]
                          (expression_statement [202, 8] - [202, 66]
                            (await_expression [202, 8] - [202, 65]
                              (call_expression [202, 14] - [202, 65]
                                function: (member_expression [202, 14] - [202, 24]
                                  object: (identifier [202, 14] - [202, 20])
                                  property: (property_identifier [202, 21] - [202, 24]))
                                arguments: (arguments [202, 24] - [202, 65]
                                  (identifier [202, 25] - [202, 40])
                                  (call_expression [202, 42] - [202, 64]
                                    function: (member_expression [202, 42] - [202, 56]
                                      object: (identifier [202, 42] - [202, 46])
                                      property: (property_identifier [202, 47] - [202, 56]))
                                    arguments: (arguments [202, 56] - [202, 64]
                                      (identifier [202, 57] - [202, 63])))))))))))))
              handler: (catch_clause [205, 4] - [207, 3]
                parameter: (identifier [205, 11] - [205, 14])
                body: (statement_block [205, 16] - [207, 3]
                  (expression_statement [206, 4] - [206, 73]
                    (call_expression [206, 4] - [206, 72]
                      function: (member_expression [206, 4] - [206, 17]
                        object: (identifier [206, 4] - [206, 11])
                        property: (property_identifier [206, 12] - [206, 17]))
                      arguments: (arguments [206, 17] - [206, 72]
                        (string [206, 18] - [206, 66]
                          (string_fragment [206, 19] - [206, 65]))
                        (identifier [206, 68] - [206, 71])))))))
            (expression_statement [209, 2] - [215, 4]
              (call_expression [209, 2] - [215, 3]
                function: (member_expression [209, 2] - [209, 23]
                  object: (identifier [209, 2] - [209, 14])
                  property: (property_identifier [209, 15] - [209, 23]))
                arguments: (arguments [209, 23] - [215, 3]
                  (member_expression [210, 4] - [210, 15]
                    object: (identifier [210, 4] - [210, 8])
                    property: (property_identifier [210, 9] - [210, 15]))
                  (ternary_expression [211, 4] - [211, 55]
                    condition: (identifier [211, 4] - [211, 15])
                    consequence: (string [211, 18] - [211, 34]
                      (string_fragment [211, 19] - [211, 33]))
                    alternative: (string [211, 37] - [211, 55]
                      (string_fragment [211, 38] - [211, 54])))
                  (identifier [212, 4] - [212, 19])
                  (object [213, 4] - [213, 6])
                  (call_expression [214, 4] - [214, 18]
                    function: (identifier [214, 4] - [214, 15])
                    arguments: (arguments [214, 15] - [214, 18]
                      (identifier [214, 16] - [214, 17]))))))
            (return_statement [217, 2] - [217, 59]
              (call_expression [217, 9] - [217, 58]
                function: (member_expression [217, 9] - [217, 15]
                  object: (identifier [217, 9] - [217, 10])
                  property: (property_identifier [217, 11] - [217, 15]))
                arguments: (arguments [217, 15] - [217, 58]
                  (object [217, 16] - [217, 57]
                    (pair [217, 18] - [217, 31]
                      key: (property_identifier [217, 18] - [217, 25])
                      value: (true [217, 27] - [217, 31]))
                    (pair [217, 33] - [217, 55]
                      key: (property_identifier [217, 33] - [217, 42])
                      value: (identifier [217, 44] - [217, 55])))))))))))
  (comment [220, 0] - [220, 60])
  (comment [221, 0] - [221, 21])
  (comment [222, 0] - [222, 60])
  (expression_statement [223, 0] - [261, 3]
    (call_expression [223, 0] - [261, 2]
      function: (member_expression [223, 0] - [223, 25]
        object: (identifier [223, 0] - [223, 20])
        property: (property_identifier [223, 21] - [223, 25]))
      arguments: (arguments [223, 25] - [261, 2]
        (string [223, 26] - [223, 52]
          (string_fragment [223, 27] - [223, 51]))
        (arrow_function [223, 54] - [261, 1]
          parameters: (formal_parameters [223, 60] - [223, 63]
            (required_parameter [223, 61] - [223, 62]
              pattern: (identifier [223, 61] - [223, 62])))
          body: (statement_block [223, 67] - [261, 1]
            (lexical_declaration [224, 2] - [224, 45]
              (variable_declarator [224, 8] - [224, 44]
                name: (identifier [224, 8] - [224, 12])
                value: (await_expression [224, 15] - [224, 44]
                  (call_expression [224, 21] - [224, 44]
                    function: (identifier [224, 21] - [224, 41])
                    arguments: (arguments [224, 41] - [224, 44]
                      (identifier [224, 42] - [224, 43]))))))
            (if_statement [225, 2] - [225, 59]
              condition: (parenthesized_expression [225, 5] - [225, 12]
                (unary_expression [225, 6] - [225, 11]
                  argument: (identifier [225, 7] - [225, 11])))
              consequence: (return_statement [225, 13] - [225, 59]
                (call_expression [225, 20] - [225, 58]
                  function: (member_expression [225, 20] - [225, 26]
                    object: (identifier [225, 20] - [225, 21])
                    property: (property_identifier [225, 22] - [225, 26]))
                  arguments: (arguments [225, 26] - [225, 58]
                    (object [225, 27] - [225, 52]
                      (pair [225, 29] - [225, 50]
                        key: (property_identifier [225, 29] - [225, 34])
                        value: (string [225, 36] - [225, 50]
                          (string_fragment [225, 37] - [225, 49]))))
                    (number [225, 54] - [225, 57])))))
            (if_statement [227, 2] - [229, 3]
              condition: (parenthesized_expression [227, 5] - [227, 40]
                (unary_expression [227, 6] - [227, 39]
                  argument: (call_expression [227, 7] - [227, 39]
                    function: (identifier [227, 7] - [227, 15])
                    arguments: (arguments [227, 15] - [227, 39]
                      (identifier [227, 16] - [227, 20])
                      (string [227, 22] - [227, 38]
                        (string_fragment [227, 23] - [227, 37]))))))
              consequence: (statement_block [227, 41] - [229, 3]
                (return_statement [228, 4] - [228, 68]
                  (call_expression [228, 11] - [228, 67]
                    function: (member_expression [228, 11] - [228, 17]
                      object: (identifier [228, 11] - [228, 12])
                      property: (property_identifier [228, 13] - [228, 17]))
                    arguments: (arguments [228, 17] - [228, 67]
                      (object [228, 18] - [228, 61]
                        (pair [228, 20] - [228, 59]
                          key: (property_identifier [228, 20] - [228, 25])
                          value: (string [228, 27] - [228, 59]
                            (string_fragment [228, 28] - [228, 58]))))
                      (number [228, 63] - [228, 66]))))))
            (lexical_declaration [231, 2] - [231, 44]
              (variable_declarator [231, 8] - [231, 43]
                name: (identifier [231, 8] - [231, 23])
                value: (call_expression [231, 26] - [231, 43]
                  function: (member_expression [231, 26] - [231, 37]
                    object: (member_expression [231, 26] - [231, 31]
                      object: (identifier [231, 26] - [231, 27])
                      property: (property_identifier [231, 28] - [231, 31]))
                    property: (property_identifier [231, 32] - [231, 37]))
                  arguments: (arguments [231, 37] - [231, 43]
                    (string [231, 38] - [231, 42]
                      (string_fragment [231, 39] - [231, 41]))))))
            (lexical_declaration [232, 2] - [232, 67]
              (variable_declarator [232, 8] - [232, 66]
                name: (object_pattern [232, 8] - [232, 27]
                  (object_assignment_pattern [232, 10] - [232, 25]
                    left: (shorthand_property_identifier_pattern [232, 10] - [232, 21])
                    right: (number [232, 24] - [232, 25])))
                value: (await_expression [232, 30] - [232, 66]
                  (call_expression [232, 36] - [232, 66]
                    function: (member_expression [232, 36] - [232, 54]
                      object: (call_expression [232, 36] - [232, 48]
                        function: (member_expression [232, 36] - [232, 46]
                          object: (member_expression [232, 36] - [232, 41]
                            object: (identifier [232, 36] - [232, 37])
                            property: (property_identifier [232, 38] - [232, 41]))
                          property: (property_identifier [232, 42] - [232, 46]))
                        arguments: (arguments [232, 46] - [232, 48]))
                      property: (property_identifier [232, 49] - [232, 54]))
                    arguments: (arguments [232, 54] - [232, 66]
                      (arrow_function [232, 55] - [232, 65]
                        parameters: (formal_parameters [232, 55] - [232, 57])
                        body: (parenthesized_expression [232, 61] - [232, 65]
                          (object [232, 62] - [232, 64]))))))))
            (lexical_declaration [233, 2] - [233, 64]
              (variable_declarator [233, 8] - [233, 63]
                name: (identifier [233, 8] - [233, 23])
                value: (call_expression [233, 26] - [233, 63]
                  function: (member_expression [233, 26] - [233, 34]
                    object: (identifier [233, 26] - [233, 30])
                    property: (property_identifier [233, 31] - [233, 34]))
                  arguments: (arguments [233, 34] - [233, 63]
                    (binary_expression [233, 35] - [233, 59]
                      left: (call_expression [233, 35] - [233, 54]
                        function: (identifier [233, 35] - [233, 41])
                        arguments: (arguments [233, 41] - [233, 54]
                          (identifier [233, 42] - [233, 53])))
                      right: (number [233, 58] - [233, 59]))
                    (number [233, 61] - [233, 62])))))
            (lexical_declaration [235, 2] - [235, 78]
              (variable_declarator [235, 8] - [235, 77]
                name: (identifier [235, 8] - [235, 15])
                value: (await_expression [235, 18] - [235, 77]
                  (call_expression [235, 24] - [235, 77]
                    function: (identifier [235, 24] - [235, 47])
                    arguments: (arguments [235, 47] - [235, 77]
                      (identifier [235, 48] - [235, 63])
                      (member_expression [235, 65] - [235, 76]
                        object: (identifier [235, 65] - [235, 69])
                        property: (property_identifier [235, 70] - [235, 76])))))))
            (if_statement [236, 2] - [238, 3]
              condition: (parenthesized_expression [236, 5] - [236, 15]
                (unary_expression [236, 6] - [236, 14]
                  argument: (identifier [236, 7] - [236, 14])))
              consequence: (statement_block [236, 16] - [238, 3]
                (return_statement [237, 4] - [237, 72]
                  (call_expression [237, 11] - [237, 71]
                    function: (member_expression [237, 11] - [237, 17]
                      object: (identifier [237, 11] - [237, 12])
                      property: (property_identifier [237, 13] - [237, 17]))
                    arguments: (arguments [237, 17] - [237, 71]
                      (object [237, 18] - [237, 65]
                        (pair [237, 20] - [237, 63]
                          key: (property_identifier [237, 20] - [237, 25])
                          value: (string [237, 27] - [237, 63]
                            (string_fragment [237, 28] - [237, 62]))))
                      (number [237, 67] - [237, 70]))))))
            (lexical_declaration [240, 2] - [240, 63]
              (variable_declarator [240, 8] - [240, 62]
                name: (identifier [240, 8] - [240, 21])
                value: (call_expression [240, 24] - [240, 62]
                  function: (member_expression [240, 24] - [240, 60]
                    object: (new_expression [240, 24] - [240, 52]
                      constructor: (identifier [240, 28] - [240, 32])
                      arguments: (arguments [240, 32] - [240, 52]
                        (member_expression [240, 33] - [240, 51]
                          object: (identifier [240, 33] - [240, 40])
                          property: (property_identifier [240, 41] - [240, 51]))))
                    property: (property_identifier [240, 53] - [240, 60]))
                  arguments: (arguments [240, 60] - [240, 62]))))
            (lexical_declaration [241, 2] - [243, 4]
              (variable_declarator [241, 8] - [243, 3]
                name: (identifier [241, 8] - [241, 17])
                value: (new_expression [241, 20] - [243, 3]
                  constructor: (identifier [241, 24] - [241, 28])
                  arguments: (arguments [241, 28] - [243, 3]
                    (binary_expression [242, 4] - [242, 71]
                      left: (call_expression [242, 4] - [242, 39]
                        function: (member_expression [242, 4] - [242, 12]
                          object: (identifier [242, 4] - [242, 8])
                          property: (property_identifier [242, 9] - [242, 12]))
                        arguments: (arguments [242, 12] - [242, 39]
                          (call_expression [242, 13] - [242, 23]
                            function: (member_expression [242, 13] - [242, 21]
                              object: (identifier [242, 13] - [242, 17])
                              property: (property_identifier [242, 18] - [242, 21]))
                            arguments: (arguments [242, 21] - [242, 23]))
                          (identifier [242, 25] - [242, 38])))
                      right: (binary_expression [242, 42] - [242, 71]
                        left: (binary_expression [242, 42] - [242, 64]
                          left: (identifier [242, 42] - [242, 57])
                          right: (number [242, 60] - [242, 64]))
                        right: (number [242, 67] - [242, 71])))))))
            (expression_statement [245, 2] - [245, 56]
              (await_expression [245, 2] - [245, 55]
                (call_expression [245, 8] - [245, 55]
                  function: (identifier [245, 8] - [245, 27])
                  arguments: (arguments [245, 27] - [245, 55]
                    (identifier [245, 28] - [245, 43])
                    (identifier [245, 45] - [245, 54])))))
            (try_statement [247, 2] - [253, 17]
              body: (statement_block [247, 6] - [253, 3]
                (lexical_declaration [248, 4] - [251, 6]
                  (variable_declarator [248, 10] - [251, 5]
                    name: (identifier [248, 10] - [248, 20])
                    value: (call_expression [248, 23] - [251, 5]
                      function: (member_expression [248, 23] - [248, 31]
                        object: (identifier [248, 23] - [248, 27])
                        property: (property_identifier [248, 28] - [248, 31]))
                      arguments: (arguments [248, 31] - [251, 5]
                        (number [249, 6] - [249, 7])
                        (call_expression [250, 6] - [250, 59]
                          function: (member_expression [250, 6] - [250, 16]
                            object: (identifier [250, 6] - [250, 10])
                            property: (property_identifier [250, 11] - [250, 16]))
                          arguments: (arguments [250, 16] - [250, 59]
                            (binary_expression [250, 17] - [250, 58]
                              left: (parenthesized_expression [250, 17] - [250, 51]
                                (binary_expression [250, 18] - [250, 50]
                                  left: (call_expression [250, 18] - [250, 37]
                                    function: (member_expression [250, 18] - [250, 35]
                                      object: (identifier [250, 18] - [250, 27])
                                      property: (property_identifier [250, 28] - [250, 35]))
                                    arguments: (arguments [250, 35] - [250, 37]))
                                  right: (call_expression [250, 40] - [250, 50]
                                    function: (member_expression [250, 40] - [250, 48]
                                      object: (identifier [250, 40] - [250, 44])
                                      property: (property_identifier [250, 45] - [250, 48]))
                                    arguments: (arguments [250, 48] - [250, 50]))))
                              right: (number [250, 54] - [250, 58]))))))))
                (expression_statement [252, 4] - [252, 53]
                  (await_expression [252, 4] - [252, 52]
                    (call_expression [252, 10] - [252, 52]
                      function: (member_expression [252, 10] - [252, 23]
                        object: (identifier [252, 10] - [252, 16])
                        property: (property_identifier [252, 17] - [252, 23]))
                      arguments: (arguments [252, 23] - [252, 52]
                        (identifier [252, 24] - [252, 39])
                        (identifier [252, 41] - [252, 51]))))))
              handler: (catch_clause [253, 4] - [253, 17]
                parameter: (identifier [253, 11] - [253, 13])
                body: (statement_block [253, 15] - [253, 17])))
            (expression_statement [255, 2] - [258, 21]
              (call_expression [255, 2] - [258, 20]
                function: (member_expression [255, 2] - [255, 23]
                  object: (identifier [255, 2] - [255, 14])
                  property: (property_identifier [255, 15] - [255, 23]))
                arguments: (arguments [255, 23] - [258, 20]
                  (member_expression [255, 24] - [255, 35]
                    object: (identifier [255, 24] - [255, 28])
                    property: (property_identifier [255, 29] - [255, 35]))
                  (string [255, 37] - [255, 55]
                    (string_fragment [255, 38] - [255, 54]))
                  (identifier [255, 57] - [255, 72])
                  (object [255, 74] - [258, 3]
                    (pair [256, 4] - [256, 38]
                      key: (property_identifier [256, 4] - [256, 21])
                      value: (identifier [256, 23] - [256, 38]))
                    (pair [257, 4] - [257, 43]
                      key: (property_identifier [257, 4] - [257, 18])
                      value: (call_expression [257, 20] - [257, 43]
                        function: (member_expression [257, 20] - [257, 41]
                          object: (identifier [257, 20] - [257, 29])
                          property: (property_identifier [257, 30] - [257, 41]))
                        arguments: (arguments [257, 41] - [257, 43]))))
                  (call_expression [258, 5] - [258, 19]
                    function: (identifier [258, 5] - [258, 16])
                    arguments: (arguments [258, 16] - [258, 19]
                      (identifier [258, 17] - [258, 18]))))))
            (return_statement [260, 2] - [260, 74]
              (call_expression [260, 9] - [260, 73]
                function: (member_expression [260, 9] - [260, 15]
                  object: (identifier [260, 9] - [260, 10])
                  property: (property_identifier [260, 11] - [260, 15]))
                arguments: (arguments [260, 15] - [260, 73]
                  (object [260, 16] - [260, 72]
                    (pair [260, 18] - [260, 31]
                      key: (property_identifier [260, 18] - [260, 25])
                      value: (true [260, 27] - [260, 31]))
                    (pair [260, 33] - [260, 70]
                      key: (property_identifier [260, 33] - [260, 45])
                      value: (call_expression [260, 47] - [260, 70]
                        function: (member_expression [260, 47] - [260, 68]
                          object: (identifier [260, 47] - [260, 56])
                          property: (property_identifier [260, 57] - [260, 68]))
                        arguments: (arguments [260, 68] - [260, 70]))))))))))))
  (comment [263, 0] - [263, 60])
  (comment [264, 0] - [264, 28])
  (comment [265, 0] - [265, 60])
  (expression_statement [266, 0] - [306, 3]
    (call_expression [266, 0] - [306, 2]
      function: (member_expression [266, 0] - [266, 27]
        object: (identifier [266, 0] - [266, 20])
        property: (property_identifier [266, 21] - [266, 27]))
      arguments: (arguments [266, 27] - [306, 2]
        (string [266, 28] - [266, 47]
          (string_fragment [266, 29] - [266, 46]))
        (arrow_function [266, 49] - [306, 1]
          parameters: (formal_parameters [266, 55] - [266, 58]
            (required_parameter [266, 56] - [266, 57]
              pattern: (identifier [266, 56] - [266, 57])))
          body: (statement_block [266, 62] - [306, 1]
            (lexical_declaration [267, 2] - [267, 45]
              (variable_declarator [267, 8] - [267, 44]
                name: (identifier [267, 8] - [267, 12])
                value: (await_expression [267, 15] - [267, 44]
                  (call_expression [267, 21] - [267, 44]
                    function: (identifier [267, 21] - [267, 41])
                    arguments: (arguments [267, 41] - [267, 44]
                      (identifier [267, 42] - [267, 43]))))))
            (if_statement [268, 2] - [268, 59]
              condition: (parenthesized_expression [268, 5] - [268, 12]
                (unary_expression [268, 6] - [268, 11]
                  argument: (identifier [268, 7] - [268, 11])))
              consequence: (return_statement [268, 13] - [268, 59]
                (call_expression [268, 20] - [268, 58]
                  function: (member_expression [268, 20] - [268, 26]
                    object: (identifier [268, 20] - [268, 21])
                    property: (property_identifier [268, 22] - [268, 26]))
                  arguments: (arguments [268, 26] - [268, 58]
                    (object [268, 27] - [268, 52]
                      (pair [268, 29] - [268, 50]
                        key: (property_identifier [268, 29] - [268, 34])
                        value: (string [268, 36] - [268, 50]
                          (string_fragment [268, 37] - [268, 49]))))
                    (number [268, 54] - [268, 57])))))
            (lexical_declaration [270, 2] - [270, 44]
              (variable_declarator [270, 8] - [270, 43]
                name: (identifier [270, 8] - [270, 23])
                value: (call_expression [270, 26] - [270, 43]
                  function: (member_expression [270, 26] - [270, 37]
                    object: (member_expression [270, 26] - [270, 31]
                      object: (identifier [270, 26] - [270, 27])
                      property: (property_identifier [270, 28] - [270, 31]))
                    property: (property_identifier [270, 32] - [270, 37]))
                  arguments: (arguments [270, 37] - [270, 43]
                    (string [270, 38] - [270, 42]
                      (string_fragment [270, 39] - [270, 41]))))))
            (if_statement [272, 2] - [276, 3]
              condition: (parenthesized_expression [272, 5] - [272, 41]
                (binary_expression [272, 6] - [272, 40]
                  left: (identifier [272, 6] - [272, 21])
                  right: (member_expression [272, 26] - [272, 40]
                    object: (identifier [272, 26] - [272, 30])
                    property: (property_identifier [272, 31] - [272, 40]))))
              consequence: (statement_block [272, 42] - [276, 3]
                (if_statement [273, 4] - [275, 5]
                  condition: (parenthesized_expression [273, 7] - [273, 42]
                    (unary_expression [273, 8] - [273, 41]
                      argument: (call_expression [273, 9] - [273, 41]
                        function: (identifier [273, 9] - [273, 17])
                        arguments: (arguments [273, 17] - [273, 41]
                          (identifier [273, 18] - [273, 22])
                          (string [273, 24] - [273, 40]
                            (string_fragment [273, 25] - [273, 39]))))))
                  consequence: (statement_block [273, 43] - [275, 5]
                    (return_statement [274, 6] - [274, 70]
                      (call_expression [274, 13] - [274, 69]
                        function: (member_expression [274, 13] - [274, 19]
                          object: (identifier [274, 13] - [274, 14])
                          property: (property_identifier [274, 15] - [274, 19]))
                        arguments: (arguments [274, 19] - [274, 69]
                          (object [274, 20] - [274, 63]
                            (pair [274, 22] - [274, 61]
                              key: (property_identifier [274, 22] - [274, 27])
                              value: (string [274, 29] - [274, 61]
                                (string_fragment [274, 30] - [274, 60]))))
                          (number [274, 65] - [274, 68]))))))))
            (lexical_declaration [278, 2] - [278, 65]
              (variable_declarator [278, 8] - [278, 64]
                name: (identifier [278, 8] - [278, 15])
                value: (binary_expression [278, 18] - [278, 64]
                  left: (call_expression [278, 18] - [278, 41]
                    function: (identifier [278, 18] - [278, 26])
                    arguments: (arguments [278, 26] - [278, 41]
                      (identifier [278, 27] - [278, 31])
                      (string [278, 33] - [278, 40]
                        (string_fragment [278, 34] - [278, 39]))))
                  right: (call_expression [278, 45] - [278, 64]
                    function: (identifier [278, 45] - [278, 53])
                    arguments: (arguments [278, 53] - [278, 64]
                      (identifier [278, 54] - [278, 58])
                      (string [278, 60] - [278, 63]
                        (string_fragment [278, 61] - [278, 62])))))))
            (lexical_declaration [279, 2] - [283, 4]
              (variable_declarator [279, 8] - [283, 3]
                name: (identifier [279, 8] - [279, 15])
                value: (await_expression [279, 18] - [283, 3]
                  (call_expression [279, 24] - [283, 3]
                    function: (identifier [279, 24] - [279, 52])
                    arguments: (arguments [279, 52] - [283, 3]
                      (identifier [280, 4] - [280, 19])
                      (member_expression [281, 4] - [281, 15]
                        object: (identifier [281, 4] - [281, 8])
                        property: (property_identifier [281, 9] - [281, 15]))
                      (identifier [282, 4] - [282, 11]))))))
            (if_statement [285, 2] - [287, 3]
              condition: (parenthesized_expression [285, 5] - [285, 15]
                (unary_expression [285, 6] - [285, 14]
                  argument: (identifier [285, 7] - [285, 14])))
              consequence: (statement_block [285, 16] - [287, 3]
                (return_statement [286, 4] - [286, 72]
                  (call_expression [286, 11] - [286, 71]
                    function: (member_expression [286, 11] - [286, 17]
                      object: (identifier [286, 11] - [286, 12])
                      property: (property_identifier [286, 13] - [286, 17]))
                    arguments: (arguments [286, 17] - [286, 71]
                      (object [286, 18] - [286, 65]
                        (pair [286, 20] - [286, 63]
                          key: (property_identifier [286, 20] - [286, 25])
                          value: (string [286, 27] - [286, 63]
                            (string_fragment [286, 28] - [286, 62]))))
                      (number [286, 67] - [286, 70]))))))
            (try_statement [289, 2] - [297, 3]
              body: (statement_block [289, 6] - [295, 3]
                (expression_statement [290, 4] - [290, 38]
                  (await_expression [290, 4] - [290, 37]
                    (call_expression [290, 10] - [290, 37]
                      function: (member_expression [290, 10] - [290, 20]
                        object: (identifier [290, 10] - [290, 16])
                        property: (property_identifier [290, 17] - [290, 20]))
                      arguments: (arguments [290, 20] - [290, 37]
                        (identifier [290, 21] - [290, 36])))))
                (expression_statement [291, 4] - [294, 6]
                  (await_expression [291, 4] - [294, 5]
                    (call_expression [291, 10] - [294, 5]
                      function: (member_expression [291, 10] - [291, 24]
                        object: (identifier [291, 10] - [291, 16])
                        property: (property_identifier [291, 17] - [291, 24]))
                      arguments: (arguments [291, 24] - [294, 5]
                        (template_string [292, 6] - [292, 43]
                          (string_fragment [292, 7] - [292, 24])
                          (template_substitution [292, 24] - [292, 42]
                            (identifier [292, 26] - [292, 41])))
                        (call_expression [293, 6] - [293, 76]
                          function: (member_expression [293, 6] - [293, 20]
                            object: (identifier [293, 6] - [293, 10])
                            property: (property_identifier [293, 11] - [293, 20]))
                          arguments: (arguments [293, 20] - [293, 76]
                            (object [293, 21] - [293, 75]
                              (pair [293, 23] - [293, 49]
                                key: (property_identifier [293, 23] - [293, 32])
                                value: (identifier [293, 34] - [293, 49]))
                              (pair [293, 51] - [293, 73]
                                key: (property_identifier [293, 51] - [293, 60])
                                value: (member_expression [293, 62] - [293, 73]
                                  object: (identifier [293, 62] - [293, 66])
                                  property: (property_identifier [293, 67] - [293, 73])))))))))))
              handler: (catch_clause [295, 4] - [297, 3]
                parameter: (identifier [295, 11] - [295, 14])
                body: (statement_block [295, 16] - [297, 3]
                  (expression_statement [296, 4] - [296, 63]
                    (call_expression [296, 4] - [296, 62]
                      function: (member_expression [296, 4] - [296, 17]
                        object: (identifier [296, 4] - [296, 11])
                        property: (property_identifier [296, 12] - [296, 17]))
                      arguments: (arguments [296, 17] - [296, 62]
                        (string [296, 18] - [296, 56]
                          (string_fragment [296, 19] - [296, 55]))
                        (identifier [296, 58] - [296, 61])))))))
            (expression_statement [299, 2] - [299, 39]
              (await_expression [299, 2] - [299, 38]
                (call_expression [299, 8] - [299, 38]
                  function: (identifier [299, 8] - [299, 21])
                  arguments: (arguments [299, 21] - [299, 38]
                    (identifier [299, 22] - [299, 37])))))
            (expression_statement [301, 2] - [303, 21]
              (call_expression [301, 2] - [303, 20]
                function: (member_expression [301, 2] - [301, 23]
                  object: (identifier [301, 2] - [301, 14])
                  property: (property_identifier [301, 15] - [301, 23]))
                arguments: (arguments [301, 23] - [303, 20]
                  (member_expression [301, 24] - [301, 35]
                    object: (identifier [301, 24] - [301, 28])
                    property: (property_identifier [301, 29] - [301, 35]))
                  (string [301, 37] - [301, 54]
                    (string_fragment [301, 38] - [301, 53]))
                  (null [301, 56] - [301, 60])
                  (object [301, 62] - [303, 3]
                    (pair [302, 4] - [302, 39]
                      key: (property_identifier [302, 4] - [302, 22])
                      value: (identifier [302, 24] - [302, 39])))
                  (call_expression [303, 5] - [303, 19]
                    function: (identifier [303, 5] - [303, 16])
                    arguments: (arguments [303, 16] - [303, 19]
                      (identifier [303, 17] - [303, 18]))))))
            (return_statement [305, 2] - [305, 35]
              (call_expression [305, 9] - [305, 34]
                function: (member_expression [305, 9] - [305, 15]
                  object: (identifier [305, 9] - [305, 10])
                  property: (property_identifier [305, 11] - [305, 15]))
                arguments: (arguments [305, 15] - [305, 34]
                  (object [305, 16] - [305, 33]
                    (pair [305, 18] - [305, 31]
                      key: (property_identifier [305, 18] - [305, 25])
                      value: (true [305, 27] - [305, 31]))))))))))))