(program [0, 0] - [263, 0]
  (import_statement [0, 0] - [0, 53]
    (import_clause [0, 7] - [0, 26]
      (named_imports [0, 7] - [0, 26]
        (import_specifier [0, 9] - [0, 24]
          name: (identifier [0, 9] - [0, 24]))))
    source: (string [0, 32] - [0, 52]
      (string_fragment [0, 33] - [0, 51])))
  (import_statement [1, 0] - [1, 54]
    (import_clause [1, 7] - [1, 20]
      (named_imports [1, 7] - [1, 20]
        (import_specifier [1, 9] - [1, 18]
          name: (identifier [1, 9] - [1, 18]))))
    source: (string [1, 26] - [1, 53]
      (string_fragment [1, 27] - [1, 52])))
  (import_statement [2, 0] - [2, 65]
    (import_clause [2, 7] - [2, 33]
      (named_imports [2, 7] - [2, 33]
        (import_specifier [2, 9] - [2, 31]
          name: (identifier [2, 9] - [2, 31]))))
    source: (string [2, 39] - [2, 64]
      (string_fragment [2, 40] - [2, 63])))
  (comment [4, 0] - [4, 44])
  (if_statement [6, 0] - [8, 1]
    condition: (parenthesized_expression [6, 3] - [6, 66]
      (binary_expression [6, 4] - [6, 65]
        left: (binary_expression [6, 4] - [6, 32]
          left: (member_expression [6, 4] - [6, 19]
            object: (member_expression [6, 4] - [6, 14]
              object: (identifier [6, 4] - [6, 8])
              property: (property_identifier [6, 9] - [6, 14]))
            property: (property_identifier [6, 15] - [6, 19]))
          right: (string [6, 24] - [6, 32]
            (string_fragment [6, 25] - [6, 31])))
        right: (binary_expression [6, 36] - [6, 65]
          left: (member_expression [6, 36] - [6, 51]
            object: (member_expression [6, 36] - [6, 46]
              object: (identifier [6, 36] - [6, 40])
              property: (property_identifier [6, 41] - [6, 46]))
            property: (property_identifier [6, 47] - [6, 51]))
          right: (string [6, 56] - [6, 65]
            (string_fragment [6, 57] - [6, 64])))))
    consequence: (statement_block [6, 67] - [8, 1]
      (throw_statement [7, 2] - [7, 46]
        (new_expression [7, 8] - [7, 45]
          constructor: (identifier [7, 12] - [7, 17])
          arguments: (arguments [7, 17] - [7, 45]
            (string [7, 18] - [7, 44]
              (string_fragment [7, 19] - [7, 43])))))))
  (lexical_declaration [10, 0] - [18, 5]
    (variable_declarator [10, 6] - [18, 4]
      name: (identifier [10, 6] - [10, 13])
      value: (call_expression [10, 16] - [18, 4]
        function: (parenthesized_expression [10, 16] - [18, 2]
          (arrow_function [10, 17] - [18, 1]
            parameters: (formal_parameters [10, 17] - [10, 19])
            body: (statement_block [10, 23] - [18, 1]
              (if_statement [11, 2] - [13, 3]
                condition: (parenthesized_expression [11, 5] - [11, 34]
                  (binary_expression [11, 6] - [11, 33]
                    left: (member_expression [11, 6] - [11, 19]
                      object: (member_expression [11, 6] - [11, 16]
                        object: (identifier [11, 6] - [11, 10])
                        property: (property_identifier [11, 11] - [11, 16]))
                      property: (property_identifier [11, 17] - [11, 19]))
                    right: (string [11, 24] - [11, 33]
                      (string_fragment [11, 25] - [11, 32]))))
                consequence: (statement_block [11, 35] - [13, 3]
                  (return_statement [12, 4] - [12, 55]
                    (string [12, 11] - [12, 54]
                      (string_fragment [12, 12] - [12, 53])))))
              (if_statement [14, 2] - [16, 3]
                condition: (parenthesized_expression [14, 5] - [14, 33]
                  (binary_expression [14, 6] - [14, 32]
                    left: (member_expression [14, 6] - [14, 19]
                      object: (member_expression [14, 6] - [14, 16]
                        object: (identifier [14, 6] - [14, 10])
                        property: (property_identifier [14, 11] - [14, 16]))
                      property: (property_identifier [14, 17] - [14, 19]))
                    right: (string [14, 24] - [14, 32]
                      (string_fragment [14, 25] - [14, 31]))))
                consequence: (statement_block [14, 34] - [16, 3]
                  (return_statement [15, 4] - [15, 60]
                    (string [15, 11] - [15, 59]
                      (string_fragment [15, 12] - [15, 58])))))
              (return_statement [17, 2] - [17, 55]
                (string [17, 9] - [17, 54]
                  (string_fragment [17, 10] - [17, 53]))))))
        arguments: (arguments [18, 2] - [18, 4]))))
  (lexical_declaration [20, 0] - [20, 50]
    (variable_declarator [20, 4] - [20, 49]
      name: (identifier [20, 4] - [20, 9])
      type: (type_annotation [20, 9] - [20, 42]
        (union_type [20, 11] - [20, 42]
          (generic_type [20, 11] - [20, 35]
            name: (nested_type_identifier [20, 11] - [20, 30]
              module: (identifier [20, 11] - [20, 15])
              name: (type_identifier [20, 16] - [20, 30]))
            type_arguments: (type_arguments [20, 30] - [20, 35]
              (predefined_type [20, 31] - [20, 34])))
          (literal_type [20, 38] - [20, 42]
            (null [20, 38] - [20, 42]))))
      value: (null [20, 45] - [20, 49])))
  (try_statement [22, 0] - [52, 1]
    body: (statement_block [22, 4] - [48, 1]
      (expression_statement [23, 2] - [47, 5]
        (assignment_expression [23, 2] - [47, 4]
          left: (identifier [23, 2] - [23, 7])
          right: (call_expression [23, 10] - [47, 4]
            function: (member_expression [23, 10] - [23, 21]
              object: (identifier [23, 10] - [23, 14])
              property: (property_identifier [23, 15] - [23, 21]))
            arguments: (arguments [23, 21] - [47, 4]
              (identifier [23, 22] - [23, 29])
              (object [23, 31] - [47, 3]
                (pair [24, 4] - [28, 5]
                  key: (property_identifier [24, 4] - [24, 14])
                  value: (object [24, 16] - [28, 5]
                    (pair [25, 6] - [25, 29]
                      key: (property_identifier [25, 6] - [25, 16])
                      value: (array [25, 18] - [25, 29]
                        (string [25, 19] - [25, 28]
                          (string_fragment [25, 20] - [25, 27]))))
                    (pair [26, 6] - [26, 23]
                      key: (property_identifier [26, 6] - [26, 12])
                      value: (string [26, 14] - [26, 23]
                        (string_fragment [26, 15] - [26, 22])))
                    (pair [27, 6] - [27, 23]
                      key: (property_identifier [27, 6] - [27, 17])
                      value: (true [27, 19] - [27, 23]))))
                (pair [29, 4] - [32, 5]
                  key: (property_identifier [29, 4] - [29, 13])
                  value: (object [29, 15] - [32, 5]
                    (pair [30, 6] - [30, 29]
                      key: (property_identifier [30, 6] - [30, 16])
                      value: (array [30, 18] - [30, 29]
                        (string [30, 19] - [30, 28]
                          (string_fragment [30, 20] - [30, 27]))))
                    (pair [31, 6] - [31, 20]
                      key: (property_identifier [31, 6] - [31, 12])
                      value: (string [31, 14] - [31, 20]
                        (string_fragment [31, 15] - [31, 19])))))
                (pair [33, 4] - [46, 5]
                  key: (property_identifier [33, 4] - [33, 19])
                  value: (object [33, 21] - [46, 5]
                    (pair [34, 6] - [43, 7]
                      key: (property_identifier [34, 6] - [34, 16])
                      value: (array [34, 18] - [43, 7]
                        (string [35, 8] - [35, 17]
                          (string_fragment [35, 9] - [35, 16]))
                        (string [36, 8] - [36, 15]
                          (string_fragment [36, 9] - [36, 14]))
                        (string [37, 8] - [37, 17]
                          (string_fragment [37, 9] - [37, 16]))
                        (string [38, 8] - [38, 15]
                          (string_fragment [38, 9] - [38, 14]))
                        (string [39, 8] - [39, 13]
                          (string_fragment [39, 9] - [39, 12]))
                        (string [40, 8] - [40, 13]
                          (string_fragment [40, 9] - [40, 12]))
                        (string [41, 8] - [41, 17]
                          (string_fragment [41, 9] - [41, 16]))
                        (string [42, 8] - [42, 15]
                          (string_fragment [42, 9] - [42, 14]))))
                    (pair [44, 6] - [44, 19]
                      key: (property_identifier [44, 6] - [44, 12])
                      value: (string [44, 14] - [44, 19]
                        (string_fragment [44, 15] - [44, 18])))
                    (pair [45, 6] - [45, 23]
                      key: (property_identifier [45, 6] - [45, 17])
                      value: (true [45, 19] - [45, 23]))))))))))
    handler: (catch_clause [48, 2] - [52, 1]
      parameter: (identifier [48, 9] - [48, 11])
      body: (statement_block [48, 13] - [52, 1]
        (expression_statement [49, 2] - [51, 4]
          (call_expression [49, 2] - [51, 3]
            function: (member_expression [49, 2] - [49, 14]
              object: (identifier [49, 2] - [49, 9])
              property: (property_identifier [49, 10] - [49, 14]))
            arguments: (arguments [49, 14] - [51, 3]
              (template_string [50, 4] - [50, 87]
                (string_fragment [50, 5] - [50, 20])
                (template_substitution [50, 20] - [50, 30]
                  (identifier [50, 22] - [50, 29]))
                (string_fragment [50, 30] - [50, 86]))))))))
  (export_statement [54, 0] - [59, 1]
    declaration: (interface_declaration [54, 7] - [59, 1]
      name: (type_identifier [54, 17] - [54, 29])
      body: (interface_body [54, 30] - [59, 1]
        (property_signature [55, 2] - [55, 19]
          name: (property_identifier [55, 2] - [55, 11])
          type: (type_annotation [55, 11] - [55, 19]
            (predefined_type [55, 13] - [55, 19])))
        (property_signature [56, 2] - [56, 23]
          name: (property_identifier [56, 2] - [56, 11])
          type: (type_annotation [56, 11] - [56, 23]
            (type_identifier [56, 13] - [56, 23])))
        (property_signature [57, 2] - [57, 27]
          name: (property_identifier [57, 2] - [57, 15])
          type: (type_annotation [57, 15] - [57, 27]
            (type_identifier [57, 17] - [57, 27])))
        (property_signature [58, 2] - [58, 20]
          name: (property_identifier [58, 2] - [58, 8])
          type: (type_annotation [58, 8] - [58, 20]
            (type_identifier [58, 10] - [58, 20]))))))
  (export_statement [61, 0] - [166, 1]
    declaration: (function_declaration [61, 7] - [166, 1]
      name: (identifier [61, 22] - [61, 41])
      parameters: (formal_parameters [61, 41] - [63, 1]
        (required_parameter [62, 2] - [62, 50]
          pattern: (identifier [62, 2] - [62, 12])
          type: (type_annotation [62, 12] - [62, 20]
            (predefined_type [62, 14] - [62, 20]))
          value: (string [62, 23] - [62, 50]
            (string_fragment [62, 24] - [62, 49]))))
      return_type: (type_annotation [63, 1] - [63, 24]
        (generic_type [63, 3] - [63, 24]
          name: (type_identifier [63, 3] - [63, 10])
          type_arguments: (type_arguments [63, 10] - [63, 24]
            (type_identifier [63, 11] - [63, 23]))))
      body: (statement_block [63, 25] - [166, 1]
        (if_statement [64, 2] - [74, 3]
          condition: (parenthesized_expression [64, 5] - [64, 13]
            (unary_expression [64, 6] - [64, 12]
              argument: (identifier [64, 7] - [64, 12])))
          consequence: (statement_block [64, 14] - [74, 3]
            (expression_statement [65, 4] - [67, 6]
              (call_expression [65, 4] - [67, 5]
                function: (member_expression [65, 4] - [65, 16]
                  object: (identifier [65, 4] - [65, 11])
                  property: (property_identifier [65, 12] - [65, 16]))
                arguments: (arguments [65, 16] - [67, 5]
                  (template_string [66, 6] - [66, 108]
                    (string_fragment [66, 7] - [66, 36])
                    (template_substitution [66, 36] - [66, 46]
                      (identifier [66, 38] - [66, 45]))
                    (string_fragment [66, 46] - [66, 107])))))
            (return_statement [68, 4] - [73, 6]
              (object [68, 11] - [73, 5]
                (pair [69, 6] - [69, 42]
                  key: (property_identifier [69, 6] - [69, 15])
                  value: (string [69, 17] - [69, 42]
                    (string_fragment [69, 18] - [69, 41])))
                (pair [70, 6] - [70, 33]
                  key: (property_identifier [70, 6] - [70, 15])
                  value: (new_expression [70, 17] - [70, 33]
                    constructor: (identifier [70, 21] - [70, 31])
                    arguments: (arguments [70, 31] - [70, 33])))
                (pair [71, 6] - [71, 37]
                  key: (property_identifier [71, 6] - [71, 19])
                  value: (new_expression [71, 21] - [71, 37]
                    constructor: (identifier [71, 25] - [71, 35])
                    arguments: (arguments [71, 35] - [71, 37])))
                (pair [72, 6] - [72, 30]
                  key: (property_identifier [72, 6] - [72, 12])
                  value: (new_expression [72, 14] - [72, 30]
                    constructor: (identifier [72, 18] - [72, 28])
                    arguments: (arguments [72, 28] - [72, 30])))))))
        (lexical_declaration [76, 2] - [76, 36]
          (variable_declarator [76, 8] - [76, 35]
            name: (identifier [76, 8] - [76, 15])
            value: (new_expression [76, 18] - [76, 35]
              constructor: (identifier [76, 22] - [76, 33])
              arguments: (arguments [76, 33] - [76, 35]))))
        (lexical_declaration [77, 2] - [77, 56]
          (variable_declarator [77, 8] - [77, 55]
            name: (identifier [77, 8] - [77, 19])
            value: (call_expression [77, 22] - [77, 55]
              function: (member_expression [77, 22] - [77, 36]
                object: (identifier [77, 22] - [77, 29])
                property: (property_identifier [77, 30] - [77, 36]))
              arguments: (arguments [77, 36] - [77, 55]
                (binary_expression [77, 37] - [77, 54]
                  left: (identifier [77, 37] - [77, 47])
                  right: (string [77, 50] - [77, 54]
                    (escape_sequence [77, 51] - [77, 53])))))))
        (lexical_declaration [78, 2] - [78, 53]
          (variable_declarator [78, 8] - [78, 52]
            name: (identifier [78, 8] - [78, 15])
            value: (call_expression [78, 18] - [78, 52]
              function: (member_expression [78, 18] - [78, 39]
                object: (member_expression [78, 18] - [78, 36]
                  object: (identifier [78, 18] - [78, 22])
                  property: (property_identifier [78, 23] - [78, 36]))
                property: (property_identifier [78, 37] - [78, 39]))
              arguments: (arguments [78, 39] - [78, 52]
                (identifier [78, 40] - [78, 51])))))
        (lexical_declaration [80, 2] - [83, 37]
          (variable_declarator [80, 8] - [83, 36]
            name: (identifier [80, 8] - [80, 18])
            value: (as_expression [80, 21] - [83, 36]
              (as_expression [80, 21] - [81, 26]
                (member_expression [80, 21] - [81, 15]
                  object: (member_expression [80, 21] - [80, 34]
                    object: (identifier [80, 21] - [80, 26])
                    property: (property_identifier [80, 27] - [80, 34]))
                  property: (property_identifier [81, 5] - [81, 15]))
                (predefined_type [81, 19] - [81, 26]))
              (parenthesized_type [81, 30] - [83, 36]
                (function_type [81, 31] - [83, 35]
                  parameters: (formal_parameters [81, 31] - [83, 5]
                    (required_parameter [82, 6] - [82, 28]
                      pattern: (identifier [82, 6] - [82, 9])
                      type: (type_annotation [82, 9] - [82, 28]
                        (nested_type_identifier [82, 11] - [82, 28]
                          module: (identifier [82, 11] - [82, 15])
                          name: (type_identifier [82, 16] - [82, 28])))))
                  return_type: (generic_type [83, 9] - [83, 35]
                    name: (type_identifier [83, 9] - [83, 16])
                    type_arguments: (type_arguments [83, 16] - [83, 35]
                      (nested_type_identifier [83, 17] - [83, 34]
                        module: (identifier [83, 17] - [83, 21])
                        name: (type_identifier [83, 22] - [83, 34])))))))))
        (lexical_declaration [84, 2] - [85, 64]
          (variable_declarator [84, 8] - [85, 63]
            name: (identifier [84, 8] - [84, 17])
            value: (as_expression [84, 20] - [85, 63]
              (as_expression [84, 20] - [85, 25]
                (member_expression [84, 20] - [85, 14]
                  object: (member_expression [84, 20] - [84, 33]
                    object: (identifier [84, 20] - [84, 25])
                    property: (property_identifier [84, 26] - [84, 33]))
                  property: (property_identifier [85, 5] - [85, 14]))
                (predefined_type [85, 18] - [85, 25]))
              (parenthesized_type [85, 29] - [85, 63]
                (function_type [85, 30] - [85, 62]
                  parameters: (formal_parameters [85, 30] - [85, 54]
                    (required_parameter [85, 31] - [85, 53]
                      pattern: (identifier [85, 31] - [85, 34])
                      type: (type_annotation [85, 34] - [85, 53]
                        (nested_type_identifier [85, 36] - [85, 53]
                          module: (identifier [85, 36] - [85, 40])
                          name: (type_identifier [85, 41] - [85, 53])))))
                  return_type: (predefined_type [85, 58] - [85, 62]))))))
        (lexical_declaration [87, 2] - [87, 43]
          (variable_declarator [87, 8] - [87, 42]
            name: (identifier [87, 8] - [87, 14])
            value: (await_expression [87, 17] - [87, 42]
              (call_expression [87, 23] - [87, 42]
                function: (identifier [87, 23] - [87, 33])
                arguments: (arguments [87, 33] - [87, 42]
                  (identifier [87, 34] - [87, 41]))))))
        (if_statement [89, 2] - [91, 3]
          condition: (parenthesized_expression [89, 5] - [89, 22]
            (binary_expression [89, 6] - [89, 21]
              left: (identifier [89, 6] - [89, 12])
              right: (null [89, 17] - [89, 21])))
          consequence: (statement_block [89, 23] - [91, 3]
            (throw_statement [90, 4] - [90, 58]
              (new_expression [90, 10] - [90, 57]
                constructor: (identifier [90, 14] - [90, 19])
                arguments: (arguments [90, 19] - [90, 57]
                  (string [90, 20] - [90, 56]
                    (string_fragment [90, 21] - [90, 55])))))))
        (lexical_declaration [93, 2] - [93, 53]
          (variable_declarator [93, 8] - [93, 52]
            name: (identifier [93, 8] - [93, 15])
            value: (new_expression [93, 18] - [93, 52]
              constructor: (member_expression [93, 22] - [93, 44]
                object: (identifier [93, 22] - [93, 26])
                property: (property_identifier [93, 27] - [93, 44]))
              arguments: (arguments [93, 44] - [93, 52]
                (identifier [93, 45] - [93, 51])))))
        (lexical_declaration [94, 2] - [94, 37]
          (variable_declarator [94, 6] - [94, 36]
            name: (identifier [94, 6] - [94, 14])
            type: (type_annotation [94, 14] - [94, 29]
              (union_type [94, 16] - [94, 29]
                (predefined_type [94, 16] - [94, 22])
                (literal_type [94, 25] - [94, 29]
                  (null [94, 25] - [94, 29]))))
            value: (null [94, 32] - [94, 36])))
        (lexical_declaration [95, 2] - [95, 38]
          (variable_declarator [95, 6] - [95, 37]
            name: (identifier [95, 6] - [95, 15])
            type: (type_annotation [95, 15] - [95, 30]
              (union_type [95, 17] - [95, 30]
                (predefined_type [95, 17] - [95, 23])
                (literal_type [95, 26] - [95, 30]
                  (null [95, 26] - [95, 30]))))
            value: (null [95, 33] - [95, 37])))
        (lexical_declaration [97, 2] - [97, 17]
          (variable_declarator [97, 6] - [97, 16]
            name: (identifier [97, 6] - [97, 12])
            value: (number [97, 15] - [97, 16])))
        (lexical_declaration [98, 2] - [98, 20]
          (variable_declarator [98, 8] - [98, 19]
            name: (identifier [98, 8] - [98, 15])
            value: (number [98, 18] - [98, 19])))
        (comment [98, 21] - [98, 39])
        (lexical_declaration [100, 2] - [100, 51]
          (variable_declarator [100, 8] - [100, 50]
            name: (identifier [100, 8] - [100, 21])
            value: (call_expression [100, 24] - [100, 50]
              function: (member_expression [100, 24] - [100, 42]
                object: (identifier [100, 24] - [100, 31])
                property: (property_identifier [100, 32] - [100, 42]))
              arguments: (arguments [100, 42] - [100, 50]
                (identifier [100, 43] - [100, 49])))))
        (expression_statement [101, 2] - [101, 20]
          (augmented_assignment_expression [101, 2] - [101, 19]
            left: (identifier [101, 2] - [101, 8])
            right: (identifier [101, 12] - [101, 19])))
        (lexical_declaration [102, 2] - [102, 51]
          (variable_declarator [102, 8] - [102, 50]
            name: (identifier [102, 8] - [102, 21])
            value: (call_expression [102, 24] - [102, 50]
              function: (member_expression [102, 24] - [102, 42]
                object: (identifier [102, 24] - [102, 31])
                property: (property_identifier [102, 32] - [102, 42]))
              arguments: (arguments [102, 42] - [102, 50]
                (identifier [102, 43] - [102, 49])))))
        (expression_statement [103, 2] - [103, 20]
          (augmented_assignment_expression [103, 2] - [103, 19]
            left: (identifier [103, 2] - [103, 8])
            right: (identifier [103, 12] - [103, 19])))
        (lexical_declaration [104, 2] - [104, 61]
          (variable_declarator [104, 8] - [104, 60]
            name: (identifier [104, 8] - [104, 21])
            value: (call_expression [104, 24] - [104, 60]
              function: (identifier [104, 24] - [104, 30])
              arguments: (arguments [104, 30] - [104, 60]
                (call_expression [104, 31] - [104, 59]
                  function: (member_expression [104, 31] - [104, 51]
                    object: (identifier [104, 31] - [104, 38])
                    property: (property_identifier [104, 39] - [104, 51]))
                  arguments: (arguments [104, 51] - [104, 59]
                    (identifier [104, 52] - [104, 58])))))))
        (expression_statement [105, 2] - [105, 20]
          (augmented_assignment_expression [105, 2] - [105, 19]
            left: (identifier [105, 2] - [105, 8])
            right: (identifier [105, 12] - [105, 19])))
        (lexical_declaration [106, 2] - [106, 55]
          (variable_declarator [106, 8] - [106, 54]
            name: (identifier [106, 8] - [106, 25])
            value: (call_expression [106, 28] - [106, 54]
              function: (member_expression [106, 28] - [106, 46]
                object: (identifier [106, 28] - [106, 35])
                property: (property_identifier [106, 36] - [106, 46]))
              arguments: (arguments [106, 46] - [106, 54]
                (identifier [106, 47] - [106, 53])))))
        (expression_statement [107, 2] - [107, 20]
          (augmented_assignment_expression [107, 2] - [107, 19]
            left: (identifier [107, 2] - [107, 8])
            right: (identifier [107, 12] - [107, 19])))
        (lexical_declaration [108, 2] - [108, 65]
          (variable_declarator [108, 8] - [108, 64]
            name: (identifier [108, 8] - [108, 25])
            value: (call_expression [108, 28] - [108, 64]
              function: (identifier [108, 28] - [108, 34])
              arguments: (arguments [108, 34] - [108, 64]
                (call_expression [108, 35] - [108, 63]
                  function: (member_expression [108, 35] - [108, 55]
                    object: (identifier [108, 35] - [108, 42])
                    property: (property_identifier [108, 43] - [108, 55]))
                  arguments: (arguments [108, 55] - [108, 63]
                    (identifier [108, 56] - [108, 62])))))))
        (expression_statement [109, 2] - [109, 20]
          (augmented_assignment_expression [109, 2] - [109, 19]
            left: (identifier [109, 2] - [109, 8])
            right: (identifier [109, 12] - [109, 19])))
        (lexical_declaration [110, 2] - [110, 48]
          (variable_declarator [110, 8] - [110, 47]
            name: (identifier [110, 8] - [110, 18])
            value: (call_expression [110, 21] - [110, 47]
              function: (member_expression [110, 21] - [110, 39]
                object: (identifier [110, 21] - [110, 28])
                property: (property_identifier [110, 29] - [110, 39]))
              arguments: (arguments [110, 39] - [110, 47]
                (identifier [110, 40] - [110, 46])))))
        (expression_statement [111, 2] - [111, 20]
          (augmented_assignment_expression [111, 2] - [111, 19]
            left: (identifier [111, 2] - [111, 8])
            right: (identifier [111, 12] - [111, 19])))
        (lexical_declaration [112, 2] - [112, 58]
          (variable_declarator [112, 8] - [112, 57]
            name: (identifier [112, 8] - [112, 18])
            value: (call_expression [112, 21] - [112, 57]
              function: (identifier [112, 21] - [112, 27])
              arguments: (arguments [112, 27] - [112, 57]
                (call_expression [112, 28] - [112, 56]
                  function: (member_expression [112, 28] - [112, 48]
                    object: (identifier [112, 28] - [112, 35])
                    property: (property_identifier [112, 36] - [112, 48]))
                  arguments: (arguments [112, 48] - [112, 56]
                    (identifier [112, 49] - [112, 55])))))))
        (expression_statement [113, 2] - [113, 20]
          (augmented_assignment_expression [113, 2] - [113, 19]
            left: (identifier [113, 2] - [113, 8])
            right: (identifier [113, 12] - [113, 19])))
        (lexical_declaration [114, 2] - [114, 47]
          (variable_declarator [114, 8] - [114, 46]
            name: (identifier [114, 8] - [114, 17])
            value: (call_expression [114, 20] - [114, 46]
              function: (member_expression [114, 20] - [114, 38]
                object: (identifier [114, 20] - [114, 27])
                property: (property_identifier [114, 28] - [114, 38]))
              arguments: (arguments [114, 38] - [114, 46]
                (identifier [114, 39] - [114, 45])))))
        (if_statement [116, 2] - [118, 3]
          condition: (parenthesized_expression [116, 5] - [116, 25]
            (binary_expression [116, 6] - [116, 24]
              left: (identifier [116, 6] - [116, 15])
              right: (null [116, 20] - [116, 24])))
          consequence: (statement_block [116, 26] - [118, 3]
            (expression_statement [117, 4] - [117, 66]
              (assignment_expression [117, 4] - [117, 65]
                left: (identifier [117, 4] - [117, 12])
                right: (call_expression [117, 15] - [117, 65]
                  function: (member_expression [117, 15] - [117, 63]
                    object: (new_expression [117, 15] - [117, 52]
                      constructor: (member_expression [117, 19] - [117, 41]
                        object: (identifier [117, 19] - [117, 23])
                        property: (property_identifier [117, 24] - [117, 41]))
                      arguments: (arguments [117, 41] - [117, 52]
                        (identifier [117, 42] - [117, 51])))
                    property: (property_identifier [117, 53] - [117, 63]))
                  arguments: (arguments [117, 63] - [117, 65]))))))
        (if_statement [120, 2] - [123, 3]
          condition: (parenthesized_expression [120, 5] - [120, 24]
            (binary_expression [120, 6] - [120, 23]
              left: (identifier [120, 6] - [120, 14])
              right: (null [120, 19] - [120, 23])))
          consequence: (statement_block [120, 25] - [123, 3]
            (expression_statement [121, 4] - [121, 22]
              (call_expression [121, 4] - [121, 21]
                function: (identifier [121, 4] - [121, 13])
                arguments: (arguments [121, 13] - [121, 21]
                  (identifier [121, 14] - [121, 20]))))
            (throw_statement [122, 4] - [122, 30]
              (new_expression [122, 10] - [122, 29]
                constructor: (identifier [122, 14] - [122, 19])
                arguments: (arguments [122, 19] - [122, 29]
                  (identifier [122, 20] - [122, 28]))))))
        (if_statement [125, 2] - [127, 3]
          condition: (parenthesized_expression [125, 5] - [125, 29]
            (binary_expression [125, 6] - [125, 28]
              left: (identifier [125, 6] - [125, 19])
              right: (null [125, 24] - [125, 28])))
          consequence: (statement_block [125, 30] - [127, 3]
            (expression_statement [126, 4] - [126, 71]
              (assignment_expression [126, 4] - [126, 70]
                left: (identifier [126, 4] - [126, 13])
                right: (call_expression [126, 16] - [126, 70]
                  function: (member_expression [126, 16] - [126, 68]
                    object: (new_expression [126, 16] - [126, 57]
                      constructor: (member_expression [126, 20] - [126, 42]
                        object: (identifier [126, 20] - [126, 24])
                        property: (property_identifier [126, 25] - [126, 42]))
                      arguments: (arguments [126, 42] - [126, 57]
                        (identifier [126, 43] - [126, 56])))
                    property: (property_identifier [126, 58] - [126, 68]))
                  arguments: (arguments [126, 68] - [126, 70]))))))
        (if_statement [129, 2] - [132, 3]
          condition: (parenthesized_expression [129, 5] - [129, 17]
            (unary_expression [129, 6] - [129, 16]
              argument: (identifier [129, 7] - [129, 16])))
          consequence: (statement_block [129, 18] - [132, 3]
            (expression_statement [130, 4] - [130, 22]
              (call_expression [130, 4] - [130, 21]
                function: (identifier [130, 4] - [130, 13])
                arguments: (arguments [130, 13] - [130, 21]
                  (identifier [130, 14] - [130, 20]))))
            (throw_statement [131, 4] - [131, 41]
              (new_expression [131, 10] - [131, 40]
                constructor: (identifier [131, 14] - [131, 19])
                arguments: (arguments [131, 19] - [131, 40]
                  (string [131, 20] - [131, 39]
                    (string_fragment [131, 21] - [131, 38])))))))
        (lexical_declaration [134, 2] - [138, 23]
          (variable_declarator [134, 8] - [138, 22]
            name: (identifier [134, 8] - [134, 17])
            value: (ternary_expression [134, 20] - [138, 22]
              condition: (binary_expression [134, 20] - [134, 63]
                left: (binary_expression [134, 20] - [134, 42]
                  left: (identifier [134, 20] - [134, 33])
                  right: (null [134, 38] - [134, 42]))
                right: (binary_expression [134, 46] - [134, 63]
                  left: (identifier [134, 46] - [134, 59])
                  right: (number [134, 62] - [134, 63])))
              consequence: (new_expression [135, 6] - [137, 5]
                constructor: (identifier [135, 10] - [135, 20])
                arguments: (arguments [135, 20] - [137, 5]
                  (call_expression [136, 6] - [136, 77]
                    function: (member_expression [136, 6] - [136, 62]
                      object: (new_expression [136, 6] - [136, 47]
                        constructor: (member_expression [136, 10] - [136, 32]
                          object: (identifier [136, 10] - [136, 14])
                          property: (property_identifier [136, 15] - [136, 32]))
                        arguments: (arguments [136, 32] - [136, 47]
                          (identifier [136, 33] - [136, 46])))
                      property: (property_identifier [136, 48] - [136, 62]))
                    arguments: (arguments [136, 62] - [136, 77]
                      (identifier [136, 63] - [136, 76])))))
              alternative: (new_expression [138, 6] - [138, 22]
                constructor: (identifier [138, 10] - [138, 20])
                arguments: (arguments [138, 20] - [138, 22])))))
        (lexical_declaration [140, 2] - [146, 23]
          (variable_declarator [140, 8] - [146, 22]
            name: (identifier [140, 8] - [140, 21])
            value: (ternary_expression [140, 24] - [146, 22]
              condition: (binary_expression [140, 24] - [140, 75]
                left: (binary_expression [140, 24] - [140, 50]
                  left: (identifier [140, 24] - [140, 41])
                  right: (null [140, 46] - [140, 50]))
                right: (binary_expression [140, 54] - [140, 75]
                  left: (identifier [140, 54] - [140, 71])
                  right: (number [140, 74] - [140, 75])))
              consequence: (new_expression [141, 6] - [145, 5]
                constructor: (identifier [141, 10] - [141, 20])
                arguments: (arguments [141, 20] - [145, 5]
                  (call_expression [142, 6] - [144, 7]
                    function: (member_expression [142, 6] - [142, 66]
                      object: (new_expression [142, 6] - [142, 51]
                        constructor: (member_expression [142, 10] - [142, 32]
                          object: (identifier [142, 10] - [142, 14])
                          property: (property_identifier [142, 15] - [142, 32]))
                        arguments: (arguments [142, 32] - [142, 51]
                          (identifier [142, 33] - [142, 50])))
                      property: (property_identifier [142, 52] - [142, 66]))
                    arguments: (arguments [142, 66] - [144, 7]
                      (identifier [143, 8] - [143, 25])))))
              alternative: (new_expression [146, 6] - [146, 22]
                constructor: (identifier [146, 10] - [146, 20])
                arguments: (arguments [146, 20] - [146, 22])))))
        (lexical_declaration [148, 2] - [152, 23]
          (variable_declarator [148, 8] - [152, 22]
            name: (identifier [148, 8] - [148, 14])
            value: (ternary_expression [148, 17] - [152, 22]
              condition: (binary_expression [148, 17] - [148, 54]
                left: (binary_expression [148, 17] - [148, 36]
                  left: (identifier [148, 17] - [148, 27])
                  right: (null [148, 32] - [148, 36]))
                right: (binary_expression [148, 40] - [148, 54]
                  left: (identifier [148, 40] - [148, 50])
                  right: (number [148, 53] - [148, 54])))
              consequence: (new_expression [149, 6] - [151, 5]
                constructor: (identifier [149, 10] - [149, 20])
                arguments: (arguments [149, 20] - [151, 5]
                  (call_expression [150, 6] - [150, 71]
                    function: (member_expression [150, 6] - [150, 59]
                      object: (new_expression [150, 6] - [150, 44]
                        constructor: (member_expression [150, 10] - [150, 32]
                          object: (identifier [150, 10] - [150, 14])
                          property: (property_identifier [150, 15] - [150, 32]))
                        arguments: (arguments [150, 32] - [150, 44]
                          (identifier [150, 33] - [150, 43])))
                      property: (property_identifier [150, 45] - [150, 59]))
                    arguments: (arguments [150, 59] - [150, 71]
                      (identifier [150, 60] - [150, 70])))))
              alternative: (new_expression [152, 6] - [152, 22]
                constructor: (identifier [152, 10] - [152, 20])
                arguments: (arguments [152, 20] - [152, 22])))))
        (comment [154, 2] - [154, 64])
        (lexical_declaration [155, 2] - [160, 4]
          (variable_declarator [155, 8] - [160, 3]
            name: (identifier [155, 8] - [155, 16])
            value: (object [155, 19] - [160, 3]
              (shorthand_property_identifier [156, 4] - [156, 13])
              (pair [157, 4] - [157, 40]
                key: (property_identifier [157, 4] - [157, 13])
                value: (new_expression [157, 15] - [157, 40]
                  constructor: (identifier [157, 19] - [157, 29])
                  arguments: (arguments [157, 29] - [157, 40]
                    (identifier [157, 30] - [157, 39]))))
              (pair [158, 4] - [158, 48]
                key: (property_identifier [158, 4] - [158, 17])
                value: (new_expression [158, 19] - [158, 48]
                  constructor: (identifier [158, 23] - [158, 33])
                  arguments: (arguments [158, 33] - [158, 48]
                    (identifier [158, 34] - [158, 47]))))
              (pair [159, 4] - [159, 34]
                key: (property_identifier [159, 4] - [159, 10])
                value: (new_expression [159, 12] - [159, 34]
                  constructor: (identifier [159, 16] - [159, 26])
                  arguments: (arguments [159, 26] - [159, 34]
                    (identifier [159, 27] - [159, 33])))))))
        (comment [162, 2] - [162, 37])
        (expression_statement [163, 2] - [163, 20]
          (call_expression [163, 2] - [163, 19]
            function: (identifier [163, 2] - [163, 11])
            arguments: (arguments [163, 11] - [163, 19]
              (identifier [163, 12] - [163, 18]))))
        (return_statement [165, 2] - [165, 18]
          (identifier [165, 9] - [165, 17])))))
  (comment [168, 0] - [170, 3])
  (export_statement [171, 0] - [202, 2]
    declaration: (lexical_declaration [171, 7] - [202, 2]
      (variable_declarator [171, 11] - [202, 1]
        name: (identifier [171, 11] - [171, 34])
        value: (function_expression [171, 37] - [202, 1]
          name: (identifier [171, 46] - [171, 69])
          parameters: (formal_parameters [171, 69] - [173, 1]
            (required_parameter [172, 2] - [172, 20]
              pattern: (identifier [172, 2] - [172, 12])
              type: (type_annotation [172, 12] - [172, 20]
                (predefined_type [172, 14] - [172, 20]))))
          return_type: (type_annotation [173, 1] - [173, 16]
            (union_type [173, 3] - [173, 16]
              (predefined_type [173, 3] - [173, 9])
              (literal_type [173, 12] - [173, 16]
                (null [173, 12] - [173, 16]))))
          body: (statement_block [173, 17] - [202, 1]
            (if_statement [174, 2] - [176, 3]
              condition: (parenthesized_expression [174, 5] - [174, 52]
                (binary_expression [174, 6] - [174, 51]
                  left: (unary_expression [174, 6] - [174, 17]
                    argument: (identifier [174, 7] - [174, 17]))
                  right: (binary_expression [174, 21] - [174, 51]
                    left: (unary_expression [174, 21] - [174, 38]
                      argument: (identifier [174, 28] - [174, 38]))
                    right: (string [174, 43] - [174, 51]
                      (string_fragment [174, 44] - [174, 50])))))
              consequence: (statement_block [174, 53] - [176, 3]
                (return_statement [175, 4] - [175, 16]
                  (null [175, 11] - [175, 15]))))
            (try_statement [178, 2] - [199, 3]
              body: (statement_block [178, 6] - [197, 3]
                (lexical_declaration [179, 4] - [179, 49]
                  (variable_declarator [179, 10] - [179, 48]
                    name: (identifier [179, 10] - [179, 14])
                    value: (new_expression [179, 17] - [179, 48]
                      constructor: (identifier [179, 21] - [179, 36])
                      arguments: (arguments [179, 36] - [179, 48]
                        (identifier [179, 37] - [179, 47])))))
                (lexical_declaration [180, 4] - [182, 6]
                  (variable_declarator [180, 10] - [182, 5]
                    name: (identifier [180, 10] - [180, 22])
                    value: (call_expression [180, 25] - [182, 5]
                      function: (member_expression [180, 25] - [180, 45]
                        object: (member_expression [180, 25] - [180, 40]
                          object: (identifier [180, 25] - [180, 29])
                          property: (property_identifier [180, 30] - [180, 40]))
                        property: (property_identifier [180, 41] - [180, 45]))
                      arguments: (arguments [180, 45] - [182, 5]
                        (arrow_function [180, 46] - [181, 30]
                          parameters: (formal_parameters [180, 46] - [180, 51]
                            (required_parameter [180, 47] - [180, 50]
                              pattern: (identifier [180, 47] - [180, 50])))
                          body: (binary_expression [181, 6] - [181, 30]
                            left: (member_expression [181, 6] - [181, 14]
                              object: (identifier [181, 6] - [181, 9])
                              property: (property_identifier [181, 10] - [181, 14]))
                            right: (string [181, 19] - [181, 30]
                              (string_fragment [181, 20] - [181, 29]))))))))
                (comment [182, 7] - [182, 34])
                (if_statement [184, 4] - [186, 5]
                  condition: (parenthesized_expression [184, 7] - [184, 22]
                    (unary_expression [184, 8] - [184, 21]
                      argument: (identifier [184, 9] - [184, 21])))
                  consequence: (statement_block [184, 23] - [186, 5]
                    (return_statement [185, 6] - [185, 18]
                      (null [185, 13] - [185, 17]))))
                (lexical_declaration [188, 4] - [188, 76]
                  (variable_declarator [188, 10] - [188, 75]
                    name: (identifier [188, 10] - [188, 13])
                    value: (call_expression [188, 16] - [188, 75]
                      function: (member_expression [188, 16] - [188, 31]
                        object: (identifier [188, 16] - [188, 25])
                        property: (property_identifier [188, 26] - [188, 31]))
                      arguments: (arguments [188, 31] - [188, 75]
                        (member_expression [188, 32] - [188, 50]
                          object: (identifier [188, 32] - [188, 44])
                          property: (property_identifier [188, 45] - [188, 50]))
                        (identifier [188, 52] - [188, 74])))))
                (for_in_statement [189, 4] - [196, 5]
                  left: (identifier [189, 15] - [189, 19])
                  right: (identifier [189, 23] - [189, 26])
                  body: (statement_block [189, 28] - [196, 5]
                    (if_statement [190, 6] - [195, 7]
                      condition: (parenthesized_expression [190, 9] - [193, 7]
                        (binary_expression [191, 8] - [192, 62]
                          left: (member_expression [191, 8] - [191, 38]
                            object: (identifier [191, 8] - [191, 12])
                            property: (property_identifier [191, 13] - [191, 38]))
                          right: (call_expression [192, 8] - [192, 62]
                            function: (member_expression [192, 8] - [192, 49]
                              object: (member_expression [192, 8] - [192, 38]
                                object: (identifier [192, 8] - [192, 12])
                                property: (property_identifier [192, 13] - [192, 38]))
                              property: (property_identifier [192, 39] - [192, 49]))
                            arguments: (arguments [192, 49] - [192, 62]
                              (string [192, 50] - [192, 61]
                                (string_fragment [192, 51] - [192, 60]))))))
                      consequence: (statement_block [193, 8] - [195, 7]
                        (return_statement [194, 8] - [194, 46]
                          (member_expression [194, 15] - [194, 45]
                            object: (identifier [194, 15] - [194, 19])
                            property: (property_identifier [194, 20] - [194, 45]))))))))
              handler: (catch_clause [197, 4] - [199, 3]
                parameter: (identifier [197, 11] - [197, 13])
                body: (statement_block [197, 15] - [199, 3]
                  (return_statement [198, 4] - [198, 16]
                    (null [198, 11] - [198, 15])))))
            (return_statement [201, 2] - [201, 14]
              (null [201, 9] - [201, 13])))))))
  (export_statement [204, 0] - [253, 1]
    declaration: (function_declaration [204, 7] - [253, 1]
      name: (identifier [204, 22] - [204, 39])
      parameters: (formal_parameters [204, 39] - [207, 1]
        (required_parameter [205, 2] - [205, 22]
          pattern: (identifier [205, 2] - [205, 10])
          type: (type_annotation [205, 10] - [205, 22]
            (type_identifier [205, 12] - [205, 22])))
        (required_parameter [206, 2] - [206, 18]
          pattern: (identifier [206, 2] - [206, 6])
          type: (type_annotation [206, 6] - [206, 18]
            (type_identifier [206, 8] - [206, 18]))))
      return_type: (type_annotation [207, 1] - [207, 22]
        (generic_type [207, 3] - [207, 22]
          name: (type_identifier [207, 3] - [207, 10])
          type_arguments: (type_arguments [207, 10] - [207, 22]
            (type_identifier [207, 11] - [207, 21]))))
      body: (statement_block [207, 23] - [253, 1]
        (lexical_declaration [208, 2] - [208, 36]
          (variable_declarator [208, 8] - [208, 35]
            name: (identifier [208, 8] - [208, 14])
            value: (new_expression [208, 17] - [208, 35]
              constructor: (identifier [208, 21] - [208, 31])
              arguments: (arguments [208, 31] - [208, 35]
                (number [208, 32] - [208, 34])))))
        (if_statement [210, 2] - [216, 3]
          condition: (parenthesized_expression [210, 5] - [210, 13]
            (unary_expression [210, 6] - [210, 12]
              argument: (identifier [210, 7] - [210, 12])))
          consequence: (statement_block [210, 14] - [216, 3]
            (expression_statement [211, 4] - [213, 6]
              (call_expression [211, 4] - [213, 5]
                function: (member_expression [211, 4] - [211, 16]
                  object: (identifier [211, 4] - [211, 11])
                  property: (property_identifier [211, 12] - [211, 16]))
                arguments: (arguments [211, 16] - [213, 5]
                  (template_string [212, 6] - [212, 114]
                    (string_fragment [212, 7] - [212, 36])
                    (template_substitution [212, 36] - [212, 46]
                      (identifier [212, 38] - [212, 45]))
                    (string_fragment [212, 46] - [212, 113])))))
            (expression_statement [214, 4] - [214, 22]
              (call_expression [214, 4] - [214, 21]
                function: (member_expression [214, 4] - [214, 15]
                  object: (identifier [214, 4] - [214, 10])
                  property: (property_identifier [214, 11] - [214, 15]))
                arguments: (arguments [214, 15] - [214, 21]
                  (number [214, 16] - [214, 20]))))
            (return_statement [215, 4] - [215, 18]
              (identifier [215, 11] - [215, 17]))))
        (lexical_declaration [218, 2] - [218, 24]
          (variable_declarator [218, 8] - [218, 23]
            name: (identifier [218, 8] - [218, 18])
            value: (number [218, 21] - [218, 23])))
        (lexical_declaration [219, 2] - [219, 25]
          (variable_declarator [219, 8] - [219, 24]
            name: (identifier [219, 8] - [219, 16])
            value: (number [219, 19] - [219, 24])))
        (lexical_declaration [221, 2] - [221, 54]
          (variable_declarator [221, 8] - [221, 53]
            name: (identifier [221, 8] - [221, 19])
            value: (call_expression [221, 22] - [221, 53]
              function: (member_expression [221, 22] - [221, 43]
                object: (member_expression [221, 22] - [221, 40]
                  object: (identifier [221, 22] - [221, 26])
                  property: (property_identifier [221, 27] - [221, 40]))
                property: (property_identifier [221, 41] - [221, 43]))
              arguments: (arguments [221, 43] - [221, 53]
                (identifier [221, 44] - [221, 52])))))
        (lexical_declaration [222, 2] - [222, 46]
          (variable_declarator [222, 8] - [222, 45]
            name: (identifier [222, 8] - [222, 15])
            value: (call_expression [222, 18] - [222, 45]
              function: (member_expression [222, 18] - [222, 39]
                object: (member_expression [222, 18] - [222, 36]
                  object: (identifier [222, 18] - [222, 22])
                  property: (property_identifier [222, 23] - [222, 36]))
                property: (property_identifier [222, 37] - [222, 39]))
              arguments: (arguments [222, 39] - [222, 45]
                (identifier [222, 40] - [222, 44])))))
        (lexical_declaration [223, 2] - [223, 47]
          (variable_declarator [223, 8] - [223, 46]
            name: (identifier [223, 8] - [223, 14])
            value: (call_expression [223, 17] - [223, 46]
              function: (member_expression [223, 17] - [223, 38]
                object: (member_expression [223, 17] - [223, 35]
                  object: (identifier [223, 17] - [223, 21])
                  property: (property_identifier [223, 22] - [223, 35]))
                property: (property_identifier [223, 36] - [223, 38]))
              arguments: (arguments [223, 38] - [223, 46]
                (identifier [223, 39] - [223, 45])))))
        (lexical_declaration [225, 2] - [235, 26]
          (variable_declarator [225, 8] - [235, 25]
            name: (identifier [225, 8] - [225, 23])
            value: (as_expression [225, 26] - [235, 25]
              (as_expression [225, 26] - [226, 31]
                (member_expression [225, 26] - [226, 20]
                  object: (member_expression [225, 26] - [225, 39]
                    object: (identifier [225, 26] - [225, 31])
                    property: (property_identifier [225, 32] - [225, 39]))
                  property: (property_identifier [226, 5] - [226, 20]))
                (predefined_type [226, 24] - [226, 31]))
              (parenthesized_type [226, 35] - [235, 25]
                (function_type [226, 36] - [235, 24]
                  parameters: (formal_parameters [226, 36] - [235, 5]
                    (required_parameter [227, 6] - [227, 36]
                      pattern: (identifier [227, 6] - [227, 17])
                      type: (type_annotation [227, 17] - [227, 36]
                        (nested_type_identifier [227, 19] - [227, 36]
                          module: (identifier [227, 19] - [227, 23])
                          name: (type_identifier [227, 24] - [227, 36]))))
                    (required_parameter [228, 6] - [228, 34]
                      pattern: (identifier [228, 6] - [228, 17])
                      type: (type_annotation [228, 17] - [228, 34]
                        (union_type [228, 19] - [228, 34]
                          (predefined_type [228, 19] - [228, 25])
                          (type_identifier [228, 28] - [228, 34]))))
                    (required_parameter [229, 6] - [229, 32]
                      pattern: (identifier [229, 6] - [229, 13])
                      type: (type_annotation [229, 13] - [229, 32]
                        (nested_type_identifier [229, 15] - [229, 32]
                          module: (identifier [229, 15] - [229, 19])
                          name: (type_identifier [229, 20] - [229, 32]))))
                    (required_parameter [230, 6] - [230, 30]
                      pattern: (identifier [230, 6] - [230, 13])
                      type: (type_annotation [230, 13] - [230, 30]
                        (union_type [230, 15] - [230, 30]
                          (predefined_type [230, 15] - [230, 21])
                          (type_identifier [230, 24] - [230, 30]))))
                    (required_parameter [231, 6] - [231, 24]
                      pattern: (identifier [231, 6] - [231, 16])
                      type: (type_annotation [231, 16] - [231, 24]
                        (predefined_type [231, 18] - [231, 24])))
                    (required_parameter [232, 6] - [232, 22]
                      pattern: (identifier [232, 6] - [232, 14])
                      type: (type_annotation [232, 14] - [232, 22]
                        (predefined_type [232, 16] - [232, 22])))
                    (required_parameter [233, 6] - [233, 31]
                      pattern: (identifier [233, 6] - [233, 12])
                      type: (type_annotation [233, 12] - [233, 31]
                        (nested_type_identifier [233, 14] - [233, 31]
                          module: (identifier [233, 14] - [233, 18])
                          name: (type_identifier [233, 19] - [233, 31]))))
                    (required_parameter [234, 6] - [234, 29]
                      pattern: (identifier [234, 6] - [234, 12])
                      type: (type_annotation [234, 12] - [234, 29]
                        (union_type [234, 14] - [234, 29]
                          (predefined_type [234, 14] - [234, 20])
                          (type_identifier [234, 23] - [234, 29])))))
                  return_type: (generic_type [235, 9] - [235, 24]
                    name: (type_identifier [235, 9] - [235, 16])
                    type_arguments: (type_arguments [235, 16] - [235, 24]
                      (predefined_type [235, 17] - [235, 23]))))))))
        (lexical_declaration [237, 2] - [246, 4]
          (variable_declarator [237, 8] - [246, 3]
            name: (identifier [237, 8] - [237, 11])
            value: (await_expression [237, 14] - [246, 3]
              (call_expression [237, 20] - [246, 3]
                function: (identifier [237, 20] - [237, 35])
                arguments: (arguments [237, 35] - [246, 3]
                  (identifier [238, 4] - [238, 15])
                  (member_expression [239, 4] - [239, 19]
                    object: (identifier [239, 4] - [239, 12])
                    property: (property_identifier [239, 13] - [239, 19]))
                  (identifier [240, 4] - [240, 11])
                  (member_expression [241, 4] - [241, 15]
                    object: (identifier [241, 4] - [241, 8])
                    property: (property_identifier [241, 9] - [241, 15]))
                  (identifier [242, 4] - [242, 14])
                  (identifier [243, 4] - [243, 12])
                  (identifier [244, 4] - [244, 10])
                  (member_expression [245, 4] - [245, 17]
                    object: (identifier [245, 4] - [245, 10])
                    property: (property_identifier [245, 11] - [245, 17])))))))
        (if_statement [248, 2] - [250, 3]
          condition: (parenthesized_expression [248, 5] - [248, 16]
            (binary_expression [248, 6] - [248, 15]
              left: (identifier [248, 6] - [248, 9])
              right: (number [248, 14] - [248, 15])))
          consequence: (statement_block [248, 17] - [250, 3]
            (throw_statement [249, 4] - [249, 58]
              (new_expression [249, 10] - [249, 57]
                constructor: (identifier [249, 14] - [249, 19])
                arguments: (arguments [249, 19] - [249, 57]
                  (template_string [249, 20] - [249, 56]
                    (string_fragment [249, 21] - [249, 49])
                    (template_substitution [249, 49] - [249, 55]
                      (identifier [249, 51] - [249, 54]))))))))
        (return_statement [252, 2] - [252, 16]
          (identifier [252, 9] - [252, 15])))))
  (export_statement [255, 0] - [262, 2]
    declaration: (lexical_declaration [255, 7] - [262, 2]
      (variable_declarator [255, 13] - [262, 1]
        name: (identifier [255, 13] - [255, 25])
        value: (object [255, 28] - [262, 1]
          (method_definition [256, 2] - [258, 3]
            name: (property_identifier [256, 6] - [256, 29])
            parameters: (formal_parameters [256, 29] - [256, 31])
            body: (statement_block [256, 32] - [258, 3]
              (return_statement [257, 4] - [257, 35]
                (identifier [257, 11] - [257, 34]))))
          (method_definition [259, 2] - [261, 3]
            name: (property_identifier [259, 6] - [259, 29])
            parameters: (formal_parameters [259, 29] - [259, 39]
              (required_parameter [259, 30] - [259, 38]
                pattern: (identifier [259, 30] - [259, 33])
                type: (type_annotation [259, 33] - [259, 38]
                  (predefined_type [259, 35] - [259, 38]))))
            body: (statement_block [259, 40] - [261, 3]
              (expression_statement [260, 4] - [260, 34]
                (assignment_expression [260, 4] - [260, 33]
                  left: (identifier [260, 4] - [260, 27])
                  right: (identifier [260, 30] - [260, 33]))))))))))