(program [0, 0] - [262, 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 [1, 0] - [1, 63]
    (import_clause [1, 7] - [1, 31]
      (named_imports [1, 7] - [1, 31]
        (import_specifier [1, 9] - [1, 18]
          name: (identifier [1, 9] - [1, 18]))
        (import_specifier [1, 20] - [1, 29]
          name: (identifier [1, 20] - [1, 29]))))
    source: (string [1, 37] - [1, 62]
      (string_fragment [1, 38] - [1, 61])))
  (import_statement [2, 0] - [2, 64]
    (import_clause [2, 7] - [2, 26]
      (named_imports [2, 7] - [2, 26]
        (import_specifier [2, 9] - [2, 24]
          name: (identifier [2, 9] - [2, 24]))))
    source: (string [2, 32] - [2, 63]
      (string_fragment [2, 33] - [2, 62])))
  (import_statement [3, 0] - [6, 39]
    (import_clause [3, 7] - [6, 1]
      (named_imports [3, 7] - [6, 1]
        (import_specifier [4, 2] - [4, 29]
          name: (identifier [4, 2] - [4, 29]))
        (import_specifier [5, 2] - [5, 28]
          name: (identifier [5, 2] - [5, 28]))))
    source: (string [6, 7] - [6, 38]
      (string_fragment [6, 8] - [6, 37])))
  (import_statement [7, 0] - [7, 78]
    (import_clause [7, 12] - [7, 40]
      (named_imports [7, 12] - [7, 40]
        (import_specifier [7, 14] - [7, 38]
          name: (identifier [7, 14] - [7, 38]))))
    source: (string [7, 46] - [7, 77]
      (string_fragment [7, 47] - [7, 76])))
  (import_statement [9, 0] - [9, 46]
    (import_clause [9, 7] - [9, 17]
      (named_imports [9, 7] - [9, 17]
        (import_specifier [9, 9] - [9, 15]
          name: (identifier [9, 9] - [9, 15]))))
    source: (string [9, 23] - [9, 45]
      (string_fragment [9, 24] - [9, 44])))
  (import_statement [10, 0] - [10, 74]
    (import_clause [10, 7] - [10, 41]
      (named_imports [10, 7] - [10, 41]
        (import_specifier [10, 9] - [10, 20]
          name: (identifier [10, 9] - [10, 20]))
        (import_specifier [10, 22] - [10, 39]
          name: (identifier [10, 22] - [10, 39]))))
    source: (string [10, 47] - [10, 73]
      (string_fragment [10, 48] - [10, 72])))
  (import_statement [11, 0] - [11, 51]
    (import_clause [11, 7] - [11, 23]
      (named_imports [11, 7] - [11, 23]
        (import_specifier [11, 9] - [11, 21]
          name: (identifier [11, 9] - [11, 21]))))
    source: (string [11, 29] - [11, 50]
      (string_fragment [11, 30] - [11, 49])))
  (import_statement [12, 0] - [12, 78]
    (import_clause [12, 7] - [12, 48]
      (named_imports [12, 7] - [12, 48]
        (import_specifier [12, 9] - [12, 29]
          name: (identifier [12, 9] - [12, 29]))
        (import_specifier [12, 31] - [12, 46]
          name: (identifier [12, 31] - [12, 46]))))
    source: (string [12, 54] - [12, 77]
      (string_fragment [12, 55] - [12, 76])))
  (import_statement [14, 0] - [21, 22]
    (import_clause [14, 7] - [21, 1]
      (named_imports [14, 7] - [21, 1]
        (import_specifier [15, 2] - [15, 15]
          name: (identifier [15, 2] - [15, 15]))
        (import_specifier [16, 2] - [16, 15]
          name: (identifier [16, 2] - [16, 15]))
        (import_specifier [17, 2] - [17, 12]
          name: (identifier [17, 2] - [17, 12]))
        (import_specifier [18, 2] - [18, 16]
          name: (identifier [18, 2] - [18, 16]))
        (import_specifier [19, 2] - [19, 19]
          name: (identifier [19, 2] - [19, 19]))
        (import_specifier [20, 2] - [20, 21]
          name: (identifier [20, 2] - [20, 21]))))
    source: (string [21, 7] - [21, 21]
      (string_fragment [21, 8] - [21, 20])))
  (import_statement [22, 0] - [22, 64]
    (import_clause [22, 7] - [22, 31]
      (named_imports [22, 7] - [22, 31]
        (import_specifier [22, 9] - [22, 29]
          name: (identifier [22, 9] - [22, 29]))))
    source: (string [22, 37] - [22, 63]
      (string_fragment [22, 38] - [22, 62])))
  (export_statement [24, 0] - [24, 41]
    declaration: (lexical_declaration [24, 7] - [24, 41]
      (variable_declarator [24, 13] - [24, 40]
        name: (identifier [24, 13] - [24, 27])
        value: (new_expression [24, 30] - [24, 40]
          constructor: (identifier [24, 34] - [24, 38])
          arguments: (arguments [24, 38] - [24, 40])))))
  (lexical_declaration [26, 0] - [27, 47]
    (variable_declarator [26, 6] - [27, 46]
      name: (identifier [26, 6] - [26, 10])
      value: (binary_expression [26, 13] - [27, 46]
        left: (call_expression [26, 13] - [26, 34]
          function: (member_expression [26, 13] - [26, 25]
            object: (member_expression [26, 13] - [26, 21]
              object: (identifier [26, 13] - [26, 17])
              property: (property_identifier [26, 18] - [26, 21]))
            property: (property_identifier [26, 22] - [26, 25]))
          arguments: (arguments [26, 25] - [26, 34]
            (string [26, 26] - [26, 33]
              (string_fragment [26, 27] - [26, 32]))))
        right: (parenthesized_expression [27, 2] - [27, 46]
          (ternary_expression [27, 3] - [27, 45]
            condition: (member_expression [27, 3] - [27, 19]
              object: (meta_property [27, 3] - [27, 14])
              property: (property_identifier [27, 15] - [27, 19]))
            consequence: (undefined [27, 22] - [27, 31])
            alternative: (string [27, 34] - [27, 45]
              (string_fragment [27, 35] - [27, 44])))))))
  (lexical_declaration [28, 0] - [29, 54]
    (variable_declarator [28, 6] - [29, 53]
      name: (identifier [28, 6] - [28, 12])
      value: (binary_expression [28, 15] - [29, 53]
        left: (call_expression [28, 15] - [28, 37]
          function: (member_expression [28, 15] - [28, 27]
            object: (member_expression [28, 15] - [28, 23]
              object: (identifier [28, 15] - [28, 19])
              property: (property_identifier [28, 20] - [28, 23]))
            property: (property_identifier [28, 24] - [28, 27]))
          arguments: (arguments [28, 27] - [28, 37]
            (string [28, 28] - [28, 36]
              (string_fragment [28, 29] - [28, 35]))))
        right: (parenthesized_expression [29, 2] - [29, 53]
          (ternary_expression [29, 3] - [29, 52]
            condition: (member_expression [29, 3] - [29, 19]
              object: (meta_property [29, 3] - [29, 14])
              property: (property_identifier [29, 15] - [29, 19]))
            consequence: (undefined [29, 22] - [29, 31])
            alternative: (string [29, 34] - [29, 52]
              (string_fragment [29, 35] - [29, 51])))))))
  (comment [31, 0] - [31, 11])
  (expression_statement [32, 0] - [39, 3]
    (call_expression [32, 0] - [39, 2]
      function: (member_expression [32, 0] - [32, 18]
        object: (identifier [32, 0] - [32, 14])
        property: (property_identifier [32, 15] - [32, 18]))
      arguments: (arguments [32, 18] - [39, 2]
        (string [32, 19] - [32, 30]
          (string_fragment [32, 20] - [32, 29]))
        (arrow_function [32, 32] - [39, 1]
          parameters: (formal_parameters [32, 38] - [32, 41]
            (required_parameter [32, 39] - [32, 40]
              pattern: (identifier [32, 39] - [32, 40])))
          body: (statement_block [32, 45] - [39, 1]
            (lexical_declaration [33, 2] - [33, 45]
              (variable_declarator [33, 8] - [33, 44]
                name: (identifier [33, 8] - [33, 12])
                value: (await_expression [33, 15] - [33, 44]
                  (call_expression [33, 21] - [33, 44]
                    function: (identifier [33, 21] - [33, 41])
                    arguments: (arguments [33, 41] - [33, 44]
                      (identifier [33, 42] - [33, 43]))))))
            (if_statement [34, 2] - [36, 3]
              condition: (parenthesized_expression [34, 5] - [34, 11]
                (identifier [34, 6] - [34, 10]))
              consequence: (statement_block [34, 12] - [36, 3]
                (return_statement [35, 4] - [35, 36]
                  (call_expression [35, 11] - [35, 35]
                    function: (member_expression [35, 11] - [35, 21]
                      object: (identifier [35, 11] - [35, 12])
                      property: (property_identifier [35, 13] - [35, 21]))
                    arguments: (arguments [35, 21] - [35, 35]
                      (string [35, 22] - [35, 34]
                        (string_fragment [35, 23] - [35, 33])))))))
            (lexical_declaration [37, 2] - [37, 41]
              (variable_declarator [37, 8] - [37, 40]
                name: (identifier [37, 8] - [37, 12])
                value: (binary_expression [37, 15] - [37, 40]
                  left: (call_expression [37, 15] - [37, 34]
                    function: (member_expression [37, 15] - [37, 26]
                      object: (member_expression [37, 15] - [37, 20]
                        object: (identifier [37, 15] - [37, 16])
                        property: (property_identifier [37, 17] - [37, 20]))
                      property: (property_identifier [37, 21] - [37, 26]))
                    arguments: (arguments [37, 26] - [37, 34]
                      (string [37, 27] - [37, 33]
                        (string_fragment [37, 28] - [37, 32]))))
                  right: (string [37, 38] - [37, 40]))))
            (return_statement [38, 2] - [38, 61]
              (call_expression [38, 9] - [38, 60]
                function: (member_expression [38, 9] - [38, 15]
                  object: (identifier [38, 9] - [38, 10])
                  property: (property_identifier [38, 11] - [38, 15]))
                arguments: (arguments [38, 15] - [38, 60]
                  (call_expression [38, 16] - [38, 59]
                    function: (identifier [38, 16] - [38, 36])
                    arguments: (arguments [38, 36] - [38, 59]
                      (object [38, 37] - [38, 58]
                        (pair [38, 39] - [38, 56]
                          key: (property_identifier [38, 39] - [38, 50])
                          value: (identifier [38, 52] - [38, 56])))))))))))))
  (comment [41, 0] - [41, 13])
  (expression_statement [42, 0] - [42, 57]
    (call_expression [42, 0] - [42, 56]
      function: (member_expression [42, 0] - [42, 18]
        object: (identifier [42, 0] - [42, 14])
        property: (property_identifier [42, 15] - [42, 18]))
      arguments: (arguments [42, 18] - [42, 56]
        (string [42, 19] - [42, 36]
          (string_fragment [42, 20] - [42, 35]))
        (identifier [42, 38] - [42, 55]))))
  (comment [44, 0] - [44, 21])
  (expression_statement [45, 0] - [96, 3]
    (call_expression [45, 0] - [96, 2]
      function: (member_expression [45, 0] - [45, 19]
        object: (identifier [45, 0] - [45, 14])
        property: (property_identifier [45, 15] - [45, 19]))
      arguments: (arguments [45, 19] - [96, 2]
        (string [45, 20] - [45, 45]
          (string_fragment [45, 21] - [45, 44]))
        (arrow_function [45, 47] - [96, 1]
          parameters: (formal_parameters [45, 53] - [45, 56]
            (required_parameter [45, 54] - [45, 55]
              pattern: (identifier [45, 54] - [45, 55])))
          body: (statement_block [45, 60] - [96, 1]
            (lexical_declaration [46, 2] - [46, 11]
              (variable_declarator [46, 6] - [46, 10]
                name: (identifier [46, 6] - [46, 10])))
            (try_statement [47, 2] - [51, 3]
              body: (statement_block [47, 6] - [49, 3]
                (expression_statement [48, 4] - [48, 30]
                  (assignment_expression [48, 4] - [48, 29]
                    left: (identifier [48, 4] - [48, 8])
                    right: (await_expression [48, 11] - [48, 29]
                      (call_expression [48, 17] - [48, 29]
                        function: (member_expression [48, 17] - [48, 27]
                          object: (member_expression [48, 17] - [48, 22]
                            object: (identifier [48, 17] - [48, 18])
                            property: (property_identifier [48, 19] - [48, 22]))
                          property: (property_identifier [48, 23] - [48, 27]))
                        arguments: (arguments [48, 27] - [48, 29]))))))
              handler: (catch_clause [49, 4] - [51, 3]
                body: (statement_block [49, 10] - [51, 3]
                  (return_statement [50, 4] - [50, 53]
                    (call_expression [50, 11] - [50, 52]
                      function: (member_expression [50, 11] - [50, 17]
                        object: (identifier [50, 11] - [50, 12])
                        property: (property_identifier [50, 13] - [50, 17]))
                      arguments: (arguments [50, 17] - [50, 52]
                        (object [50, 18] - [50, 46]
                          (pair [50, 20] - [50, 44]
                            key: (property_identifier [50, 20] - [50, 25])
                            value: (string [50, 27] - [50, 44]
                              (string_fragment [50, 28] - [50, 43]))))
                        (number [50, 48] - [50, 51])))))))
            (lexical_declaration [52, 2] - [52, 40]
              (variable_declarator [52, 8] - [52, 39]
                name: (object_pattern [52, 8] - [52, 32]
                  (shorthand_property_identifier_pattern [52, 10] - [52, 18])
                  (shorthand_property_identifier_pattern [52, 20] - [52, 30]))
                value: (identifier [52, 35] - [52, 39])))
            (if_statement [54, 2] - [56, 3]
              condition: (parenthesized_expression [54, 5] - [54, 31]
                (binary_expression [54, 6] - [54, 30]
                  left: (unary_expression [54, 6] - [54, 15]
                    argument: (identifier [54, 7] - [54, 15]))
                  right: (unary_expression [54, 19] - [54, 30]
                    argument: (identifier [54, 20] - [54, 30]))))
              consequence: (statement_block [54, 32] - [56, 3]
                (return_statement [55, 4] - [55, 75]
                  (call_expression [55, 11] - [55, 74]
                    function: (member_expression [55, 11] - [55, 17]
                      object: (identifier [55, 11] - [55, 12])
                      property: (property_identifier [55, 13] - [55, 17]))
                    arguments: (arguments [55, 17] - [55, 74]
                      (object [55, 18] - [55, 68]
                        (pair [55, 20] - [55, 66]
                          key: (property_identifier [55, 20] - [55, 25])
                          value: (string [55, 27] - [55, 66]
                            (string_fragment [55, 28] - [55, 65]))))
                      (number [55, 70] - [55, 73]))))))
            (if_statement [58, 2] - [58, 45]
              condition: (parenthesized_expression [58, 5] - [58, 12]
                (unary_expression [58, 6] - [58, 11]
                  argument: (identifier [58, 7] - [58, 11])))
              consequence: (throw_statement [58, 13] - [58, 45]
                (new_expression [58, 19] - [58, 44]
                  constructor: (identifier [58, 23] - [58, 28])
                  arguments: (arguments [58, 28] - [58, 44]
                    (string [58, 29] - [58, 43]
                      (string_fragment [58, 30] - [58, 42]))))))
            (lexical_declaration [60, 2] - [60, 41]
              (variable_declarator [60, 8] - [60, 40]
                name: (identifier [60, 8] - [60, 19])
                value: (new_expression [60, 22] - [60, 40]
                  constructor: (identifier [60, 26] - [60, 36])
                  arguments: (arguments [60, 36] - [60, 40]
                    (number [60, 37] - [60, 39])))))
            (expression_statement [61, 2] - [61, 38]
              (call_expression [61, 2] - [61, 37]
                function: (member_expression [61, 2] - [61, 24]
                  object: (identifier [61, 2] - [61, 8])
                  property: (property_identifier [61, 9] - [61, 24]))
                arguments: (arguments [61, 24] - [61, 37]
                  (identifier [61, 25] - [61, 36]))))
            (lexical_declaration [62, 2] - [62, 40]
              (variable_declarator [62, 8] - [62, 39]
                name: (identifier [62, 8] - [62, 17])
                value: (call_expression [62, 20] - [62, 39]
                  function: (member_expression [62, 20] - [62, 37]
                    object: (identifier [62, 20] - [62, 26])
                    property: (property_identifier [62, 27] - [62, 37]))
                  arguments: (arguments [62, 37] - [62, 39]))))
            (lexical_declaration [64, 2] - [79, 5]
              (variable_declarator [64, 8] - [79, 4]
                name: (identifier [64, 8] - [64, 15])
                value: (await_expression [64, 18] - [79, 4]
                  (call_expression [64, 24] - [79, 4]
                    function: (identifier [64, 24] - [64, 51])
                    arguments: (arguments [64, 51] - [79, 4]
                      (object [64, 52] - [79, 3]
                        (pair [65, 4] - [65, 31]
                          key: (property_identifier [65, 4] - [65, 10])
                          value: (string [65, 12] - [65, 31]
                            (string_fragment [65, 13] - [65, 30])))
                        (shorthand_property_identifier [66, 4] - [66, 8])
                        (pair [67, 4] - [67, 22]
                          key: (property_identifier [67, 4] - [67, 12])
                          value: (identifier [67, 14] - [67, 22]))
                        (pair [68, 4] - [68, 23]
                          key: (property_identifier [68, 4] - [68, 10])
                          value: (identifier [68, 12] - [68, 23]))
                        (pair [69, 4] - [69, 29]
                          key: (property_identifier [69, 4] - [69, 19])
                          value: (string [69, 21] - [69, 29]
                            (string_fragment [69, 22] - [69, 28])))
                        (pair [70, 4] - [74, 5]
                          key: (property_identifier [70, 4] - [70, 26])
                          value: (object [70, 28] - [74, 5]
                            (pair [71, 6] - [71, 29]
                              key: (property_identifier [71, 6] - [71, 17])
                              value: (string [71, 19] - [71, 29]
                                (string_fragment [71, 20] - [71, 28])))
                            (pair [72, 6] - [72, 30]
                              key: (property_identifier [72, 6] - [72, 24])
                              value: (true [72, 26] - [72, 30]))
                            (pair [73, 6] - [73, 35]
                              key: (property_identifier [73, 6] - [73, 22])
                              value: (string [73, 24] - [73, 35]
                                (string_fragment [73, 25] - [73, 34])))))
                        (pair [75, 4] - [75, 18]
                          key: (property_identifier [75, 4] - [75, 11])
                          value: (number [75, 13] - [75, 18]))
                        (pair [76, 4] - [78, 12]
                          key: (property_identifier [76, 4] - [76, 14])
                          value: (as_expression [76, 16] - [78, 12]
                            (object [76, 16] - [78, 5]
                              (pair [77, 6] - [77, 27]
                                key: (computed_property_name [77, 6] - [77, 23]
                                  (as_expression [77, 7] - [77, 22]
                                    (string [77, 7] - [77, 12]
                                      (string_fragment [77, 8] - [77, 11]))
                                    (predefined_type [77, 16] - [77, 22])))
                                value: (object [77, 25] - [77, 27])))
                            (predefined_type [78, 9] - [78, 12])))))))))
            (expression_statement [81, 2] - [86, 5]
              (call_expression [81, 2] - [86, 4]
                function: (identifier [81, 2] - [81, 11])
                arguments: (arguments [81, 11] - [86, 4]
                  (identifier [81, 12] - [81, 13])
                  (string [81, 15] - [81, 48]
                    (string_fragment [81, 16] - [81, 47]))
                  (member_expression [81, 50] - [81, 67]
                    object: (identifier [81, 50] - [81, 57])
                    property: (property_identifier [81, 58] - [81, 67]))
                  (object [81, 69] - [86, 3]
                    (pair [82, 4] - [82, 18]
                      key: (property_identifier [82, 4] - [82, 12])
                      value: (true [82, 14] - [82, 18]))
                    (pair [83, 4] - [83, 16]
                      key: (property_identifier [83, 4] - [83, 10])
                      value: (true [83, 12] - [83, 16]))
                    (pair [84, 4] - [84, 19]
                      key: (property_identifier [84, 4] - [84, 12])
                      value: (string [84, 14] - [84, 19]
                        (string_fragment [84, 15] - [84, 18])))
                    (pair [85, 4] - [85, 15]
                      key: (property_identifier [85, 4] - [85, 10])
                      value: (number [85, 12] - [85, 15]))))))
            (expression_statement [88, 2] - [93, 5]
              (call_expression [88, 2] - [93, 4]
                function: (identifier [88, 2] - [88, 11])
                arguments: (arguments [88, 11] - [93, 4]
                  (identifier [88, 12] - [88, 13])
                  (string [88, 15] - [88, 37]
                    (string_fragment [88, 16] - [88, 36]))
                  (identifier [88, 39] - [88, 48])
                  (object [88, 50] - [93, 3]
                    (pair [89, 4] - [89, 18]
                      key: (property_identifier [89, 4] - [89, 12])
                      value: (true [89, 14] - [89, 18]))
                    (pair [90, 4] - [90, 16]
                      key: (property_identifier [90, 4] - [90, 10])
                      value: (true [90, 12] - [90, 16]))
                    (pair [91, 4] - [91, 19]
                      key: (property_identifier [91, 4] - [91, 12])
                      value: (string [91, 14] - [91, 19]
                        (string_fragment [91, 15] - [91, 18])))
                    (pair [92, 4] - [92, 15]
                      key: (property_identifier [92, 4] - [92, 10])
                      value: (number [92, 12] - [92, 15]))))))
            (return_statement [95, 2] - [95, 39]
              (call_expression [95, 9] - [95, 38]
                function: (member_expression [95, 9] - [95, 15]
                  object: (identifier [95, 9] - [95, 10])
                  property: (property_identifier [95, 11] - [95, 15]))
                arguments: (arguments [95, 15] - [95, 38]
                  (object [95, 16] - [95, 37]
                    (shorthand_property_identifier [95, 18] - [95, 25])
                    (shorthand_property_identifier [95, 27] - [95, 35]))))))))))
  (comment [98, 0] - [98, 46])
  (expression_statement [99, 0] - [261, 3]
    (call_expression [99, 0] - [261, 2]
      function: (member_expression [99, 0] - [99, 19]
        object: (identifier [99, 0] - [99, 14])
        property: (property_identifier [99, 15] - [99, 19]))
      arguments: (arguments [99, 19] - [261, 2]
        (string [99, 20] - [99, 42]
          (string_fragment [99, 21] - [99, 41]))
        (arrow_function [99, 44] - [261, 1]
          parameters: (formal_parameters [99, 50] - [99, 53]
            (required_parameter [99, 51] - [99, 52]
              pattern: (identifier [99, 51] - [99, 52])))
          body: (statement_block [99, 57] - [261, 1]
            (try_statement [100, 2] - [260, 3]
              body: (statement_block [100, 6] - [254, 3]
                (lexical_declaration [101, 4] - [102, 14]
                  (variable_declarator [101, 10] - [102, 13]
                    name: (object_pattern [101, 10] - [101, 61]
                      (shorthand_property_identifier_pattern [101, 12] - [101, 20])
                      (shorthand_property_identifier_pattern [101, 22] - [101, 30])
                      (shorthand_property_identifier_pattern [101, 32] - [101, 42])
                      (shorthand_property_identifier_pattern [101, 44] - [101, 59]))
                    value: (await_expression [101, 64] - [102, 13]
                      (call_expression [101, 70] - [102, 13]
                        function: (member_expression [101, 70] - [102, 11]
                          object: (member_expression [101, 70] - [101, 75]
                            object: (identifier [101, 70] - [101, 71])
                            property: (property_identifier [101, 72] - [101, 75]))
                          property: (property_identifier [102, 7] - [102, 11]))
                        arguments: (arguments [102, 11] - [102, 13])))))
                (if_statement [104, 4] - [106, 5]
                  condition: (parenthesized_expression [104, 7] - [104, 40]
                    (binary_expression [104, 8] - [104, 39]
                      left: (unary_expression [104, 8] - [104, 19]
                        argument: (identifier [104, 9] - [104, 19]))
                      right: (unary_expression [104, 23] - [104, 39]
                        argument: (identifier [104, 24] - [104, 39]))))
                  consequence: (statement_block [104, 41] - [106, 5]
                    (return_statement [105, 6] - [105, 78]
                      (call_expression [105, 13] - [105, 77]
                        function: (member_expression [105, 13] - [105, 19]
                          object: (identifier [105, 13] - [105, 14])
                          property: (property_identifier [105, 15] - [105, 19]))
                        arguments: (arguments [105, 19] - [105, 77]
                          (object [105, 20] - [105, 71]
                            (pair [105, 22] - [105, 69]
                              key: (property_identifier [105, 22] - [105, 27])
                              value: (string [105, 29] - [105, 69]
                                (string_fragment [105, 30] - [105, 68]))))
                          (number [105, 73] - [105, 76]))))))
                (lexical_declaration [108, 4] - [108, 78]
                  (variable_declarator [108, 10] - [108, 77]
                    name: (identifier [108, 10] - [108, 27])
                    value: (call_expression [108, 30] - [108, 77]
                      function: (identifier [108, 30] - [108, 39])
                      arguments: (arguments [108, 39] - [108, 77]
                        (identifier [108, 40] - [108, 41])
                        (string [108, 43] - [108, 76]
                          (string_fragment [108, 44] - [108, 75]))))))
                (lexical_declaration [109, 4] - [109, 68]
                  (variable_declarator [109, 10] - [109, 67]
                    name: (identifier [109, 10] - [109, 28])
                    value: (call_expression [109, 31] - [109, 67]
                      function: (identifier [109, 31] - [109, 40])
                      arguments: (arguments [109, 40] - [109, 67]
                        (identifier [109, 41] - [109, 42])
                        (string [109, 44] - [109, 66]
                          (string_fragment [109, 45] - [109, 65]))))))
                (if_statement [110, 4] - [114, 5]
                  condition: (parenthesized_expression [110, 7] - [110, 50]
                    (binary_expression [110, 8] - [110, 49]
                      left: (unary_expression [110, 8] - [110, 26]
                        argument: (identifier [110, 9] - [110, 26]))
                      right: (unary_expression [110, 30] - [110, 49]
                        argument: (identifier [110, 31] - [110, 49]))))
                  consequence: (statement_block [110, 51] - [114, 5]
                    (return_statement [111, 6] - [113, 14]
                      (call_expression [111, 13] - [113, 13]
                        function: (member_expression [111, 13] - [111, 19]
                          object: (identifier [111, 13] - [111, 14])
                          property: (property_identifier [111, 15] - [111, 19]))
                        arguments: (arguments [111, 19] - [113, 13]
                          (object [111, 20] - [113, 7]
                            (pair [112, 8] - [112, 66]
                              key: (property_identifier [112, 8] - [112, 13])
                              value: (string [112, 15] - [112, 66]
                                (string_fragment [112, 16] - [112, 65]))))
                          (number [113, 9] - [113, 12]))))))
                (lexical_declaration [116, 4] - [116, 49]
                  (variable_declarator [116, 8] - [116, 48]
                    name: (identifier [116, 8] - [116, 12])
                    value: (await_expression [116, 15] - [116, 48]
                      (call_expression [116, 21] - [116, 48]
                        function: (identifier [116, 21] - [116, 38])
                        arguments: (arguments [116, 38] - [116, 48]
                          (identifier [116, 39] - [116, 47]))))))
                (if_statement [117, 4] - [119, 5]
                  condition: (parenthesized_expression [117, 7] - [117, 13]
                    (identifier [117, 8] - [117, 12]))
                  consequence: (statement_block [117, 14] - [119, 5]
                    (return_statement [118, 6] - [118, 63]
                      (call_expression [118, 13] - [118, 62]
                        function: (member_expression [118, 13] - [118, 19]
                          object: (identifier [118, 13] - [118, 14])
                          property: (property_identifier [118, 15] - [118, 19]))
                        arguments: (arguments [118, 19] - [118, 62]
                          (object [118, 20] - [118, 56]
                            (pair [118, 22] - [118, 54]
                              key: (property_identifier [118, 22] - [118, 27])
                              value: (string [118, 29] - [118, 54]
                                (string_fragment [118, 30] - [118, 53]))))
                          (number [118, 58] - [118, 61]))))))
                (if_statement [121, 4] - [121, 68]
                  condition: (parenthesized_expression [121, 7] - [121, 25]
                    (binary_expression [121, 8] - [121, 24]
                      left: (unary_expression [121, 8] - [121, 15]
                        argument: (identifier [121, 9] - [121, 15]))
                      right: (unary_expression [121, 19] - [121, 24]
                        argument: (identifier [121, 20] - [121, 24]))))
                  consequence: (throw_statement [121, 26] - [121, 68]
                    (new_expression [121, 32] - [121, 67]
                      constructor: (identifier [121, 36] - [121, 41])
                      arguments: (arguments [121, 41] - [121, 67]
                        (string [121, 42] - [121, 66]
                          (string_fragment [121, 43] - [121, 65]))))))
                (lexical_declaration [123, 4] - [123, 21]
                  (variable_declarator [123, 8] - [123, 20]
                    name: (identifier [123, 8] - [123, 20])))
                (try_statement [124, 4] - [134, 5]
                  body: (statement_block [124, 8] - [132, 5]
                    (expression_statement [125, 6] - [131, 9]
                      (assignment_expression [125, 6] - [131, 8]
                        left: (identifier [125, 6] - [125, 18])
                        right: (await_expression [125, 21] - [131, 8]
                          (call_expression [125, 27] - [131, 8]
                            function: (identifier [125, 27] - [125, 53])
                            arguments: (arguments [125, 53] - [131, 8]
                              (object [125, 54] - [131, 7]
                                (pair [126, 8] - [126, 54]
                                  key: (property_identifier [126, 8] - [126, 16])
                                  value: (as_expression [126, 18] - [126, 54]
                                    (identifier [126, 18] - [126, 26])
                                    (type_identifier [126, 30] - [126, 54])))
                                (shorthand_property_identifier [127, 8] - [127, 25])
                                (pair [128, 8] - [128, 30]
                                  key: (property_identifier [128, 8] - [128, 22])
                                  value: (identifier [128, 24] - [128, 30]))
                                (pair [129, 8] - [129, 26]
                                  key: (property_identifier [129, 8] - [129, 20])
                                  value: (identifier [129, 22] - [129, 26]))
                                (pair [130, 8] - [130, 38]
                                  key: (property_identifier [130, 8] - [130, 31])
                                  value: (false [130, 33] - [130, 38])))))))))
                  handler: (catch_clause [132, 6] - [134, 5]
                    parameter: (identifier [132, 13] - [132, 18])
                    type: (type_annotation [132, 18] - [132, 23]
                      (predefined_type [132, 20] - [132, 23]))
                    body: (statement_block [132, 25] - [134, 5]
                      (return_statement [133, 6] - [133, 51]
                        (call_expression [133, 13] - [133, 50]
                          function: (member_expression [133, 13] - [133, 19]
                            object: (identifier [133, 13] - [133, 14])
                            property: (property_identifier [133, 15] - [133, 19]))
                          arguments: (arguments [133, 19] - [133, 50]
                            (object [133, 20] - [133, 44]
                              (pair [133, 22] - [133, 42]
                                key: (property_identifier [133, 22] - [133, 27])
                                value: (member_expression [133, 29] - [133, 42]
                                  object: (identifier [133, 29] - [133, 34])
                                  property: (property_identifier [133, 35] - [133, 42]))))
                            (number [133, 46] - [133, 49])))))))
                (lexical_declaration [136, 4] - [136, 56]
                  (variable_declarator [136, 10] - [136, 55]
                    name: (object_pattern [136, 10] - [136, 40]
                      (shorthand_property_identifier_pattern [136, 12] - [136, 20])
                      (shorthand_property_identifier_pattern [136, 22] - [136, 38]))
                    value: (identifier [136, 43] - [136, 55])))
                (if_statement [137, 4] - [139, 5]
                  condition: (parenthesized_expression [137, 7] - [137, 39]
                    (binary_expression [137, 8] - [137, 38]
                      left: (unary_expression [137, 8] - [137, 17]
                        argument: (identifier [137, 9] - [137, 17]))
                      right: (unary_expression [137, 21] - [137, 38]
                        argument: (identifier [137, 22] - [137, 38]))))
                  consequence: (statement_block [137, 40] - [139, 5]
                    (return_statement [138, 6] - [138, 59]
                      (call_expression [138, 13] - [138, 58]
                        function: (member_expression [138, 13] - [138, 19]
                          object: (identifier [138, 13] - [138, 14])
                          property: (property_identifier [138, 15] - [138, 19]))
                        arguments: (arguments [138, 19] - [138, 58]
                          (object [138, 20] - [138, 52]
                            (pair [138, 22] - [138, 50]
                              key: (property_identifier [138, 22] - [138, 27])
                              value: (string [138, 29] - [138, 50]
                                (string_fragment [138, 30] - [138, 49]))))
                          (number [138, 54] - [138, 57]))))))
                (lexical_declaration [141, 4] - [141, 56]
                  (variable_declarator [141, 10] - [141, 55]
                    name: (identifier [141, 10] - [141, 22])
                    value: (member_expression [141, 25] - [141, 55]
                      object: (member_expression [141, 25] - [141, 52]
                        object: (identifier [141, 25] - [141, 41])
                        property: (property_identifier [141, 42] - [141, 52]))
                      property: (property_identifier [141, 53] - [141, 55]))))
                (lexical_declaration [142, 4] - [142, 70]
                  (variable_declarator [142, 10] - [142, 69]
                    name: (identifier [142, 10] - [142, 29])
                    value: (member_expression [142, 32] - [142, 69]
                      object: (member_expression [142, 32] - [142, 59]
                        object: (identifier [142, 32] - [142, 48])
                        property: (property_identifier [142, 49] - [142, 59]))
                      property: (property_identifier [142, 60] - [142, 69]))))
                (lexical_declaration [143, 4] - [143, 56]
                  (variable_declarator [143, 10] - [143, 55]
                    name: (identifier [143, 10] - [143, 17])
                    value: (member_expression [143, 20] - [143, 55]
                      object: (member_expression [143, 20] - [143, 47]
                        object: (identifier [143, 20] - [143, 36])
                        property: (property_identifier [143, 37] - [143, 47]))
                      property: (property_identifier [143, 48] - [143, 55]))))
                (lexical_declaration [145, 4] - [147, 80]
                  (variable_declarator [145, 10] - [147, 79]
                    name: (identifier [145, 10] - [145, 28])
                    value: (ternary_expression [145, 31] - [147, 79]
                      condition: (binary_expression [145, 31] - [145, 63]
                        left: (unary_expression [145, 31] - [145, 50]
                          argument: (identifier [145, 38] - [145, 50]))
                        right: (string [145, 55] - [145, 63]
                          (string_fragment [145, 56] - [145, 62])))
                      consequence: (identifier [146, 8] - [146, 20])
                      alternative: (call_expression [147, 8] - [147, 79]
                        function: (identifier [147, 8] - [147, 23])
                        arguments: (arguments [147, 23] - [147, 79]
                          (new_expression [147, 24] - [147, 78]
                            constructor: (identifier [147, 28] - [147, 38])
                            arguments: (arguments [147, 38] - [147, 78]
                              (as_expression [147, 39] - [147, 77]
                                (as_expression [147, 39] - [147, 62]
                                  (identifier [147, 39] - [147, 51])
                                  (predefined_type [147, 55] - [147, 62]))
                                (type_identifier [147, 66] - [147, 77])))))))))
                (lexical_declaration [148, 4] - [150, 6]
                  (variable_declarator [148, 10] - [150, 5]
                    name: (identifier [148, 10] - [148, 25])
                    value: (call_expression [148, 28] - [150, 5]
                      function: (identifier [148, 28] - [148, 43])
                      arguments: (arguments [148, 43] - [150, 5]
                        (new_expression [149, 6] - [149, 67]
                          constructor: (identifier [149, 10] - [149, 20])
                          arguments: (arguments [149, 20] - [149, 67]
                            (as_expression [149, 21] - [149, 66]
                              (as_expression [149, 21] - [149, 51]
                                (identifier [149, 21] - [149, 40])
                                (predefined_type [149, 44] - [149, 51]))
                              (type_identifier [149, 55] - [149, 66]))))))))
                (lexical_declaration [152, 4] - [153, 70]
                  (variable_declarator [152, 10] - [153, 69]
                    name: (identifier [152, 10] - [152, 20])
                    value: (binary_expression [153, 6] - [153, 69]
                      left: (member_expression [153, 6] - [153, 60]
                        object: (member_expression [153, 6] - [153, 51]
                          object: (parenthesized_expression [153, 6] - [153, 46]
                            (as_expression [153, 7] - [153, 45]
                              (member_expression [153, 7] - [153, 38]
                                object: (identifier [153, 7] - [153, 15])
                                property: (property_identifier [153, 16] - [153, 38]))
                              (predefined_type [153, 42] - [153, 45])))
                          optional_chain: (optional_chain [153, 46] - [153, 48])
                          property: (property_identifier [153, 48] - [153, 51]))
                        optional_chain: (optional_chain [153, 51] - [153, 53])
                        property: (property_identifier [153, 53] - [153, 60]))
                      right: (true [153, 65] - [153, 69]))))
                (lexical_declaration [154, 4] - [154, 23]
                  (variable_declarator [154, 8] - [154, 22]
                    name: (identifier [154, 8] - [154, 15])
                    value: (null [154, 18] - [154, 22])))
                (if_statement [155, 4] - [158, 5]
                  condition: (parenthesized_expression [155, 7] - [155, 19]
                    (identifier [155, 8] - [155, 18]))
                  consequence: (statement_block [155, 20] - [158, 5]
                    (lexical_declaration [156, 6] - [156, 67]
                      (variable_declarator [156, 12] - [156, 66]
                        name: (identifier [156, 12] - [156, 21])
                        value: (call_expression [156, 24] - [156, 66]
                          function: (member_expression [156, 24] - [156, 46]
                            object: (identifier [156, 24] - [156, 30])
                            property: (property_identifier [156, 31] - [156, 46]))
                          arguments: (arguments [156, 46] - [156, 66]
                            (new_expression [156, 47] - [156, 65]
                              constructor: (identifier [156, 51] - [156, 61])
                              arguments: (arguments [156, 61] - [156, 65]
                                (number [156, 62] - [156, 64])))))))
                    (expression_statement [157, 6] - [157, 43]
                      (assignment_expression [157, 6] - [157, 42]
                        left: (identifier [157, 6] - [157, 13])
                        right: (call_expression [157, 16] - [157, 42]
                          function: (identifier [157, 16] - [157, 31])
                          arguments: (arguments [157, 31] - [157, 42]
                            (identifier [157, 32] - [157, 41])))))))
                (if_statement [160, 4] - [219, 5]
                  condition: (parenthesized_expression [160, 7] - [160, 24]
                    (identifier [160, 8] - [160, 23]))
                  consequence: (statement_block [160, 25] - [196, 5]
                    (lexical_declaration [161, 6] - [161, 63]
                      (variable_declarator [161, 12] - [161, 62]
                        name: (identifier [161, 12] - [161, 26])
                        value: (await_expression [161, 29] - [161, 62]
                          (call_expression [161, 35] - [161, 62]
                            function: (member_expression [161, 35] - [161, 45]
                              object: (identifier [161, 35] - [161, 41])
                              property: (property_identifier [161, 42] - [161, 45]))
                            arguments: (arguments [161, 45] - [161, 62]
                              (identifier [161, 46] - [161, 61]))))))
                    (if_statement [162, 6] - [164, 7]
                      condition: (parenthesized_expression [162, 9] - [162, 26]
                        (unary_expression [162, 10] - [162, 25]
                          argument: (identifier [162, 11] - [162, 25])))
                      consequence: (statement_block [162, 27] - [164, 7]
                        (return_statement [163, 8] - [163, 74]
                          (call_expression [163, 15] - [163, 73]
                            function: (member_expression [163, 15] - [163, 21]
                              object: (identifier [163, 15] - [163, 16])
                              property: (property_identifier [163, 17] - [163, 21]))
                            arguments: (arguments [163, 21] - [163, 73]
                              (object [163, 22] - [163, 67]
                                (pair [163, 24] - [163, 65]
                                  key: (property_identifier [163, 24] - [163, 29])
                                  value: (string [163, 31] - [163, 65]
                                    (string_fragment [163, 32] - [163, 64]))))
                              (number [163, 69] - [163, 72]))))))
                    (lexical_declaration [165, 6] - [165, 53]
                      (variable_declarator [165, 12] - [165, 52]
                        name: (identifier [165, 12] - [165, 23])
                        value: (call_expression [165, 26] - [165, 52]
                          function: (member_expression [165, 26] - [165, 36]
                            object: (identifier [165, 26] - [165, 30])
                            property: (property_identifier [165, 31] - [165, 36]))
                          arguments: (arguments [165, 36] - [165, 52]
                            (identifier [165, 37] - [165, 51])))))
                    (if_statement [166, 6] - [171, 7]
                      condition: (parenthesized_expression [166, 9] - [169, 7]
                        (binary_expression [167, 8] - [168, 46]
                          left: (binary_expression [167, 8] - [167, 41]
                            left: (unary_expression [167, 8] - [167, 20]
                              argument: (identifier [167, 9] - [167, 20]))
                            right: (unary_expression [167, 24] - [167, 41]
                              argument: (member_expression [167, 25] - [167, 41]
                                object: (identifier [167, 25] - [167, 36])
                                property: (property_identifier [167, 37] - [167, 41]))))
                          right: (binary_expression [168, 8] - [168, 46]
                            left: (member_expression [168, 8] - [168, 34]
                              object: (identifier [168, 8] - [168, 19])
                              property: (property_identifier [168, 20] - [168, 34]))
                            right: (string [168, 39] - [168, 46]
                              (string_fragment [168, 40] - [168, 45])))))
                      consequence: (statement_block [169, 8] - [171, 7]
                        (return_statement [170, 8] - [170, 69]
                          (call_expression [170, 15] - [170, 68]
                            function: (member_expression [170, 15] - [170, 21]
                              object: (identifier [170, 15] - [170, 16])
                              property: (property_identifier [170, 17] - [170, 21]))
                            arguments: (arguments [170, 21] - [170, 68]
                              (object [170, 22] - [170, 62]
                                (pair [170, 24] - [170, 60]
                                  key: (property_identifier [170, 24] - [170, 29])
                                  value: (string [170, 31] - [170, 60]
                                    (string_fragment [170, 32] - [170, 59]))))
                              (number [170, 64] - [170, 67]))))))
                    (lexical_declaration [173, 6] - [173, 41]
                      (variable_declarator [173, 12] - [173, 40]
                        name: (identifier [173, 12] - [173, 21])
                        value: (member_expression [173, 24] - [173, 40]
                          object: (identifier [173, 24] - [173, 35])
                          property: (property_identifier [173, 36] - [173, 40]))))
                    (expression_statement [175, 6] - [175, 51]
                      (assignment_expression [175, 6] - [175, 50]
                        left: (identifier [175, 6] - [175, 10])
                        right: (await_expression [175, 13] - [175, 50]
                          (call_expression [175, 19] - [175, 50]
                            function: (identifier [175, 19] - [175, 29])
                            arguments: (arguments [175, 29] - [175, 50]
                              (identifier [175, 30] - [175, 39])
                              (identifier [175, 41] - [175, 49]))))))
                    (expression_statement [177, 6] - [186, 8]
                      (await_expression [177, 6] - [186, 7]
                        (call_expression [177, 12] - [186, 7]
                          function: (identifier [177, 12] - [177, 25])
                          arguments: (arguments [177, 25] - [186, 7]
                            (member_expression [178, 8] - [178, 15]
                              object: (identifier [178, 8] - [178, 12])
                              property: (property_identifier [178, 13] - [178, 15]))
                            (identifier [179, 8] - [179, 26])
                            (identifier [180, 8] - [180, 23])
                            (identifier [181, 8] - [181, 15])
                            (binary_expression [182, 8] - [182, 73]
                              left: (member_expression [182, 8] - [182, 31]
                                object: (identifier [182, 8] - [182, 24])
                                property: (property_identifier [182, 25] - [182, 31]))
                              right: (string [182, 35] - [182, 73]
                                (string_fragment [182, 36] - [182, 72])))
                            (string [183, 8] - [183, 24]
                              (string_fragment [183, 9] - [183, 23]))
                            (identifier [184, 8] - [184, 18])
                            (identifier [185, 8] - [185, 15])))))
                    (expression_statement [188, 6] - [192, 8]
                      (await_expression [188, 6] - [192, 7]
                        (call_expression [188, 12] - [192, 7]
                          function: (member_expression [188, 12] - [188, 24]
                            object: (identifier [188, 12] - [188, 18])
                            property: (property_identifier [188, 19] - [188, 24]))
                          arguments: (arguments [188, 24] - [192, 7]
                            (identifier [189, 8] - [189, 23])
                            (number [190, 8] - [190, 13])
                            (call_expression [191, 8] - [191, 79]
                              function: (member_expression [191, 8] - [191, 22]
                                object: (identifier [191, 8] - [191, 12])
                                property: (property_identifier [191, 13] - [191, 22]))
                              arguments: (arguments [191, 22] - [191, 79]
                                (object [191, 23] - [191, 78]
                                  (pair [191, 25] - [191, 40]
                                    key: (property_identifier [191, 25] - [191, 29])
                                    value: (identifier [191, 31] - [191, 40]))
                                  (shorthand_property_identifier [191, 42] - [191, 50])
                                  (pair [191, 52] - [191, 76]
                                    key: (property_identifier [191, 52] - [191, 66])
                                    value: (string [191, 68] - [191, 76]
                                      (string_fragment [191, 69] - [191, 75]))))))))))
                    (lexical_declaration [194, 6] - [194, 66]
                      (variable_declarator [194, 12] - [194, 65]
                        name: (identifier [194, 12] - [194, 21])
                        value: (new_expression [194, 24] - [194, 65]
                          constructor: (identifier [194, 28] - [194, 32])
                          arguments: (arguments [194, 32] - [194, 65]
                            (binary_expression [194, 33] - [194, 64]
                              left: (call_expression [194, 33] - [194, 43]
                                function: (member_expression [194, 33] - [194, 41]
                                  object: (identifier [194, 33] - [194, 37])
                                  property: (property_identifier [194, 38] - [194, 41]))
                                arguments: (arguments [194, 41] - [194, 43]))
                              right: (binary_expression [194, 46] - [194, 64]
                                left: (binary_expression [194, 46] - [194, 57]
                                  left: (binary_expression [194, 46] - [194, 52]
                                    left: (number [194, 46] - [194, 47])
                                    right: (number [194, 50] - [194, 52]))
                                  right: (number [194, 55] - [194, 57]))
                                right: (number [194, 60] - [194, 64])))))))
                    (expression_statement [195, 6] - [195, 63]
                      (await_expression [195, 6] - [195, 62]
                        (call_expression [195, 12] - [195, 62]
                          function: (identifier [195, 12] - [195, 25])
                          arguments: (arguments [195, 25] - [195, 62]
                            (identifier [195, 26] - [195, 41])
                            (member_expression [195, 43] - [195, 50]
                              object: (identifier [195, 43] - [195, 47])
                              property: (property_identifier [195, 48] - [195, 50]))
                            (identifier [195, 52] - [195, 61]))))))
                  alternative: (else_clause [196, 6] - [219, 5]
                    (statement_block [196, 11] - [219, 5]
                      (lexical_declaration [197, 6] - [197, 54]
                        (variable_declarator [197, 12] - [197, 53]
                          name: (identifier [197, 12] - [197, 18])
                          value: (await_expression [197, 21] - [197, 53]
                            (call_expression [197, 27] - [197, 53]
                              function: (identifier [197, 27] - [197, 41])
                              arguments: (arguments [197, 41] - [197, 53]
                                (identifier [197, 42] - [197, 52]))))))
                      (if_statement [198, 6] - [203, 7]
                        condition: (parenthesized_expression [198, 9] - [198, 18]
                          (unary_expression [198, 10] - [198, 17]
                            argument: (identifier [198, 11] - [198, 17])))
                        consequence: (statement_block [198, 19] - [203, 7]
                          (return_statement [199, 8] - [202, 10]
                            (call_expression [199, 15] - [202, 9]
                              function: (member_expression [199, 15] - [199, 21]
                                object: (identifier [199, 15] - [199, 16])
                                property: (property_identifier [199, 17] - [199, 21]))
                              arguments: (arguments [199, 21] - [202, 9]
                                (object [200, 10] - [200, 69]
                                  (pair [200, 12] - [200, 67]
                                    key: (property_identifier [200, 12] - [200, 17])
                                    value: (string [200, 19] - [200, 67]
                                      (string_fragment [200, 20] - [200, 66]))))
                                (number [201, 10] - [201, 13]))))))
                      (expression_statement [205, 6] - [205, 60]
                        (assignment_expression [205, 6] - [205, 59]
                          left: (identifier [205, 6] - [205, 10])
                          right: (await_expression [205, 13] - [205, 59]
                            (call_expression [205, 19] - [205, 59]
                              function: (identifier [205, 19] - [205, 29])
                              arguments: (arguments [205, 29] - [205, 59]
                                (identifier [205, 30] - [205, 48])
                                (identifier [205, 50] - [205, 58]))))))
                      (expression_statement [207, 6] - [216, 8]
                        (await_expression [207, 6] - [216, 7]
                          (call_expression [207, 12] - [216, 7]
                            function: (identifier [207, 12] - [207, 25])
                            arguments: (arguments [207, 25] - [216, 7]
                              (member_expression [208, 8] - [208, 15]
                                object: (identifier [208, 8] - [208, 12])
                                property: (property_identifier [208, 13] - [208, 15]))
                              (identifier [209, 8] - [209, 26])
                              (identifier [210, 8] - [210, 23])
                              (identifier [211, 8] - [211, 15])
                              (binary_expression [212, 8] - [212, 73]
                                left: (member_expression [212, 8] - [212, 31]
                                  object: (identifier [212, 8] - [212, 24])
                                  property: (property_identifier [212, 25] - [212, 31]))
                                right: (string [212, 35] - [212, 73]
                                  (string_fragment [212, 36] - [212, 72])))
                              (string [213, 8] - [213, 24]
                                (string_fragment [213, 9] - [213, 23]))
                              (identifier [214, 8] - [214, 18])
                              (identifier [215, 8] - [215, 15])))))
                      (expression_statement [218, 6] - [218, 52]
                        (await_expression [218, 6] - [218, 51]
                          (call_expression [218, 12] - [218, 51]
                            function: (identifier [218, 12] - [218, 31])
                            arguments: (arguments [218, 31] - [218, 51]
                              (member_expression [218, 32] - [218, 41]
                                object: (identifier [218, 32] - [218, 38])
                                property: (property_identifier [218, 39] - [218, 41]))
                              (member_expression [218, 43] - [218, 50]
                                object: (identifier [218, 43] - [218, 47])
                                property: (property_identifier [218, 48] - [218, 50])))))))))
                (expression_statement [221, 4] - [227, 6]
                  (call_expression [221, 4] - [227, 5]
                    function: (member_expression [221, 4] - [221, 25]
                      object: (identifier [221, 4] - [221, 16])
                      property: (property_identifier [221, 17] - [221, 25]))
                    arguments: (arguments [221, 25] - [227, 5]
                      (member_expression [222, 6] - [222, 13]
                        object: (identifier [222, 6] - [222, 10])
                        property: (property_identifier [222, 11] - [222, 13]))
                      (string [223, 6] - [223, 23]
                        (string_fragment [223, 7] - [223, 22]))
                      (null [224, 6] - [224, 10])
                      (object [225, 6] - [225, 30]
                        (shorthand_property_identifier [225, 8] - [225, 16])
                        (shorthand_property_identifier [225, 18] - [225, 28]))
                      (call_expression [226, 6] - [226, 20]
                        function: (identifier [226, 6] - [226, 17])
                        arguments: (arguments [226, 17] - [226, 20]
                          (identifier [226, 18] - [226, 19]))))))
                (expression_statement [229, 4] - [234, 7]
                  (call_expression [229, 4] - [234, 6]
                    function: (identifier [229, 4] - [229, 13])
                    arguments: (arguments [229, 13] - [234, 6]
                      (identifier [229, 14] - [229, 15])
                      (string [229, 17] - [229, 50]
                        (string_fragment [229, 18] - [229, 49]))
                      (string [229, 52] - [229, 54])
                      (object [229, 56] - [234, 5]
                        (pair [230, 6] - [230, 20]
                          key: (property_identifier [230, 6] - [230, 14])
                          value: (true [230, 16] - [230, 20]))
                        (pair [231, 6] - [231, 18]
                          key: (property_identifier [231, 6] - [231, 12])
                          value: (true [231, 14] - [231, 18]))
                        (pair [232, 6] - [232, 21]
                          key: (property_identifier [232, 6] - [232, 14])
                          value: (string [232, 16] - [232, 21]
                            (string_fragment [232, 17] - [232, 20])))
                        (pair [233, 6] - [233, 15]
                          key: (property_identifier [233, 6] - [233, 12])
                          value: (number [233, 14] - [233, 15]))))))
                (expression_statement [236, 4] - [241, 7]
                  (call_expression [236, 4] - [241, 6]
                    function: (identifier [236, 4] - [236, 13])
                    arguments: (arguments [236, 13] - [241, 6]
                      (identifier [236, 14] - [236, 15])
                      (string [236, 17] - [236, 39]
                        (string_fragment [236, 18] - [236, 38]))
                      (string [236, 41] - [236, 43])
                      (object [236, 45] - [241, 5]
                        (pair [237, 6] - [237, 20]
                          key: (property_identifier [237, 6] - [237, 14])
                          value: (true [237, 16] - [237, 20]))
                        (pair [238, 6] - [238, 18]
                          key: (property_identifier [238, 6] - [238, 12])
                          value: (true [238, 14] - [238, 18]))
                        (pair [239, 6] - [239, 21]
                          key: (property_identifier [239, 6] - [239, 14])
                          value: (string [239, 16] - [239, 21]
                            (string_fragment [239, 17] - [239, 20])))
                        (pair [240, 6] - [240, 15]
                          key: (property_identifier [240, 6] - [240, 12])
                          value: (number [240, 14] - [240, 15]))))))
                (lexical_declaration [243, 4] - [243, 47]
                  (variable_declarator [243, 10] - [243, 46]
                    name: (identifier [243, 10] - [243, 22])
                    value: (call_expression [243, 25] - [243, 46]
                      function: (identifier [243, 25] - [243, 40])
                      arguments: (arguments [243, 40] - [243, 46]
                        (identifier [243, 41] - [243, 45])))))
                (if_statement [244, 4] - [250, 5]
                  condition: (parenthesized_expression [244, 7] - [244, 21]
                    (identifier [244, 8] - [244, 20]))
                  consequence: (statement_block [244, 22] - [250, 5]
                    (expression_statement [245, 6] - [249, 9]
                      (call_expression [245, 6] - [249, 8]
                        function: (identifier [245, 6] - [245, 15])
                        arguments: (arguments [245, 15] - [249, 8]
                          (identifier [245, 16] - [245, 17])
                          (string [245, 19] - [245, 31]
                            (string_fragment [245, 20] - [245, 30]))
                          (string [245, 33] - [245, 35])
                          (object [245, 37] - [249, 7]
                            (pair [246, 8] - [246, 28]
                              key: (property_identifier [246, 8] - [246, 14])
                              value: (identifier [246, 16] - [246, 28]))
                            (pair [247, 8] - [247, 17]
                              key: (property_identifier [247, 8] - [247, 12])
                              value: (string [247, 14] - [247, 17]
                                (string_fragment [247, 15] - [247, 16])))
                            (pair [248, 8] - [248, 17]
                              key: (property_identifier [248, 8] - [248, 14])
                              value: (number [248, 16] - [248, 17]))))))))
                (expression_statement [251, 4] - [251, 61]
                  (call_expression [251, 4] - [251, 60]
                    function: (identifier [251, 4] - [251, 13])
                    arguments: (arguments [251, 13] - [251, 60]
                      (identifier [251, 14] - [251, 15])
                      (string [251, 17] - [251, 29]
                        (string_fragment [251, 18] - [251, 28]))
                      (string [251, 31] - [251, 33])
                      (object [251, 35] - [251, 59]
                        (pair [251, 37] - [251, 46]
                          key: (property_identifier [251, 37] - [251, 41])
                          value: (string [251, 43] - [251, 46]
                            (string_fragment [251, 44] - [251, 45])))
                        (pair [251, 48] - [251, 57]
                          key: (property_identifier [251, 48] - [251, 54])
                          value: (number [251, 56] - [251, 57]))))))
                (return_statement [253, 4] - [253, 37]
                  (call_expression [253, 11] - [253, 36]
                    function: (member_expression [253, 11] - [253, 17]
                      object: (identifier [253, 11] - [253, 12])
                      property: (property_identifier [253, 13] - [253, 17]))
                    arguments: (arguments [253, 17] - [253, 36]
                      (object [253, 18] - [253, 35]
                        (pair [253, 20] - [253, 33]
                          key: (property_identifier [253, 20] - [253, 27])
                          value: (true [253, 29] - [253, 33])))))))
              handler: (catch_clause [254, 4] - [260, 3]
                parameter: (identifier [254, 11] - [254, 16])
                type: (type_annotation [254, 16] - [254, 21]
                  (predefined_type [254, 18] - [254, 21]))
                body: (statement_block [254, 23] - [260, 3]
                  (expression_statement [255, 4] - [258, 6]
                    (call_expression [255, 4] - [258, 5]
                      function: (member_expression [255, 4] - [255, 17]
                        object: (identifier [255, 4] - [255, 11])
                        property: (property_identifier [255, 12] - [255, 17]))
                      arguments: (arguments [255, 17] - [258, 5]
                        (string [256, 6] - [256, 62]
                          (string_fragment [256, 7] - [256, 61]))
                        (identifier [257, 6] - [257, 11]))))
                  (return_statement [259, 4] - [259, 76]
                    (call_expression [259, 11] - [259, 75]
                      function: (member_expression [259, 11] - [259, 17]
                        object: (identifier [259, 11] - [259, 12])
                        property: (property_identifier [259, 13] - [259, 17]))
                      arguments: (arguments [259, 17] - [259, 75]
                        (object [259, 18] - [259, 69]
                          (pair [259, 20] - [259, 67]
                            key: (property_identifier [259, 20] - [259, 25])
                            value: (binary_expression [259, 27] - [259, 67]
                              left: (member_expression [259, 27] - [259, 40]
                                object: (identifier [259, 27] - [259, 32])
                                property: (property_identifier [259, 33] - [259, 40]))
                              right: (string [259, 44] - [259, 67]
                                (string_fragment [259, 45] - [259, 66])))))
                        (number [259, 71] - [259, 74])))))))))))))