(program [0, 0] - [92, 0]
  (import_statement [0, 0] - [0, 46]
    (import_clause [0, 7] - [0, 21]
      (named_imports [0, 7] - [0, 21]
        (import_specifier [0, 9] - [0, 19]
          name: (identifier [0, 9] - [0, 19]))))
    source: (string [0, 27] - [0, 45]
      (string_fragment [0, 28] - [0, 44])))
  (export_statement [2, 0] - [10, 1]
    declaration: (function_declaration [2, 7] - [10, 1]
      name: (identifier [2, 22] - [2, 39])
      parameters: (formal_parameters [2, 39] - [2, 55]
        (required_parameter [2, 40] - [2, 54]
          pattern: (identifier [2, 40] - [2, 46])
          type: (type_annotation [2, 46] - [2, 54]
            (predefined_type [2, 48] - [2, 54]))))
      body: (statement_block [2, 56] - [10, 1]
        (lexical_declaration [3, 2] - [8, 6]
          (variable_declarator [3, 8] - [8, 5]
            name: (identifier [3, 8] - [3, 16])
            value: (await_expression [3, 19] - [8, 5]
              (call_expression [3, 25] - [8, 5]
                function: (member_expression [3, 25] - [3, 39]
                  object: (identifier [3, 25] - [3, 35])
                  property: (property_identifier [3, 36] - [3, 39]))
                arguments: (template_string [3, 39] - [8, 5]
                  (string_fragment [3, 40] - [6, 24])
                  (template_substitution [6, 24] - [6, 33]
                    (identifier [6, 26] - [6, 32]))
                  (string_fragment [6, 33] - [8, 4]))))))
        (return_statement [9, 2] - [9, 18]
          (identifier [9, 9] - [9, 17])))))
  (export_statement [12, 0] - [23, 1]
    declaration: (function_declaration [12, 7] - [23, 1]
      name: (identifier [12, 22] - [12, 37])
      parameters: (formal_parameters [12, 37] - [18, 1]
        (required_parameter [13, 2] - [13, 19]
          pattern: (identifier [13, 2] - [13, 11])
          type: (type_annotation [13, 11] - [13, 19]
            (predefined_type [13, 13] - [13, 19])))
        (required_parameter [14, 2] - [14, 16]
          pattern: (identifier [14, 2] - [14, 8])
          type: (type_annotation [14, 8] - [14, 16]
            (predefined_type [14, 10] - [14, 16])))
        (required_parameter [15, 2] - [15, 15]
          pattern: (identifier [15, 2] - [15, 7])
          type: (type_annotation [15, 7] - [15, 15]
            (predefined_type [15, 9] - [15, 15])))
        (required_parameter [16, 2] - [16, 24]
          pattern: (identifier [16, 2] - [16, 14])
          type: (type_annotation [16, 14] - [16, 24]
            (array_type [16, 16] - [16, 24]
              (predefined_type [16, 16] - [16, 22]))))
        (required_parameter [17, 2] - [17, 17]
          pattern: (identifier [17, 2] - [17, 11])
          type: (type_annotation [17, 11] - [17, 17]
            (type_identifier [17, 13] - [17, 17]))))
      body: (statement_block [18, 2] - [23, 1]
        (expression_statement [19, 2] - [22, 6]
          (await_expression [19, 2] - [22, 5]
            (call_expression [19, 8] - [22, 5]
              function: (member_expression [19, 8] - [19, 22]
                object: (identifier [19, 8] - [19, 18])
                property: (property_identifier [19, 19] - [19, 22]))
              arguments: (template_string [19, 22] - [22, 5]
                (string_fragment [19, 23] - [21, 16])
                (template_substitution [21, 16] - [21, 28]
                  (identifier [21, 18] - [21, 27]))
                (string_fragment [21, 28] - [21, 30])
                (template_substitution [21, 30] - [21, 39]
                  (identifier [21, 32] - [21, 38]))
                (string_fragment [21, 39] - [21, 41])
                (template_substitution [21, 41] - [21, 49]
                  (identifier [21, 43] - [21, 48]))
                (string_fragment [21, 49] - [21, 57])
                (template_substitution [21, 57] - [21, 72]
                  (identifier [21, 59] - [21, 71]))
                (string_fragment [21, 72] - [21, 74])
                (template_substitution [21, 74] - [21, 100]
                  (call_expression [21, 76] - [21, 99]
                    function: (member_expression [21, 76] - [21, 97]
                      object: (identifier [21, 76] - [21, 85])
                      property: (property_identifier [21, 86] - [21, 97]))
                    arguments: (arguments [21, 97] - [21, 99])))
                (string_fragment [21, 100] - [22, 4]))))))))
  (export_statement [25, 0] - [34, 1]
    declaration: (function_declaration [25, 7] - [34, 1]
      name: (identifier [25, 22] - [25, 45])
      parameters: (formal_parameters [25, 45] - [28, 1]
        (required_parameter [26, 2] - [26, 19]
          pattern: (identifier [26, 2] - [26, 11])
          type: (type_annotation [26, 11] - [26, 19]
            (predefined_type [26, 13] - [26, 19])))
        (required_parameter [27, 2] - [27, 16]
          pattern: (identifier [27, 2] - [27, 8])
          type: (type_annotation [27, 8] - [27, 16]
            (predefined_type [27, 10] - [27, 16]))))
      body: (statement_block [28, 2] - [34, 1]
        (lexical_declaration [29, 2] - [31, 6]
          (variable_declarator [29, 8] - [31, 5]
            name: (identifier [29, 8] - [29, 15])
            value: (await_expression [29, 18] - [31, 5]
              (call_expression [29, 24] - [31, 5]
                function: (member_expression [29, 24] - [29, 38]
                  object: (identifier [29, 24] - [29, 34])
                  property: (property_identifier [29, 35] - [29, 38]))
                arguments: (template_string [29, 38] - [31, 5]
                  (string_fragment [29, 39] - [30, 65])
                  (template_substitution [30, 65] - [30, 77]
                    (identifier [30, 67] - [30, 76]))
                  (string_fragment [30, 77] - [30, 92])
                  (template_substitution [30, 92] - [30, 101]
                    (identifier [30, 94] - [30, 100]))
                  (string_fragment [30, 101] - [31, 4]))))))
        (if_statement [32, 2] - [32, 52]
          condition: (parenthesized_expression [32, 5] - [32, 39]
            (binary_expression [32, 6] - [32, 38]
              left: (unary_expression [32, 6] - [32, 14]
                argument: (identifier [32, 7] - [32, 14]))
              right: (binary_expression [32, 18] - [32, 38]
                left: (member_expression [32, 18] - [32, 32]
                  object: (identifier [32, 18] - [32, 25])
                  property: (property_identifier [32, 26] - [32, 32]))
                right: (number [32, 37] - [32, 38]))))
          consequence: (return_statement [32, 40] - [32, 52]
            (null [32, 47] - [32, 51])))
        (return_statement [33, 2] - [33, 20]
          (subscript_expression [33, 9] - [33, 19]
            object: (identifier [33, 9] - [33, 16])
            index: (number [33, 17] - [33, 18]))))))
  (export_statement [36, 0] - [43, 1]
    declaration: (function_declaration [36, 7] - [43, 1]
      name: (identifier [36, 22] - [36, 41])
      parameters: (formal_parameters [36, 41] - [39, 1]
        (required_parameter [37, 2] - [37, 19]
          pattern: (identifier [37, 2] - [37, 11])
          type: (type_annotation [37, 11] - [37, 19]
            (predefined_type [37, 13] - [37, 19])))
        (required_parameter [38, 2] - [38, 24]
          pattern: (identifier [38, 2] - [38, 14])
          type: (type_annotation [38, 14] - [38, 24]
            (array_type [38, 16] - [38, 24]
              (predefined_type [38, 16] - [38, 22])))))
      body: (statement_block [39, 2] - [43, 1]
        (expression_statement [40, 2] - [42, 6]
          (await_expression [40, 2] - [42, 5]
            (call_expression [40, 8] - [42, 5]
              function: (member_expression [40, 8] - [40, 22]
                object: (identifier [40, 8] - [40, 18])
                property: (property_identifier [40, 19] - [40, 22]))
              arguments: (template_string [40, 22] - [42, 5]
                (string_fragment [40, 23] - [41, 44])
                (template_substitution [41, 44] - [41, 59]
                  (identifier [41, 46] - [41, 58]))
                (string_fragment [41, 59] - [41, 71])
                (template_substitution [41, 71] - [41, 83]
                  (identifier [41, 73] - [41, 82]))
                (string_fragment [41, 83] - [42, 4]))))))))
  (export_statement [45, 0] - [51, 1]
    declaration: (function_declaration [45, 7] - [51, 1]
      name: (identifier [45, 22] - [45, 36])
      parameters: (formal_parameters [45, 36] - [45, 55]
        (required_parameter [45, 37] - [45, 54]
          pattern: (identifier [45, 37] - [45, 46])
          type: (type_annotation [45, 46] - [45, 54]
            (predefined_type [45, 48] - [45, 54]))))
      body: (statement_block [45, 56] - [51, 1]
        (lexical_declaration [46, 2] - [48, 6]
          (variable_declarator [46, 8] - [48, 5]
            name: (identifier [46, 8] - [46, 15])
            value: (await_expression [46, 18] - [48, 5]
              (call_expression [46, 24] - [48, 5]
                function: (member_expression [46, 24] - [46, 38]
                  object: (identifier [46, 24] - [46, 34])
                  property: (property_identifier [46, 35] - [46, 38]))
                arguments: (template_string [46, 38] - [48, 5]
                  (string_fragment [46, 39] - [47, 43])
                  (template_substitution [47, 43] - [47, 55]
                    (identifier [47, 45] - [47, 54]))
                  (string_fragment [47, 55] - [48, 4]))))))
        (if_statement [49, 2] - [49, 52]
          condition: (parenthesized_expression [49, 5] - [49, 39]
            (binary_expression [49, 6] - [49, 38]
              left: (unary_expression [49, 6] - [49, 14]
                argument: (identifier [49, 7] - [49, 14]))
              right: (binary_expression [49, 18] - [49, 38]
                left: (member_expression [49, 18] - [49, 32]
                  object: (identifier [49, 18] - [49, 25])
                  property: (property_identifier [49, 26] - [49, 32]))
                right: (number [49, 37] - [49, 38]))))
          consequence: (return_statement [49, 40] - [49, 52]
            (null [49, 47] - [49, 51])))
        (return_statement [50, 2] - [50, 20]
          (subscript_expression [50, 9] - [50, 19]
            object: (identifier [50, 9] - [50, 16])
            index: (number [50, 17] - [50, 18]))))))
  (export_statement [53, 0] - [57, 1]
    declaration: (function_declaration [53, 7] - [57, 1]
      name: (identifier [53, 22] - [53, 38])
      parameters: (formal_parameters [53, 38] - [53, 76]
        (required_parameter [53, 39] - [53, 56]
          pattern: (identifier [53, 39] - [53, 48])
          type: (type_annotation [53, 48] - [53, 56]
            (predefined_type [53, 50] - [53, 56])))
        (required_parameter [53, 58] - [53, 75]
          pattern: (identifier [53, 58] - [53, 66])
          type: (type_annotation [53, 66] - [53, 75]
            (predefined_type [53, 68] - [53, 75]))))
      body: (statement_block [53, 77] - [57, 1]
        (expression_statement [54, 2] - [56, 6]
          (await_expression [54, 2] - [56, 5]
            (call_expression [54, 8] - [56, 5]
              function: (member_expression [54, 8] - [54, 22]
                object: (identifier [54, 8] - [54, 18])
                property: (property_identifier [54, 19] - [54, 22]))
              arguments: (template_string [54, 22] - [56, 5]
                (string_fragment [54, 23] - [55, 40])
                (template_substitution [55, 40] - [55, 51]
                  (identifier [55, 42] - [55, 50]))
                (string_fragment [55, 51] - [55, 63])
                (template_substitution [55, 63] - [55, 75]
                  (identifier [55, 65] - [55, 74]))
                (string_fragment [55, 75] - [56, 4]))))))))
  (export_statement [59, 0] - [63, 1]
    declaration: (function_declaration [59, 7] - [63, 1]
      name: (identifier [59, 22] - [59, 41])
      parameters: (formal_parameters [59, 41] - [59, 77]
        (required_parameter [59, 42] - [59, 59]
          pattern: (identifier [59, 42] - [59, 51])
          type: (type_annotation [59, 51] - [59, 59]
            (predefined_type [59, 53] - [59, 59])))
        (required_parameter [59, 61] - [59, 76]
          pattern: (identifier [59, 61] - [59, 70])
          type: (type_annotation [59, 70] - [59, 76]
            (type_identifier [59, 72] - [59, 76]))))
      body: (statement_block [59, 78] - [63, 1]
        (expression_statement [60, 2] - [62, 6]
          (await_expression [60, 2] - [62, 5]
            (call_expression [60, 8] - [62, 5]
              function: (member_expression [60, 8] - [60, 22]
                object: (identifier [60, 8] - [60, 18])
                property: (property_identifier [60, 19] - [60, 22]))
              arguments: (template_string [60, 22] - [62, 5]
                (string_fragment [60, 23] - [61, 41])
                (template_substitution [61, 41] - [61, 67]
                  (call_expression [61, 43] - [61, 66]
                    function: (member_expression [61, 43] - [61, 64]
                      object: (identifier [61, 43] - [61, 52])
                      property: (property_identifier [61, 53] - [61, 64]))
                    arguments: (arguments [61, 64] - [61, 66])))
                (string_fragment [61, 67] - [61, 79])
                (template_substitution [61, 79] - [61, 91]
                  (identifier [61, 81] - [61, 90]))
                (string_fragment [61, 91] - [62, 4]))))))))
  (export_statement [65, 0] - [67, 1]
    declaration: (function_declaration [65, 7] - [67, 1]
      name: (identifier [65, 22] - [65, 35])
      parameters: (formal_parameters [65, 35] - [65, 54]
        (required_parameter [65, 36] - [65, 53]
          pattern: (identifier [65, 36] - [65, 45])
          type: (type_annotation [65, 45] - [65, 53]
            (predefined_type [65, 47] - [65, 53]))))
      body: (statement_block [65, 55] - [67, 1]
        (expression_statement [66, 2] - [66, 69]
          (await_expression [66, 2] - [66, 68]
            (call_expression [66, 8] - [66, 68]
              function: (member_expression [66, 8] - [66, 22]
                object: (identifier [66, 8] - [66, 18])
                property: (property_identifier [66, 19] - [66, 22]))
              arguments: (template_string [66, 22] - [66, 68]
                (string_fragment [66, 23] - [66, 55])
                (template_substitution [66, 55] - [66, 67]
                  (identifier [66, 57] - [66, 66])))))))))
  (export_statement [69, 0] - [91, 1]
    declaration: (function_declaration [69, 7] - [91, 1]
      name: (identifier [69, 22] - [69, 50])
      parameters: (formal_parameters [69, 50] - [73, 1]
        (required_parameter [70, 2] - [70, 19]
          pattern: (identifier [70, 2] - [70, 11])
          type: (type_annotation [70, 11] - [70, 19]
            (predefined_type [70, 13] - [70, 19])))
        (required_parameter [71, 2] - [71, 16]
          pattern: (identifier [71, 2] - [71, 8])
          type: (type_annotation [71, 8] - [71, 16]
            (predefined_type [71, 10] - [71, 16])))
        (required_parameter [72, 2] - [72, 18]
          pattern: (identifier [72, 2] - [72, 9])
          type: (type_annotation [72, 9] - [72, 18]
            (predefined_type [72, 11] - [72, 18]))))
      body: (statement_block [73, 2] - [91, 1]
        (lexical_declaration [74, 2] - [88, 6]
          (variable_declarator [74, 8] - [88, 5]
            name: (identifier [74, 8] - [74, 15])
            value: (await_expression [74, 18] - [88, 5]
              (call_expression [74, 24] - [88, 5]
                function: (member_expression [74, 24] - [74, 38]
                  object: (identifier [74, 24] - [74, 34])
                  property: (property_identifier [74, 35] - [74, 38]))
                arguments: (template_string [74, 38] - [88, 5]
                  (string_fragment [74, 39] - [78, 21])
                  (template_substitution [78, 21] - [78, 33]
                    (identifier [78, 23] - [78, 32]))
                  (string_fragment [78, 33] - [80, 24])
                  (template_substitution [80, 24] - [80, 33]
                    (identifier [80, 26] - [80, 32]))
                  (string_fragment [80, 33] - [81, 15])
                  (template_substitution [81, 15] - [81, 25]
                    (identifier [81, 17] - [81, 24]))
                  (string_fragment [81, 25] - [84, 36])
                  (template_substitution [84, 36] - [84, 45]
                    (identifier [84, 38] - [84, 44]))
                  (string_fragment [84, 45] - [88, 4]))))))
        (if_statement [89, 2] - [89, 52]
          condition: (parenthesized_expression [89, 5] - [89, 39]
            (binary_expression [89, 6] - [89, 38]
              left: (unary_expression [89, 6] - [89, 14]
                argument: (identifier [89, 7] - [89, 14]))
              right: (binary_expression [89, 18] - [89, 38]
                left: (member_expression [89, 18] - [89, 32]
                  object: (identifier [89, 18] - [89, 25])
                  property: (property_identifier [89, 26] - [89, 32]))
                right: (number [89, 37] - [89, 38]))))
          consequence: (return_statement [89, 40] - [89, 52]
            (null [89, 47] - [89, 51])))
        (return_statement [90, 2] - [90, 20]
          (subscript_expression [90, 9] - [90, 19]
            object: (identifier [90, 9] - [90, 16])
            index: (number [90, 17] - [90, 18])))))))