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