(program [0, 0] - [390, 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, 64]
    (import_clause [1, 7] - [1, 26]
      (named_imports [1, 7] - [1, 26]
        (import_specifier [1, 9] - [1, 24]
          name: (identifier [1, 9] - [1, 24]))))
    source: (string [1, 32] - [1, 63]
      (string_fragment [1, 33] - [1, 62])))
  (import_statement [2, 0] - [2, 61]
    (import_clause [2, 7] - [2, 31]
      (named_imports [2, 7] - [2, 31]
        (import_specifier [2, 9] - [2, 29]
          name: (identifier [2, 9] - [2, 29]))))
    source: (string [2, 37] - [2, 60]
      (string_fragment [2, 38] - [2, 59])))
  (import_statement [3, 0] - [3, 46]
    (import_clause [3, 7] - [3, 17]
      (named_imports [3, 7] - [3, 17]
        (import_specifier [3, 9] - [3, 15]
          name: (identifier [3, 9] - [3, 15]))))
    source: (string [3, 23] - [3, 45]
      (string_fragment [3, 24] - [3, 44])))
  (import_statement [4, 0] - [4, 51]
    (import_clause [4, 7] - [4, 23]
      (named_imports [4, 7] - [4, 23]
        (import_specifier [4, 9] - [4, 21]
          name: (identifier [4, 9] - [4, 21]))))
    source: (string [4, 29] - [4, 50]
      (string_fragment [4, 30] - [4, 49])))
  (import_statement [5, 0] - [5, 55]
    (import_clause [5, 7] - [5, 22]
      (named_imports [5, 7] - [5, 22]
        (import_specifier [5, 9] - [5, 20]
          name: (identifier [5, 9] - [5, 20]))))
    source: (string [5, 28] - [5, 54]
      (string_fragment [5, 29] - [5, 53])))
  (import_statement [6, 0] - [26, 22]
    (import_clause [6, 7] - [26, 1]
      (named_imports [6, 7] - [26, 1]
        (import_specifier [7, 2] - [7, 11]
          name: (identifier [7, 2] - [7, 11]))
        (import_specifier [8, 2] - [8, 17]
          name: (identifier [8, 2] - [8, 17]))
        (import_specifier [9, 2] - [9, 11]
          name: (identifier [9, 2] - [9, 11]))
        (import_specifier [10, 2] - [10, 14]
          name: (identifier [10, 2] - [10, 14]))
        (import_specifier [11, 2] - [11, 20]
          name: (identifier [11, 2] - [11, 20]))
        (import_specifier [12, 2] - [12, 12]
          name: (identifier [12, 2] - [12, 12]))
        (import_specifier [13, 2] - [13, 11]
          name: (identifier [13, 2] - [13, 11]))
        (import_specifier [14, 2] - [14, 12]
          name: (identifier [14, 2] - [14, 12]))
        (import_specifier [15, 2] - [15, 13]
          name: (identifier [15, 2] - [15, 13]))
        (import_specifier [16, 2] - [16, 14]
          name: (identifier [16, 2] - [16, 14]))
        (import_specifier [17, 2] - [17, 17]
          name: (identifier [17, 2] - [17, 17]))
        (import_specifier [18, 2] - [18, 23]
          name: (identifier [18, 2] - [18, 23]))
        (import_specifier [19, 2] - [19, 14]
          name: (identifier [19, 2] - [19, 14]))
        (import_specifier [20, 2] - [20, 19]
          name: (identifier [20, 2] - [20, 19]))
        (import_specifier [21, 2] - [21, 19]
          name: (identifier [21, 2] - [21, 19]))
        (import_specifier [22, 2] - [22, 11]
          name: (identifier [22, 2] - [22, 11]))
        (import_specifier [23, 2] - [23, 12]
          name: (identifier [23, 2] - [23, 12]))
        (import_specifier [24, 2] - [24, 19]
          name: (identifier [24, 2] - [24, 19]))
        (import_specifier [25, 2] - [25, 18]
          name: (identifier [25, 2] - [25, 18]))))
    source: (string [26, 7] - [26, 21]
      (string_fragment [26, 8] - [26, 20])))
  (export_statement [28, 0] - [28, 45]
    declaration: (lexical_declaration [28, 7] - [28, 45]
      (variable_declarator [28, 13] - [28, 44]
        name: (identifier [28, 13] - [28, 31])
        value: (new_expression [28, 34] - [28, 44]
          constructor: (identifier [28, 38] - [28, 42])
          arguments: (arguments [28, 42] - [28, 44])))))
  (comment [30, 0] - [30, 17])
  (expression_statement [31, 0] - [57, 3]
    (call_expression [31, 0] - [57, 2]
      function: (member_expression [31, 0] - [31, 23]
        object: (identifier [31, 0] - [31, 18])
        property: (property_identifier [31, 19] - [31, 23]))
      arguments: (arguments [31, 23] - [57, 2]
        (string [31, 24] - [31, 43]
          (string_fragment [31, 25] - [31, 42]))
        (arrow_function [31, 45] - [57, 1]
          parameters: (formal_parameters [31, 51] - [31, 54]
            (required_parameter [31, 52] - [31, 53]
              pattern: (identifier [31, 52] - [31, 53])))
          body: (statement_block [31, 58] - [57, 1]
            (lexical_declaration [32, 2] - [32, 45]
              (variable_declarator [32, 8] - [32, 44]
                name: (identifier [32, 8] - [32, 12])
                value: (await_expression [32, 15] - [32, 44]
                  (call_expression [32, 21] - [32, 44]
                    function: (identifier [32, 21] - [32, 41])
                    arguments: (arguments [32, 41] - [32, 44]
                      (identifier [32, 42] - [32, 43]))))))
            (if_statement [33, 2] - [33, 59]
              condition: (parenthesized_expression [33, 5] - [33, 12]
                (unary_expression [33, 6] - [33, 11]
                  argument: (identifier [33, 7] - [33, 11])))
              consequence: (return_statement [33, 13] - [33, 59]
                (call_expression [33, 20] - [33, 58]
                  function: (member_expression [33, 20] - [33, 26]
                    object: (identifier [33, 20] - [33, 21])
                    property: (property_identifier [33, 22] - [33, 26]))
                  arguments: (arguments [33, 26] - [33, 58]
                    (object [33, 27] - [33, 52]
                      (pair [33, 29] - [33, 50]
                        key: (property_identifier [33, 29] - [33, 34])
                        value: (string [33, 36] - [33, 50]
                          (string_fragment [33, 37] - [33, 49]))))
                    (number [33, 54] - [33, 57])))))
            (lexical_declaration [35, 2] - [35, 41]
              (variable_declarator [35, 8] - [35, 40]
                name: (identifier [35, 8] - [35, 20])
                value: (call_expression [35, 23] - [35, 40]
                  function: (member_expression [35, 23] - [35, 34]
                    object: (member_expression [35, 23] - [35, 28]
                      object: (identifier [35, 23] - [35, 24])
                      property: (property_identifier [35, 25] - [35, 28]))
                    property: (property_identifier [35, 29] - [35, 34]))
                  arguments: (arguments [35, 34] - [35, 40]
                    (string [35, 35] - [35, 39]
                      (string_fragment [35, 36] - [35, 38]))))))
            (lexical_declaration [36, 2] - [36, 40]
              (variable_declarator [36, 8] - [36, 39]
                name: (object_pattern [36, 8] - [36, 18]
                  (shorthand_property_identifier_pattern [36, 10] - [36, 16]))
                value: (await_expression [36, 21] - [36, 39]
                  (call_expression [36, 27] - [36, 39]
                    function: (member_expression [36, 27] - [36, 37]
                      object: (member_expression [36, 27] - [36, 32]
                        object: (identifier [36, 27] - [36, 28])
                        property: (property_identifier [36, 29] - [36, 32]))
                      property: (property_identifier [36, 33] - [36, 37]))
                    arguments: (arguments [36, 37] - [36, 39])))))
            (if_statement [38, 2] - [40, 3]
              condition: (parenthesized_expression [38, 5] - [38, 48]
                (unary_expression [38, 6] - [38, 47]
                  argument: (call_expression [38, 7] - [38, 47]
                    function: (member_expression [38, 7] - [38, 39]
                      object: (array [38, 7] - [38, 30]
                        (string [38, 8] - [38, 16]
                          (string_fragment [38, 9] - [38, 15]))
                        (string [38, 18] - [38, 29]
                          (string_fragment [38, 19] - [38, 28])))
                      property: (property_identifier [38, 31] - [38, 39]))
                    arguments: (arguments [38, 39] - [38, 47]
                      (identifier [38, 40] - [38, 46])))))
              consequence: (statement_block [38, 49] - [40, 3]
                (return_statement [39, 4] - [39, 58]
                  (call_expression [39, 11] - [39, 57]
                    function: (member_expression [39, 11] - [39, 17]
                      object: (identifier [39, 11] - [39, 12])
                      property: (property_identifier [39, 13] - [39, 17]))
                    arguments: (arguments [39, 17] - [39, 57]
                      (object [39, 18] - [39, 51]
                        (pair [39, 20] - [39, 49]
                          key: (property_identifier [39, 20] - [39, 25])
                          value: (string [39, 27] - [39, 49]
                            (string_fragment [39, 28] - [39, 48]))))
                      (number [39, 53] - [39, 56]))))))
            (lexical_declaration [42, 2] - [42, 63]
              (variable_declarator [42, 8] - [42, 62]
                name: (identifier [42, 8] - [42, 15])
                value: (await_expression [42, 18] - [42, 62]
                  (call_expression [42, 24] - [42, 62]
                    function: (identifier [42, 24] - [42, 40])
                    arguments: (arguments [42, 40] - [42, 62]
                      (identifier [42, 41] - [42, 53])
                      (identifier [42, 55] - [42, 61]))))))
            (if_statement [43, 2] - [43, 64]
              condition: (parenthesized_expression [43, 5] - [43, 15]
                (unary_expression [43, 6] - [43, 14]
                  argument: (identifier [43, 7] - [43, 14])))
              consequence: (return_statement [43, 16] - [43, 64]
                (call_expression [43, 23] - [43, 63]
                  function: (member_expression [43, 23] - [43, 29]
                    object: (identifier [43, 23] - [43, 24])
                    property: (property_identifier [43, 25] - [43, 29]))
                  arguments: (arguments [43, 29] - [43, 63]
                    (object [43, 30] - [43, 57]
                      (pair [43, 32] - [43, 55]
                        key: (property_identifier [43, 32] - [43, 37])
                        value: (string [43, 39] - [43, 55]
                          (string_fragment [43, 40] - [43, 54]))))
                    (number [43, 59] - [43, 62])))))
            (if_statement [45, 2] - [47, 3]
              condition: (parenthesized_expression [45, 5] - [45, 29]
                (binary_expression [45, 6] - [45, 28]
                  left: (identifier [45, 6] - [45, 12])
                  right: (string [45, 17] - [45, 28]
                    (string_fragment [45, 18] - [45, 27]))))
              consequence: (statement_block [45, 30] - [47, 3]
                (expression_statement [46, 4] - [46, 46]
                  (await_expression [46, 4] - [46, 45]
                    (call_expression [46, 10] - [46, 45]
                      function: (identifier [46, 10] - [46, 31])
                      arguments: (arguments [46, 31] - [46, 45]
                        (identifier [46, 32] - [46, 44])))))))
            (expression_statement [49, 2] - [55, 4]
              (call_expression [49, 2] - [55, 3]
                function: (member_expression [49, 2] - [49, 23]
                  object: (identifier [49, 2] - [49, 14])
                  property: (property_identifier [49, 15] - [49, 23]))
                arguments: (arguments [49, 23] - [55, 3]
                  (member_expression [50, 4] - [50, 15]
                    object: (identifier [50, 4] - [50, 8])
                    property: (property_identifier [50, 9] - [50, 15]))
                  (string [51, 4] - [51, 25]
                    (string_fragment [51, 5] - [51, 24]))
                  (identifier [52, 4] - [52, 16])
                  (object [53, 4] - [53, 26]
                    (pair [53, 6] - [53, 24]
                      key: (property_identifier [53, 6] - [53, 16])
                      value: (identifier [53, 18] - [53, 24])))
                  (call_expression [54, 4] - [54, 18]
                    function: (identifier [54, 4] - [54, 15])
                    arguments: (arguments [54, 15] - [54, 18]
                      (identifier [54, 16] - [54, 17]))))))
            (return_statement [56, 2] - [56, 43]
              (call_expression [56, 9] - [56, 42]
                function: (member_expression [56, 9] - [56, 15]
                  object: (identifier [56, 9] - [56, 10])
                  property: (property_identifier [56, 11] - [56, 15]))
                arguments: (arguments [56, 15] - [56, 42]
                  (object [56, 16] - [56, 41]
                    (pair [56, 18] - [56, 31]
                      key: (property_identifier [56, 18] - [56, 25])
                      value: (true [56, 27] - [56, 31]))
                    (shorthand_property_identifier [56, 33] - [56, 39]))))))))))
  (expression_statement [59, 0] - [80, 3]
    (call_expression [59, 0] - [80, 2]
      function: (member_expression [59, 0] - [59, 23]
        object: (identifier [59, 0] - [59, 18])
        property: (property_identifier [59, 19] - [59, 23]))
      arguments: (arguments [59, 23] - [80, 2]
        (string [59, 24] - [59, 44]
          (string_fragment [59, 25] - [59, 43]))
        (arrow_function [59, 46] - [80, 1]
          parameters: (formal_parameters [59, 52] - [59, 55]
            (required_parameter [59, 53] - [59, 54]
              pattern: (identifier [59, 53] - [59, 54])))
          body: (statement_block [59, 59] - [80, 1]
            (lexical_declaration [60, 2] - [60, 45]
              (variable_declarator [60, 8] - [60, 44]
                name: (identifier [60, 8] - [60, 12])
                value: (await_expression [60, 15] - [60, 44]
                  (call_expression [60, 21] - [60, 44]
                    function: (identifier [60, 21] - [60, 41])
                    arguments: (arguments [60, 41] - [60, 44]
                      (identifier [60, 42] - [60, 43]))))))
            (if_statement [61, 2] - [61, 59]
              condition: (parenthesized_expression [61, 5] - [61, 12]
                (unary_expression [61, 6] - [61, 11]
                  argument: (identifier [61, 7] - [61, 11])))
              consequence: (return_statement [61, 13] - [61, 59]
                (call_expression [61, 20] - [61, 58]
                  function: (member_expression [61, 20] - [61, 26]
                    object: (identifier [61, 20] - [61, 21])
                    property: (property_identifier [61, 22] - [61, 26]))
                  arguments: (arguments [61, 26] - [61, 58]
                    (object [61, 27] - [61, 52]
                      (pair [61, 29] - [61, 50]
                        key: (property_identifier [61, 29] - [61, 34])
                        value: (string [61, 36] - [61, 50]
                          (string_fragment [61, 37] - [61, 49]))))
                    (number [61, 54] - [61, 57])))))
            (lexical_declaration [63, 2] - [63, 41]
              (variable_declarator [63, 8] - [63, 40]
                name: (identifier [63, 8] - [63, 20])
                value: (call_expression [63, 23] - [63, 40]
                  function: (member_expression [63, 23] - [63, 34]
                    object: (member_expression [63, 23] - [63, 28]
                      object: (identifier [63, 23] - [63, 24])
                      property: (property_identifier [63, 25] - [63, 28]))
                    property: (property_identifier [63, 29] - [63, 34]))
                  arguments: (arguments [63, 34] - [63, 40]
                    (string [63, 35] - [63, 39]
                      (string_fragment [63, 36] - [63, 38]))))))
            (lexical_declaration [64, 2] - [64, 45]
              (variable_declarator [64, 8] - [64, 44]
                name: (object_pattern [64, 8] - [64, 23]
                  (shorthand_property_identifier_pattern [64, 10] - [64, 21]))
                value: (await_expression [64, 26] - [64, 44]
                  (call_expression [64, 32] - [64, 44]
                    function: (member_expression [64, 32] - [64, 42]
                      object: (member_expression [64, 32] - [64, 37]
                        object: (identifier [64, 32] - [64, 33])
                        property: (property_identifier [64, 34] - [64, 37]))
                      property: (property_identifier [64, 38] - [64, 42]))
                    arguments: (arguments [64, 42] - [64, 44])))))
            (lexical_declaration [66, 2] - [69, 4]
              (variable_declarator [66, 8] - [69, 3]
                name: (identifier [66, 8] - [66, 15])
                value: (await_expression [66, 18] - [69, 3]
                  (call_expression [66, 24] - [69, 3]
                    function: (identifier [66, 24] - [66, 41])
                    arguments: (arguments [66, 41] - [69, 3]
                      (identifier [67, 4] - [67, 16])
                      (binary_expression [68, 4] - [68, 31]
                        left: (call_expression [68, 4] - [68, 23]
                          function: (member_expression [68, 4] - [68, 21]
                            object: (identifier [68, 4] - [68, 15])
                            optional_chain: (optional_chain [68, 15] - [68, 17])
                            property: (property_identifier [68, 17] - [68, 21]))
                          arguments: (arguments [68, 21] - [68, 23]))
                        right: (null [68, 27] - [68, 31])))))))
            (if_statement [70, 2] - [70, 64]
              condition: (parenthesized_expression [70, 5] - [70, 15]
                (unary_expression [70, 6] - [70, 14]
                  argument: (identifier [70, 7] - [70, 14])))
              consequence: (return_statement [70, 16] - [70, 64]
                (call_expression [70, 23] - [70, 63]
                  function: (member_expression [70, 23] - [70, 29]
                    object: (identifier [70, 23] - [70, 24])
                    property: (property_identifier [70, 25] - [70, 29]))
                  arguments: (arguments [70, 29] - [70, 63]
                    (object [70, 30] - [70, 57]
                      (pair [70, 32] - [70, 55]
                        key: (property_identifier [70, 32] - [70, 37])
                        value: (string [70, 39] - [70, 55]
                          (string_fragment [70, 40] - [70, 54]))))
                    (number [70, 59] - [70, 62])))))
            (expression_statement [72, 2] - [78, 4]
              (call_expression [72, 2] - [78, 3]
                function: (member_expression [72, 2] - [72, 23]
                  object: (identifier [72, 2] - [72, 14])
                  property: (property_identifier [72, 15] - [72, 23]))
                arguments: (arguments [72, 23] - [78, 3]
                  (member_expression [73, 4] - [73, 15]
                    object: (identifier [73, 4] - [73, 8])
                    property: (property_identifier [73, 9] - [73, 15]))
                  (string [74, 4] - [74, 26]
                    (string_fragment [74, 5] - [74, 25]))
                  (identifier [75, 4] - [75, 16])
                  (object [76, 4] - [76, 33]
                    (pair [76, 6] - [76, 31]
                      key: (property_identifier [76, 6] - [76, 18])
                      value: (identifier [76, 20] - [76, 31])))
                  (call_expression [77, 4] - [77, 18]
                    function: (identifier [77, 4] - [77, 15])
                    arguments: (arguments [77, 15] - [77, 18]
                      (identifier [77, 16] - [77, 17]))))))
            (return_statement [79, 2] - [79, 50]
              (call_expression [79, 9] - [79, 49]
                function: (member_expression [79, 9] - [79, 15]
                  object: (identifier [79, 9] - [79, 10])
                  property: (property_identifier [79, 11] - [79, 15]))
                arguments: (arguments [79, 15] - [79, 49]
                  (object [79, 16] - [79, 48]
                    (pair [79, 18] - [79, 31]
                      key: (property_identifier [79, 18] - [79, 25])
                      value: (true [79, 27] - [79, 31]))
                    (pair [79, 33] - [79, 46]
                      key: (property_identifier [79, 33] - [79, 37])
                      value: (identifier [79, 39] - [79, 46])))))))))))
  (expression_statement [82, 0] - [106, 3]
    (call_expression [82, 0] - [106, 2]
      function: (member_expression [82, 0] - [82, 23]
        object: (identifier [82, 0] - [82, 18])
        property: (property_identifier [82, 19] - [82, 23]))
      arguments: (arguments [82, 23] - [106, 2]
        (string [82, 24] - [82, 43]
          (string_fragment [82, 25] - [82, 42]))
        (arrow_function [82, 45] - [106, 1]
          parameters: (formal_parameters [82, 51] - [82, 54]
            (required_parameter [82, 52] - [82, 53]
              pattern: (identifier [82, 52] - [82, 53])))
          body: (statement_block [82, 58] - [106, 1]
            (lexical_declaration [83, 2] - [83, 45]
              (variable_declarator [83, 8] - [83, 44]
                name: (identifier [83, 8] - [83, 12])
                value: (await_expression [83, 15] - [83, 44]
                  (call_expression [83, 21] - [83, 44]
                    function: (identifier [83, 21] - [83, 41])
                    arguments: (arguments [83, 41] - [83, 44]
                      (identifier [83, 42] - [83, 43]))))))
            (if_statement [84, 2] - [84, 59]
              condition: (parenthesized_expression [84, 5] - [84, 12]
                (unary_expression [84, 6] - [84, 11]
                  argument: (identifier [84, 7] - [84, 11])))
              consequence: (return_statement [84, 13] - [84, 59]
                (call_expression [84, 20] - [84, 58]
                  function: (member_expression [84, 20] - [84, 26]
                    object: (identifier [84, 20] - [84, 21])
                    property: (property_identifier [84, 22] - [84, 26]))
                  arguments: (arguments [84, 26] - [84, 58]
                    (object [84, 27] - [84, 52]
                      (pair [84, 29] - [84, 50]
                        key: (property_identifier [84, 29] - [84, 34])
                        value: (string [84, 36] - [84, 50]
                          (string_fragment [84, 37] - [84, 49]))))
                    (number [84, 54] - [84, 57])))))
            (lexical_declaration [86, 2] - [86, 41]
              (variable_declarator [86, 8] - [86, 40]
                name: (identifier [86, 8] - [86, 20])
                value: (call_expression [86, 23] - [86, 40]
                  function: (member_expression [86, 23] - [86, 34]
                    object: (member_expression [86, 23] - [86, 28]
                      object: (identifier [86, 23] - [86, 24])
                      property: (property_identifier [86, 25] - [86, 28]))
                    property: (property_identifier [86, 29] - [86, 34]))
                  arguments: (arguments [86, 34] - [86, 40]
                    (string [86, 35] - [86, 39]
                      (string_fragment [86, 36] - [86, 38]))))))
            (lexical_declaration [87, 2] - [87, 45]
              (variable_declarator [87, 8] - [87, 44]
                name: (object_pattern [87, 8] - [87, 23]
                  (shorthand_property_identifier_pattern [87, 10] - [87, 15])
                  (shorthand_property_identifier_pattern [87, 17] - [87, 21]))
                value: (await_expression [87, 26] - [87, 44]
                  (call_expression [87, 32] - [87, 44]
                    function: (member_expression [87, 32] - [87, 42]
                      object: (member_expression [87, 32] - [87, 37]
                        object: (identifier [87, 32] - [87, 33])
                        property: (property_identifier [87, 34] - [87, 37]))
                      property: (property_identifier [87, 38] - [87, 42]))
                    arguments: (arguments [87, 42] - [87, 44])))))
            (if_statement [89, 2] - [91, 3]
              condition: (parenthesized_expression [89, 5] - [89, 22]
                (binary_expression [89, 6] - [89, 21]
                  left: (unary_expression [89, 6] - [89, 12]
                    argument: (identifier [89, 7] - [89, 12]))
                  right: (unary_expression [89, 16] - [89, 21]
                    argument: (identifier [89, 17] - [89, 21]))))
              consequence: (statement_block [89, 23] - [91, 3]
                (return_statement [90, 4] - [90, 63]
                  (call_expression [90, 11] - [90, 62]
                    function: (member_expression [90, 11] - [90, 17]
                      object: (identifier [90, 11] - [90, 12])
                      property: (property_identifier [90, 13] - [90, 17]))
                    arguments: (arguments [90, 17] - [90, 62]
                      (object [90, 18] - [90, 56]
                        (pair [90, 20] - [90, 54]
                          key: (property_identifier [90, 20] - [90, 25])
                          value: (string [90, 27] - [90, 54]
                            (string_fragment [90, 28] - [90, 53]))))
                      (number [90, 58] - [90, 61]))))))
            (expression_statement [93, 2] - [93, 51]
              (await_expression [93, 2] - [93, 50]
                (call_expression [93, 8] - [93, 50]
                  function: (identifier [93, 8] - [93, 23])
                  arguments: (arguments [93, 23] - [93, 50]
                    (identifier [93, 24] - [93, 36])
                    (identifier [93, 38] - [93, 43])
                    (identifier [93, 45] - [93, 49])))))
            (try_statement [94, 2] - [96, 19]
              body: (statement_block [94, 6] - [96, 3]
                (expression_statement [95, 4] - [95, 61]
                  (await_expression [95, 4] - [95, 60]
                    (call_expression [95, 10] - [95, 60]
                      function: (member_expression [95, 10] - [95, 20]
                        object: (identifier [95, 10] - [95, 16])
                        property: (property_identifier [95, 17] - [95, 20]))
                      arguments: (arguments [95, 20] - [95, 60]
                        (template_string [95, 21] - [95, 59]
                          (string_fragment [95, 22] - [95, 34])
                          (template_substitution [95, 34] - [95, 49]
                            (identifier [95, 36] - [95, 48]))
                          (string_fragment [95, 49] - [95, 50])
                          (template_substitution [95, 50] - [95, 58]
                            (identifier [95, 52] - [95, 57]))))))))
              handler: (catch_clause [96, 4] - [96, 19]
                parameter: (identifier [96, 11] - [96, 15])
                body: (statement_block [96, 17] - [96, 19])))
            (expression_statement [98, 2] - [104, 4]
              (call_expression [98, 2] - [104, 3]
                function: (member_expression [98, 2] - [98, 23]
                  object: (identifier [98, 2] - [98, 14])
                  property: (property_identifier [98, 15] - [98, 23]))
                arguments: (arguments [98, 23] - [104, 3]
                  (member_expression [99, 4] - [99, 15]
                    object: (identifier [99, 4] - [99, 8])
                    property: (property_identifier [99, 9] - [99, 15]))
                  (string [100, 4] - [100, 20]
                    (string_fragment [100, 5] - [100, 19]))
                  (identifier [101, 4] - [101, 16])
                  (object [102, 4] - [102, 27]
                    (pair [102, 6] - [102, 19]
                      key: (property_identifier [102, 6] - [102, 12])
                      value: (identifier [102, 14] - [102, 19]))
                    (shorthand_property_identifier [102, 21] - [102, 25]))
                  (call_expression [103, 4] - [103, 18]
                    function: (identifier [103, 4] - [103, 15])
                    arguments: (arguments [103, 15] - [103, 18]
                      (identifier [103, 16] - [103, 17]))))))
            (return_statement [105, 2] - [105, 35]
              (call_expression [105, 9] - [105, 34]
                function: (member_expression [105, 9] - [105, 15]
                  object: (identifier [105, 9] - [105, 10])
                  property: (property_identifier [105, 11] - [105, 15]))
                arguments: (arguments [105, 15] - [105, 34]
                  (object [105, 16] - [105, 33]
                    (pair [105, 18] - [105, 31]
                      key: (property_identifier [105, 18] - [105, 25])
                      value: (true [105, 27] - [105, 31])))))))))))
  (expression_statement [108, 0] - [128, 3]
    (call_expression [108, 0] - [128, 2]
      function: (member_expression [108, 0] - [108, 25]
        object: (identifier [108, 0] - [108, 18])
        property: (property_identifier [108, 19] - [108, 25]))
      arguments: (arguments [108, 25] - [128, 2]
        (string [108, 26] - [108, 52]
          (string_fragment [108, 27] - [108, 51]))
        (arrow_function [108, 54] - [128, 1]
          parameters: (formal_parameters [108, 60] - [108, 63]
            (required_parameter [108, 61] - [108, 62]
              pattern: (identifier [108, 61] - [108, 62])))
          body: (statement_block [108, 67] - [128, 1]
            (lexical_declaration [109, 2] - [109, 45]
              (variable_declarator [109, 8] - [109, 44]
                name: (identifier [109, 8] - [109, 12])
                value: (await_expression [109, 15] - [109, 44]
                  (call_expression [109, 21] - [109, 44]
                    function: (identifier [109, 21] - [109, 41])
                    arguments: (arguments [109, 41] - [109, 44]
                      (identifier [109, 42] - [109, 43]))))))
            (if_statement [110, 2] - [110, 59]
              condition: (parenthesized_expression [110, 5] - [110, 12]
                (unary_expression [110, 6] - [110, 11]
                  argument: (identifier [110, 7] - [110, 11])))
              consequence: (return_statement [110, 13] - [110, 59]
                (call_expression [110, 20] - [110, 58]
                  function: (member_expression [110, 20] - [110, 26]
                    object: (identifier [110, 20] - [110, 21])
                    property: (property_identifier [110, 22] - [110, 26]))
                  arguments: (arguments [110, 26] - [110, 58]
                    (object [110, 27] - [110, 52]
                      (pair [110, 29] - [110, 50]
                        key: (property_identifier [110, 29] - [110, 34])
                        value: (string [110, 36] - [110, 50]
                          (string_fragment [110, 37] - [110, 49]))))
                    (number [110, 54] - [110, 57])))))
            (lexical_declaration [112, 2] - [112, 41]
              (variable_declarator [112, 8] - [112, 40]
                name: (identifier [112, 8] - [112, 20])
                value: (call_expression [112, 23] - [112, 40]
                  function: (member_expression [112, 23] - [112, 34]
                    object: (member_expression [112, 23] - [112, 28]
                      object: (identifier [112, 23] - [112, 24])
                      property: (property_identifier [112, 25] - [112, 28]))
                    property: (property_identifier [112, 29] - [112, 34]))
                  arguments: (arguments [112, 34] - [112, 40]
                    (string [112, 35] - [112, 39]
                      (string_fragment [112, 36] - [112, 38]))))))
            (lexical_declaration [113, 2] - [113, 37]
              (variable_declarator [113, 8] - [113, 36]
                name: (identifier [113, 8] - [113, 13])
                value: (call_expression [113, 16] - [113, 36]
                  function: (member_expression [113, 16] - [113, 27]
                    object: (member_expression [113, 16] - [113, 21]
                      object: (identifier [113, 16] - [113, 17])
                      property: (property_identifier [113, 18] - [113, 21]))
                    property: (property_identifier [113, 22] - [113, 27]))
                  arguments: (arguments [113, 27] - [113, 36]
                    (string [113, 28] - [113, 35]
                      (string_fragment [113, 29] - [113, 34]))))))
            (expression_statement [115, 2] - [115, 45]
              (await_expression [115, 2] - [115, 44]
                (call_expression [115, 8] - [115, 44]
                  function: (identifier [115, 8] - [115, 23])
                  arguments: (arguments [115, 23] - [115, 44]
                    (identifier [115, 24] - [115, 36])
                    (identifier [115, 38] - [115, 43])))))
            (try_statement [116, 2] - [118, 19]
              body: (statement_block [116, 6] - [118, 3]
                (expression_statement [117, 4] - [117, 61]
                  (await_expression [117, 4] - [117, 60]
                    (call_expression [117, 10] - [117, 60]
                      function: (member_expression [117, 10] - [117, 20]
                        object: (identifier [117, 10] - [117, 16])
                        property: (property_identifier [117, 17] - [117, 20]))
                      arguments: (arguments [117, 20] - [117, 60]
                        (template_string [117, 21] - [117, 59]
                          (string_fragment [117, 22] - [117, 34])
                          (template_substitution [117, 34] - [117, 49]
                            (identifier [117, 36] - [117, 48]))
                          (string_fragment [117, 49] - [117, 50])
                          (template_substitution [117, 50] - [117, 58]
                            (identifier [117, 52] - [117, 57]))))))))
              handler: (catch_clause [118, 4] - [118, 19]
                parameter: (identifier [118, 11] - [118, 15])
                body: (statement_block [118, 17] - [118, 19])))
            (expression_statement [120, 2] - [126, 4]
              (call_expression [120, 2] - [126, 3]
                function: (member_expression [120, 2] - [120, 23]
                  object: (identifier [120, 2] - [120, 14])
                  property: (property_identifier [120, 15] - [120, 23]))
                arguments: (arguments [120, 23] - [126, 3]
                  (member_expression [121, 4] - [121, 15]
                    object: (identifier [121, 4] - [121, 8])
                    property: (property_identifier [121, 9] - [121, 15]))
                  (string [122, 4] - [122, 19]
                    (string_fragment [122, 5] - [122, 18]))
                  (identifier [123, 4] - [123, 16])
                  (object [124, 4] - [124, 21]
                    (pair [124, 6] - [124, 19]
                      key: (property_identifier [124, 6] - [124, 12])
                      value: (identifier [124, 14] - [124, 19])))
                  (call_expression [125, 4] - [125, 18]
                    function: (identifier [125, 4] - [125, 15])
                    arguments: (arguments [125, 15] - [125, 18]
                      (identifier [125, 16] - [125, 17]))))))
            (return_statement [127, 2] - [127, 35]
              (call_expression [127, 9] - [127, 34]
                function: (member_expression [127, 9] - [127, 15]
                  object: (identifier [127, 9] - [127, 10])
                  property: (property_identifier [127, 11] - [127, 15]))
                arguments: (arguments [127, 15] - [127, 34]
                  (object [127, 16] - [127, 33]
                    (pair [127, 18] - [127, 31]
                      key: (property_identifier [127, 18] - [127, 25])
                      value: (true [127, 27] - [127, 31])))))))))))
  (expression_statement [130, 0] - [144, 3]
    (call_expression [130, 0] - [144, 2]
      function: (member_expression [130, 0] - [130, 25]
        object: (identifier [130, 0] - [130, 18])
        property: (property_identifier [130, 19] - [130, 25]))
      arguments: (arguments [130, 25] - [144, 2]
        (string [130, 26] - [130, 47]
          (string_fragment [130, 27] - [130, 46]))
        (arrow_function [130, 49] - [144, 1]
          parameters: (formal_parameters [130, 55] - [130, 58]
            (required_parameter [130, 56] - [130, 57]
              pattern: (identifier [130, 56] - [130, 57])))
          body: (statement_block [130, 62] - [144, 1]
            (lexical_declaration [131, 2] - [131, 45]
              (variable_declarator [131, 8] - [131, 44]
                name: (identifier [131, 8] - [131, 12])
                value: (await_expression [131, 15] - [131, 44]
                  (call_expression [131, 21] - [131, 44]
                    function: (identifier [131, 21] - [131, 41])
                    arguments: (arguments [131, 41] - [131, 44]
                      (identifier [131, 42] - [131, 43]))))))
            (if_statement [132, 2] - [132, 59]
              condition: (parenthesized_expression [132, 5] - [132, 12]
                (unary_expression [132, 6] - [132, 11]
                  argument: (identifier [132, 7] - [132, 11])))
              consequence: (return_statement [132, 13] - [132, 59]
                (call_expression [132, 20] - [132, 58]
                  function: (member_expression [132, 20] - [132, 26]
                    object: (identifier [132, 20] - [132, 21])
                    property: (property_identifier [132, 22] - [132, 26]))
                  arguments: (arguments [132, 26] - [132, 58]
                    (object [132, 27] - [132, 52]
                      (pair [132, 29] - [132, 50]
                        key: (property_identifier [132, 29] - [132, 34])
                        value: (string [132, 36] - [132, 50]
                          (string_fragment [132, 37] - [132, 49]))))
                    (number [132, 54] - [132, 57])))))
            (lexical_declaration [133, 2] - [133, 41]
              (variable_declarator [133, 8] - [133, 40]
                name: (identifier [133, 8] - [133, 20])
                value: (call_expression [133, 23] - [133, 40]
                  function: (member_expression [133, 23] - [133, 34]
                    object: (member_expression [133, 23] - [133, 28]
                      object: (identifier [133, 23] - [133, 24])
                      property: (property_identifier [133, 25] - [133, 28]))
                    property: (property_identifier [133, 29] - [133, 34]))
                  arguments: (arguments [133, 34] - [133, 40]
                    (string [133, 35] - [133, 39]
                      (string_fragment [133, 36] - [133, 38]))))))
            (expression_statement [135, 2] - [135, 44]
              (await_expression [135, 2] - [135, 43]
                (call_expression [135, 8] - [135, 43]
                  function: (identifier [135, 8] - [135, 29])
                  arguments: (arguments [135, 29] - [135, 43]
                    (identifier [135, 30] - [135, 42])))))
            (expression_statement [136, 2] - [142, 4]
              (call_expression [136, 2] - [142, 3]
                function: (member_expression [136, 2] - [136, 23]
                  object: (identifier [136, 2] - [136, 14])
                  property: (property_identifier [136, 15] - [136, 23]))
                arguments: (arguments [136, 23] - [142, 3]
                  (member_expression [137, 4] - [137, 15]
                    object: (identifier [137, 4] - [137, 8])
                    property: (property_identifier [137, 9] - [137, 15]))
                  (string [138, 4] - [138, 31]
                    (string_fragment [138, 5] - [138, 30]))
                  (identifier [139, 4] - [139, 16])
                  (null [140, 4] - [140, 8])
                  (call_expression [141, 4] - [141, 18]
                    function: (identifier [141, 4] - [141, 15])
                    arguments: (arguments [141, 15] - [141, 18]
                      (identifier [141, 16] - [141, 17]))))))
            (return_statement [143, 2] - [143, 35]
              (call_expression [143, 9] - [143, 34]
                function: (member_expression [143, 9] - [143, 15]
                  object: (identifier [143, 9] - [143, 10])
                  property: (property_identifier [143, 11] - [143, 15]))
                arguments: (arguments [143, 15] - [143, 34]
                  (object [143, 16] - [143, 33]
                    (pair [143, 18] - [143, 31]
                      key: (property_identifier [143, 18] - [143, 25])
                      value: (true [143, 27] - [143, 31])))))))))))
  (expression_statement [146, 0] - [165, 3]
    (call_expression [146, 0] - [165, 2]
      function: (member_expression [146, 0] - [146, 25]
        object: (identifier [146, 0] - [146, 18])
        property: (property_identifier [146, 19] - [146, 25]))
      arguments: (arguments [146, 25] - [165, 2]
        (string [146, 26] - [146, 58]
          (string_fragment [146, 27] - [146, 57]))
        (arrow_function [146, 60] - [165, 1]
          parameters: (formal_parameters [146, 66] - [146, 69]
            (required_parameter [146, 67] - [146, 68]
              pattern: (identifier [146, 67] - [146, 68])))
          body: (statement_block [146, 73] - [165, 1]
            (lexical_declaration [147, 2] - [147, 45]
              (variable_declarator [147, 8] - [147, 44]
                name: (identifier [147, 8] - [147, 12])
                value: (await_expression [147, 15] - [147, 44]
                  (call_expression [147, 21] - [147, 44]
                    function: (identifier [147, 21] - [147, 41])
                    arguments: (arguments [147, 41] - [147, 44]
                      (identifier [147, 42] - [147, 43]))))))
            (if_statement [148, 2] - [148, 59]
              condition: (parenthesized_expression [148, 5] - [148, 12]
                (unary_expression [148, 6] - [148, 11]
                  argument: (identifier [148, 7] - [148, 11])))
              consequence: (return_statement [148, 13] - [148, 59]
                (call_expression [148, 20] - [148, 58]
                  function: (member_expression [148, 20] - [148, 26]
                    object: (identifier [148, 20] - [148, 21])
                    property: (property_identifier [148, 22] - [148, 26]))
                  arguments: (arguments [148, 26] - [148, 58]
                    (object [148, 27] - [148, 52]
                      (pair [148, 29] - [148, 50]
                        key: (property_identifier [148, 29] - [148, 34])
                        value: (string [148, 36] - [148, 50]
                          (string_fragment [148, 37] - [148, 49]))))
                    (number [148, 54] - [148, 57])))))
            (lexical_declaration [150, 2] - [150, 41]
              (variable_declarator [150, 8] - [150, 40]
                name: (identifier [150, 8] - [150, 20])
                value: (call_expression [150, 23] - [150, 40]
                  function: (member_expression [150, 23] - [150, 34]
                    object: (member_expression [150, 23] - [150, 28]
                      object: (identifier [150, 23] - [150, 24])
                      property: (property_identifier [150, 25] - [150, 28]))
                    property: (property_identifier [150, 29] - [150, 34]))
                  arguments: (arguments [150, 34] - [150, 40]
                    (string [150, 35] - [150, 39]
                      (string_fragment [150, 36] - [150, 38]))))))
            (lexical_declaration [151, 2] - [151, 45]
              (variable_declarator [151, 8] - [151, 44]
                name: (identifier [151, 8] - [151, 17])
                value: (call_expression [151, 20] - [151, 44]
                  function: (member_expression [151, 20] - [151, 31]
                    object: (member_expression [151, 20] - [151, 25]
                      object: (identifier [151, 20] - [151, 21])
                      property: (property_identifier [151, 22] - [151, 25]))
                    property: (property_identifier [151, 26] - [151, 31]))
                  arguments: (arguments [151, 31] - [151, 44]
                    (string [151, 32] - [151, 43]
                      (string_fragment [151, 33] - [151, 42]))))))
            (lexical_declaration [153, 2] - [153, 67]
              (variable_declarator [153, 8] - [153, 66]
                name: (identifier [153, 8] - [153, 15])
                value: (await_expression [153, 18] - [153, 66]
                  (call_expression [153, 24] - [153, 66]
                    function: (identifier [153, 24] - [153, 41])
                    arguments: (arguments [153, 41] - [153, 66]
                      (identifier [153, 42] - [153, 54])
                      (identifier [153, 56] - [153, 65]))))))
            (if_statement [154, 2] - [163, 3]
              condition: (parenthesized_expression [154, 5] - [154, 14]
                (identifier [154, 6] - [154, 13]))
              consequence: (statement_block [154, 15] - [163, 3]
                (expression_statement [155, 4] - [161, 6]
                  (call_expression [155, 4] - [161, 5]
                    function: (member_expression [155, 4] - [155, 25]
                      object: (identifier [155, 4] - [155, 16])
                      property: (property_identifier [155, 17] - [155, 25]))
                    arguments: (arguments [155, 25] - [161, 5]
                      (member_expression [156, 6] - [156, 17]
                        object: (identifier [156, 6] - [156, 10])
                        property: (property_identifier [156, 11] - [156, 17]))
                      (string [157, 6] - [157, 28]
                        (string_fragment [157, 7] - [157, 27]))
                      (identifier [158, 6] - [158, 18])
                      (object [159, 6] - [159, 31]
                        (pair [159, 8] - [159, 29]
                          key: (property_identifier [159, 8] - [159, 18])
                          value: (identifier [159, 20] - [159, 29])))
                      (call_expression [160, 6] - [160, 20]
                        function: (identifier [160, 6] - [160, 17])
                        arguments: (arguments [160, 17] - [160, 20]
                          (identifier [160, 18] - [160, 19]))))))
                (return_statement [162, 4] - [162, 37]
                  (call_expression [162, 11] - [162, 36]
                    function: (member_expression [162, 11] - [162, 17]
                      object: (identifier [162, 11] - [162, 12])
                      property: (property_identifier [162, 13] - [162, 17]))
                    arguments: (arguments [162, 17] - [162, 36]
                      (object [162, 18] - [162, 35]
                        (pair [162, 20] - [162, 33]
                          key: (property_identifier [162, 20] - [162, 27])
                          value: (true [162, 29] - [162, 33]))))))))
            (return_statement [164, 2] - [164, 53]
              (call_expression [164, 9] - [164, 52]
                function: (member_expression [164, 9] - [164, 15]
                  object: (identifier [164, 9] - [164, 10])
                  property: (property_identifier [164, 11] - [164, 15]))
                arguments: (arguments [164, 15] - [164, 52]
                  (object [164, 16] - [164, 46]
                    (pair [164, 18] - [164, 44]
                      key: (property_identifier [164, 18] - [164, 23])
                      value: (string [164, 25] - [164, 44]
                        (string_fragment [164, 26] - [164, 43]))))
                  (number [164, 48] - [164, 51])))))))))
  (expression_statement [167, 0] - [191, 3]
    (call_expression [167, 0] - [191, 2]
      function: (member_expression [167, 0] - [167, 23]
        object: (identifier [167, 0] - [167, 18])
        property: (property_identifier [167, 19] - [167, 23]))
      arguments: (arguments [167, 23] - [191, 2]
        (string [167, 24] - [167, 45]
          (string_fragment [167, 25] - [167, 44]))
        (arrow_function [167, 47] - [191, 1]
          parameters: (formal_parameters [167, 53] - [167, 56]
            (required_parameter [167, 54] - [167, 55]
              pattern: (identifier [167, 54] - [167, 55])))
          body: (statement_block [167, 60] - [191, 1]
            (lexical_declaration [168, 2] - [168, 45]
              (variable_declarator [168, 8] - [168, 44]
                name: (identifier [168, 8] - [168, 12])
                value: (await_expression [168, 15] - [168, 44]
                  (call_expression [168, 21] - [168, 44]
                    function: (identifier [168, 21] - [168, 41])
                    arguments: (arguments [168, 41] - [168, 44]
                      (identifier [168, 42] - [168, 43]))))))
            (if_statement [169, 2] - [169, 59]
              condition: (parenthesized_expression [169, 5] - [169, 12]
                (unary_expression [169, 6] - [169, 11]
                  argument: (identifier [169, 7] - [169, 11])))
              consequence: (return_statement [169, 13] - [169, 59]
                (call_expression [169, 20] - [169, 58]
                  function: (member_expression [169, 20] - [169, 26]
                    object: (identifier [169, 20] - [169, 21])
                    property: (property_identifier [169, 22] - [169, 26]))
                  arguments: (arguments [169, 26] - [169, 58]
                    (object [169, 27] - [169, 52]
                      (pair [169, 29] - [169, 50]
                        key: (property_identifier [169, 29] - [169, 34])
                        value: (string [169, 36] - [169, 50]
                          (string_fragment [169, 37] - [169, 49]))))
                    (number [169, 54] - [169, 57])))))
            (lexical_declaration [170, 2] - [170, 41]
              (variable_declarator [170, 8] - [170, 40]
                name: (identifier [170, 8] - [170, 20])
                value: (call_expression [170, 23] - [170, 40]
                  function: (member_expression [170, 23] - [170, 34]
                    object: (member_expression [170, 23] - [170, 28]
                      object: (identifier [170, 23] - [170, 24])
                      property: (property_identifier [170, 25] - [170, 28]))
                    property: (property_identifier [170, 29] - [170, 34]))
                  arguments: (arguments [170, 34] - [170, 40]
                    (string [170, 35] - [170, 39]
                      (string_fragment [170, 36] - [170, 38]))))))
            (lexical_declaration [172, 2] - [172, 53]
              (variable_declarator [172, 8] - [172, 52]
                name: (identifier [172, 8] - [172, 18])
                value: (await_expression [172, 21] - [172, 52]
                  (call_expression [172, 27] - [172, 52]
                    function: (identifier [172, 27] - [172, 38])
                    arguments: (arguments [172, 38] - [172, 52]
                      (identifier [172, 39] - [172, 51]))))))
            (if_statement [173, 2] - [173, 67]
              condition: (parenthesized_expression [173, 5] - [173, 18]
                (unary_expression [173, 6] - [173, 17]
                  argument: (identifier [173, 7] - [173, 17])))
              consequence: (return_statement [173, 19] - [173, 67]
                (call_expression [173, 26] - [173, 66]
                  function: (member_expression [173, 26] - [173, 32]
                    object: (identifier [173, 26] - [173, 27])
                    property: (property_identifier [173, 28] - [173, 32]))
                  arguments: (arguments [173, 32] - [173, 66]
                    (object [173, 33] - [173, 60]
                      (pair [173, 35] - [173, 58]
                        key: (property_identifier [173, 35] - [173, 40])
                        value: (string [173, 42] - [173, 58]
                          (string_fragment [173, 43] - [173, 57]))))
                    (number [173, 62] - [173, 65])))))
            (lexical_declaration [175, 2] - [177, 4]
              (variable_declarator [175, 8] - [177, 3]
                name: (identifier [175, 8] - [175, 20])
                value: (call_expression [175, 23] - [177, 3]
                  function: (identifier [175, 23] - [175, 38])
                  arguments: (arguments [175, 38] - [177, 3]
                    (call_expression [176, 4] - [176, 46]
                      function: (member_expression [176, 4] - [176, 26]
                        object: (identifier [176, 4] - [176, 10])
                        property: (property_identifier [176, 11] - [176, 26]))
                      arguments: (arguments [176, 26] - [176, 46]
                        (new_expression [176, 27] - [176, 45]
                          constructor: (identifier [176, 31] - [176, 41])
                          arguments: (arguments [176, 41] - [176, 45]
                            (number [176, 42] - [176, 44])))))))))
            (lexical_declaration [178, 2] - [178, 31]
              (variable_declarator [178, 8] - [178, 30]
                name: (identifier [178, 8] - [178, 17])
                value: (new_expression [178, 20] - [178, 30]
                  constructor: (identifier [178, 24] - [178, 28])
                  arguments: (arguments [178, 28] - [178, 30]))))
            (expression_statement [179, 2] - [179, 45]
              (call_expression [179, 2] - [179, 44]
                function: (member_expression [179, 2] - [179, 19]
                  object: (identifier [179, 2] - [179, 11])
                  property: (property_identifier [179, 12] - [179, 19]))
                arguments: (arguments [179, 19] - [179, 44]
                  (binary_expression [179, 20] - [179, 43]
                    left: (call_expression [179, 20] - [179, 39]
                      function: (member_expression [179, 20] - [179, 37]
                        object: (identifier [179, 20] - [179, 29])
                        property: (property_identifier [179, 30] - [179, 37]))
                      arguments: (arguments [179, 37] - [179, 39]))
                    right: (number [179, 42] - [179, 43])))))
            (expression_statement [181, 2] - [181, 79]
              (await_expression [181, 2] - [181, 78]
                (call_expression [181, 8] - [181, 78]
                  function: (identifier [181, 8] - [181, 26])
                  arguments: (arguments [181, 26] - [181, 78]
                    (identifier [181, 27] - [181, 39])
                    (identifier [181, 41] - [181, 53])
                    (member_expression [181, 55] - [181, 66]
                      object: (identifier [181, 55] - [181, 59])
                      property: (property_identifier [181, 60] - [181, 66]))
                    (identifier [181, 68] - [181, 77])))))
            (expression_statement [183, 2] - [189, 4]
              (call_expression [183, 2] - [189, 3]
                function: (member_expression [183, 2] - [183, 23]
                  object: (identifier [183, 2] - [183, 14])
                  property: (property_identifier [183, 15] - [183, 23]))
                arguments: (arguments [183, 23] - [189, 3]
                  (member_expression [184, 4] - [184, 15]
                    object: (identifier [184, 4] - [184, 8])
                    property: (property_identifier [184, 9] - [184, 15]))
                  (string [185, 4] - [185, 27]
                    (string_fragment [185, 5] - [185, 26]))
                  (identifier [186, 4] - [186, 16])
                  (null [187, 4] - [187, 8])
                  (call_expression [188, 4] - [188, 18]
                    function: (identifier [188, 4] - [188, 15])
                    arguments: (arguments [188, 15] - [188, 18]
                      (identifier [188, 16] - [188, 17]))))))
            (return_statement [190, 2] - [190, 60]
              (call_expression [190, 9] - [190, 59]
                function: (member_expression [190, 9] - [190, 15]
                  object: (identifier [190, 9] - [190, 10])
                  property: (property_identifier [190, 11] - [190, 15]))
                arguments: (arguments [190, 15] - [190, 59]
                  (object [190, 16] - [190, 58]
                    (pair [190, 18] - [190, 31]
                      key: (property_identifier [190, 18] - [190, 25])
                      value: (true [190, 27] - [190, 31]))
                    (shorthand_property_identifier [190, 33] - [190, 45])
                    (shorthand_property_identifier [190, 47] - [190, 56]))))))))))
  (expression_statement [193, 0] - [211, 3]
    (call_expression [193, 0] - [211, 2]
      function: (member_expression [193, 0] - [193, 25]
        object: (identifier [193, 0] - [193, 18])
        property: (property_identifier [193, 19] - [193, 25]))
      arguments: (arguments [193, 25] - [211, 2]
        (string [193, 26] - [193, 41]
          (string_fragment [193, 27] - [193, 40]))
        (arrow_function [193, 43] - [211, 1]
          parameters: (formal_parameters [193, 49] - [193, 52]
            (required_parameter [193, 50] - [193, 51]
              pattern: (identifier [193, 50] - [193, 51])))
          body: (statement_block [193, 56] - [211, 1]
            (lexical_declaration [194, 2] - [194, 45]
              (variable_declarator [194, 8] - [194, 44]
                name: (identifier [194, 8] - [194, 12])
                value: (await_expression [194, 15] - [194, 44]
                  (call_expression [194, 21] - [194, 44]
                    function: (identifier [194, 21] - [194, 41])
                    arguments: (arguments [194, 41] - [194, 44]
                      (identifier [194, 42] - [194, 43]))))))
            (if_statement [195, 2] - [195, 59]
              condition: (parenthesized_expression [195, 5] - [195, 12]
                (unary_expression [195, 6] - [195, 11]
                  argument: (identifier [195, 7] - [195, 11])))
              consequence: (return_statement [195, 13] - [195, 59]
                (call_expression [195, 20] - [195, 58]
                  function: (member_expression [195, 20] - [195, 26]
                    object: (identifier [195, 20] - [195, 21])
                    property: (property_identifier [195, 22] - [195, 26]))
                  arguments: (arguments [195, 26] - [195, 58]
                    (object [195, 27] - [195, 52]
                      (pair [195, 29] - [195, 50]
                        key: (property_identifier [195, 29] - [195, 34])
                        value: (string [195, 36] - [195, 50]
                          (string_fragment [195, 37] - [195, 49]))))
                    (number [195, 54] - [195, 57])))))
            (lexical_declaration [196, 2] - [196, 38]
              (variable_declarator [196, 8] - [196, 37]
                name: (identifier [196, 8] - [196, 17])
                value: (call_expression [196, 20] - [196, 37]
                  function: (member_expression [196, 20] - [196, 31]
                    object: (member_expression [196, 20] - [196, 25]
                      object: (identifier [196, 20] - [196, 21])
                      property: (property_identifier [196, 22] - [196, 25]))
                    property: (property_identifier [196, 26] - [196, 31]))
                  arguments: (arguments [196, 31] - [196, 37]
                    (string [196, 32] - [196, 36]
                      (string_fragment [196, 33] - [196, 35]))))))
            (expression_statement [198, 2] - [198, 37]
              (await_expression [198, 2] - [198, 36]
                (call_expression [198, 8] - [198, 36]
                  function: (identifier [198, 8] - [198, 25])
                  arguments: (arguments [198, 25] - [198, 36]
                    (identifier [198, 26] - [198, 35])))))
            (try_statement [199, 2] - [201, 19]
              body: (statement_block [199, 6] - [201, 3]
                (expression_statement [200, 4] - [200, 32]
                  (await_expression [200, 4] - [200, 31]
                    (call_expression [200, 10] - [200, 31]
                      function: (member_expression [200, 10] - [200, 20]
                        object: (identifier [200, 10] - [200, 16])
                        property: (property_identifier [200, 17] - [200, 20]))
                      arguments: (arguments [200, 20] - [200, 31]
                        (identifier [200, 21] - [200, 30]))))))
              handler: (catch_clause [201, 4] - [201, 19]
                parameter: (identifier [201, 11] - [201, 15])
                body: (statement_block [201, 17] - [201, 19])))
            (expression_statement [203, 2] - [209, 4]
              (call_expression [203, 2] - [209, 3]
                function: (member_expression [203, 2] - [203, 23]
                  object: (identifier [203, 2] - [203, 14])
                  property: (property_identifier [203, 15] - [203, 23]))
                arguments: (arguments [203, 23] - [209, 3]
                  (member_expression [204, 4] - [204, 15]
                    object: (identifier [204, 4] - [204, 8])
                    property: (property_identifier [204, 9] - [204, 15]))
                  (string [205, 4] - [205, 27]
                    (string_fragment [205, 5] - [205, 26]))
                  (identifier [206, 4] - [206, 13])
                  (null [207, 4] - [207, 8])
                  (call_expression [208, 4] - [208, 18]
                    function: (identifier [208, 4] - [208, 15])
                    arguments: (arguments [208, 15] - [208, 18]
                      (identifier [208, 16] - [208, 17]))))))
            (return_statement [210, 2] - [210, 35]
              (call_expression [210, 9] - [210, 34]
                function: (member_expression [210, 9] - [210, 15]
                  object: (identifier [210, 9] - [210, 10])
                  property: (property_identifier [210, 11] - [210, 15]))
                arguments: (arguments [210, 15] - [210, 34]
                  (object [210, 16] - [210, 33]
                    (pair [210, 18] - [210, 31]
                      key: (property_identifier [210, 18] - [210, 25])
                      value: (true [210, 27] - [210, 31])))))))))))
  (comment [213, 0] - [213, 18])
  (expression_statement [214, 0] - [227, 3]
    (call_expression [214, 0] - [227, 2]
      function: (member_expression [214, 0] - [214, 23]
        object: (identifier [214, 0] - [214, 18])
        property: (property_identifier [214, 19] - [214, 23]))
      arguments: (arguments [214, 23] - [227, 2]
        (string [214, 24] - [214, 32]
          (string_fragment [214, 25] - [214, 31]))
        (arrow_function [214, 34] - [227, 1]
          parameters: (formal_parameters [214, 40] - [214, 43]
            (required_parameter [214, 41] - [214, 42]
              pattern: (identifier [214, 41] - [214, 42])))
          body: (statement_block [214, 47] - [227, 1]
            (lexical_declaration [215, 2] - [215, 45]
              (variable_declarator [215, 8] - [215, 44]
                name: (identifier [215, 8] - [215, 12])
                value: (await_expression [215, 15] - [215, 44]
                  (call_expression [215, 21] - [215, 44]
                    function: (identifier [215, 21] - [215, 41])
                    arguments: (arguments [215, 41] - [215, 44]
                      (identifier [215, 42] - [215, 43]))))))
            (if_statement [216, 2] - [216, 59]
              condition: (parenthesized_expression [216, 5] - [216, 12]
                (unary_expression [216, 6] - [216, 11]
                  argument: (identifier [216, 7] - [216, 11])))
              consequence: (return_statement [216, 13] - [216, 59]
                (call_expression [216, 20] - [216, 58]
                  function: (member_expression [216, 20] - [216, 26]
                    object: (identifier [216, 20] - [216, 21])
                    property: (property_identifier [216, 22] - [216, 26]))
                  arguments: (arguments [216, 26] - [216, 58]
                    (object [216, 27] - [216, 52]
                      (pair [216, 29] - [216, 50]
                        key: (property_identifier [216, 29] - [216, 34])
                        value: (string [216, 36] - [216, 50]
                          (string_fragment [216, 37] - [216, 49]))))
                    (number [216, 54] - [216, 57])))))
            (lexical_declaration [217, 2] - [217, 63]
              (variable_declarator [217, 8] - [217, 62]
                name: (object_pattern [217, 8] - [217, 41]
                  (shorthand_property_identifier_pattern [217, 10] - [217, 12])
                  (shorthand_property_identifier_pattern [217, 14] - [217, 18])
                  (shorthand_property_identifier_pattern [217, 20] - [217, 31])
                  (shorthand_property_identifier_pattern [217, 33] - [217, 39]))
                value: (await_expression [217, 44] - [217, 62]
                  (call_expression [217, 50] - [217, 62]
                    function: (member_expression [217, 50] - [217, 60]
                      object: (member_expression [217, 50] - [217, 55]
                        object: (identifier [217, 50] - [217, 51])
                        property: (property_identifier [217, 52] - [217, 55]))
                      property: (property_identifier [217, 56] - [217, 60]))
                    arguments: (arguments [217, 60] - [217, 62])))))
            (if_statement [218, 2] - [218, 68]
              condition: (parenthesized_expression [218, 5] - [218, 12]
                (unary_expression [218, 6] - [218, 11]
                  argument: (identifier [218, 7] - [218, 11])))
              consequence: (return_statement [218, 13] - [218, 68]
                (call_expression [218, 20] - [218, 67]
                  function: (member_expression [218, 20] - [218, 26]
                    object: (identifier [218, 20] - [218, 21])
                    property: (property_identifier [218, 22] - [218, 26]))
                  arguments: (arguments [218, 26] - [218, 67]
                    (object [218, 27] - [218, 61]
                      (pair [218, 29] - [218, 59]
                        key: (property_identifier [218, 29] - [218, 34])
                        value: (string [218, 36] - [218, 59]
                          (string_fragment [218, 37] - [218, 58]))))
                    (number [218, 63] - [218, 66])))))
            (lexical_declaration [220, 2] - [220, 11]
              (variable_declarator [220, 6] - [220, 10]
                name: (identifier [220, 6] - [220, 10])))
            (if_statement [221, 2] - [225, 3]
              condition: (parenthesized_expression [221, 5] - [221, 9]
                (identifier [221, 6] - [221, 8]))
              consequence: (statement_block [221, 10] - [223, 3]
                (expression_statement [222, 4] - [222, 73]
                  (assignment_expression [222, 4] - [222, 72]
                    left: (identifier [222, 4] - [222, 8])
                    right: (await_expression [222, 11] - [222, 72]
                      (call_expression [222, 17] - [222, 72]
                        function: (identifier [222, 17] - [222, 27])
                        arguments: (arguments [222, 27] - [222, 72]
                          (identifier [222, 28] - [222, 30])
                          (identifier [222, 32] - [222, 36])
                          (binary_expression [222, 38] - [222, 55]
                            left: (identifier [222, 38] - [222, 49])
                            right: (string [222, 53] - [222, 55]))
                          (binary_expression [222, 57] - [222, 71]
                            left: (identifier [222, 57] - [222, 63])
                            right: (null [222, 67] - [222, 71]))))))))
              alternative: (else_clause [223, 4] - [225, 3]
                (statement_block [223, 9] - [225, 3]
                  (expression_statement [224, 4] - [224, 69]
                    (assignment_expression [224, 4] - [224, 68]
                      left: (identifier [224, 4] - [224, 8])
                      right: (await_expression [224, 11] - [224, 68]
                        (call_expression [224, 17] - [224, 68]
                          function: (identifier [224, 17] - [224, 27])
                          arguments: (arguments [224, 27] - [224, 68]
                            (identifier [224, 28] - [224, 32])
                            (binary_expression [224, 34] - [224, 51]
                              left: (identifier [224, 34] - [224, 45])
                              right: (string [224, 49] - [224, 51]))
                            (binary_expression [224, 53] - [224, 67]
                              left: (identifier [224, 53] - [224, 59])
                              right: (null [224, 63] - [224, 67]))))))))))
            (return_statement [226, 2] - [226, 41]
              (call_expression [226, 9] - [226, 40]
                function: (member_expression [226, 9] - [226, 15]
                  object: (identifier [226, 9] - [226, 10])
                  property: (property_identifier [226, 11] - [226, 15]))
                arguments: (arguments [226, 15] - [226, 40]
                  (object [226, 16] - [226, 39]
                    (pair [226, 18] - [226, 31]
                      key: (property_identifier [226, 18] - [226, 25])
                      value: (true [226, 27] - [226, 31]))
                    (shorthand_property_identifier [226, 33] - [226, 37]))))))))))
  (expression_statement [229, 0] - [235, 3]
    (call_expression [229, 0] - [235, 2]
      function: (member_expression [229, 0] - [229, 25]
        object: (identifier [229, 0] - [229, 18])
        property: (property_identifier [229, 19] - [229, 25]))
      arguments: (arguments [229, 25] - [235, 2]
        (string [229, 26] - [229, 38]
          (string_fragment [229, 27] - [229, 37]))
        (arrow_function [229, 40] - [235, 1]
          parameters: (formal_parameters [229, 46] - [229, 49]
            (required_parameter [229, 47] - [229, 48]
              pattern: (identifier [229, 47] - [229, 48])))
          body: (statement_block [229, 53] - [235, 1]
            (lexical_declaration [230, 2] - [230, 45]
              (variable_declarator [230, 8] - [230, 44]
                name: (identifier [230, 8] - [230, 12])
                value: (await_expression [230, 15] - [230, 44]
                  (call_expression [230, 21] - [230, 44]
                    function: (identifier [230, 21] - [230, 41])
                    arguments: (arguments [230, 41] - [230, 44]
                      (identifier [230, 42] - [230, 43]))))))
            (if_statement [231, 2] - [231, 59]
              condition: (parenthesized_expression [231, 5] - [231, 12]
                (unary_expression [231, 6] - [231, 11]
                  argument: (identifier [231, 7] - [231, 11])))
              consequence: (return_statement [231, 13] - [231, 59]
                (call_expression [231, 20] - [231, 58]
                  function: (member_expression [231, 20] - [231, 26]
                    object: (identifier [231, 20] - [231, 21])
                    property: (property_identifier [231, 22] - [231, 26]))
                  arguments: (arguments [231, 26] - [231, 58]
                    (object [231, 27] - [231, 52]
                      (pair [231, 29] - [231, 50]
                        key: (property_identifier [231, 29] - [231, 34])
                        value: (string [231, 36] - [231, 50]
                          (string_fragment [231, 37] - [231, 49]))))
                    (number [231, 54] - [231, 57])))))
            (lexical_declaration [232, 2] - [232, 35]
              (variable_declarator [232, 8] - [232, 34]
                name: (identifier [232, 8] - [232, 14])
                value: (call_expression [232, 17] - [232, 34]
                  function: (member_expression [232, 17] - [232, 28]
                    object: (member_expression [232, 17] - [232, 22]
                      object: (identifier [232, 17] - [232, 18])
                      property: (property_identifier [232, 19] - [232, 22]))
                    property: (property_identifier [232, 23] - [232, 28]))
                  arguments: (arguments [232, 28] - [232, 34]
                    (string [232, 29] - [232, 33]
                      (string_fragment [232, 30] - [232, 32]))))))
            (expression_statement [233, 2] - [233, 27]
              (await_expression [233, 2] - [233, 26]
                (call_expression [233, 8] - [233, 26]
                  function: (identifier [233, 8] - [233, 18])
                  arguments: (arguments [233, 18] - [233, 26]
                    (identifier [233, 19] - [233, 25])))))
            (return_statement [234, 2] - [234, 35]
              (call_expression [234, 9] - [234, 34]
                function: (member_expression [234, 9] - [234, 15]
                  object: (identifier [234, 9] - [234, 10])
                  property: (property_identifier [234, 11] - [234, 15]))
                arguments: (arguments [234, 15] - [234, 34]
                  (object [234, 16] - [234, 33]
                    (pair [234, 18] - [234, 31]
                      key: (property_identifier [234, 18] - [234, 25])
                      value: (true [234, 27] - [234, 31])))))))))))
  (comment [237, 0] - [237, 20])
  (expression_statement [238, 0] - [257, 3]
    (call_expression [238, 0] - [257, 2]
      function: (member_expression [238, 0] - [238, 23]
        object: (identifier [238, 0] - [238, 18])
        property: (property_identifier [238, 19] - [238, 23]))
      arguments: (arguments [238, 23] - [257, 2]
        (string [238, 24] - [238, 34]
          (string_fragment [238, 25] - [238, 33]))
        (arrow_function [238, 36] - [257, 1]
          parameters: (formal_parameters [238, 42] - [238, 45]
            (required_parameter [238, 43] - [238, 44]
              pattern: (identifier [238, 43] - [238, 44])))
          body: (statement_block [238, 49] - [257, 1]
            (lexical_declaration [239, 2] - [239, 45]
              (variable_declarator [239, 8] - [239, 44]
                name: (identifier [239, 8] - [239, 12])
                value: (await_expression [239, 15] - [239, 44]
                  (call_expression [239, 21] - [239, 44]
                    function: (identifier [239, 21] - [239, 41])
                    arguments: (arguments [239, 41] - [239, 44]
                      (identifier [239, 42] - [239, 43]))))))
            (if_statement [240, 2] - [240, 59]
              condition: (parenthesized_expression [240, 5] - [240, 12]
                (unary_expression [240, 6] - [240, 11]
                  argument: (identifier [240, 7] - [240, 11])))
              consequence: (return_statement [240, 13] - [240, 59]
                (call_expression [240, 20] - [240, 58]
                  function: (member_expression [240, 20] - [240, 26]
                    object: (identifier [240, 20] - [240, 21])
                    property: (property_identifier [240, 22] - [240, 26]))
                  arguments: (arguments [240, 26] - [240, 58]
                    (object [240, 27] - [240, 52]
                      (pair [240, 29] - [240, 50]
                        key: (property_identifier [240, 29] - [240, 34])
                        value: (string [240, 36] - [240, 50]
                          (string_fragment [240, 37] - [240, 49]))))
                    (number [240, 54] - [240, 57])))))
            (lexical_declaration [241, 2] - [241, 73]
              (variable_declarator [241, 8] - [241, 72]
                name: (object_pattern [241, 8] - [241, 51]
                  (shorthand_property_identifier_pattern [241, 10] - [241, 16])
                  (shorthand_property_identifier_pattern [241, 18] - [241, 22])
                  (shorthand_property_identifier_pattern [241, 24] - [241, 32])
                  (shorthand_property_identifier_pattern [241, 34] - [241, 49]))
                value: (await_expression [241, 54] - [241, 72]
                  (call_expression [241, 60] - [241, 72]
                    function: (member_expression [241, 60] - [241, 70]
                      object: (member_expression [241, 60] - [241, 65]
                        object: (identifier [241, 60] - [241, 61])
                        property: (property_identifier [241, 62] - [241, 65]))
                      property: (property_identifier [241, 66] - [241, 70]))
                    arguments: (arguments [241, 70] - [241, 72])))))
            (lexical_declaration [243, 2] - [243, 75]
              (variable_declarator [243, 8] - [243, 74]
                name: (identifier [243, 8] - [243, 12])
                value: (call_expression [243, 15] - [243, 74]
                  function: (identifier [243, 15] - [243, 30])
                  arguments: (arguments [243, 30] - [243, 74]
                    (call_expression [243, 31] - [243, 73]
                      function: (member_expression [243, 31] - [243, 53]
                        object: (identifier [243, 31] - [243, 37])
                        property: (property_identifier [243, 38] - [243, 53]))
                      arguments: (arguments [243, 53] - [243, 73]
                        (new_expression [243, 54] - [243, 72]
                          constructor: (identifier [243, 58] - [243, 68])
                          arguments: (arguments [243, 68] - [243, 72]
                            (number [243, 69] - [243, 71])))))))))
            (lexical_declaration [244, 2] - [244, 31]
              (variable_declarator [244, 8] - [244, 30]
                name: (identifier [244, 8] - [244, 17])
                value: (new_expression [244, 20] - [244, 30]
                  constructor: (identifier [244, 24] - [244, 28])
                  arguments: (arguments [244, 28] - [244, 30]))))
            (expression_statement [245, 2] - [245, 74]
              (call_expression [245, 2] - [245, 73]
                function: (member_expression [245, 2] - [245, 19]
                  object: (identifier [245, 2] - [245, 11])
                  property: (property_identifier [245, 12] - [245, 19]))
                arguments: (arguments [245, 19] - [245, 73]
                  (binary_expression [245, 20] - [245, 72]
                    left: (call_expression [245, 20] - [245, 39]
                      function: (member_expression [245, 20] - [245, 37]
                        object: (identifier [245, 20] - [245, 29])
                        property: (property_identifier [245, 30] - [245, 37]))
                      arguments: (arguments [245, 37] - [245, 39]))
                    right: (parenthesized_expression [245, 42] - [245, 72]
                      (binary_expression [245, 43] - [245, 71]
                        left: (call_expression [245, 43] - [245, 66]
                          function: (identifier [245, 43] - [245, 49])
                          arguments: (arguments [245, 49] - [245, 66]
                            (identifier [245, 50] - [245, 65])))
                        right: (number [245, 70] - [245, 71])))))))
            (lexical_declaration [246, 2] - [246, 68]
              (variable_declarator [246, 8] - [246, 67]
                name: (identifier [246, 8] - [246, 18])
                value: (ternary_expression [246, 21] - [246, 67]
                  condition: (binary_expression [246, 21] - [246, 41]
                    left: (call_expression [246, 21] - [246, 37]
                      function: (identifier [246, 21] - [246, 27])
                      arguments: (arguments [246, 27] - [246, 37]
                        (identifier [246, 28] - [246, 36])))
                    right: (number [246, 40] - [246, 41]))
                  consequence: (call_expression [246, 44] - [246, 60]
                    function: (identifier [246, 44] - [246, 50])
                    arguments: (arguments [246, 50] - [246, 60]
                      (identifier [246, 51] - [246, 59])))
                  alternative: (null [246, 63] - [246, 67]))))
            (lexical_declaration [248, 2] - [255, 4]
              (variable_declarator [248, 8] - [255, 3]
                name: (identifier [248, 8] - [248, 14])
                value: (await_expression [248, 17] - [255, 3]
                  (call_expression [248, 23] - [255, 3]
                    function: (identifier [248, 23] - [248, 35])
                    arguments: (arguments [248, 35] - [255, 3]
                      (identifier [249, 4] - [249, 8])
                      (binary_expression [250, 4] - [250, 18]
                        left: (identifier [250, 4] - [250, 10])
                        right: (null [250, 14] - [250, 18]))
                      (binary_expression [251, 4] - [251, 18]
                        left: (identifier [251, 4] - [251, 8])
                        right: (string [251, 12] - [251, 18]
                          (string_fragment [251, 13] - [251, 17])))
                      (identifier [252, 4] - [252, 14])
                      (identifier [253, 4] - [253, 13])
                      (true [254, 4] - [254, 8]))))))
            (return_statement [256, 2] - [256, 43]
              (call_expression [256, 9] - [256, 42]
                function: (member_expression [256, 9] - [256, 15]
                  object: (identifier [256, 9] - [256, 10])
                  property: (property_identifier [256, 11] - [256, 15]))
                arguments: (arguments [256, 15] - [256, 42]
                  (object [256, 16] - [256, 41]
                    (pair [256, 18] - [256, 31]
                      key: (property_identifier [256, 18] - [256, 25])
                      value: (true [256, 27] - [256, 31]))
                    (shorthand_property_identifier [256, 33] - [256, 39]))))))))))
  (expression_statement [259, 0] - [265, 3]
    (call_expression [259, 0] - [265, 2]
      function: (member_expression [259, 0] - [259, 25]
        object: (identifier [259, 0] - [259, 18])
        property: (property_identifier [259, 19] - [259, 25]))
      arguments: (arguments [259, 25] - [265, 2]
        (string [259, 26] - [259, 40]
          (string_fragment [259, 27] - [259, 39]))
        (arrow_function [259, 42] - [265, 1]
          parameters: (formal_parameters [259, 48] - [259, 51]
            (required_parameter [259, 49] - [259, 50]
              pattern: (identifier [259, 49] - [259, 50])))
          body: (statement_block [259, 55] - [265, 1]
            (lexical_declaration [260, 2] - [260, 45]
              (variable_declarator [260, 8] - [260, 44]
                name: (identifier [260, 8] - [260, 12])
                value: (await_expression [260, 15] - [260, 44]
                  (call_expression [260, 21] - [260, 44]
                    function: (identifier [260, 21] - [260, 41])
                    arguments: (arguments [260, 41] - [260, 44]
                      (identifier [260, 42] - [260, 43]))))))
            (if_statement [261, 2] - [261, 59]
              condition: (parenthesized_expression [261, 5] - [261, 12]
                (unary_expression [261, 6] - [261, 11]
                  argument: (identifier [261, 7] - [261, 11])))
              consequence: (return_statement [261, 13] - [261, 59]
                (call_expression [261, 20] - [261, 58]
                  function: (member_expression [261, 20] - [261, 26]
                    object: (identifier [261, 20] - [261, 21])
                    property: (property_identifier [261, 22] - [261, 26]))
                  arguments: (arguments [261, 26] - [261, 58]
                    (object [261, 27] - [261, 52]
                      (pair [261, 29] - [261, 50]
                        key: (property_identifier [261, 29] - [261, 34])
                        value: (string [261, 36] - [261, 50]
                          (string_fragment [261, 37] - [261, 49]))))
                    (number [261, 54] - [261, 57])))))
            (lexical_declaration [262, 2] - [262, 37]
              (variable_declarator [262, 8] - [262, 36]
                name: (identifier [262, 8] - [262, 16])
                value: (call_expression [262, 19] - [262, 36]
                  function: (member_expression [262, 19] - [262, 30]
                    object: (member_expression [262, 19] - [262, 24]
                      object: (identifier [262, 19] - [262, 20])
                      property: (property_identifier [262, 21] - [262, 24]))
                    property: (property_identifier [262, 25] - [262, 30]))
                  arguments: (arguments [262, 30] - [262, 36]
                    (string [262, 31] - [262, 35]
                      (string_fragment [262, 32] - [262, 34]))))))
            (expression_statement [263, 2] - [263, 31]
              (await_expression [263, 2] - [263, 30]
                (call_expression [263, 8] - [263, 30]
                  function: (identifier [263, 8] - [263, 20])
                  arguments: (arguments [263, 20] - [263, 30]
                    (identifier [263, 21] - [263, 29])))))
            (return_statement [264, 2] - [264, 35]
              (call_expression [264, 9] - [264, 34]
                function: (member_expression [264, 9] - [264, 15]
                  object: (identifier [264, 9] - [264, 10])
                  property: (property_identifier [264, 11] - [264, 15]))
                arguments: (arguments [264, 15] - [264, 34]
                  (object [264, 16] - [264, 33]
                    (pair [264, 18] - [264, 31]
                      key: (property_identifier [264, 18] - [264, 25])
                      value: (true [264, 27] - [264, 31])))))))))))
  (comment [267, 0] - [267, 19])
  (expression_statement [268, 0] - [276, 3]
    (call_expression [268, 0] - [276, 2]
      function: (member_expression [268, 0] - [268, 23]
        object: (identifier [268, 0] - [268, 18])
        property: (property_identifier [268, 19] - [268, 23]))
      arguments: (arguments [268, 23] - [276, 2]
        (string [268, 24] - [268, 33]
          (string_fragment [268, 25] - [268, 32]))
        (arrow_function [268, 35] - [276, 1]
          parameters: (formal_parameters [268, 41] - [268, 44]
            (required_parameter [268, 42] - [268, 43]
              pattern: (identifier [268, 42] - [268, 43])))
          body: (statement_block [268, 48] - [276, 1]
            (lexical_declaration [269, 2] - [269, 45]
              (variable_declarator [269, 8] - [269, 44]
                name: (identifier [269, 8] - [269, 12])
                value: (await_expression [269, 15] - [269, 44]
                  (call_expression [269, 21] - [269, 44]
                    function: (identifier [269, 21] - [269, 41])
                    arguments: (arguments [269, 41] - [269, 44]
                      (identifier [269, 42] - [269, 43]))))))
            (if_statement [270, 2] - [270, 59]
              condition: (parenthesized_expression [270, 5] - [270, 12]
                (unary_expression [270, 6] - [270, 11]
                  argument: (identifier [270, 7] - [270, 11])))
              consequence: (return_statement [270, 13] - [270, 59]
                (call_expression [270, 20] - [270, 58]
                  function: (member_expression [270, 20] - [270, 26]
                    object: (identifier [270, 20] - [270, 21])
                    property: (property_identifier [270, 22] - [270, 26]))
                  arguments: (arguments [270, 26] - [270, 58]
                    (object [270, 27] - [270, 52]
                      (pair [270, 29] - [270, 50]
                        key: (property_identifier [270, 29] - [270, 34])
                        value: (string [270, 36] - [270, 50]
                          (string_fragment [270, 37] - [270, 49]))))
                    (number [270, 54] - [270, 57])))))
            (lexical_declaration [271, 2] - [271, 53]
              (variable_declarator [271, 8] - [271, 52]
                name: (object_pattern [271, 8] - [271, 31]
                  (shorthand_property_identifier_pattern [271, 10] - [271, 16])
                  (shorthand_property_identifier_pattern [271, 18] - [271, 29]))
                value: (await_expression [271, 34] - [271, 52]
                  (call_expression [271, 40] - [271, 52]
                    function: (member_expression [271, 40] - [271, 50]
                      object: (member_expression [271, 40] - [271, 45]
                        object: (identifier [271, 40] - [271, 41])
                        property: (property_identifier [271, 42] - [271, 45]))
                      property: (property_identifier [271, 46] - [271, 50]))
                    arguments: (arguments [271, 50] - [271, 52])))))
            (if_statement [272, 2] - [272, 67]
              condition: (parenthesized_expression [272, 5] - [272, 14]
                (unary_expression [272, 6] - [272, 13]
                  argument: (identifier [272, 7] - [272, 13])))
              consequence: (return_statement [272, 15] - [272, 67]
                (call_expression [272, 22] - [272, 66]
                  function: (member_expression [272, 22] - [272, 28]
                    object: (identifier [272, 22] - [272, 23])
                    property: (property_identifier [272, 24] - [272, 28]))
                  arguments: (arguments [272, 28] - [272, 66]
                    (object [272, 29] - [272, 60]
                      (pair [272, 31] - [272, 58]
                        key: (property_identifier [272, 31] - [272, 36])
                        value: (string [272, 38] - [272, 58]
                          (string_fragment [272, 39] - [272, 57]))))
                    (number [272, 62] - [272, 65])))))
            (lexical_declaration [274, 2] - [274, 66]
              (variable_declarator [274, 8] - [274, 65]
                name: (identifier [274, 8] - [274, 13])
                value: (await_expression [274, 16] - [274, 65]
                  (call_expression [274, 22] - [274, 65]
                    function: (identifier [274, 22] - [274, 31])
                    arguments: (arguments [274, 31] - [274, 65]
                      (call_expression [274, 32] - [274, 45]
                        function: (member_expression [274, 32] - [274, 43]
                          object: (identifier [274, 32] - [274, 38])
                          property: (property_identifier [274, 39] - [274, 43]))
                        arguments: (arguments [274, 43] - [274, 45]))
                      (binary_expression [274, 47] - [274, 64]
                        left: (identifier [274, 47] - [274, 58])
                        right: (string [274, 62] - [274, 64])))))))
            (return_statement [275, 2] - [275, 42]
              (call_expression [275, 9] - [275, 41]
                function: (member_expression [275, 9] - [275, 15]
                  object: (identifier [275, 9] - [275, 10])
                  property: (property_identifier [275, 11] - [275, 15]))
                arguments: (arguments [275, 15] - [275, 41]
                  (object [275, 16] - [275, 40]
                    (pair [275, 18] - [275, 31]
                      key: (property_identifier [275, 18] - [275, 25])
                      value: (true [275, 27] - [275, 31]))
                    (shorthand_property_identifier [275, 33] - [275, 38]))))))))))
  (expression_statement [278, 0] - [284, 3]
    (call_expression [278, 0] - [284, 2]
      function: (member_expression [278, 0] - [278, 25]
        object: (identifier [278, 0] - [278, 18])
        property: (property_identifier [278, 19] - [278, 25]))
      arguments: (arguments [278, 25] - [284, 2]
        (string [278, 26] - [278, 39]
          (string_fragment [278, 27] - [278, 38]))
        (arrow_function [278, 41] - [284, 1]
          parameters: (formal_parameters [278, 47] - [278, 50]
            (required_parameter [278, 48] - [278, 49]
              pattern: (identifier [278, 48] - [278, 49])))
          body: (statement_block [278, 54] - [284, 1]
            (lexical_declaration [279, 2] - [279, 45]
              (variable_declarator [279, 8] - [279, 44]
                name: (identifier [279, 8] - [279, 12])
                value: (await_expression [279, 15] - [279, 44]
                  (call_expression [279, 21] - [279, 44]
                    function: (identifier [279, 21] - [279, 41])
                    arguments: (arguments [279, 41] - [279, 44]
                      (identifier [279, 42] - [279, 43]))))))
            (if_statement [280, 2] - [280, 59]
              condition: (parenthesized_expression [280, 5] - [280, 12]
                (unary_expression [280, 6] - [280, 11]
                  argument: (identifier [280, 7] - [280, 11])))
              consequence: (return_statement [280, 13] - [280, 59]
                (call_expression [280, 20] - [280, 58]
                  function: (member_expression [280, 20] - [280, 26]
                    object: (identifier [280, 20] - [280, 21])
                    property: (property_identifier [280, 22] - [280, 26]))
                  arguments: (arguments [280, 26] - [280, 58]
                    (object [280, 27] - [280, 52]
                      (pair [280, 29] - [280, 50]
                        key: (property_identifier [280, 29] - [280, 34])
                        value: (string [280, 36] - [280, 50]
                          (string_fragment [280, 37] - [280, 49]))))
                    (number [280, 54] - [280, 57])))))
            (lexical_declaration [281, 2] - [281, 31]
              (variable_declarator [281, 8] - [281, 30]
                name: (identifier [281, 8] - [281, 10])
                value: (call_expression [281, 13] - [281, 30]
                  function: (member_expression [281, 13] - [281, 24]
                    object: (member_expression [281, 13] - [281, 18]
                      object: (identifier [281, 13] - [281, 14])
                      property: (property_identifier [281, 15] - [281, 18]))
                    property: (property_identifier [281, 19] - [281, 24]))
                  arguments: (arguments [281, 24] - [281, 30]
                    (string [281, 25] - [281, 29]
                      (string_fragment [281, 26] - [281, 28]))))))
            (expression_statement [282, 2] - [282, 25]
              (await_expression [282, 2] - [282, 24]
                (call_expression [282, 8] - [282, 24]
                  function: (identifier [282, 8] - [282, 20])
                  arguments: (arguments [282, 20] - [282, 24]
                    (identifier [282, 21] - [282, 23])))))
            (return_statement [283, 2] - [283, 35]
              (call_expression [283, 9] - [283, 34]
                function: (member_expression [283, 9] - [283, 15]
                  object: (identifier [283, 9] - [283, 10])
                  property: (property_identifier [283, 11] - [283, 15]))
                arguments: (arguments [283, 15] - [283, 34]
                  (object [283, 16] - [283, 33]
                    (pair [283, 18] - [283, 31]
                      key: (property_identifier [283, 18] - [283, 25])
                      value: (true [283, 27] - [283, 31])))))))))))
  (comment [286, 0] - [286, 25])
  (expression_statement [287, 0] - [329, 3]
    (call_expression [287, 0] - [329, 2]
      function: (member_expression [287, 0] - [287, 23]
        object: (identifier [287, 0] - [287, 18])
        property: (property_identifier [287, 19] - [287, 23]))
      arguments: (arguments [287, 23] - [329, 2]
        (string [287, 24] - [287, 31]
          (string_fragment [287, 25] - [287, 30]))
        (arrow_function [287, 33] - [329, 1]
          parameters: (formal_parameters [287, 39] - [287, 42]
            (required_parameter [287, 40] - [287, 41]
              pattern: (identifier [287, 40] - [287, 41])))
          body: (statement_block [287, 46] - [329, 1]
            (lexical_declaration [288, 2] - [288, 45]
              (variable_declarator [288, 8] - [288, 44]
                name: (identifier [288, 8] - [288, 12])
                value: (await_expression [288, 15] - [288, 44]
                  (call_expression [288, 21] - [288, 44]
                    function: (identifier [288, 21] - [288, 41])
                    arguments: (arguments [288, 41] - [288, 44]
                      (identifier [288, 42] - [288, 43]))))))
            (if_statement [289, 2] - [289, 59]
              condition: (parenthesized_expression [289, 5] - [289, 12]
                (unary_expression [289, 6] - [289, 11]
                  argument: (identifier [289, 7] - [289, 11])))
              consequence: (return_statement [289, 13] - [289, 59]
                (call_expression [289, 20] - [289, 58]
                  function: (member_expression [289, 20] - [289, 26]
                    object: (identifier [289, 20] - [289, 21])
                    property: (property_identifier [289, 22] - [289, 26]))
                  arguments: (arguments [289, 26] - [289, 58]
                    (object [289, 27] - [289, 52]
                      (pair [289, 29] - [289, 50]
                        key: (property_identifier [289, 29] - [289, 34])
                        value: (string [289, 36] - [289, 50]
                          (string_fragment [289, 37] - [289, 49]))))
                    (number [289, 54] - [289, 57])))))
            (lexical_declaration [291, 2] - [299, 25]
              (variable_declarator [291, 8] - [299, 24]
                name: (object_pattern [291, 8] - [299, 3]
                  (shorthand_property_identifier_pattern [292, 4] - [292, 8])
                  (shorthand_property_identifier_pattern [293, 4] - [293, 12])
                  (shorthand_property_identifier_pattern [294, 4] - [294, 15])
                  (shorthand_property_identifier_pattern [295, 4] - [295, 10])
                  (shorthand_property_identifier_pattern [296, 4] - [296, 13])
                  (shorthand_property_identifier_pattern [297, 4] - [297, 16])
                  (shorthand_property_identifier_pattern [298, 4] - [298, 17]))
                value: (await_expression [299, 6] - [299, 24]
                  (call_expression [299, 12] - [299, 24]
                    function: (member_expression [299, 12] - [299, 22]
                      object: (member_expression [299, 12] - [299, 17]
                        object: (identifier [299, 12] - [299, 13])
                        property: (property_identifier [299, 14] - [299, 17]))
                      property: (property_identifier [299, 18] - [299, 22]))
                    arguments: (arguments [299, 22] - [299, 24])))))
            (if_statement [301, 2] - [303, 3]
              condition: (parenthesized_expression [301, 5] - [301, 25]
                (binary_expression [301, 6] - [301, 24]
                  left: (unary_expression [301, 6] - [301, 11]
                    argument: (identifier [301, 7] - [301, 11]))
                  right: (unary_expression [301, 15] - [301, 24]
                    argument: (identifier [301, 16] - [301, 24]))))
              consequence: (statement_block [301, 26] - [303, 3]
                (return_statement [302, 4] - [302, 69]
                  (call_expression [302, 11] - [302, 68]
                    function: (member_expression [302, 11] - [302, 17]
                      object: (identifier [302, 11] - [302, 12])
                      property: (property_identifier [302, 13] - [302, 17]))
                    arguments: (arguments [302, 17] - [302, 68]
                      (object [302, 18] - [302, 62]
                        (pair [302, 20] - [302, 60]
                          key: (property_identifier [302, 20] - [302, 25])
                          value: (string [302, 27] - [302, 60]
                            (string_fragment [302, 28] - [302, 59]))))
                      (number [302, 64] - [302, 67]))))))
            (try_statement [305, 2] - [328, 3]
              body: (statement_block [305, 6] - [321, 3]
                (lexical_declaration [306, 4] - [314, 6]
                  (variable_declarator [306, 10] - [314, 5]
                    name: (identifier [306, 10] - [306, 16])
                    value: (await_expression [306, 19] - [314, 5]
                      (call_expression [306, 25] - [314, 5]
                        function: (identifier [306, 25] - [306, 34])
                        arguments: (arguments [306, 34] - [314, 5]
                          (identifier [307, 6] - [307, 10])
                          (identifier [308, 6] - [308, 14])
                          (identifier [309, 6] - [309, 17])
                          (identifier [310, 6] - [310, 12])
                          (identifier [311, 6] - [311, 15])
                          (identifier [312, 6] - [312, 18])
                          (identifier [313, 6] - [313, 19]))))))
                (expression_statement [316, 4] - [319, 23]
                  (call_expression [316, 4] - [319, 22]
                    function: (member_expression [316, 4] - [316, 25]
                      object: (identifier [316, 4] - [316, 16])
                      property: (property_identifier [316, 17] - [316, 25]))
                    arguments: (arguments [316, 25] - [319, 22]
                      (member_expression [316, 26] - [316, 37]
                        object: (identifier [316, 26] - [316, 30])
                        property: (property_identifier [316, 31] - [316, 37]))
                      (string [316, 39] - [316, 55]
                        (string_fragment [316, 40] - [316, 54]))
                      (member_expression [316, 57] - [316, 66]
                        object: (identifier [316, 57] - [316, 63])
                        property: (property_identifier [316, 64] - [316, 66]))
                      (object [316, 68] - [319, 5]
                        (pair [317, 6] - [317, 23]
                          key: (property_identifier [317, 6] - [317, 10])
                          value: (member_expression [317, 12] - [317, 23]
                            object: (identifier [317, 12] - [317, 18])
                            property: (property_identifier [317, 19] - [317, 23])))
                        (pair [318, 6] - [318, 33]
                          key: (property_identifier [318, 6] - [318, 15])
                          value: (member_expression [318, 17] - [318, 33]
                            object: (identifier [318, 17] - [318, 23])
                            property: (property_identifier [318, 24] - [318, 33]))))
                      (call_expression [319, 7] - [319, 21]
                        function: (identifier [319, 7] - [319, 18])
                        arguments: (arguments [319, 18] - [319, 21]
                          (identifier [319, 19] - [319, 20]))))))
                (return_statement [320, 4] - [320, 50]
                  (call_expression [320, 11] - [320, 49]
                    function: (member_expression [320, 11] - [320, 17]
                      object: (identifier [320, 11] - [320, 12])
                      property: (property_identifier [320, 13] - [320, 17]))
                    arguments: (arguments [320, 17] - [320, 49]
                      (object [320, 18] - [320, 48]
                        (pair [320, 20] - [320, 33]
                          key: (property_identifier [320, 20] - [320, 27])
                          value: (true [320, 29] - [320, 33]))
                        (pair [320, 35] - [320, 46]
                          key: (property_identifier [320, 35] - [320, 38])
                          value: (identifier [320, 40] - [320, 46])))))))
              handler: (catch_clause [321, 4] - [328, 3]
                parameter: (identifier [321, 11] - [321, 14])
                type: (type_annotation [321, 14] - [321, 19]
                  (predefined_type [321, 16] - [321, 19]))
                body: (statement_block [321, 21] - [328, 3]
                  (if_statement [322, 4] - [326, 5]
                    condition: (parenthesized_expression [322, 7] - [322, 29]
                      (binary_expression [322, 8] - [322, 28]
                        left: (member_expression [322, 8] - [322, 16]
                          object: (identifier [322, 8] - [322, 11])
                          property: (property_identifier [322, 12] - [322, 16]))
                        right: (string [322, 21] - [322, 28]
                          (string_fragment [322, 22] - [322, 27]))))
                    consequence: (statement_block [322, 30] - [326, 5]
                      (return_statement [323, 6] - [325, 14]
                        (call_expression [323, 13] - [325, 13]
                          function: (member_expression [323, 13] - [323, 19]
                            object: (identifier [323, 13] - [323, 14])
                            property: (property_identifier [323, 15] - [323, 19]))
                          arguments: (arguments [323, 19] - [325, 13]
                            (object [323, 20] - [325, 7]
                              (pair [324, 8] - [324, 66]
                                key: (property_identifier [324, 8] - [324, 13])
                                value: (string [324, 15] - [324, 66]
                                  (string_fragment [324, 16] - [324, 65]))))
                            (number [325, 9] - [325, 12]))))))
                  (return_statement [327, 4] - [327, 68]
                    (call_expression [327, 11] - [327, 67]
                      function: (member_expression [327, 11] - [327, 17]
                        object: (identifier [327, 11] - [327, 12])
                        property: (property_identifier [327, 13] - [327, 17]))
                      arguments: (arguments [327, 17] - [327, 67]
                        (object [327, 18] - [327, 61]
                          (pair [327, 20] - [327, 59]
                            key: (property_identifier [327, 20] - [327, 25])
                            value: (string [327, 27] - [327, 59]
                              (string_fragment [327, 28] - [327, 58]))))
                        (number [327, 63] - [327, 66]))))))))))))
  (expression_statement [331, 0] - [370, 3]
    (call_expression [331, 0] - [370, 2]
      function: (member_expression [331, 0] - [331, 22]
        object: (identifier [331, 0] - [331, 18])
        property: (property_identifier [331, 19] - [331, 22]))
      arguments: (arguments [331, 22] - [370, 2]
        (string [331, 23] - [331, 34]
          (string_fragment [331, 24] - [331, 33]))
        (arrow_function [331, 36] - [370, 1]
          parameters: (formal_parameters [331, 42] - [331, 45]
            (required_parameter [331, 43] - [331, 44]
              pattern: (identifier [331, 43] - [331, 44])))
          body: (statement_block [331, 49] - [370, 1]
            (lexical_declaration [332, 2] - [332, 45]
              (variable_declarator [332, 8] - [332, 44]
                name: (identifier [332, 8] - [332, 12])
                value: (await_expression [332, 15] - [332, 44]
                  (call_expression [332, 21] - [332, 44]
                    function: (identifier [332, 21] - [332, 41])
                    arguments: (arguments [332, 41] - [332, 44]
                      (identifier [332, 42] - [332, 43]))))))
            (if_statement [333, 2] - [333, 59]
              condition: (parenthesized_expression [333, 5] - [333, 12]
                (unary_expression [333, 6] - [333, 11]
                  argument: (identifier [333, 7] - [333, 11])))
              consequence: (return_statement [333, 13] - [333, 59]
                (call_expression [333, 20] - [333, 58]
                  function: (member_expression [333, 20] - [333, 26]
                    object: (identifier [333, 20] - [333, 21])
                    property: (property_identifier [333, 22] - [333, 26]))
                  arguments: (arguments [333, 26] - [333, 58]
                    (object [333, 27] - [333, 52]
                      (pair [333, 29] - [333, 50]
                        key: (property_identifier [333, 29] - [333, 34])
                        value: (string [333, 36] - [333, 50]
                          (string_fragment [333, 37] - [333, 49]))))
                    (number [333, 54] - [333, 57])))))
            (lexical_declaration [335, 2] - [335, 34]
              (variable_declarator [335, 8] - [335, 33]
                name: (identifier [335, 8] - [335, 13])
                value: (call_expression [335, 16] - [335, 33]
                  function: (member_expression [335, 16] - [335, 27]
                    object: (member_expression [335, 16] - [335, 21]
                      object: (identifier [335, 16] - [335, 17])
                      property: (property_identifier [335, 18] - [335, 21]))
                    property: (property_identifier [335, 22] - [335, 27]))
                  arguments: (arguments [335, 27] - [335, 33]
                    (string [335, 28] - [335, 32]
                      (string_fragment [335, 29] - [335, 31]))))))
            (lexical_declaration [336, 2] - [343, 25]
              (variable_declarator [336, 8] - [343, 24]
                name: (object_pattern [336, 8] - [343, 3]
                  (shorthand_property_identifier_pattern [337, 4] - [337, 8])
                  (shorthand_property_identifier_pattern [338, 4] - [338, 15])
                  (shorthand_property_identifier_pattern [339, 4] - [339, 10])
                  (shorthand_property_identifier_pattern [340, 4] - [340, 13])
                  (shorthand_property_identifier_pattern [341, 4] - [341, 16])
                  (shorthand_property_identifier_pattern [342, 4] - [342, 17]))
                value: (await_expression [343, 6] - [343, 24]
                  (call_expression [343, 12] - [343, 24]
                    function: (member_expression [343, 12] - [343, 22]
                      object: (member_expression [343, 12] - [343, 17]
                        object: (identifier [343, 12] - [343, 13])
                        property: (property_identifier [343, 14] - [343, 17]))
                      property: (property_identifier [343, 18] - [343, 22]))
                    arguments: (arguments [343, 22] - [343, 24])))))
            (if_statement [345, 2] - [347, 3]
              condition: (parenthesized_expression [345, 5] - [345, 12]
                (unary_expression [345, 6] - [345, 11]
                  argument: (identifier [345, 7] - [345, 11])))
              consequence: (statement_block [345, 13] - [347, 3]
                (return_statement [346, 4] - [346, 66]
                  (call_expression [346, 11] - [346, 65]
                    function: (member_expression [346, 11] - [346, 17]
                      object: (identifier [346, 11] - [346, 12])
                      property: (property_identifier [346, 13] - [346, 17]))
                    arguments: (arguments [346, 17] - [346, 65]
                      (object [346, 18] - [346, 59]
                        (pair [346, 20] - [346, 57]
                          key: (property_identifier [346, 20] - [346, 25])
                          value: (string [346, 27] - [346, 57]
                            (string_fragment [346, 28] - [346, 56]))))
                      (number [346, 61] - [346, 64]))))))
            (try_statement [349, 2] - [369, 3]
              body: (statement_block [349, 6] - [367, 3]
                (lexical_declaration [350, 4] - [358, 6]
                  (variable_declarator [350, 10] - [358, 5]
                    name: (identifier [350, 10] - [350, 20])
                    value: (await_expression [350, 23] - [358, 5]
                      (call_expression [350, 29] - [358, 5]
                        function: (identifier [350, 29] - [350, 38])
                        arguments: (arguments [350, 38] - [358, 5]
                          (identifier [351, 6] - [351, 11])
                          (identifier [352, 6] - [352, 10])
                          (identifier [353, 6] - [353, 17])
                          (identifier [354, 6] - [354, 12])
                          (identifier [355, 6] - [355, 15])
                          (identifier [356, 6] - [356, 18])
                          (identifier [357, 6] - [357, 19]))))))
                (if_statement [360, 4] - [360, 76]
                  condition: (parenthesized_expression [360, 7] - [360, 20]
                    (unary_expression [360, 8] - [360, 19]
                      argument: (identifier [360, 9] - [360, 19])))
                  consequence: (return_statement [360, 21] - [360, 76]
                    (call_expression [360, 28] - [360, 75]
                      function: (member_expression [360, 28] - [360, 34]
                        object: (identifier [360, 28] - [360, 29])
                        property: (property_identifier [360, 30] - [360, 34]))
                      arguments: (arguments [360, 34] - [360, 75]
                        (object [360, 35] - [360, 69]
                          (pair [360, 37] - [360, 67]
                            key: (property_identifier [360, 37] - [360, 42])
                            value: (string [360, 44] - [360, 67]
                              (string_fragment [360, 45] - [360, 66]))))
                        (number [360, 71] - [360, 74])))))
                (expression_statement [362, 4] - [364, 23]
                  (call_expression [362, 4] - [364, 22]
                    function: (member_expression [362, 4] - [362, 25]
                      object: (identifier [362, 4] - [362, 16])
                      property: (property_identifier [362, 17] - [362, 25]))
                    arguments: (arguments [362, 25] - [364, 22]
                      (member_expression [362, 26] - [362, 37]
                        object: (identifier [362, 26] - [362, 30])
                        property: (property_identifier [362, 31] - [362, 37]))
                      (string [362, 39] - [362, 52]
                        (string_fragment [362, 40] - [362, 51]))
                      (member_expression [362, 54] - [362, 67]
                        object: (identifier [362, 54] - [362, 64])
                        property: (property_identifier [362, 65] - [362, 67]))
                      (object [362, 69] - [364, 5]
                        (pair [363, 6] - [363, 27]
                          key: (property_identifier [363, 6] - [363, 10])
                          value: (member_expression [363, 12] - [363, 27]
                            object: (identifier [363, 12] - [363, 22])
                            property: (property_identifier [363, 23] - [363, 27]))))
                      (call_expression [364, 7] - [364, 21]
                        function: (identifier [364, 7] - [364, 18])
                        arguments: (arguments [364, 18] - [364, 21]
                          (identifier [364, 19] - [364, 20]))))))
                (return_statement [366, 4] - [366, 54]
                  (call_expression [366, 11] - [366, 53]
                    function: (member_expression [366, 11] - [366, 17]
                      object: (identifier [366, 11] - [366, 12])
                      property: (property_identifier [366, 13] - [366, 17]))
                    arguments: (arguments [366, 17] - [366, 53]
                      (object [366, 18] - [366, 52]
                        (pair [366, 20] - [366, 33]
                          key: (property_identifier [366, 20] - [366, 27])
                          value: (true [366, 29] - [366, 33]))
                        (pair [366, 35] - [366, 50]
                          key: (property_identifier [366, 35] - [366, 38])
                          value: (identifier [366, 40] - [366, 50])))))))
              handler: (catch_clause [367, 4] - [369, 3]
                parameter: (identifier [367, 11] - [367, 15])
                type: (type_annotation [367, 15] - [367, 20]
                  (predefined_type [367, 17] - [367, 20]))
                body: (statement_block [367, 22] - [369, 3]
                  (return_statement [368, 4] - [368, 66]
                    (call_expression [368, 11] - [368, 65]
                      function: (member_expression [368, 11] - [368, 17]
                        object: (identifier [368, 11] - [368, 12])
                        property: (property_identifier [368, 13] - [368, 17]))
                      arguments: (arguments [368, 17] - [368, 65]
                        (object [368, 18] - [368, 59]
                          (pair [368, 20] - [368, 57]
                            key: (property_identifier [368, 20] - [368, 25])
                            value: (string [368, 27] - [368, 57]
                              (string_fragment [368, 28] - [368, 56]))))
                        (number [368, 61] - [368, 64]))))))))))))
  (expression_statement [372, 0] - [389, 3]
    (call_expression [372, 0] - [389, 2]
      function: (member_expression [372, 0] - [372, 25]
        object: (identifier [372, 0] - [372, 18])
        property: (property_identifier [372, 19] - [372, 25]))
      arguments: (arguments [372, 25] - [389, 2]
        (string [372, 26] - [372, 37]
          (string_fragment [372, 27] - [372, 36]))
        (arrow_function [372, 39] - [389, 1]
          parameters: (formal_parameters [372, 45] - [372, 48]
            (required_parameter [372, 46] - [372, 47]
              pattern: (identifier [372, 46] - [372, 47])))
          body: (statement_block [372, 52] - [389, 1]
            (lexical_declaration [373, 2] - [373, 45]
              (variable_declarator [373, 8] - [373, 44]
                name: (identifier [373, 8] - [373, 12])
                value: (await_expression [373, 15] - [373, 44]
                  (call_expression [373, 21] - [373, 44]
                    function: (identifier [373, 21] - [373, 41])
                    arguments: (arguments [373, 41] - [373, 44]
                      (identifier [373, 42] - [373, 43]))))))
            (if_statement [374, 2] - [374, 59]
              condition: (parenthesized_expression [374, 5] - [374, 12]
                (unary_expression [374, 6] - [374, 11]
                  argument: (identifier [374, 7] - [374, 11])))
              consequence: (return_statement [374, 13] - [374, 59]
                (call_expression [374, 20] - [374, 58]
                  function: (member_expression [374, 20] - [374, 26]
                    object: (identifier [374, 20] - [374, 21])
                    property: (property_identifier [374, 22] - [374, 26]))
                  arguments: (arguments [374, 26] - [374, 58]
                    (object [374, 27] - [374, 52]
                      (pair [374, 29] - [374, 50]
                        key: (property_identifier [374, 29] - [374, 34])
                        value: (string [374, 36] - [374, 50]
                          (string_fragment [374, 37] - [374, 49]))))
                    (number [374, 54] - [374, 57])))))
            (lexical_declaration [376, 2] - [376, 34]
              (variable_declarator [376, 8] - [376, 33]
                name: (identifier [376, 8] - [376, 13])
                value: (call_expression [376, 16] - [376, 33]
                  function: (member_expression [376, 16] - [376, 27]
                    object: (member_expression [376, 16] - [376, 21]
                      object: (identifier [376, 16] - [376, 17])
                      property: (property_identifier [376, 18] - [376, 21]))
                    property: (property_identifier [376, 22] - [376, 27]))
                  arguments: (arguments [376, 27] - [376, 33]
                    (string [376, 28] - [376, 32]
                      (string_fragment [376, 29] - [376, 31]))))))
            (lexical_declaration [377, 2] - [377, 37]
              (variable_declarator [377, 8] - [377, 36]
                name: (identifier [377, 8] - [377, 11])
                value: (await_expression [377, 14] - [377, 36]
                  (call_expression [377, 20] - [377, 36]
                    function: (identifier [377, 20] - [377, 29])
                    arguments: (arguments [377, 29] - [377, 36]
                      (identifier [377, 30] - [377, 35]))))))
            (if_statement [378, 2] - [387, 3]
              condition: (parenthesized_expression [378, 5] - [378, 10]
                (identifier [378, 6] - [378, 9]))
              consequence: (statement_block [378, 11] - [387, 3]
                (expression_statement [379, 4] - [385, 6]
                  (call_expression [379, 4] - [385, 5]
                    function: (member_expression [379, 4] - [379, 25]
                      object: (identifier [379, 4] - [379, 16])
                      property: (property_identifier [379, 17] - [379, 25]))
                    arguments: (arguments [379, 25] - [385, 5]
                      (member_expression [380, 6] - [380, 17]
                        object: (identifier [380, 6] - [380, 10])
                        property: (property_identifier [380, 11] - [380, 17]))
                      (string [381, 6] - [381, 19]
                        (string_fragment [381, 7] - [381, 18]))
                      (identifier [382, 6] - [382, 11])
                      (object [383, 6] - [383, 24]
                        (pair [383, 8] - [383, 22]
                          key: (property_identifier [383, 8] - [383, 12])
                          value: (member_expression [383, 14] - [383, 22]
                            object: (identifier [383, 14] - [383, 17])
                            property: (property_identifier [383, 18] - [383, 22]))))
                      (call_expression [384, 6] - [384, 20]
                        function: (identifier [384, 6] - [384, 17])
                        arguments: (arguments [384, 17] - [384, 20]
                          (identifier [384, 18] - [384, 19]))))))
                (return_statement [386, 4] - [386, 37]
                  (call_expression [386, 11] - [386, 36]
                    function: (member_expression [386, 11] - [386, 17]
                      object: (identifier [386, 11] - [386, 12])
                      property: (property_identifier [386, 13] - [386, 17]))
                    arguments: (arguments [386, 17] - [386, 36]
                      (object [386, 18] - [386, 35]
                        (pair [386, 20] - [386, 33]
                          key: (property_identifier [386, 20] - [386, 27])
                          value: (true [386, 29] - [386, 33]))))))))
            (return_statement [388, 2] - [388, 57]
              (call_expression [388, 9] - [388, 56]
                function: (member_expression [388, 9] - [388, 15]
                  object: (identifier [388, 9] - [388, 10])
                  property: (property_identifier [388, 11] - [388, 15]))
                arguments: (arguments [388, 15] - [388, 56]
                  (object [388, 16] - [388, 50]
                    (pair [388, 18] - [388, 48]
                      key: (property_identifier [388, 18] - [388, 23])
                      value: (string [388, 25] - [388, 48]
                        (string_fragment [388, 26] - [388, 47]))))
                  (number [388, 52] - [388, 55]))))))))))