1001 update

lib/Screens/CheckInternetConnection/CheckInternetConnection.dart

+import 'dart:async';
+import 'dart:developer' as developer;
+
+import 'package:connectivity_plus/connectivity_plus.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:lottie/lottie.dart';
+
+class MyHomePage extends StatefulWidget {
+  @override
+  State<MyHomePage> createState() => _MyHomePageState();
+}
+
+class _MyHomePageState extends State<MyHomePage> {
+  ConnectivityResult _connectionStatus = ConnectivityResult.none;
+  final Connectivity _connectivity = Connectivity();
+  late StreamSubscription<ConnectivityResult> _connectivitySubscription;
+
+  @override
+  void initState() {
+    super.initState();
+    initConnectivity();
+
+    _connectivitySubscription = _connectivity.onConnectivityChanged.listen(_updateConnectionStatus);
+  }
+
+  @override
+  void dispose() {
+    _connectivitySubscription.cancel();
+    super.dispose();
+  }
+
+  // Platform messages are asynchronous, so we initialize in an async method.
+  Future<void> initConnectivity() async {
+    late ConnectivityResult result;
+    // Platform messages may fail, so we use a try/catch PlatformException.
+    try {
+      result = await _connectivity.checkConnectivity();
+    } on PlatformException catch (e) {
+      developer.log('Couldn\'t check connectivity status', error: e);
+      return;
+    }
+
+    // If the widget was removed from the tree while the asynchronous platform
+    // message was in flight, we want to discard the reply rather than calling
+    // setState to update our non-existent appearance.
+    if (!mounted) {
+      return Future.value(null);
+    }
+
+    return _updateConnectionStatus(result);
+  }
+
+  Future<void> _updateConnectionStatus(ConnectivityResult result) async {
+    setState(() {
+      _connectionStatus = result;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      child: Column(
+        children: [
+          SizedBox(
+            width: 250,
+            height: 250,
+            child: LottieBuilder.asset(
+                'assets/animation/animation_no_internet.json',
+                repeat: true),
+          ),
+          Text(
+            "No Internet Connection",
+            style: GoogleFonts.josefinSans(fontSize: 18),
+          ),
+          Padding(
+            padding: EdgeInsets.all(15),
+            child: Text(
+              'You Are Not Connected to The Internet. Please check your Wifi or Mobile Data!',
+              style: GoogleFonts.zillaSlab(fontSize: 16),
+            ),
+          ),
+          ElevatedButton(
+              onPressed: (){
+
+              },
+              child: Text("Retry",
+                  textAlign: TextAlign.center,
+                  style: TextStyle(
+                      color: Colors.white,
+                      fontSize: 17,
+                      fontWeight: FontWeight.w500)
+              )
+          )
+        ],
+      ),
+    );
+  }
+}

lib/Screens/CheckInternetConnection/ConnectivityProvider.dart

+import 'package:flutter/material.dart';
+
+class ConnectivityProvider with ChangeNotifier{
+  /*Connectivity
+  ConnectivityProvider _connectivityProvider = new ConnectivityProvider();
+
+  late bool _isOnline;
+  bool get isOnline => _isOnline;
+
+  startMonitoring() async {
+
+  }
+
+  Future<void> initConnectivity() async {
+    try {
+      var connectivityResult = await (Connectivity().checkConnectivity());
+    } catch {
+
+    }
+  }*/
+}

lib/Screens/CheckInternetConnection/NoInternetConnection.dart

+import 'package:flutter/material.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:lottie/lottie.dart';
+
+class NoInternetConnection extends StatefulWidget {
+  const NoInternetConnection({Key? key}) : super(key: key);
+
+  @override
+  State<NoInternetConnection> createState() => _NoInternetConnectionState();
+}
+
+class _NoInternetConnectionState extends State<NoInternetConnection> {
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      child: Column(
+        children: [
+          SizedBox(
+            width: 250,
+            height: 250,
+            child: LottieBuilder.asset(
+                'assets/animation/animation_no_internet.json',
+                repeat: true),
+          ),
+          Text(
+            "No Internet Connection",
+            style: GoogleFonts.josefinSans(fontSize: 18),
+          ),
+          Padding(
+            padding: EdgeInsets.all(15),
+            child: Text(
+              'You Are Not Connected to The Internet. Please check your Wifi or Mobile Data!',
+              style: GoogleFonts.zillaSlab(fontSize: 16),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/Screens/ForgotPassword/forgotPassword_screen.dart

                                           okButton,
                                         ],
                                       );
-
                                       // show the dialog
                                       showDialog(
                                         context: context,

lib/Screens/Home/home_screen.dart

                                 ),
                                 Container(
                                   margin: EdgeInsets.only(top: 10),
+                                  padding: EdgeInsets.all(5),
                                   child: Text(
-                                    'Absensi',
+                                    'Attendance',
                                     textAlign: TextAlign.center,
                                     style: GoogleFonts.acme(
                                         fontSize: 18, color: Colors.black),
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
-                                  'Slip Gaji',
+                                  'Salary Slip',
                                   textAlign: TextAlign.center,
                                   style: GoogleFonts.acme(
                                       fontSize: 18, color: Colors.black),
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
-                                  'Ajukan Cuti',
+                                  'Time Off Submission',
                                   textAlign: TextAlign.center,
                                   style: GoogleFonts.acme(
                                       fontSize: 18, color: Colors.black),
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
                                   'Berita',
                                   textAlign: TextAlign.center,
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
-                                  'Surat Tugas',
+                                  'Assignment Letter',
                                   textAlign: TextAlign.center,
                                   style: GoogleFonts.acme(
                                       fontSize: 18, color: Colors.black),
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
                                   'Reimburse',
                                   textAlign: TextAlign.center,
                               ),
                               Container(
                                 margin: EdgeInsets.only(top: 10),
+                                padding: EdgeInsets.all(5),
                                 child: Text(
                                   'About',
                                   textAlign: TextAlign.center,

lib/Screens/Menu/Absensi/absensi_screen.dart

 import 'package:flutter/material.dart';
 import 'package:flutter_map/plugin_api.dart';
 import 'package:geolocator/geolocator.dart';
-import 'package:google_maps_flutter/google_maps_flutter.dart';
 import 'package:hris_selfservice_mobile/Screens/Menu/Absensi/absensi_history_screen.dart';
-import 'package:latlong/latlong.dart' as latlong;
+//import 'package:latlong/latlong.dart' as latlong;
 import 'package:latlong2/latlong.dart';
 
 
 class _AbsensiScreenState extends State<AbsensiScreen> {
   double long = 49.5;
   double lat = -0.09;
-  latlong.LatLng point = latlong.LatLng(-6.186729296979901, 106.93023205185953);
+  //latlong.LatLng point = latlong.LatLng(-6.186729296979901, 106.93023205185953);
   var location = [];
 
   @override
           children: [
             Container(
               //Ganti yg ini untuk maps
-              height: size.height * 0.3,
+              height: size.height * 0.5,
               child: FlutterMap(
                 options: MapOptions(
-                  center: point,
-                    zoom: 10.0,
+
                 ),
                 children: [
                   TileLayer(

lib/Screens/Menu/AjukanCuti/ajukancuti_screen.dart

 import 'package:file_picker/file_picker.dart';
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter/rendering.dart';
 import 'package:fluttertoast/fluttertoast.dart';
 import 'package:google_fonts/google_fonts.dart';
 import 'package:hris_selfservice_mobile/Screens/Menu/AjukanCuti/RequestHttp/jenisCuti_post.dart';
     deskripsiTeksController.clear();
     cutiType = [""];
     idCutiType = [""];
+
+    formattedDateFrom = "";
+    visibleDateFrom = false;
+    formattedDateTo = "";
+    visibleDateTo = false;
+    deskripsiTeksController.clear();
+
     WidgetsBinding.instance.addPostFrameCallback((_) {
       cutiType = getJenisCuti();
     });
                     crossAxisAlignment: CrossAxisAlignment.end,
                     children: [
                       Text(
-                        'Ajukan Cuti\t\t',
+                        'Time Off\t\t',
                         maxLines: 1,
                         style: GoogleFonts.luckiestGuy(
                           fontSize: 28,
                             child: Row(
                               mainAxisAlignment: MainAxisAlignment.center,
                               children: [
-                                Text('Lihat Riwayat Cuti\t\t',
+                                Text(' See Time Off History\t\t',
                                     textAlign: TextAlign.center,
                                     style: TextStyle(
                                         color: Colors.white,
                               ],
                             )),
                         onTap: () {
+                          deskripsiTeksController.clear();
+                          visibleDateFrom = !visibleDateFrom;
+                          visibleDateTo = !visibleDateTo;
                           Navigator.push(context, MaterialPageRoute(
                               builder: (context) => HistoryCuti()));
                         },
                                 borderRadius: BorderRadius.circular(10)),
                             child: Column(
                               children: [
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 15, bottom: 10),
+                                  child: Text('Time Off Submission', style:
+                                  GoogleFonts.josefinSans(fontSize: 18, fontWeight: FontWeight.bold, decoration: TextDecoration.underline,
+                                  decorationStyle: TextDecorationStyle.dashed),),
+                                ),
                                 Container(
                                   margin: EdgeInsets.only(
                                       left: 10, right: 10, top: 10, bottom: 10),
                                       Expanded(
                                           flex: 2,
                                           child: Text(
-                                            'Tipe',
+                                            'Type',
                                             style: GoogleFonts.inconsolata(
                                                 fontSize: 17),
                                           )),
                                               isExpanded: true,
                                               underline: SizedBox(),
                                               hint: Text(
-                                                '\t\t\tPilih Tipe Cuti',
+                                                '\t\t\tChoose Time Off Type',
                                                 style: TextStyle(
                                                     color: Colors.black54),
                                               ),
                                                       idCuti = idCutiType.elementAt(i);
                                                     }
                                                   }
-                                                  logDev.log(idCuti, name: "ID CUTINYA APA");
                                                 });
                                               },
                                               items: cutiType
                                                 CrossAxisAlignment.start,
                                             children: [
                                               Text(
-                                                'Mulai',
+                                                'From',
                                                 style: GoogleFonts.inconsolata(
                                                     fontSize: 17),
                                               ),
                                               child: Container(
                                                 width: double.infinity,
                                                 child: Text(
-                                                  "Pilih Tanggal",
+                                                  "Choose Date",
                                                   style: TextStyle(
                                                       color: Colors.white,
                                                       fontSize: 16,
                                                 CrossAxisAlignment.start,
                                             children: [
                                               Text(
-                                                'Sampai',
+                                                'To',
                                                 style: GoogleFonts.inconsolata(
                                                     fontSize: 17),
                                               ),
                                               child: Container(
                                                 width: double.infinity,
                                                 child: Text(
-                                                  "Pilih Tanggal",
+                                                  "Choose Date",
                                                   style: TextStyle(
                                                       color: Colors.white,
                                                       fontSize: 16,
                                       Expanded(
                                           flex: 3,
                                           child: Text(
-                                            'Deskripsi',
+                                            'Description',
                                             style: GoogleFonts.inconsolata(
                                                 fontSize: 17),
                                           )),
                                                     decoration: InputDecoration(
                                                         border:
                                                             InputBorder.none,
-                                                        hintText: "Deskripsi")),
+                                                        hintText: "description")),
                                               ))),
                                     ],
                                   ),
                                           Expanded(
                                             flex: 3,
                                             child: Text(
-                                              'Lampiran',
+                                              'Attachment',
                                               style: GoogleFonts.inconsolata(
                                                   fontSize: 17),
                                             ),
                                                             .systemGrey2),*/
                                                 child: Container(
                                                   width: double.infinity,
-                                                  child: Text("Pilih File",
+                                                  child: Text("Choose File",
                                                       style: TextStyle(
                                                           color: Colors.white,
                                                           fontSize: 16,
                                                 Color(0xFFFF9945),
                                                 Color(0xFFFc6076)
                                               ])),
-                                          child: Text('Ajukan',
+                                          child: Text('Submit',
                                               textAlign: TextAlign.center,
                                               style: TextStyle(
                                                   color: Colors.white,
                                                 // set up the AlertDialog
                                                 AlertDialog alert = AlertDialog(
                                                   title: Text("Employee Self Service"),
-                                                  content: Text("Berhasil Mengajukan Cuti"),
+                                                  content: Text("Success Submit Time Off"),
                                                   actions: [
                                                     okButton,
                                                   ],
         fileAttach.add(toBase64);
       }
       fileAttach.removeAt(0);
-      /*logDev.log(fileAttach.toString(), name: "File Attach Base64");*/
       logDev.log(fileAttach.length.toString(), name: "Length File Attach");
       logDev.log(files.toString(), name: "Files Picked");
 
     bool result = true;
     if (selectedType == null) {
       Fluttertoast.showToast(
-          msg: "Tipe Cuti Belum Dipilih",
+          msg: "Time Off Type Not Selected",
           toastLength: Toast.LENGTH_SHORT,
           gravity: ToastGravity.CENTER,
           timeInSecForIosWeb: 1,
       result = false;
     } else if  (formattedDateFrom == "" || formattedDateTo == "") {
       Fluttertoast.showToast(
-          msg: "Tanggal Cuti Belum Dipilih",
+          msg: "Time Off Date Not Selected",
           toastLength: Toast.LENGTH_SHORT,
           gravity: ToastGravity.CENTER,
           timeInSecForIosWeb: 1,
       result = false;
     } else if (deskripsiTeksController.text.toString().isEmpty) {
       Fluttertoast.showToast(
-          msg: "Deskripsi Harus Diisi",
+          msg: "Description Required!",
           toastLength: Toast.LENGTH_SHORT,
           gravity: ToastGravity.CENTER,
           timeInSecForIosWeb: 1,

lib/Screens/Menu/AjukanCuti/history_cuti.dart

                           crossAxisAlignment: CrossAxisAlignment.end,
                           children: [
                             Text(
-                              'Riwayat Cuti\t\t',
+                              'Time Off History\t\t',
                               maxLines: 1,
                               style: GoogleFonts.luckiestGuy(
                                 fontSize: 28,
                                         children: [
                                           Text(type_cuti_List[i], style: GoogleFonts.rubikBubbles(fontSize: 16)),
                                           Text(start_date_List[i] + " - " + end_date_List[i] + " (" + duration_List[i] + ") ", style: GoogleFonts.nunito(fontSize: 15)),
-                                          Text("\nKeterangan : " + detail_List[i], style: GoogleFonts.nunito(fontSize: 15)),
+                                          Text("\nDescription : " + detail_List[i], style: GoogleFonts.nunito(fontSize: 15)),
                                           Text("\nCreated : " + created_on_List[i], style: GoogleFonts.yeonSung(fontSize: 14, fontStyle: FontStyle.italic)),
                                         ],
                                       ),

lib/Screens/Menu/AjukanCuti/model.dart

-class cuti_model{
-  late final String jenisCuti;
-  late final String dateFrom;
-  late final String dateTo;
-  late final String deskripsi;
-
-  cuti_model(this.jenisCuti, this.dateFrom, this.dateTo, this.deskripsi);
-
-}

lib/Screens/Menu/Reimburse/RequestHttp/categoryReimburse_post.dart

+import 'dart:convert';
+import 'dart:core';
+import 'package:http/http.dart' as http;
+import 'package:hris_selfservice_mobile/constants.dart';
+import 'dart:developer' as developer;
+
+import 'package:shared_preferences/shared_preferences.dart';
+
+class CategoryReimburse_Post {
+  late String session;
+
+  CategoryReimburse_Post({required this.session});
+
+  static Future<String> connectToAPI() async {
+    String URL = baseURL + "/api/v1/kategori_reimburse";
+
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final session = prefs.getString('session');
+
+    var sendData = await http.post(Uri.parse(URL), body: jsonEncode({
+      "data": [
+        {
+          "session": session
+        }
+      ]
+    }), headers: {
+      "Content-Type": "application/json",
+      "Api-key": apiKey
+    });
+
+    //developer.log(sendData.body, name: "Get Jenis Cuti Result");
+    return sendData.body;
+
+    /*var jsonObject = json.decode(sendData.body);
+    developer.log(jsonObject.toString(), name: 'Log');*/
+    // return jsonObject;
+    // return LoginPostResult.createPostResult(jsonObject);
+  }
+}

lib/Screens/Menu/Reimburse/RequestHttp/historyReimburse_post.dart

+import 'dart:convert';
+import 'dart:core';
+import 'package:http/http.dart' as http;
+import 'package:hris_selfservice_mobile/constants.dart';
+import 'dart:developer' as developer;
+
+import 'package:shared_preferences/shared_preferences.dart';
+
+class HistoryReimburse_Post {
+  late String session;
+
+  HistoryReimburse_Post({required this.session});
+
+  static Future<String> connectToAPI() async {
+    String URL = baseURL + "/api/v1/history_reimburse";
+
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final session = prefs.getString('session');
+
+    var sendData = await http.post(Uri.parse(URL), body: jsonEncode({
+      "data": [
+        {
+          "session": "2113213123211321123112123123"
+        }
+      ]
+    }), headers: {
+      "Content-Type": "application/json",
+      "Api-key": apiKey
+    });
+
+    developer.log(sendData.body, name: "Get History Reimburse Result");
+    return sendData.body;
+  }
+}

lib/Screens/Menu/Reimburse/RequestHttp/pengajuanReimburse_post.dart

+import 'dart:convert';
+import 'dart:core';
+import 'package:http/http.dart' as http;
+import 'package:hris_selfservice_mobile/constants.dart';
+import 'dart:developer' as developer;
+
+import 'package:shared_preferences/shared_preferences.dart';
+
+class PengajuanReimburse_Post {
+  late String name;
+  late String product;
+  late String date;
+  late String total;
+  late String payment_mode;
+  late String description;
+  late List<String> file;
+  late String session;
+
+  PengajuanReimburse_Post({required this.session});
+
+  static Future<String> connectToAPI(String name, String product, String date, String total, String payment_mode, String description) async {
+    String URL = baseURL + "/api/v1/pengajuan_reimburse";
+
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final session = prefs.getString('session');
+
+    var sendData = await http.post(Uri.parse(URL), body: jsonEncode({
+      "data": [
+        {
+          "name" : name,
+          "product" : product,
+          "date" : date,
+          "total" : total,
+          "payment_mode" : payment_mode,
+          "description" : description,
+          "session": session
+        }
+      ]
+    }), headers: {
+      "Content-Type": "application/json",
+      "Api-key": apiKey
+    });
+
+    //developer.log(sendData.body, name: "Get Jenis Cuti Result");
+    return sendData.body;
+  }
+}

lib/Screens/Menu/Reimburse/history_reimburse.dart

+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+import 'package:fluttertoast/fluttertoast.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:progress_dialog_null_safe/progress_dialog_null_safe.dart';
+import 'dart:developer' as logDev;
+
+import '../AjukanCuti/backgroundHistory.dart';
+import 'RequestHttp/historyReimburse_post.dart';
+
+class HistoryReimburse extends StatefulWidget {
+  const HistoryReimburse({Key? key}) : super(key: key);
+
+  @override
+  State<HistoryReimburse> createState() => _HistoryReimburse();
+}
+
+class _HistoryReimburse extends State<HistoryReimburse> {
+  late List <String> date_List;
+  late List <String> name_List;
+  late List <String> employee_List;
+  late List <String> payment_List;
+  late List <String> activity_List;
+  late List <String> total_List;
+  late List <String> status_List;
+
+  late List <Color> statusColor;
+  late List <bool> visible;
+
+  int HistoryLength = 0;
+
+  @override
+  initState() {
+    super.initState();
+    date_List = [""];
+    name_List = [""];
+    employee_List = [""];
+    payment_List = [""];
+    activity_List = [""];
+    total_List = [""];
+    status_List = [""];
+
+    statusColor = [Colors.black54];
+    visible = [false];
+
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      getHistoryData();
+    });
+    logDev.log(HistoryLength.toString(), name: "Banyak History");
+  }
+
+  getHistoryData() async {
+    ProgressDialog loading = ProgressDialog(context);
+    loading = ProgressDialog(context,
+        type: ProgressDialogType.normal, isDismissible: false, showLogs: true);
+    loading.style(
+        message: 'Please Wait .....',
+        borderRadius: 3,
+        backgroundColor: Colors.white,
+        progressWidget: CircularProgressIndicator(),
+        elevation: 10.0,
+        padding: EdgeInsets.all(10),
+        insetAnimCurve: Curves.easeInOut,
+        progress: 0.0,
+        maxProgress: 100.0,
+        progressTextStyle: TextStyle(
+            color: Colors.black, fontSize: 10.0, fontWeight: FontWeight.w400),
+        messageTextStyle: TextStyle(
+            color: Colors.black, fontSize: 15.0, fontWeight: FontWeight.w600));
+
+    loading.show();
+    HistoryReimburse_Post.connectToAPI().then((valueResult) async {
+      Map<String, dynamic> object = jsonDecode(valueResult);
+      if (object.containsKey("result").toString() == "true") {
+        String result = object['result'].toString();
+        if (result.contains("failed")) {
+          loading.hide();
+          alertDialogFailedRetrievedData(context);
+        } else {
+          List <dynamic> historyReimburse = object['result'];
+          setState(() {
+            for (int i = 0; i < historyReimburse.length; i++){
+              String date = historyReimburse[i]['date'].toString();
+              String name = historyReimburse[i]['name'].toString();
+              String employee = historyReimburse[i]['employee'].toString();
+              String payment = historyReimburse[i]['payment'].toString();
+              String activity = historyReimburse[i]['activity'].toString();
+              String total = historyReimburse[i]['total'].toString();
+              String status = historyReimburse[i]['status'].toString();
+
+              /*if (detail == "false"){
+                detail = "-";
+              }*/
+
+              date_List.add(date);
+              name_List.add(name);
+              employee_List.add(employee);
+              payment_List.add(payment);
+              activity_List.add(activity);
+              total_List.add(total);
+              status_List.add(status);
+              visible.add(false);
+
+              var statColor;
+              if (status == "draft"){
+                statColor = Colors.red;
+              } else if (status == "approved"){
+                statColor = Colors.green;
+              } else if (status == "done"){
+                statColor = Colors.blueAccent;
+              }
+              statusColor.add(statColor);
+            }
+
+            date_List.removeAt(0);
+            name_List.removeAt(0);
+            employee_List.removeAt(0);
+            payment_List.removeAt(0);
+            activity_List.removeAt(0);
+            total_List.removeAt(0);
+            status_List.removeAt(0);
+            statusColor.removeAt(0);
+            visible.removeAt(0);
+
+            HistoryLength = historyReimburse.length;
+          });
+          loading.hide();
+        }
+      } else {
+        Fluttertoast.showToast(
+            msg: "Server Response Error",
+            toastLength: Toast.LENGTH_SHORT,
+            gravity: ToastGravity.CENTER,
+            timeInSecForIosWeb: 1,
+            textColor: Colors.white,
+            fontSize: 16.0);
+      }
+    });
+    loading.hide();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    var size = MediaQuery.of(context).size;
+    return Scaffold(
+      body: Stack(
+          children: [
+            Column(
+              children: <Widget>[
+                Stack(
+                  children: [
+                    WavyHeader(),
+                    Container(
+                        margin: EdgeInsets.only(
+                            top: (size.height / 6) - 20),
+                        padding: EdgeInsets.fromLTRB(0, 5, 25, 5),
+                        child: Row(
+                          mainAxisAlignment: MainAxisAlignment.end,
+                          crossAxisAlignment: CrossAxisAlignment.end,
+                          children: [
+                            Text(
+                              'Reimburse History\t\t',
+                              maxLines: 1,
+                              style: GoogleFonts.luckiestGuy(
+                                fontSize: 28,
+                                color: Colors.red,
+                                fontStyle: FontStyle.italic,
+                              ),
+                            ),
+                            Image.asset(
+                              'assets/images/ic_history.png',
+                              width: 40,
+                              height: 40,
+                            ),
+                          ],
+                        )
+                    ),
+                  ],
+                ),
+              ],
+            ),
+            Container(
+              margin: EdgeInsets.only(top: (MediaQuery.of(context).size.height / 6) + 40, left: 5, right: 5, bottom: 10),
+              child: ListView.builder(
+                scrollDirection: Axis.vertical,
+                shrinkWrap: true,
+                itemCount: HistoryLength,
+                itemBuilder: (context, int i) {
+                  return Container(
+                    child: InkWell(
+                      child: Card(
+                        elevation: 10,
+                        child: Column(
+                          children: [
+                            Row(
+                              children: [
+                                Expanded(
+                                    flex: 8,
+                                    child: Padding(
+                                      padding: EdgeInsets.fromLTRB(10, 5, 5, 5),
+                                      child: Column(
+                                        mainAxisAlignment: MainAxisAlignment.center,
+                                        crossAxisAlignment: CrossAxisAlignment.start,
+                                        children: [
+                                          Text(name_List[i], style: GoogleFonts.rubikBubbles(fontSize: 16)),
+                                          Text(activity_List[i], style: GoogleFonts.nunito(fontSize: 15)),
+                                          Text(date_List[i], style: GoogleFonts.nunito(fontSize: 15)),
+                                          Text("\Total : " + total_List[i], style: GoogleFonts.nunito(fontSize: 15)),
+                                          Text("Payment : " + payment_List[i], style: GoogleFonts.yeonSung(fontSize: 14, fontStyle: FontStyle.italic)),
+                                        ],
+                                      ),
+                                    )
+                                ),
+                                Expanded(
+                                    flex: 2,
+                                    child: Padding(
+                                      padding: EdgeInsets.fromLTRB(5, 5, 5, 5),
+                                      child: Text(status_List[i], style: GoogleFonts.lilitaOne(color: statusColor[i], fontSize: 17),
+                                      ),
+                                    )
+                                ),
+                              ],
+                            ),
+                            Align(
+                              alignment: Alignment.centerLeft,
+                              child: Visibility(
+                                  visible: visible[i],
+                                  child: Padding(
+                                    padding: EdgeInsets.fromLTRB(10, 5, 5, 5),
+                                    child: Column(
+                                      mainAxisAlignment: MainAxisAlignment.start,
+                                      crossAxisAlignment: CrossAxisAlignment.start,
+                                      children: [
+                                        Text("\nAttachment : ", style: GoogleFonts.josefinSans(fontSize: 15, fontWeight: FontWeight.bold)),
+                                        Text("\Total : " + total_List[i], style: GoogleFonts.nunito(fontSize: 15)),
+                                        Text("Payment : " + payment_List[i], style: GoogleFonts.yeonSung(fontSize: 14, fontStyle: FontStyle.italic)),
+                                      ],
+                                    ),
+                                  )
+                              ),
+                            )
+                          ],
+                        ),
+                      ),
+                      onTap: (){
+                        setState(() {
+                          visible[i] = !visible[i];
+                        });
+                      },
+                    ),
+                  );
+                },
+              ),
+            )
+          ]),
+    );
+  }
+}
+
+alertDialogFailedRetrievedData(BuildContext context) {
+  Widget okButton = TextButton(
+    child: Text("Refresh"),
+    onPressed: () {
+      Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pushReplacement(
+          context, MaterialPageRoute(builder: (context) => HistoryReimburse()));
+    },
+  );
+
+  Widget noButton = TextButton(
+    child: Text("Back"),
+    onPressed: () {
+      Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pop(context);
+    },
+  );
+
+  // set up the AlertDialog
+  AlertDialog alert = AlertDialog(
+    title: Text("Employee Self Service"),
+    content: Text("Failed to Retrieve Data"),
+    actions: [
+      noButton,
+      okButton,
+    ],
+  );
+
+  // show the dialog
+  showDialog(
+    context: context,
+    builder: (BuildContext context) {
+      return alert;
+    },
+  );
+}

lib/Screens/Menu/SlipGaji/slipgaji_screen.dart

                   crossAxisAlignment: CrossAxisAlignment.end,
                   children: [
                     Text(
-                      'Slip Gaji\t\t',
+                      'Salary Slip\t\t',
                       maxLines: 1,
                       style: GoogleFonts.luckiestGuy(
                         fontSize: 28,
                     Visibility(
                       visible: visible,
                       child: Text(
-                        'Detail Slip Gaji Bulan ' + selectedDate.toString(),
+                        'Salary Slip ' + selectedDate.toString(),
                         style: GoogleFonts.viga(
                           fontSize: 15,
                           fontWeight: FontWeight.bold,

lib/Screens/Menu/SuratTugas/pengajuan_st.dart

+import 'dart:convert';
+import 'dart:io';
+import 'package:file_picker/file_picker.dart';
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:fluttertoast/fluttertoast.dart';
+import 'package:google_fonts/google_fonts.dart';
+import 'package:hris_selfservice_mobile/Screens/Menu/AjukanCuti/RequestHttp/jenisCuti_post.dart';
+import 'package:intl/intl.dart';
+import 'package:progress_dialog_null_safe/progress_dialog_null_safe.dart';
+
+import 'dart:developer' as logDev;
+import '../AjukanCuti/RequestHttp/pengajuanCuti_post.dart';
+import '../SlipGaji/background.dart';
+
+List<String> fileAttach = [""];
+TextEditingController deskripsiTeksController = TextEditingController();
+
+
+class PengajuanST_Screen extends StatefulWidget {
+  const PengajuanST_Screen({Key? key}) : super(key: key);
+
+  @override
+  State<PengajuanST_Screen> createState() => _PengajuanST_Screen_State();
+}
+
+class _PengajuanST_Screen_State extends State<PengajuanST_Screen> {
+  var selectedType;
+
+  String _fileText = "";
+  String _totalFile= "";
+
+  bool visibleDateFrom = false;
+  bool visibleDateTo = false;
+
+  late List <String> idCutiType;
+  late List <String> cutiType;
+
+  DateTime dateFrom = DateTime.now();
+
+  late String formattedDateFrom = "";
+  late String idCuti;
+
+  var selectedCategory;
+  var selectedDate;
+
+  int _value = 0;
+
+  initState(){
+    deskripsiTeksController.clear();
+    cutiType = [""];
+    idCutiType = [""];
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      cutiType = getJenisCuti();
+    });
+    super.initState();
+  }
+
+  getJenisCuti () {
+    ProgressDialog loading = ProgressDialog(context);
+    loading = ProgressDialog(context,
+        type: ProgressDialogType.normal, isDismissible: false, showLogs: true);
+    loading.style(
+        message: 'Please Wait .....',
+        borderRadius: 3,
+        backgroundColor: Colors.white,
+        progressWidget: CircularProgressIndicator(),
+        elevation: 10.0,
+        padding: EdgeInsets.all(10),
+        insetAnimCurve: Curves.easeInOut,
+        progress: 0.0,
+        maxProgress: 100.0,
+        progressTextStyle: TextStyle(
+            color: Colors.black, fontSize: 10.0, fontWeight: FontWeight.w400),
+        messageTextStyle: TextStyle(
+            color: Colors.black, fontSize: 15.0, fontWeight: FontWeight.w600));
+
+    loading.show();
+    JenisCuti_Post.connectToAPI().then((valueResult) async {
+      Map<String, dynamic> object = json.decode(valueResult);
+      if (object.containsKey("result").toString() == "true"){
+        String result = object['result'].toString();
+        logDev.log(result, name: "Jenis Cuti Result");
+        if (result.contains("Failed")) {
+          loading.hide();
+          setState(() {
+            cutiType = [""];
+            alertDialogFailedRetrievedData(context);
+          });
+        } else {
+          List <dynamic> jenis = object['result']['jenis'];
+          setState(() {
+            idCutiType.removeAt(0);
+            cutiType.removeAt(0);
+            for (int i = 0; i < jenis.length; i++){
+              String id = jenis[i]['id'].toString();
+              String text = jenis[i]['text'].toString();
+              idCutiType.add(id);
+              cutiType.add(text);
+            }
+          });
+          loading.hide();
+        }
+      } else {
+        setState((){
+          cutiType = [""];
+          alertDialogFailedResponse(context);
+          /*Fluttertoast.showToast(
+              msg: "Server Response Error",
+              toastLength: Toast.LENGTH_SHORT,
+              gravity: ToastGravity.CENTER,
+              timeInSecForIosWeb: 1,
+              textColor: Colors.white,
+              fontSize: 16.0);*/
+        });
+        loading.hide();
+      }
+    });
+    return cutiType;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: SingleChildScrollView(
+          child: Column(
+            children: <Widget>[
+              Stack(
+                children: [
+                  WavyHeader(),
+                  Container(
+                      margin: EdgeInsets.only(top: 90),
+                      padding: EdgeInsets.fromLTRB(20, 5, 25, 5),
+                      child: Row(
+                        mainAxisAlignment: MainAxisAlignment.end,
+                        crossAxisAlignment: CrossAxisAlignment.end,
+                        children: [
+                          Text(
+                            'Submission\t\t',
+                            maxLines: 2,
+                            style: GoogleFonts.luckiestGuy(
+                              fontSize: 28,
+                              color: Colors.red,
+                              fontStyle: FontStyle.italic,
+                            ),
+                          ),
+                          Image.asset('assets/images/submit_st.png',
+                            width: 40,
+                            height: 40,
+                          ),
+                        ],
+                      )),
+                  SafeArea(
+                    child: Container(
+                      width: MediaQuery.of(context).size.width,
+                      margin: EdgeInsets.only(
+                        top: MediaQuery.of(context).size.height / 5,
+                        left: 10,
+                        right: 10,
+                      ),
+                      child: Column(
+                        children: [
+                          Container(
+                        child: Card(
+                          elevation: 10,
+                          child: Container(
+                            decoration: BoxDecoration(
+                                color: Color(0XFFFAF7EE),
+                                borderRadius: BorderRadius.circular(10)),
+                            child: Column(
+                              children: [
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Row(
+                                    children: [
+                                      Expanded(
+                                          flex: 3,
+                                          child: Text(
+                                            'Category',
+                                            style: GoogleFonts.inconsolata(
+                                                fontSize: 17),
+                                          )),
+                                      Expanded(
+                                          flex: 7,
+                                          child: Container(
+                                            decoration: BoxDecoration(
+                                                color:
+                                                    CupertinoColors.systemGrey2,
+                                                borderRadius:
+                                                    BorderRadius.circular(5)),
+                                            child: DropdownButton(
+                                              value: this.selectedCategory,
+                                              isExpanded: true,
+                                              underline: SizedBox(),
+                                              hint: Text(
+                                                '\t\tChoose Category',
+                                                style: TextStyle(
+                                                    color: Colors.black54),
+                                              ),
+                                              onChanged: (value) {
+                                                print(value);
+                                                setState(() {
+                                                  selectedCategory = value!;
+                                                });
+                                              },
+                                              items: reimburseCategory
+                                                  .map(
+                                                    (e) => DropdownMenuItem(
+                                                        value: e,
+                                                        child:
+                                                            Text("\t\t\t" + e)),
+                                                  )
+                                                  .toList(),
+                                            ),
+                                          )),
+                                    ],
+                                  ),
+                                ),
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Column(
+                                    children: [
+                                      Row(
+                                        children: [
+                                          Expanded(
+                                              flex: 3,
+                                              child: Text(
+                                                'Date',
+                                                style: GoogleFonts.inconsolata(
+                                                    fontSize: 17),
+                                              )),
+                                          Expanded(
+                                              flex: 7,
+                                              child: Column(
+                                                children: [
+                                                  ElevatedButton(
+                                                    onPressed: () async {
+                                                      DateTime? newDate =
+                                                      await showDatePicker(
+                                                          context: context,
+                                                          initialDate: dateFrom,
+                                                          firstDate:
+                                                          DateTime(1900),
+                                                          lastDate:
+                                                          DateTime(2100));
+                                                      final DateFormat formatter = DateFormat('yyyy-MM-dd');
+                                                      if (newDate == null) {
+                                                        return;
+                                                      } else {
+                                                        setState(() {
+                                                          if (visibleDateFrom == false){
+                                                            visibleDateFrom = !visibleDateFrom;
+                                                          }
+                                                          formattedDateFrom = formatter.format(newDate);
+                                                          //dateFrom = formattedFrom as DateTime;
+                                                        });
+                                                      }
+                                                    },
+                                                    /*style: ElevatedButton.styleFrom(
+                                                  backgroundColor:
+                                                      CupertinoColors
+                                                          .systemGrey2),*/
+                                                    child: Container(
+                                                      width: double.infinity,
+                                                      child: Text(
+                                                        "Choose Date",
+                                                        style: TextStyle(
+                                                            color: Colors.white,
+                                                            fontSize: 16,
+                                                            fontWeight:
+                                                            FontWeight.w400),
+                                                      ),
+                                                    ),
+                                                  ),
+                                                ],
+                                              ),
+                                          ),
+                                        ],
+                                      ),Row(
+                                        children: [
+                                          Expanded(
+                                              flex: 3,
+                                              child: Text(
+                                                '',
+                                                style: GoogleFonts.inconsolata(
+                                                    fontSize: 17),
+                                              )),
+                                          Expanded(
+                                            flex: 7,
+                                            child: Column(
+                                              children: [
+                                                Visibility(
+                                                  visible: visibleDateFrom,
+                                                  child: Container(
+                                                    alignment: Alignment.centerLeft,
+                                                    margin: EdgeInsets.only(
+                                                        left: 15,
+                                                        right: 15,
+                                                        bottom: 5),
+                                                    child: Text(formattedDateFrom,
+                                                      overflow:
+                                                      TextOverflow.ellipsis,
+                                                      maxLines: 1,
+                                                      style: TextStyle(
+                                                          color: Colors.black54),
+                                                    ),
+                                                  ),
+                                                )
+                                              ],
+                                            ),
+                                          ),
+                                        ],
+                                      ),
+                                    ],
+                                  ),
+                                ),
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Row(
+                                    children: [
+                                      Expanded(
+                                          flex: 3,
+                                          child: Text(
+                                            'Total Amount',
+                                            style: GoogleFonts.inconsolata(
+                                                fontSize: 17),
+                                          )),
+                                      Expanded(
+                                          flex: 7,
+                                          child: Container(
+                                              decoration: BoxDecoration(
+                                                  color: Colors.white,
+                                                  borderRadius:
+                                                      BorderRadius.circular(5)),
+                                              child: Padding(
+                                                padding: EdgeInsets.only(
+                                                    left: 10,
+                                                    right: 10,
+                                                    top: 5,
+                                                    bottom: 5),
+                                                child: TextFormField(
+                                                    keyboardType:
+                                                        TextInputType.number,
+                                                    maxLines: 1,
+                                                    textInputAction:
+                                                        TextInputAction.next,
+                                                    decoration: InputDecoration(
+                                                        border:
+                                                            InputBorder.none,
+                                                        hintText: "ex. 3000000")),
+                                              ))),
+                                    ],
+                                  ),
+                                ),
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Row(
+                                    children: [
+                                      Expanded(
+                                          flex: 3,
+                                          child: Text(
+                                            'Description',
+                                            style: GoogleFonts.inconsolata(
+                                                fontSize: 17),
+                                          )),
+                                      Expanded(
+                                          flex: 7,
+                                          child: Container(
+                                              decoration: BoxDecoration(
+                                                  color: Colors.white,
+                                                  borderRadius:
+                                                      BorderRadius.circular(5)),
+                                              child: Padding(
+                                                padding: EdgeInsets.only(
+                                                    left: 10,
+                                                    right: 10,
+                                                    top: 5,
+                                                    bottom: 5),
+                                                child: TextFormField(
+                                                    keyboardType:
+                                                        TextInputType.multiline,
+                                                    maxLines: null,
+                                                    textInputAction:
+                                                        TextInputAction.done,
+                                                    decoration: InputDecoration(
+                                                        border:
+                                                            InputBorder.none,
+                                                        hintText: "description")),
+                                              ))),
+                                    ],
+                                  ),
+                                ),
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Column(
+                                    children: [
+                                      Row(
+                                        children: [
+                                          Expanded(
+                                              flex: 3,
+                                              child: Text(
+                                                'Payment',
+                                                style: GoogleFonts.inconsolata(
+                                                    fontSize: 17),
+                                              )),
+                                          Expanded(
+                                              flex: 7,
+                                              child: Container(
+                                                child: Column(
+                                                  children: [
+                                                    Row(
+                                                      children: [
+                                                        Radio(
+                                                          value: 1,
+                                                          groupValue: _value,
+                                                          onChanged: (value) {
+                                                            setState(() {
+                                                              _value = value!;
+                                                            });
+                                                          },
+                                                        ),
+                                                        Flexible(
+                                                            child: Text(
+                                                                "Own (Need Reimburse)",
+                                                                style:
+                                                                    TextStyle(
+                                                                  color: Colors
+                                                                      .black54,
+                                                                ))),
+                                                      ],
+                                                    ),
+                                                    Row(
+                                                      children: [
+                                                        Radio(
+                                                          value: 2,
+                                                          groupValue: _value,
+                                                          onChanged: (value) {
+                                                            setState(() {
+                                                              _value = value!;
+                                                            });
+                                                          },
+                                                        ),
+                                                        Flexible(
+                                                            child: Text(
+                                                                "Company",
+                                                                style: TextStyle(
+                                                                    color: Colors
+                                                                        .black54)))
+                                                      ],
+                                                    ),
+                                                  ],
+                                                ),
+                                              )),
+                                        ],
+                                      ),
+                                    ],
+                                  ),
+                                ),
+                                Container(
+                                  margin: EdgeInsets.only(
+                                      left: 10, right: 10, top: 10, bottom: 10),
+                                  child: Column(
+                                    children: [
+                                      Row(
+                                        children: [
+                                          Expanded(
+                                            flex: 3,
+                                            child: Text(
+                                              'Attachment',
+                                              style: GoogleFonts.inconsolata(
+                                                  fontSize: 17),
+                                            ),
+                                          ),
+                                          Expanded(
+                                            flex: 7,
+                                            child: Container(
+                                              child: ElevatedButton(
+                                                onPressed: () {
+                                                  _pickMultipleFiles();
+                                                },
+                                                /*style: ElevatedButton.styleFrom(
+                                                    backgroundColor:
+                                                        CupertinoColors
+                                                            .systemGrey2),*/
+                                                child: Container(
+                                                  width: double.infinity,
+                                                  child: Text("Choose File",
+                                                      style: TextStyle(
+                                                          color: Colors.white,
+                                                          fontSize: 16,
+                                                          fontWeight:
+                                                          FontWeight.w400)),
+                                                ),
+                                              ),
+                                            ),
+                                          )
+                                        ],
+                                      ),
+                                      Row(
+                                        children: [
+                                          Expanded(
+                                            flex: 3,
+                                            child: Text(
+                                              '',
+                                              style: GoogleFonts.inconsolata(
+                                                  fontSize: 17),
+                                            ),
+                                          ),
+                                          Expanded(
+                                            flex: 7,
+                                            child:  Container(
+                                              alignment:
+                                              Alignment.centerLeft,
+                                              margin: EdgeInsets.only(
+                                                  left: 15,
+                                                  right: 15,
+                                                  bottom: 10),
+                                              child: Text(_totalFile + _fileText,
+                                                overflow:
+                                                TextOverflow.ellipsis,
+                                                /*maxLines: 7,*/
+                                                style: TextStyle(
+                                                    color: Colors.black54),
+                                              ),
+                                            ),
+                                          )
+                                        ],
+                                      ),
+                                      InkWell(
+                                        child: Container(
+                                          padding: EdgeInsets.fromLTRB(
+                                              10, 10, 10, 10),
+                                          width: double.infinity,
+                                          decoration: BoxDecoration(
+                                              borderRadius:
+                                              BorderRadius.circular(5),
+                                              gradient: LinearGradient(colors: [
+                                                Color(0xFFFF9945),
+                                                Color(0xFFFc6076)
+                                              ])),
+                                          child: Text('Submit',
+                                              textAlign: TextAlign.center,
+                                              style: TextStyle(
+                                                  color: Colors.white,
+                                                  fontSize: 17,
+                                                  fontWeight: FontWeight.w500)),
+                                        ),
+                                        onTap: () {
+                                          ProgressDialog loading = ProgressDialog(context);
+                                          loading = ProgressDialog(context,
+                                              type: ProgressDialogType.normal, isDismissible: false, showLogs: true);
+                                          loading.style(
+                                              message: 'Please Wait .....',
+                                              borderRadius: 3,
+                                              backgroundColor: Colors.white,
+                                              progressWidget: CircularProgressIndicator(),
+                                              elevation: 10.0,
+                                              padding: EdgeInsets.all(10),
+                                              insetAnimCurve: Curves.easeInOut,
+                                              progress: 0.0,
+                                              maxProgress: 100.0,
+                                              progressTextStyle: TextStyle(
+                                                  color: Colors.black, fontSize: 10.0, fontWeight: FontWeight.w400),
+                                              messageTextStyle: TextStyle(
+                                                  color: Colors.black, fontSize: 15.0, fontWeight: FontWeight.w600));
+
+                                          //loading.show();
+
+                                          if (!validateFormCuti(context)){
+                                            return;
+                                          } else if (validateFormCuti(context)){
+                                            /*loading.show();
+                                            PengajuanCuti_Post.connectToAPI(idCuti, formattedDateFrom,
+                                                formattedDateTo, deskripsiTeksController.text.toString(), fileAttach)
+                                                .then((valueResult) async {
+                                              Map<String, dynamic> object = json.decode(valueResult);
+                                              logDev.log(fileAttach.toString(), name: "Attachment File Upload");
+                                              if (object.containsKey("result").toString() == "true") {
+                                                *//*String employee = object['result']['employee'].toString();
+                                              String tipe = object['result']['tipe'].toString();
+                                              String from = object['result']['from'].toString();
+                                              String to = object['result']['to'].toString();
+                                              String deskripsi = object['result']['deskripsi'].toString();
+                                              String attachment = object['result']['attachment'].toString();*//*
+                                                loading.hide();
+                                                deskripsiTeksController.clear();
+                                                Widget okButton = TextButton(
+                                                  child: Text("OK"),
+                                                  onPressed: () {
+                                                    Navigator.of(context, rootNavigator: true).pop();
+                                                    Navigator.pushReplacement(context, MaterialPageRoute(
+                                                        builder: (context) => AjukanCutiScreen()));
+                                                  },
+                                                );
+
+                                                // set up the AlertDialog
+                                                AlertDialog alert = AlertDialog(
+                                                  title: Text("Employee Self Service"),
+                                                  content: Text("Berhasil Mengajukan Cuti"),
+                                                  actions: [
+                                                    okButton,
+                                                  ],
+                                                );
+
+                                                // show the dialog
+                                                showDialog(
+                                                  context: context,
+                                                  builder: (BuildContext context) {
+                                                    return alert;
+                                                  },
+                                                );
+                                                *//* deskripsiTeksController.clear();
+                                                formattedDateFrom = "";
+                                                formattedDateTo = "";
+                                                visibleDateFrom = false;
+                                                visibleDateFrom = false;*//*
+                                              } else if (object.containsKey("error").toString() == "true") {
+                                                String errorMessage = object['error']['data']['message']
+                                                    .toString();
+                                                loading.hide();
+                                                Widget okButton = TextButton(
+                                                  child: Text("OK"),
+                                                  onPressed: () {
+                                                    Navigator.of(context, rootNavigator: true).pop();
+                                                  },
+                                                );
+
+                                                // set up the AlertDialog
+                                                AlertDialog alert = AlertDialog(
+                                                  title: Text("Employee Self Service"),
+                                                  content: Text(errorMessage),
+                                                  actions: [
+                                                    okButton,
+                                                  ],
+                                                );
+
+                                                // show the dialog
+                                                showDialog(
+                                                  context: context,
+                                                  builder: (BuildContext context) {
+                                                    return alert;
+                                                  },
+                                                );
+                                              }
+                                            });*/
+                                          }
+                                        },
+                                      )
+                                    ],
+                                  ),
+                                ),
+                              ],
+                            ),
+                          ),
+                        ),
+                      ),
+                        ],
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ],
+          )),
+    );
+  }
+
+  void _pickMultipleFiles() async {
+    FilePickerResult? result = await FilePicker.platform.pickFiles(allowMultiple: true);
+
+    if (_fileText != ""){
+      _fileText = "";
+    }
+
+    if (result != null) {
+      List<File> files = result.paths.map((path) => File(path!)).toList();
+      for (int i = 0; i< files.length; i++){
+        String fileName = files[i].path.split('/').last;
+        _fileText = _fileText + "\n" + fileName;
+
+        List<int> fileInBytes = files[i].readAsBytesSync();
+        String toBase64 = base64Encode(fileInBytes);
+        fileAttach.add(toBase64);
+      }
+      fileAttach.removeAt(0);
+      /*logDev.log(fileAttach.toString(), name: "File Attach Base64");*/
+      logDev.log(fileAttach.length.toString(), name: "Length File Attach");
+      logDev.log(files.toString(), name: "Files Picked");
+
+      setState(() {
+        _fileText;
+        _totalFile = "Total File : " + files.length.toString();
+      });
+    } else {
+      // User canceled the picker
+    }
+  }
+
+  bool validateFormCuti(BuildContext context) {
+    bool result = true;
+    if (selectedType == null) {
+      Fluttertoast.showToast(
+          msg: "Tipe Cuti Belum Dipilih",
+          toastLength: Toast.LENGTH_SHORT,
+          gravity: ToastGravity.CENTER,
+          timeInSecForIosWeb: 1,
+          textColor: Colors.white,
+          fontSize: 16.0);
+      result = false;
+    } else if (deskripsiTeksController.text.toString().isEmpty) {
+      Fluttertoast.showToast(
+          msg: "Deskripsi Harus Diisi",
+          toastLength: Toast.LENGTH_SHORT,
+          gravity: ToastGravity.CENTER,
+          timeInSecForIosWeb: 1,
+          textColor: Colors.white,
+          fontSize: 16.0);
+      result = false;
+    }
+
+    return result;
+  }
+}
+
+alertDialogFailedRetrievedData(BuildContext context){
+  Widget okButton = TextButton(
+    child: Text("Refresh"),
+    onPressed: () {
+      /*Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pushReplacement(context, MaterialPageRoute(
+          builder: (context) => AjukanCutiScreen()));*/
+    },
+  );
+
+  Widget noButton = TextButton(
+    child: Text("Back"),
+    onPressed: () {
+      Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pop(context);
+
+    },
+  );
+
+  // set up the AlertDialog
+  AlertDialog alert = AlertDialog(
+    title: Text("Employee Self Service"),
+    content: Text("Failed to Retrieve Data"),
+    actions: [
+      noButton,
+      okButton,
+    ],
+  );
+
+  // show the dialog
+  showDialog(
+    context: context,
+    builder: (BuildContext context) {
+      return alert;
+    },
+  );
+}
+
+alertDialogFailedResponse(BuildContext context){
+  Widget okButton = TextButton(
+    child: Text("Refresh"),
+    onPressed: () {
+     /* Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pushReplacement(context, MaterialPageRoute(
+          builder: (context) => AjukanCutiScreen()));*/
+    },
+  );
+
+  Widget noButton = TextButton(
+    child: Text("Back"),
+    onPressed: () {
+      Navigator.of(context, rootNavigator: true).pop();
+      Navigator.pop(context);
+
+    },
+  );
+
+  // set up the AlertDialog
+  AlertDialog alert = AlertDialog(
+    title: Text("Employee Self Service"),
+    content: Text("Server Response Error"),
+    actions: [
+      noButton,
+      okButton,
+    ],
+  );
+
+  // show the dialog
+  showDialog(
+    context: context,
+    builder: (BuildContext context) {
+      return alert;
+    },
+  );
+}
+
+List<String> reimburseCategory = [
+  "Paid Time Off",
+  "Sick Time Off",
+  "Compensatory Days",
+  "Unpaid"
+];

lib/Screens/Menu/SuratTugas/surattugas_screen.dart

 import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:google_fonts/google_fonts.dart';
+import 'package:hris_selfservice_mobile/Screens/Menu/SuratTugas/pengajuan_st.dart';
 
 import '../SlipGaji/background.dart';
 
                     crossAxisAlignment: CrossAxisAlignment.end,
                     children: [
                       Text(
-                        'Surat Tugas\t\t',
-                        maxLines: 1,
+                        'Assignment\nLetter\t\t',
                         style: GoogleFonts.luckiestGuy(
                           fontSize: 28,
                           color: Colors.red,
                     children: [
                       InkWell(
                         child: Container(
-                            margin: EdgeInsets.only(top: 15, bottom: 15),
+                            margin: EdgeInsets.fromLTRB(15, 15, 15, 5),
                             padding: EdgeInsets.fromLTRB(10, 10, 10, 10),
                             width: double.infinity,
                             decoration: BoxDecoration(
                               mainAxisAlignment: MainAxisAlignment.center,
                               children: [
                                 Flexible(
-                                    child: Text('Lihat Riwayat Surat Tugas\t\t',
+                                    child: Text('Assignment Letter Submission\t\t',
                                         textAlign: TextAlign.center,
                                         style: TextStyle(
                                             color: Colors.white,
                                             fontSize: 17,
                                             fontWeight: FontWeight.w500))),
-                                Image.asset(
-                                  'assets/images/ic_history.png',
+                                Image.asset('assets/images/submit_st.png',
+                                  width: 30,
+                                  height: 30,
+                                )
+                              ],
+                            )),
+                        onTap: () {
+                          Navigator.push(
+                              context,
+                              MaterialPageRoute(
+                                  builder: (context) => PengajuanST_Screen()));
+                        },
+                      ),
+                      InkWell(
+                        child: Container(
+                            margin: EdgeInsets.fromLTRB(15, 5, 15, 5),
+                            padding: EdgeInsets.fromLTRB(10, 10, 10, 10),
+                            width: double.infinity,
+                            decoration: BoxDecoration(
+                                borderRadius: BorderRadius.circular(5),
+                                gradient: LinearGradient(colors: [
+                                  Color(0xFF2D4059),
+                                  Color(0xFF2D4059),
+                                  /*Color(0xFFEAFFD0),
+                                  Color(0xFF95E1D3),*/
+                                ])),
+                            child: Row(
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: [
+                                Flexible(
+                                    child: Text('Declaration of Assignment Letter\t\t',
+                                        textAlign: TextAlign.center,
+                                        style: TextStyle(
+                                            color: Colors.white,
+                                            fontSize: 17,
+                                            fontWeight: FontWeight.w500))),
+                                Image.asset('assets/images/declaration.png',
+                                  width: 30,
+                                  height: 30,
+                                )
+                              ],
+                            )),
+                        onTap: () {},
+                      ),
+                      InkWell(
+                        child: Container(
+                            margin: EdgeInsets.fromLTRB(15, 5, 15, 5),
+                            padding: EdgeInsets.fromLTRB(10, 10, 10, 10),
+                            width: double.infinity,
+                            decoration: BoxDecoration(
+                                borderRadius: BorderRadius.circular(5),
+                                gradient: LinearGradient(colors: [
+                                  Color(0xFF2D4059),
+                                  Color(0xFF2D4059),
+                                  /*Color(0xFFEAFFD0),
+                                  Color(0xFF95E1D3),*/
+                                ])),
+                            child: Row(
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: [
+                                Flexible(
+                                    child: Text('See Assignment Letter History\t\t',
+                                        textAlign: TextAlign.center,
+                                        style: TextStyle(
+                                            color: Colors.white,
+                                            fontSize: 17,
+                                            fontWeight: FontWeight.w500))),
+                                Image.asset('assets/images/ic_history.png',
                                   width: 30,
                                   height: 30,
                                 )
                             )),
                         onTap: () {},
                       ),
-                      Container(
+                      InkWell(
+                        child: Container(
+                            margin: EdgeInsets.fromLTRB(15, 5, 15, 5),
+                            padding: EdgeInsets.fromLTRB(10, 10, 10, 10),
+                            width: double.infinity,
+                            decoration: BoxDecoration(
+                                borderRadius: BorderRadius.circular(5),
+                                gradient: LinearGradient(colors: [
+                                  Color(0xFF2D4059),
+                                  Color(0xFF2D4059),
+                                  /*Color(0xFFEAFFD0),
+                                  Color(0xFF95E1D3),*/
+                                ])),
+                            child: Row(
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: [
+                                Flexible(
+                                    child: Text('Additional Advance Payment\t\t',
+                                        textAlign: TextAlign.center,
+                                        style: TextStyle(
+                                            color: Colors.white,
+                                            fontSize: 17,
+                                            fontWeight: FontWeight.w500))),
+                                Image.asset('assets/images/extra_money.png',
+                                  width: 30,
+                                  height: 30,
+                                )
+                              ],
+                            )),
+                        onTap: () {},
+                      ),
+                      InkWell(
+                        child: Container(
+                            margin: EdgeInsets.fromLTRB(15, 5, 15, 5),
+                            padding: EdgeInsets.fromLTRB(10, 10, 10, 10),
+                            width: double.infinity,
+                            decoration: BoxDecoration(
+                                borderRadius: BorderRadius.circular(5),
+                                gradient: LinearGradient(colors: [
+                                  Color(0xFF2D4059),
+                                  Color(0xFF2D4059),
+                                  /*Color(0xFFEAFFD0),
+                                  Color(0xFF95E1D3),*/
+                                ])),
+                            child: Row(
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: [
+                                Flexible(
+                                    child: Text('Return Date Extension\t\t',
+                                        textAlign: TextAlign.center,
+                                        style: TextStyle(
+                                            color: Colors.white,
+                                            fontSize: 17,
+                                            fontWeight: FontWeight.w500))),
+                                Image.asset('assets/images/extend_tanggal.png',
+                                  width: 30,
+                                  height: 30,
+                                )
+                              ],
+                            )),
+                        onTap: () {}
+                      ),
+                      /*Container(
                         child: Card(
                           elevation: 10,
                           child: Container(
                             ),
                           ),
                         ),
-                      ),
+                      ),*/
                     ],
                   ),
                 ),

lib/Screens/Settings/settings_screen.dart

               fontSize: 15.0,
               fontWeight: FontWeight.w600));
       loading.show();
-      logDev.log(getProfileImage().toString(), name: "APA ISINYA");
       _imageToShow = getProfileImage();
     });
   }
                             ChangeProfileImage_Post.connectToAPI(
                                     session!, base64Image)
                                 .then((valueResult) async {
-                              logDev.log(valueResult, name: "HASIL CHANGE");
                               Map<String, dynamic> object =
                                   json.decode(valueResult);
-                              if (object.containsKey("result").toString() ==
-                                  "true") {
-                                String status =
-                                    object['result']['status'].toString();
-                                String message =
-                                    object['result']['message'].toString();
+                              if (object.containsKey("result").toString() == "true") {
+                                String status = object['result']['status'].toString();
+                                String message = object['result']['message'].toString();
                                 if (status == "success") {
                                   _imageToShow =
                                       FileImage(File(imagePicked.path));
                               setState(() {});
                             });
                           } else if (imagePicked == null) {
-                            logDev.log("NULL", name: "NO IMAGE SELECTED");
                             //_imagePath = await getImageFileFromAssets('assets/images/ic_administrator.png') as File?;
                           }
                         },
                               Padding(
                                 padding: EdgeInsets.only(bottom: 5),
                                 child: Text(
-                                  "Nama Pegawai",
+                                  "Name",
                                   style: TextStyle(
                                       fontSize: 16, color: Colors.black87),
                                 ),
                               Padding(
                                 padding: EdgeInsets.only(bottom: 5),
                                 child: Text(
-                                  "Tanggal Lahir",
+                                  "Date of Birth",
                                   style: TextStyle(
                                       fontSize: 16, color: Colors.black87),
                                 ),
                               Padding(
                                 padding: EdgeInsets.only(bottom: 5),
                                 child: Text(
-                                  "Nomor Telepon",
+                                  "Phone Number",
                                   style: TextStyle(
                                       fontSize: 16, color: Colors.black87),
                                 ),
                               Padding(
                                 padding: EdgeInsets.only(bottom: 5),
                                 child: Text(
-                                  "Alamat Email",
+                                  "Email Address",
                                   style: TextStyle(
                                       fontSize: 16, color: Colors.black87),
                                 ),
                               Padding(
                                 padding: EdgeInsets.only(bottom: 5),
                                 child: Text(
-                                  "Alamat Rumah",
+                                  "Address",
                                   style: TextStyle(
                                       fontSize: 16, color: Colors.black87),
                                 ),
                   borderRadius:
                       BorderRadius.all(Radius.circular(radiusCircular))),
               color: Colors.blueGrey,
-              /*gradient: LinearGradient(
-                  colors: gradient,
-                  begin: Alignment.topLeft,
-                  end: Alignment.bottomRight),*/
             ),
             child: Padding(
               padding: EdgeInsets.fromLTRB(3, 3, 3, 3),
             retypeNewPasswordController.clear();
 
             final session = await prefs.remove('session');
-            logDev.log(session.toString(), name: "SESSION KEHAPUS GAAAA?");
             await loading.hide();
             Navigator.of(context, rootNavigator: true).pop();
             Navigator.pushReplacement(
           String status = object['result']['status'].toString();
           if (status == "success") {
             final session = await prefs.remove('session');
-            logDev.log(session.toString(), name: "SESSION KEHAPUS GA?");
             Navigator.of(context, rootNavigator: true).pop();
             await loading.hide();
             Navigator.pushAndRemoveUntil(
   // set up the AlertDialog
   AlertDialog alert = AlertDialog(
     title: Text("Employee Self Service"),
-    //content: Text("Are you sure you want to logout from this Application?"),
-    content: Text("Apakah Anda yakin ingin keluar dari aplikasi ini?"),
+    content: Text("Are you sure you want to logout from this Application?"),
+    //content: Text("Apakah Anda yakin ingin keluar dari aplikasi ini?"),
     actions: [noButton, okButton],
   );
 

macos/Flutter/GeneratedPluginRegistrant.swift

 import FlutterMacOS
 import Foundation
 
+import connectivity_plus
 import device_info_plus
 import firebase_core
 import firebase_messaging
 import url_launcher_macos
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
+  ConnectivityPlugin.register(with: registry.registrar(forPlugin: "ConnectivityPlugin"))
   DeviceInfoPlusMacosPlugin.register(with: registry.registrar(forPlugin: "DeviceInfoPlusMacosPlugin"))
   FLTFirebaseCorePlugin.register(with: registry.registrar(forPlugin: "FLTFirebaseCorePlugin"))
   FLTFirebaseMessagingPlugin.register(with: registry.registrar(forPlugin: "FLTFirebaseMessagingPlugin"))

node_modules/.bin/firebase

+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../firebase-tools/lib/bin/firebase.js" "$@"
+else 
+  exec node  "$basedir/../firebase-tools/lib/bin/firebase.js" "$@"
+fi

node_modules/.bin/firebase.cmd

+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\firebase-tools\lib\bin\firebase.js" %*

node_modules/.bin/firebase.ps1

+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../firebase-tools/lib/bin/firebase.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../firebase-tools/lib/bin/firebase.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../firebase-tools/lib/bin/firebase.js" $args
+  } else {
+    & "node$exe"  "$basedir/../firebase-tools/lib/bin/firebase.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/firebase-tools/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2015 Firebase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/firebase-tools/README.md

+# Firebase CLI [![Actions Status][gh-actions-badge]][gh-actions] [![Node Version][node-badge]][npm] [![NPM version][npm-badge]][npm]
+
+The Firebase Command Line Interface (CLI) Tools can be used to test, manage, and deploy your Firebase project from the command line.
+
+- Deploy code and assets to your Firebase projects
+- Run a local web server for your Firebase Hosting site
+- Interact with data in your Firebase database
+- Import/Export users into/from Firebase Auth
+
+To get started with the Firebase CLI, read the full list of commands below or check out the [documentation](https://firebase.google.com/docs/cli).
+
+## Installation
+
+### Node Package
+
+You can install the Firebase CLI using npm (the Node Package Manager). Note that you will need to install
+[Node.js](http://nodejs.org/) and [npm](https://npmjs.org/). Installing Node.js should install npm as well.
+
+To download and install the Firebase CLI run the following command:
+
+```bash
+npm install -g firebase-tools
+```
+
+This will provide you with the globally accessible `firebase` command.
+
+### Standalone Binary
+
+The standalone binary distribution of the Firebase CLI allows you to download a `firebase` executable
+without any dependencies.
+
+To download and install the CLI run the following command:
+
+```bash
+curl -sL firebase.tools | bash
+```
+
+## Commands
+
+**The command `firebase --help` lists the available commands and `firebase <command> --help` shows more details for an individual command.**
+
+If a command is project-specific, you must either be inside a project directory with an
+active project alias or specify the Firebase project id with the `-P <project_id>` flag.
+
+Below is a brief list of the available commands and their function:
+
+### Configuration Commands
+
+| Command        | Description                                                                                                                                     |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| **login**      | Authenticate to your Firebase account. Requires access to a web browser.                                                                        |
+| **logout**     | Sign out of the Firebase CLI.                                                                                                                   |
+| **login:ci**   | Generate an authentication token for use in non-interactive environments.                                                                       |
+| **login:add**  | Authorize the CLI for an additional account.                                                                                                    |
+| **login:list** | List authorized CLI accounts.                                                                                                                   |
+| **login:use**  | Set the default account to use for this project                                                                                                 |
+| **use**        | Set active Firebase project, manage project aliases.                                                                                            |
+| **open**       | Quickly open a browser to relevant project resources.                                                                                           |
+| **init**       | Setup a new Firebase project in the current directory. This command will create a `firebase.json` configuration file in your current directory. |
+| **help**       | Display help information about the CLI or specific commands.                                                                                    |
+
+Append `--no-localhost` to login (i.e., `firebase login --no-localhost`) to copy and paste code instead of starting a local server for authentication. A use case might be if you SSH into an instance somewhere and you need to authenticate to Firebase on that machine.
+
+### Project Management Commands
+
+| Command                  | Description                                                |
+| ------------------------ | ---------------------------------------------------------- |
+| **apps:create**          | Create a new Firebase app in a project.                    |
+| **apps:list**            | List the registered apps of a Firebase project.            |
+| **apps:sdkconfig**       | Print the configuration of a Firebase app.                 |
+| **projects:addfirebase** | Add Firebase resources to a Google Cloud Platform project. |
+| **projects:create**      | Create a new Firebase project.                             |
+| **projects:list**        | Print a list of all of your Firebase projects.             |
+
+### Deployment and Local Emulation
+
+These commands let you deploy and interact with your Firebase services.
+
+| Command                       | Description                                                                                                                   |
+| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| **emulators:exec**            | Start the local Firebase emulators, run a test script, then shut down the emulators.                                          |
+| **emulators:start**           | Start the local Firebase emulators.                                                                                           |
+| **deploy**                    | Deploys your Firebase project. Relies on `firebase.json` configuration and your local project folder.                         |
+| **serve**                     | Start a local server with your Firebase Hosting configuration and HTTPS-triggered Cloud Functions. Relies on `firebase.json`. |
+| **setup:emulators:database**  | Downloads the database emulator.                                                                                              |
+| **setup:emulators:firestore** | Downloads the firestore emulator.                                                                                             |
+
+### App Distribution Commands
+
+| Command                        | Description            |
+| ------------------------------ | ---------------------- |
+| **appdistribution:distribute** | Upload a distribution. |
+
+### Auth Commands
+
+| Command         | Description                                            |
+| --------------- | ------------------------------------------------------ |
+| **auth:import** | Batch importing accounts into Firebase from data file. |
+| **auth:export** | Batch exporting accounts from Firebase into data file. |
+
+Detailed doc is [here](https://firebase.google.com/docs/cli/auth).
+
+### Realtime Database Commands
+
+| Command                       | Description                                                                                                                                 |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| **database:get**              | Fetch data from the current project's database and display it as JSON. Supports querying on indexed data.                                   |
+| **database:set**              | Replace all data at a specified location in the current project's database. Takes input from file, STDIN, or command-line argument.         |
+| **database:push**             | Push new data to a list at a specified location in the current project's database. Takes input from file, STDIN, or command-line argument.  |
+| **database:remove**           | Delete all data at a specified location in the current project's database.                                                                  |
+| **database:update**           | Perform a partial update at a specified location in the current project's database. Takes input from file, STDIN, or command-line argument. |
+| **database:profile**          | Profile database usage and generate a report.                                                                                               |
+| **database:instances:create** | Create a realtime database instance.                                                                                                        |
+| **database:instances:list**   | List realtime database instances.                                                                                                           |
+| **database:settings:get**     | Read the realtime database setting at path                                                                                                  |
+| **database:settings:set**     | Set the realtime database setting at path.                                                                                                  |
+
+### Extensions Commands
+
+| Command           | Description                                                                                 |
+| ----------------- | ------------------------------------------------------------------------------------------- |
+| **ext**           | Display information on how to use ext commands and extensions installed to your project.    |
+| **ext:configure** | Configure an existing extension instance.                                                   |
+| **ext:info**      | Display information about an extension by name (extensionName@x.y.z for a specific version) |
+| **ext:install**   | Install an extension.                                                                       |
+| **ext:list**      | List all the extensions that are installed in your Firebase project.                        |
+| **ext:uninstall** | Uninstall an extension that is installed in your Firebase project by Instance ID.           |
+| **ext:update**    | Update an existing extension instance to the latest version.                                |
+
+### Cloud Firestore Commands
+
+| Command               | Description                                                                                                         |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| **firestore:delete**  | Delete documents or collections from the current project's database. Supports recursive deletion of subcollections. |
+| **firestore:indexes** | List all deployed indexes from the current project.                                                                 |
+
+### Cloud Functions Commands
+
+| Command                       | Description                                                                                                  |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| **functions:log**             | Read logs from deployed Cloud Functions.                                                                     |
+| **functions:list**            | List all deployed functions in your Firebase project.                                                        |
+| **functions:config:set**      | Store runtime configuration values for the current project's Cloud Functions.                                |
+| **functions:config:get**      | Retrieve existing configuration values for the current project's Cloud Functions.                            |
+| **functions:config:unset**    | Remove values from the current project's runtime configuration.                                              |
+| **functions:config:clone**    | Copy runtime configuration from one project environment to another.                                          |
+| **functions:secrets:set**     | Create or update a secret for use in Cloud Functions for Firebase.                                           |
+| **functions:secrets:get**     | Get metadata for secret and its versions.                                                                    |
+| **functions:secrets:access**  | Access secret value given secret and its version. Defaults to accessing the latest version.                  |
+| **functions:secrets:prune**   | Destroys unused secrets.                                                                                     |
+| **functions:secrets:destroy** | Destroy a secret. Defaults to destroying the latest version.                                                 |
+| **functions:delete**          | Delete one or more Cloud Functions by name or group name.                                                    |
+| **functions:shell**           | Locally emulate functions and start Node.js shell where these local functions can be invoked with test data. |
+
+### Hosting Commands
+
+| Command             | Description                                                                                                                                                          |
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **hosting:disable** | Stop serving Firebase Hosting traffic for the active project. A "Site Not Found" message will be displayed at your project's Hosting URL after running this command. |
+
+### Remote Config Commands
+
+| Command                        | Description                                                                                                |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------- |
+| **remoteconfig:get**           | Get a Firebase project's Remote Config template.                                                           |
+| **remoteconfig:versions:list** | Get a list of the most recent Firebase Remote Config template versions that have been published.           |
+| **remoteconfig:rollback**      | Roll back a project's published Remote Config template to the version provided by `--version_number` flag. |
+
+Use `firebase:deploy --only remoteconfig` to update and publish a project's Firebase Remote Config template.
+
+## Authentication
+
+### General
+
+The Firebase CLI can use one of four authentication methods listed in descending priority:
+
+- **User Token** - **DEPRECATED: this authentication method will be removed in a future major version of `firebase-tools`; use a service account to authenticate instead** - provide an explicit long-lived Firebase user token generated from `firebase login:ci`. Note that these tokens are extremely sensitive long-lived credentials and are not the right option for most cases. Consider using service account authorization instead. The token can be set in one of two ways:
+  - Set the `--token` flag on any command, for example `firebase --token="<token>" projects:list`.
+  - Set the `FIREBASE_TOKEN` environment variable.
+- **Local Login** - run `firebase login` to log in to the CLI directly as yourself. The CLI will cache an authorized user credential on your machine.
+- **Service Account** - set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to point to the path of a JSON service account key file. For more details, see Google Cloud's [Getting started with authentication](https://cloud.google.com/docs/authentication/getting-started) guide.
+- **Application Default Credentials** - if you use the `gcloud` CLI and log in with `gcloud auth application-default login`, the Firebase CLI will use them if none of the above credentials are present.
+
+### Multiple Accounts
+
+By default `firebase login` sets a single global account for use on all projects.
+If you have multiple Google accounts which you use for Firebase projects you can
+authorize multiple accounts and use them on a per-project or per-command basis.
+
+To authorize an additonal account for use with the CLI, run `firebase login:add`.
+You can view the list of authorized accounts with `firebase login:list`.
+
+To set the default account for a specific Firebase project directory, run
+`firebase login:use` from within the directory and select the desired account.
+To check the default account for a directory, run `firebase login:list` and the
+default account for the current context will be listed first.
+
+To set the account for a specific command invocation, use the `--account` flag
+with any command. For example `firebase --account=user@domain.com deploy`. The
+specified account must have already been added to the Firebase CLI using
+`firebase login:add`.
+
+### Cloud Functions Emulator
+
+The Cloud Functions emulator is exposed through commands like `emulators:start`,
+`serve` and `functions:shell`. Emulated Cloud Functions run as independent `node` processes
+on your development machine which means they have their own credential discovery mechanism.
+
+By default these `node` processes are not able to discover credentials from `firebase login`.
+In order to provide a better development experience, when you are logged in to the CLI
+through `firebase login` we take the user credentials and construct a temporary credential
+that we pass into the emulator through `GOOGLE_APPLICATION_CREDENTIALS`. We **only** do this
+if you have not already set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable
+yourself.
+
+## Using behind a proxy
+
+The CLI supports HTTP(S) proxies via environment variables. To use a proxy, set the `HTTPS_PROXY`
+or `HTTP_PROXY` value in your environment to the URL of your proxy (e.g.
+`HTTP_PROXY=http://127.0.0.1:12345`).
+
+## Using with CI Systems
+
+The Firebase CLI requires a browser to complete authentication, but is fully
+compatible with CI and other headless environments.
+
+Complete the following steps to run Firebase commands in a CI environment. Find detailed instructions for each step in Google Cloud's [Getting started with authentication](https://cloud.google.com/docs/authentication/getting-started) guide.
+
+1. Create a service account and grant it the appropriate level of access to your project.
+1. Create a service account key (JSON file) for that service account.
+1. Store the key file in a secure, accessible way in your CI system.
+1. Set `GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json` in your CI system when running Firebase commands.
+
+To disable access for the service account, [find the service account](https://console.cloud.google.com/projectselector/iam-admin/serviceaccounts) for your project in the Google Cloud Console, and then either remove the key, or disable or delete the service account.
+
+## Using as a Module
+
+The Firebase CLI can also be used programmatically as a standard Node module.
+Each command is exposed as a function that takes positional arguments followed
+by an options object and returns a Promise.
+
+So if we run this command at our command line:
+
+```bash
+$ firebase --project="foo" apps:list ANDROID
+```
+
+That translates to the following in Node:
+
+```js
+const client = require("firebase-tools");
+client.apps
+  .list("ANDROID", { project: "foo" })
+  .then((data) => {
+    // ...
+  })
+  .catch((err) => {
+    // ...
+  });
+```
+
+The options object must be the very last argument and any unspecified
+positional argument will get the default value of `""`. The following
+two invocations are equivalent:
+
+```js
+const client = require("firebase-tools");
+
+// #1 - No arguments or options, defaults will be inferred
+client.apps.list();
+
+// #2 - Explicitly provide "" for all arguments and {} for options
+client.apps.list("", {});
+```
+
+Note: when used in a limited environment like Cloud Functions, not all `firebase-tools` commands will work programatically
+because they require access to a local filesystem.
+
+[gh-actions]: https://github.com/firebase/firebase-tools/actions
+[npm]: https://www.npmjs.com/package/firebase-tools
+[gh-actions-badge]: https://github.com/firebase/firebase-tools/workflows/CI%20Tests/badge.svg
+[node-badge]: https://img.shields.io/node/v/firebase-tools.svg
+[npm-badge]: https://img.shields.io/npm/v/firebase-tools.svg

node_modules/firebase-tools/lib/accountExporter.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialExportUsers = exports.validateOptions = void 0;
+const os = require("os");
+const path = require("path");
+const apiv2_1 = require("./apiv2");
+const error_1 = require("./error");
+const api_1 = require("./api");
+const utils = require("./utils");
+const apiClient = new apiv2_1.Client({
+    urlPrefix: api_1.googleOrigin,
+});
+const EXPORTED_JSON_KEYS = [
+    "localId",
+    "email",
+    "emailVerified",
+    "passwordHash",
+    "salt",
+    "displayName",
+    "photoUrl",
+    "lastLoginAt",
+    "createdAt",
+    "phoneNumber",
+    "disabled",
+    "customAttributes",
+];
+const EXPORTED_JSON_KEYS_RENAMING = {
+    lastLoginAt: "lastSignedInAt",
+};
+const EXPORTED_PROVIDER_USER_INFO_KEYS = [
+    "providerId",
+    "rawId",
+    "email",
+    "displayName",
+    "photoUrl",
+];
+const PROVIDER_ID_INDEX_MAP = new Map([
+    ["google.com", 7],
+    ["facebook.com", 11],
+    ["twitter.com", 15],
+    ["github.com", 19],
+]);
+function escapeComma(str) {
+    if (str.includes(",")) {
+        return `"${str}"`;
+    }
+    return str;
+}
+function convertToNormalBase64(data) {
+    return data.replace(/_/g, "/").replace(/-/g, "+");
+}
+function addProviderUserInfo(providerInfo, arr, startPos) {
+    arr[startPos] = providerInfo.rawId;
+    arr[startPos + 1] = providerInfo.email || "";
+    arr[startPos + 2] = escapeComma(providerInfo.displayName || "");
+    arr[startPos + 3] = providerInfo.photoUrl || "";
+}
+function transUserToArray(user) {
+    const arr = Array(27).fill("");
+    arr[0] = user.localId;
+    arr[1] = user.email || "";
+    arr[2] = user.emailVerified || false;
+    arr[3] = convertToNormalBase64(user.passwordHash || "");
+    arr[4] = convertToNormalBase64(user.salt || "");
+    arr[5] = escapeComma(user.displayName || "");
+    arr[6] = user.photoUrl || "";
+    for (let i = 0; i < (!user.providerUserInfo ? 0 : user.providerUserInfo.length); i++) {
+        const providerInfo = user.providerUserInfo[i];
+        if (providerInfo) {
+            const providerIndex = PROVIDER_ID_INDEX_MAP.get(providerInfo.providerId);
+            if (providerIndex) {
+                addProviderUserInfo(providerInfo, arr, providerIndex);
+            }
+        }
+    }
+    arr[23] = user.createdAt;
+    arr[24] = user.lastLoginAt;
+    arr[25] = user.phoneNumber;
+    arr[26] = user.disabled;
+    arr[27] = user.customAttributes;
+    return arr;
+}
+function transUserJson(user) {
+    const newUser = {};
+    const pickedUser = {};
+    for (const k of EXPORTED_JSON_KEYS) {
+        pickedUser[k] = user[k];
+    }
+    for (const [key, value] of Object.entries(pickedUser)) {
+        const newKey = EXPORTED_JSON_KEYS_RENAMING[key] || key;
+        newUser[newKey] = value;
+    }
+    if (newUser.passwordHash) {
+        newUser.passwordHash = convertToNormalBase64(newUser.passwordHash);
+    }
+    if (newUser.salt) {
+        newUser.salt = convertToNormalBase64(newUser.salt);
+    }
+    if (user.providerUserInfo) {
+        newUser.providerUserInfo = [];
+        for (const providerInfo of user.providerUserInfo) {
+            if (PROVIDER_ID_INDEX_MAP.has(providerInfo.providerId)) {
+                const picked = {};
+                for (const k of EXPORTED_PROVIDER_USER_INFO_KEYS) {
+                    picked[k] = providerInfo[k];
+                }
+                newUser.providerUserInfo.push(picked);
+            }
+        }
+    }
+    return newUser;
+}
+function validateOptions(options, fileName) {
+    const exportOptions = {};
+    if (fileName === undefined) {
+        throw new error_1.FirebaseError("Must specify data file");
+    }
+    const extName = path.extname(fileName.toLowerCase());
+    if (extName === ".csv") {
+        exportOptions.format = "csv";
+    }
+    else if (extName === ".json") {
+        exportOptions.format = "json";
+    }
+    else if (options.format) {
+        const format = options.format.toLowerCase();
+        if (format === "csv" || format === "json") {
+            exportOptions.format = format;
+        }
+        else {
+            throw new error_1.FirebaseError("Unsupported data file format, should be csv or json");
+        }
+    }
+    else {
+        throw new error_1.FirebaseError("Please specify data file format in file name, or use `format` parameter");
+    }
+    return exportOptions;
+}
+exports.validateOptions = validateOptions;
+function createWriteUsersToFile() {
+    let jsonSep = "";
+    return (userList, format, writeStream) => {
+        userList.map((user) => {
+            if (user.passwordHash && user.version !== 0) {
+                delete user.passwordHash;
+                delete user.salt;
+            }
+            if (format === "csv") {
+                writeStream.write(transUserToArray(user).join(",") + "," + os.EOL, "utf8");
+            }
+            else {
+                writeStream.write(jsonSep + JSON.stringify(transUserJson(user), null, 2), "utf8");
+                jsonSep = "," + os.EOL;
+            }
+        });
+    };
+}
+async function serialExportUsers(projectId, options) {
+    var _a;
+    if (!options.writeUsersToFile) {
+        options.writeUsersToFile = createWriteUsersToFile();
+    }
+    const postBody = {
+        targetProjectId: projectId,
+        maxResults: options.batchSize,
+    };
+    if (options.nextPageToken) {
+        postBody.nextPageToken = options.nextPageToken;
+    }
+    if (!options.timeoutRetryCount) {
+        options.timeoutRetryCount = 0;
+    }
+    try {
+        const ret = await apiClient.post("/identitytoolkit/v3/relyingparty/downloadAccount", postBody, {
+            skipLog: { resBody: true },
+        });
+        options.timeoutRetryCount = 0;
+        const userList = ret.body.users;
+        if (userList && userList.length > 0) {
+            options.writeUsersToFile(userList, options.format, options.writeStream);
+            utils.logSuccess("Exported " + userList.length + " account(s) successfully.");
+            if (!ret.body.nextPageToken) {
+                return;
+            }
+            options.nextPageToken = ret.body.nextPageToken;
+            return serialExportUsers(projectId, options);
+        }
+    }
+    catch (err) {
+        if (((_a = err.original) === null || _a === void 0 ? void 0 : _a.code) === "ETIMEDOUT") {
+            options.timeoutRetryCount++;
+            if (options.timeoutRetryCount > 5) {
+                return err;
+            }
+            return serialExportUsers(projectId, options);
+        }
+        if (err instanceof error_1.FirebaseError) {
+            throw err;
+        }
+        else {
+            throw new error_1.FirebaseError(`Failed to export accounts: ${err}`, { original: err });
+        }
+    }
+}
+exports.serialExportUsers = serialExportUsers;

node_modules/firebase-tools/lib/accountImporter.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialImportUsers = exports.validateUserJson = exports.validateOptions = exports.transArrayToUser = void 0;
+const clc = require("colorette");
+const apiv2_1 = require("./apiv2");
+const api_1 = require("./api");
+const logger_1 = require("./logger");
+const error_1 = require("./error");
+const utils = require("./utils");
+const apiClient = new apiv2_1.Client({
+    urlPrefix: api_1.googleOrigin,
+});
+const ALLOWED_JSON_KEYS = [
+    "localId",
+    "email",
+    "emailVerified",
+    "passwordHash",
+    "salt",
+    "displayName",
+    "photoUrl",
+    "createdAt",
+    "lastSignedInAt",
+    "providerUserInfo",
+    "phoneNumber",
+    "disabled",
+    "customAttributes",
+];
+const ALLOWED_JSON_KEYS_RENAMING = {
+    lastSignedInAt: "lastLoginAt",
+};
+const ALLOWED_PROVIDER_USER_INFO_KEYS = ["providerId", "rawId", "email", "displayName", "photoUrl"];
+const ALLOWED_PROVIDER_IDS = ["google.com", "facebook.com", "twitter.com", "github.com"];
+function isValidBase64(str) {
+    const expected = Buffer.from(str, "base64").toString("base64");
+    if (str.length < expected.length && !str.endsWith("=")) {
+        str += "=".repeat(expected.length - str.length);
+    }
+    return expected === str;
+}
+function toWebSafeBase64(data) {
+    return data.replace(/\//g, "_").replace(/\+/g, "-");
+}
+function addProviderUserInfo(user, providerId, arr) {
+    if (arr[0]) {
+        user.providerUserInfo.push({
+            providerId: providerId,
+            rawId: arr[0],
+            email: arr[1],
+            displayName: arr[2],
+            photoUrl: arr[3],
+        });
+    }
+}
+function genUploadAccountPostBody(projectId, accounts, hashOptions) {
+    const postBody = {
+        users: accounts.map((account) => {
+            if (account.passwordHash) {
+                account.passwordHash = toWebSafeBase64(account.passwordHash);
+            }
+            if (account.salt) {
+                account.salt = toWebSafeBase64(account.salt);
+            }
+            for (const [key, value] of Object.entries(ALLOWED_JSON_KEYS_RENAMING)) {
+                if (account[key]) {
+                    account[value] = account[key];
+                    delete account[key];
+                }
+            }
+            return account;
+        }),
+    };
+    if (hashOptions.hashAlgo) {
+        postBody.hashAlgorithm = hashOptions.hashAlgo;
+    }
+    if (hashOptions.hashKey) {
+        postBody.signerKey = toWebSafeBase64(hashOptions.hashKey);
+    }
+    if (hashOptions.saltSeparator) {
+        postBody.saltSeparator = toWebSafeBase64(hashOptions.saltSeparator);
+    }
+    if (hashOptions.rounds) {
+        postBody.rounds = hashOptions.rounds;
+    }
+    if (hashOptions.memCost) {
+        postBody.memoryCost = hashOptions.memCost;
+    }
+    if (hashOptions.cpuMemCost) {
+        postBody.cpuMemCost = hashOptions.cpuMemCost;
+    }
+    if (hashOptions.parallelization) {
+        postBody.parallelization = hashOptions.parallelization;
+    }
+    if (hashOptions.blockSize) {
+        postBody.blockSize = hashOptions.blockSize;
+    }
+    if (hashOptions.dkLen) {
+        postBody.dkLen = hashOptions.dkLen;
+    }
+    if (hashOptions.passwordHashOrder) {
+        postBody.passwordHashOrder = hashOptions.passwordHashOrder;
+    }
+    postBody.targetProjectId = projectId;
+    return postBody;
+}
+function transArrayToUser(arr) {
+    const user = {
+        localId: arr[0],
+        email: arr[1],
+        emailVerified: arr[2] === "true",
+        passwordHash: arr[3],
+        salt: arr[4],
+        displayName: arr[5],
+        photoUrl: arr[6],
+        createdAt: arr[23],
+        lastLoginAt: arr[24],
+        phoneNumber: arr[25],
+        providerUserInfo: [],
+        disabled: arr[26],
+        customAttributes: arr[27],
+    };
+    addProviderUserInfo(user, "google.com", arr.slice(7, 11));
+    addProviderUserInfo(user, "facebook.com", arr.slice(11, 15));
+    addProviderUserInfo(user, "twitter.com", arr.slice(15, 19));
+    addProviderUserInfo(user, "github.com", arr.slice(19, 23));
+    if (user.passwordHash && !isValidBase64(user.passwordHash)) {
+        return {
+            error: "Password hash should be base64 encoded.",
+        };
+    }
+    if (user.salt && !isValidBase64(user.salt)) {
+        return {
+            error: "Password salt should be base64 encoded.",
+        };
+    }
+    return user;
+}
+exports.transArrayToUser = transArrayToUser;
+function validateOptions(options) {
+    const hashOptions = validateRequiredParameters(options);
+    if (!hashOptions.valid) {
+        return hashOptions;
+    }
+    const hashInputOrder = options.hashInputOrder ? options.hashInputOrder.toUpperCase() : undefined;
+    if (hashInputOrder) {
+        if (hashInputOrder !== "SALT_FIRST" && hashInputOrder !== "PASSWORD_FIRST") {
+            throw new error_1.FirebaseError("Unknown password hash order flag");
+        }
+        else {
+            hashOptions["passwordHashOrder"] =
+                hashInputOrder === "SALT_FIRST" ? "SALT_AND_PASSWORD" : "PASSWORD_AND_SALT";
+        }
+    }
+    return hashOptions;
+}
+exports.validateOptions = validateOptions;
+function validateRequiredParameters(options) {
+    if (!options.hashAlgo) {
+        utils.logWarning("No hash algorithm specified. Password users cannot be imported.");
+        return { valid: true };
+    }
+    const hashAlgo = options.hashAlgo.toUpperCase();
+    let roundsNum;
+    switch (hashAlgo) {
+        case "HMAC_SHA512":
+        case "HMAC_SHA256":
+        case "HMAC_SHA1":
+        case "HMAC_MD5":
+            if (!options.hashKey || options.hashKey === "") {
+                throw new error_1.FirebaseError("Must provide hash key(base64 encoded) for hash algorithm " + options.hashAlgo);
+            }
+            return { hashAlgo: hashAlgo, hashKey: options.hashKey, valid: true };
+        case "MD5":
+        case "SHA1":
+        case "SHA256":
+        case "SHA512":
+            roundsNum = parseInt(options.rounds, 10);
+            const minRounds = hashAlgo === "MD5" ? 0 : 1;
+            if (isNaN(roundsNum) || roundsNum < minRounds || roundsNum > 8192) {
+                throw new error_1.FirebaseError(`Must provide valid rounds(${minRounds}..8192) for hash algorithm ${options.hashAlgo}`);
+            }
+            return { hashAlgo: hashAlgo, rounds: options.rounds, valid: true };
+        case "PBKDF_SHA1":
+        case "PBKDF2_SHA256":
+            roundsNum = parseInt(options.rounds, 10);
+            if (isNaN(roundsNum) || roundsNum < 0 || roundsNum > 120000) {
+                throw new error_1.FirebaseError("Must provide valid rounds(0..120000) for hash algorithm " + options.hashAlgo);
+            }
+            return { hashAlgo: hashAlgo, rounds: options.rounds, valid: true };
+        case "SCRYPT":
+            if (!options.hashKey || options.hashKey === "") {
+                throw new error_1.FirebaseError("Must provide hash key(base64 encoded) for hash algorithm " + options.hashAlgo);
+            }
+            roundsNum = parseInt(options.rounds, 10);
+            if (isNaN(roundsNum) || roundsNum <= 0 || roundsNum > 8) {
+                throw new error_1.FirebaseError("Must provide valid rounds(1..8) for hash algorithm " + options.hashAlgo);
+            }
+            const memCost = parseInt(options.memCost, 10);
+            if (isNaN(memCost) || memCost <= 0 || memCost > 14) {
+                throw new error_1.FirebaseError("Must provide valid memory cost(1..14) for hash algorithm " + options.hashAlgo);
+            }
+            let saltSeparator = "";
+            if (options.saltSeparator) {
+                saltSeparator = options.saltSeparator;
+            }
+            return {
+                hashAlgo: hashAlgo,
+                hashKey: options.hashKey,
+                saltSeparator: saltSeparator,
+                rounds: options.rounds,
+                memCost: options.memCost,
+                valid: true,
+            };
+        case "BCRYPT":
+            return { hashAlgo: hashAlgo, valid: true };
+        case "STANDARD_SCRYPT":
+            const cpuMemCost = parseInt(options.memCost, 10);
+            const parallelization = parseInt(options.parallelization, 10);
+            const blockSize = parseInt(options.blockSize, 10);
+            const dkLen = parseInt(options.dkLen, 10);
+            return {
+                hashAlgo: hashAlgo,
+                valid: true,
+                cpuMemCost: cpuMemCost,
+                parallelization: parallelization,
+                blockSize: blockSize,
+                dkLen: dkLen,
+            };
+        default:
+            throw new error_1.FirebaseError("Unsupported hash algorithm " + clc.bold(options.hashAlgo));
+    }
+}
+function validateProviderUserInfo(providerUserInfo) {
+    if (!ALLOWED_PROVIDER_IDS.includes(providerUserInfo.providerId)) {
+        return {
+            error: JSON.stringify(providerUserInfo, null, 2) + " has unsupported providerId",
+        };
+    }
+    const keydiff = Object.keys(providerUserInfo).filter((k) => !ALLOWED_PROVIDER_USER_INFO_KEYS.includes(k));
+    if (keydiff.length) {
+        return {
+            error: JSON.stringify(providerUserInfo, null, 2) + " has unsupported keys: " + keydiff.join(","),
+        };
+    }
+    return {};
+}
+function validateUserJson(userJson) {
+    const keydiff = Object.keys(userJson).filter((k) => !ALLOWED_JSON_KEYS.includes(k));
+    if (keydiff.length) {
+        return {
+            error: JSON.stringify(userJson, null, 2) + " has unsupported keys: " + keydiff.join(","),
+        };
+    }
+    if (userJson.providerUserInfo) {
+        for (let i = 0; i < userJson.providerUserInfo.length; i++) {
+            const res = validateProviderUserInfo(userJson.providerUserInfo[i]);
+            if (res.error) {
+                return res;
+            }
+        }
+    }
+    const badFormat = JSON.stringify(userJson, null, 2) + " has invalid data format: ";
+    if (userJson.passwordHash && !isValidBase64(userJson.passwordHash)) {
+        return {
+            error: badFormat + "Password hash should be base64 encoded.",
+        };
+    }
+    if (userJson.salt && !isValidBase64(userJson.salt)) {
+        return {
+            error: badFormat + "Password salt should be base64 encoded.",
+        };
+    }
+    return {};
+}
+exports.validateUserJson = validateUserJson;
+async function sendRequest(projectId, userList, hashOptions) {
+    logger_1.logger.info("Starting importing " + userList.length + " account(s).");
+    const postData = genUploadAccountPostBody(projectId, userList, hashOptions);
+    return apiClient
+        .post("/identitytoolkit/v3/relyingparty/uploadAccount", postData, {
+        skipLog: { body: true },
+    })
+        .then((ret) => {
+        if (ret.body.error) {
+            logger_1.logger.info("Encountered problems while importing accounts. Details:");
+            logger_1.logger.info(ret.body.error.map((rawInfo) => {
+                return {
+                    account: JSON.stringify(userList[parseInt(rawInfo.index, 10)], null, 2),
+                    reason: rawInfo.message,
+                };
+            }));
+        }
+        else {
+            utils.logSuccess("Imported successfully.");
+        }
+        logger_1.logger.info();
+    });
+}
+function serialImportUsers(projectId, hashOptions, userListArr, index) {
+    return sendRequest(projectId, userListArr[index], hashOptions).then(() => {
+        if (index < userListArr.length - 1) {
+            return serialImportUsers(projectId, hashOptions, userListArr, index + 1);
+        }
+    });
+}
+exports.serialImportUsers = serialImportUsers;

node_modules/firebase-tools/lib/api.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubClientSecret = exports.githubClientId = exports.secretManagerOrigin = exports.githubApiOrigin = exports.githubOrigin = exports.serviceUsageOrigin = exports.cloudRunApiOrigin = exports.hostingApiOrigin = exports.firebaseStorageOrigin = exports.storageOrigin = exports.runtimeconfigOrigin = exports.rulesOrigin = exports.resourceManagerOrigin = exports.remoteConfigApiOrigin = exports.rtdbMetadataOrigin = exports.rtdbManagementOrigin = exports.realtimeOrigin = exports.extensionsOrigin = exports.iamOrigin = exports.identityOrigin = exports.hostingOrigin = exports.googleOrigin = exports.pubsubOrigin = exports.cloudTasksOrigin = exports.cloudschedulerOrigin = exports.functionsDefaultRegion = exports.runOrigin = exports.functionsV2Origin = exports.functionsOrigin = exports.firestoreOrigin = exports.firestoreOriginOrEmulator = exports.firedataOrigin = exports.firebaseExtensionsRegistryOrigin = exports.firebaseApiOrigin = exports.eventarcOrigin = exports.dynamicLinksKey = exports.dynamicLinksOrigin = exports.deployOrigin = exports.consoleOrigin = exports.authOrigin = exports.appengineOrigin = exports.appDistributionOrigin = exports.artifactRegistryDomain = exports.containerRegistryDomain = exports.cloudMonitoringOrigin = exports.cloudloggingOrigin = exports.cloudbillingOrigin = exports.clientSecret = exports.clientId = exports.authProxyOrigin = void 0;
+exports.setScopes = exports.getScopes = void 0;
+const constants_1 = require("./emulator/constants");
+const logger_1 = require("./logger");
+const scopes = require("./scopes");
+const utils = require("./utils");
+let commandScopes = new Set();
+exports.authProxyOrigin = utils.envOverride("FIREBASE_AUTHPROXY_URL", "https://auth.firebase.tools");
+exports.clientId = utils.envOverride("FIREBASE_CLIENT_ID", "563584335869-fgrhgmd47bqnekij5i8b5pr03ho849e6.apps.googleusercontent.com");
+exports.clientSecret = utils.envOverride("FIREBASE_CLIENT_SECRET", "j9iVZfS8kkCEFUPaAeJV0sAi");
+exports.cloudbillingOrigin = utils.envOverride("FIREBASE_CLOUDBILLING_URL", "https://cloudbilling.googleapis.com");
+exports.cloudloggingOrigin = utils.envOverride("FIREBASE_CLOUDLOGGING_URL", "https://logging.googleapis.com");
+exports.cloudMonitoringOrigin = utils.envOverride("CLOUD_MONITORING_URL", "https://monitoring.googleapis.com");
+exports.containerRegistryDomain = utils.envOverride("CONTAINER_REGISTRY_DOMAIN", "gcr.io");
+exports.artifactRegistryDomain = utils.envOverride("ARTIFACT_REGISTRY_DOMAIN", "https://artifactregistry.googleapis.com");
+exports.appDistributionOrigin = utils.envOverride("FIREBASE_APP_DISTRIBUTION_URL", "https://firebaseappdistribution.googleapis.com");
+exports.appengineOrigin = utils.envOverride("FIREBASE_APPENGINE_URL", "https://appengine.googleapis.com");
+exports.authOrigin = utils.envOverride("FIREBASE_AUTH_URL", "https://accounts.google.com");
+exports.consoleOrigin = utils.envOverride("FIREBASE_CONSOLE_URL", "https://console.firebase.google.com");
+exports.deployOrigin = utils.envOverride("FIREBASE_DEPLOY_URL", utils.envOverride("FIREBASE_UPLOAD_URL", "https://deploy.firebase.com"));
+exports.dynamicLinksOrigin = utils.envOverride("FIREBASE_DYNAMIC_LINKS_URL", "https://firebasedynamiclinks.googleapis.com");
+exports.dynamicLinksKey = utils.envOverride("FIREBASE_DYNAMIC_LINKS_KEY", "AIzaSyB6PtY5vuiSB8MNgt20mQffkOlunZnHYiQ");
+exports.eventarcOrigin = utils.envOverride("EVENTARC_URL", "https://eventarc.googleapis.com");
+exports.firebaseApiOrigin = utils.envOverride("FIREBASE_API_URL", "https://firebase.googleapis.com");
+exports.firebaseExtensionsRegistryOrigin = utils.envOverride("FIREBASE_EXT_REGISTRY_ORIGIN", "https://extensions-registry.firebaseapp.com");
+exports.firedataOrigin = utils.envOverride("FIREBASE_FIREDATA_URL", "https://mobilesdk-pa.googleapis.com");
+exports.firestoreOriginOrEmulator = utils.envOverride(constants_1.Constants.FIRESTORE_EMULATOR_HOST, utils.envOverride("FIRESTORE_URL", "https://firestore.googleapis.com"), (val) => {
+    if (val.startsWith("http")) {
+        return val;
+    }
+    return `http://${val}`;
+});
+exports.firestoreOrigin = utils.envOverride("FIRESTORE_URL", "https://firestore.googleapis.com");
+exports.functionsOrigin = utils.envOverride("FIREBASE_FUNCTIONS_URL", "https://cloudfunctions.googleapis.com");
+exports.functionsV2Origin = utils.envOverride("FIREBASE_FUNCTIONS_V2_URL", "https://cloudfunctions.googleapis.com");
+exports.runOrigin = utils.envOverride("CLOUD_RUN_URL", "https://run.googleapis.com");
+exports.functionsDefaultRegion = utils.envOverride("FIREBASE_FUNCTIONS_DEFAULT_REGION", "us-central1");
+exports.cloudschedulerOrigin = utils.envOverride("FIREBASE_CLOUDSCHEDULER_URL", "https://cloudscheduler.googleapis.com");
+exports.cloudTasksOrigin = utils.envOverride("FIREBASE_CLOUD_TAKS_URL", "https://cloudtasks.googleapis.com");
+exports.pubsubOrigin = utils.envOverride("FIREBASE_PUBSUB_URL", "https://pubsub.googleapis.com");
+exports.googleOrigin = utils.envOverride("FIREBASE_TOKEN_URL", utils.envOverride("FIREBASE_GOOGLE_URL", "https://www.googleapis.com"));
+exports.hostingOrigin = utils.envOverride("FIREBASE_HOSTING_URL", "https://web.app");
+exports.identityOrigin = utils.envOverride("FIREBASE_IDENTITY_URL", "https://identitytoolkit.googleapis.com");
+exports.iamOrigin = utils.envOverride("FIREBASE_IAM_URL", "https://iam.googleapis.com");
+exports.extensionsOrigin = utils.envOverride("FIREBASE_EXT_URL", "https://firebaseextensions.googleapis.com");
+exports.realtimeOrigin = utils.envOverride("FIREBASE_REALTIME_URL", "https://firebaseio.com");
+exports.rtdbManagementOrigin = utils.envOverride("FIREBASE_RTDB_MANAGEMENT_URL", "https://firebasedatabase.googleapis.com");
+exports.rtdbMetadataOrigin = utils.envOverride("FIREBASE_RTDB_METADATA_URL", "https://metadata-dot-firebase-prod.appspot.com");
+exports.remoteConfigApiOrigin = utils.envOverride("FIREBASE_REMOTE_CONFIG_URL", "https://firebaseremoteconfig.googleapis.com");
+exports.resourceManagerOrigin = utils.envOverride("FIREBASE_RESOURCEMANAGER_URL", "https://cloudresourcemanager.googleapis.com");
+exports.rulesOrigin = utils.envOverride("FIREBASE_RULES_URL", "https://firebaserules.googleapis.com");
+exports.runtimeconfigOrigin = utils.envOverride("FIREBASE_RUNTIMECONFIG_URL", "https://runtimeconfig.googleapis.com");
+exports.storageOrigin = utils.envOverride("FIREBASE_STORAGE_URL", "https://storage.googleapis.com");
+exports.firebaseStorageOrigin = utils.envOverride("FIREBASE_FIREBASESTORAGE_URL", "https://firebasestorage.googleapis.com");
+exports.hostingApiOrigin = utils.envOverride("FIREBASE_HOSTING_API_URL", "https://firebasehosting.googleapis.com");
+exports.cloudRunApiOrigin = utils.envOverride("CLOUD_RUN_API_URL", "https://run.googleapis.com");
+exports.serviceUsageOrigin = utils.envOverride("FIREBASE_SERVICE_USAGE_URL", "https://serviceusage.googleapis.com");
+exports.githubOrigin = utils.envOverride("GITHUB_URL", "https://github.com");
+exports.githubApiOrigin = utils.envOverride("GITHUB_API_URL", "https://api.github.com");
+exports.secretManagerOrigin = utils.envOverride("CLOUD_SECRET_MANAGER_URL", "https://secretmanager.googleapis.com");
+exports.githubClientId = utils.envOverride("GITHUB_CLIENT_ID", "89cf50f02ac6aaed3484");
+exports.githubClientSecret = utils.envOverride("GITHUB_CLIENT_SECRET", "3330d14abc895d9a74d5f17cd7a00711fa2c5bf0");
+function getScopes() {
+    return Array.from(commandScopes);
+}
+exports.getScopes = getScopes;
+function setScopes(sps = []) {
+    commandScopes = new Set([
+        scopes.EMAIL,
+        scopes.OPENID,
+        scopes.CLOUD_PROJECTS_READONLY,
+        scopes.FIREBASE_PLATFORM,
+    ]);
+    for (const s of sps) {
+        commandScopes.add(s);
+    }
+    logger_1.logger.debug("> command requires scopes:", Array.from(commandScopes));
+}
+exports.setScopes = setScopes;

node_modules/firebase-tools/lib/apiv2.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.setAccessToken = exports.setRefreshToken = void 0;
+const url_1 = require("url");
+const stream_1 = require("stream");
+const ProxyAgent = require("proxy-agent");
+const retry = require("retry");
+const abort_controller_1 = require("abort-controller");
+const node_fetch_1 = require("node-fetch");
+const util_1 = require("util");
+const auth = require("./auth");
+const error_1 = require("./error");
+const logger_1 = require("./logger");
+const responseToError_1 = require("./responseToError");
+const FormData = require("form-data");
+const pkg = require("../package.json");
+const CLI_VERSION = pkg.version;
+const GOOG_QUOTA_USER = "x-goog-quota-user";
+let accessToken = "";
+let refreshToken = "";
+function setRefreshToken(token = "") {
+    refreshToken = token;
+}
+exports.setRefreshToken = setRefreshToken;
+function setAccessToken(token = "") {
+    accessToken = token;
+}
+exports.setAccessToken = setAccessToken;
+function proxyURIFromEnv() {
+    return (process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        undefined);
+}
+class Client {
+    constructor(opts) {
+        this.opts = opts;
+        if (this.opts.auth === undefined) {
+            this.opts.auth = true;
+        }
+        if (this.opts.urlPrefix.endsWith("/")) {
+            this.opts.urlPrefix = this.opts.urlPrefix.substring(0, this.opts.urlPrefix.length - 1);
+        }
+    }
+    get(path, options = {}) {
+        const reqOptions = Object.assign(options, {
+            method: "GET",
+            path,
+        });
+        return this.request(reqOptions);
+    }
+    post(path, json, options = {}) {
+        const reqOptions = Object.assign(options, {
+            method: "POST",
+            path,
+            body: json,
+        });
+        return this.request(reqOptions);
+    }
+    patch(path, json, options = {}) {
+        const reqOptions = Object.assign(options, {
+            method: "PATCH",
+            path,
+            body: json,
+        });
+        return this.request(reqOptions);
+    }
+    put(path, json, options = {}) {
+        const reqOptions = Object.assign(options, {
+            method: "PUT",
+            path,
+            body: json,
+        });
+        return this.request(reqOptions);
+    }
+    delete(path, options = {}) {
+        const reqOptions = Object.assign(options, {
+            method: "DELETE",
+            path,
+        });
+        return this.request(reqOptions);
+    }
+    async request(reqOptions) {
+        if (!reqOptions.responseType) {
+            reqOptions.responseType = "json";
+        }
+        if (reqOptions.responseType === "stream" && !reqOptions.resolveOnHTTPError) {
+            throw new error_1.FirebaseError("apiv2 will not handle HTTP errors while streaming and you must set `resolveOnHTTPError` and check for res.status >= 400 on your own", { exit: 2 });
+        }
+        let internalReqOptions = Object.assign(reqOptions, {
+            headers: new node_fetch_1.Headers(reqOptions.headers),
+        });
+        internalReqOptions = this.addRequestHeaders(internalReqOptions);
+        if (this.opts.auth) {
+            internalReqOptions = await this.addAuthHeader(internalReqOptions);
+        }
+        try {
+            return await this.doRequest(internalReqOptions);
+        }
+        catch (thrown) {
+            if (thrown instanceof error_1.FirebaseError) {
+                throw thrown;
+            }
+            let err;
+            if (thrown instanceof Error) {
+                err = thrown;
+            }
+            else {
+                err = new Error(thrown);
+            }
+            throw new error_1.FirebaseError(`Failed to make request: ${err.message}`, { original: err });
+        }
+    }
+    addRequestHeaders(reqOptions) {
+        if (!reqOptions.headers) {
+            reqOptions.headers = new node_fetch_1.Headers();
+        }
+        reqOptions.headers.set("Connection", "keep-alive");
+        if (!reqOptions.headers.has("User-Agent")) {
+            reqOptions.headers.set("User-Agent", `FirebaseCLI/${CLI_VERSION}`);
+        }
+        reqOptions.headers.set("X-Client-Version", `FirebaseCLI/${CLI_VERSION}`);
+        if (!reqOptions.headers.has("Content-Type")) {
+            if (reqOptions.responseType === "json") {
+                reqOptions.headers.set("Content-Type", "application/json");
+            }
+        }
+        return reqOptions;
+    }
+    async addAuthHeader(reqOptions) {
+        if (!reqOptions.headers) {
+            reqOptions.headers = new node_fetch_1.Headers();
+        }
+        let token;
+        if (isLocalInsecureRequest(this.opts.urlPrefix)) {
+            token = "owner";
+        }
+        else {
+            token = await this.getAccessToken();
+        }
+        reqOptions.headers.set("Authorization", `Bearer ${token}`);
+        return reqOptions;
+    }
+    async getAccessToken() {
+        if (accessToken) {
+            return accessToken;
+        }
+        const data = (await auth.getAccessToken(refreshToken, []));
+        return data.access_token;
+    }
+    requestURL(options) {
+        const versionPath = this.opts.apiVersion ? `/${this.opts.apiVersion}` : "";
+        return `${this.opts.urlPrefix}${versionPath}${options.path}`;
+    }
+    async doRequest(options) {
+        var _a;
+        if (!options.path.startsWith("/")) {
+            options.path = "/" + options.path;
+        }
+        let fetchURL = this.requestURL(options);
+        if (options.queryParams) {
+            if (!(options.queryParams instanceof url_1.URLSearchParams)) {
+                const sp = new url_1.URLSearchParams();
+                for (const key of Object.keys(options.queryParams)) {
+                    const value = options.queryParams[key];
+                    sp.append(key, `${value}`);
+                }
+                options.queryParams = sp;
+            }
+            const queryString = options.queryParams.toString();
+            if (queryString) {
+                fetchURL += `?${queryString}`;
+            }
+        }
+        const fetchOptions = {
+            headers: options.headers,
+            method: options.method,
+            redirect: options.redirect,
+            compress: options.compress,
+        };
+        if (this.opts.proxy) {
+            fetchOptions.agent = new ProxyAgent(this.opts.proxy);
+        }
+        const envProxy = proxyURIFromEnv();
+        if (envProxy) {
+            fetchOptions.agent = new ProxyAgent(envProxy);
+        }
+        if (options.signal) {
+            fetchOptions.signal = options.signal;
+        }
+        let reqTimeout;
+        if (options.timeout) {
+            const controller = new abort_controller_1.default();
+            reqTimeout = setTimeout(() => {
+                controller.abort();
+            }, options.timeout);
+            fetchOptions.signal = controller.signal;
+        }
+        if (typeof options.body === "string" || isStream(options.body)) {
+            fetchOptions.body = options.body;
+        }
+        else if (options.body !== undefined) {
+            fetchOptions.body = JSON.stringify(options.body);
+        }
+        const operationOptions = {
+            retries: ((_a = options.retryCodes) === null || _a === void 0 ? void 0 : _a.length) ? 1 : 2,
+            minTimeout: 1 * 1000,
+            maxTimeout: 5 * 1000,
+        };
+        if (typeof options.retries === "number") {
+            operationOptions.retries = options.retries;
+        }
+        if (typeof options.retryMinTimeout === "number") {
+            operationOptions.minTimeout = options.retryMinTimeout;
+        }
+        if (typeof options.retryMaxTimeout === "number") {
+            operationOptions.maxTimeout = options.retryMaxTimeout;
+        }
+        const operation = retry.operation(operationOptions);
+        return await new Promise((resolve, reject) => {
+            operation.attempt(async (currentAttempt) => {
+                var _a;
+                let res;
+                let body;
+                try {
+                    if (currentAttempt > 1) {
+                        logger_1.logger.debug(`*** [apiv2] Attempting the request again. Attempt number ${currentAttempt}`);
+                    }
+                    this.logRequest(options);
+                    try {
+                        res = await (0, node_fetch_1.default)(fetchURL, fetchOptions);
+                    }
+                    catch (thrown) {
+                        const err = thrown instanceof Error ? thrown : new Error(thrown);
+                        const isAbortError = err.name.includes("AbortError");
+                        if (isAbortError) {
+                            throw new error_1.FirebaseError(`Timeout reached making request to ${fetchURL}`, {
+                                original: err,
+                            });
+                        }
+                        throw new error_1.FirebaseError(`Failed to make request to ${fetchURL}`, { original: err });
+                    }
+                    finally {
+                        if (reqTimeout) {
+                            clearTimeout(reqTimeout);
+                        }
+                    }
+                    if (options.responseType === "json") {
+                        const text = await res.text();
+                        if (!text.length) {
+                            body = undefined;
+                        }
+                        else {
+                            try {
+                                body = JSON.parse(text);
+                            }
+                            catch (err) {
+                                this.logResponse(res, text, options);
+                                throw new error_1.FirebaseError(`Unable to parse JSON: ${err}`);
+                            }
+                        }
+                    }
+                    else if (options.responseType === "xml") {
+                        body = (await res.text());
+                    }
+                    else if (options.responseType === "stream") {
+                        body = res.body;
+                    }
+                    else {
+                        throw new error_1.FirebaseError(`Unable to interpret response. Please set responseType.`, {
+                            exit: 2,
+                        });
+                    }
+                }
+                catch (err) {
+                    return err instanceof error_1.FirebaseError ? reject(err) : reject(new error_1.FirebaseError(`${err}`));
+                }
+                this.logResponse(res, body, options);
+                if (res.status >= 400) {
+                    if ((_a = options.retryCodes) === null || _a === void 0 ? void 0 : _a.includes(res.status)) {
+                        const err = (0, responseToError_1.responseToError)({ statusCode: res.status }, body) || undefined;
+                        if (operation.retry(err)) {
+                            return;
+                        }
+                    }
+                    if (!options.resolveOnHTTPError) {
+                        return reject((0, responseToError_1.responseToError)({ statusCode: res.status }, body));
+                    }
+                }
+                resolve({
+                    status: res.status,
+                    response: res,
+                    body,
+                });
+            });
+        });
+    }
+    logRequest(options) {
+        var _a, _b;
+        let queryParamsLog = "[none]";
+        if (options.queryParams) {
+            queryParamsLog = "[omitted]";
+            if (!((_a = options.skipLog) === null || _a === void 0 ? void 0 : _a.queryParams)) {
+                queryParamsLog =
+                    options.queryParams instanceof url_1.URLSearchParams
+                        ? options.queryParams.toString()
+                        : JSON.stringify(options.queryParams);
+            }
+        }
+        const logURL = this.requestURL(options);
+        logger_1.logger.debug(`>>> [apiv2][query] ${options.method} ${logURL} ${queryParamsLog}`);
+        const headers = options.headers;
+        if (headers && headers.has(GOOG_QUOTA_USER)) {
+            logger_1.logger.debug(`>>> [apiv2][(partial)header] ${options.method} ${logURL} x-goog-quota-user=${headers.get(GOOG_QUOTA_USER) || ""}`);
+        }
+        if (options.body !== undefined) {
+            let logBody = "[omitted]";
+            if (!((_b = options.skipLog) === null || _b === void 0 ? void 0 : _b.body)) {
+                logBody = bodyToString(options.body);
+            }
+            logger_1.logger.debug(`>>> [apiv2][body] ${options.method} ${logURL} ${logBody}`);
+        }
+    }
+    logResponse(res, body, options) {
+        var _a;
+        const logURL = this.requestURL(options);
+        logger_1.logger.debug(`<<< [apiv2][status] ${options.method} ${logURL} ${res.status}`);
+        let logBody = "[omitted]";
+        if (!((_a = options.skipLog) === null || _a === void 0 ? void 0 : _a.resBody)) {
+            logBody = bodyToString(body);
+        }
+        logger_1.logger.debug(`<<< [apiv2][body] ${options.method} ${logURL} ${logBody}`);
+    }
+}
+exports.Client = Client;
+function isLocalInsecureRequest(urlPrefix) {
+    const u = new url_1.URL(urlPrefix);
+    return u.protocol === "http:";
+}
+function bodyToString(body) {
+    if (isStream(body)) {
+        return "[stream]";
+    }
+    else {
+        try {
+            return JSON.stringify(body);
+        }
+        catch (_) {
+            return util_1.default.inspect(body);
+        }
+    }
+}
+function isStream(o) {
+    return o instanceof stream_1.Readable || o instanceof FormData;
+}

node_modules/firebase-tools/lib/appdistribution/client.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppDistributionClient = exports.UploadReleaseResult = exports.IntegrationState = void 0;
+const utils = require("../utils");
+const operationPoller = require("../operation-poller");
+const error_1 = require("../error");
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+var IntegrationState;
+(function (IntegrationState) {
+    IntegrationState["AAB_INTEGRATION_STATE_UNSPECIFIED"] = "AAB_INTEGRATION_STATE_UNSPECIFIED";
+    IntegrationState["INTEGRATED"] = "INTEGRATED";
+    IntegrationState["PLAY_ACCOUNT_NOT_LINKED"] = "PLAY_ACCOUNT_NOT_LINKED";
+    IntegrationState["NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT"] = "NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT";
+    IntegrationState["APP_NOT_PUBLISHED"] = "APP_NOT_PUBLISHED";
+    IntegrationState["AAB_STATE_UNAVAILABLE"] = "AAB_STATE_UNAVAILABLE";
+    IntegrationState["PLAY_IAS_TERMS_NOT_ACCEPTED"] = "PLAY_IAS_TERMS_NOT_ACCEPTED";
+})(IntegrationState = exports.IntegrationState || (exports.IntegrationState = {}));
+var UploadReleaseResult;
+(function (UploadReleaseResult) {
+    UploadReleaseResult["UPLOAD_RELEASE_RESULT_UNSPECIFIED"] = "UPLOAD_RELEASE_RESULT_UNSPECIFIED";
+    UploadReleaseResult["RELEASE_CREATED"] = "RELEASE_CREATED";
+    UploadReleaseResult["RELEASE_UPDATED"] = "RELEASE_UPDATED";
+    UploadReleaseResult["RELEASE_UNMODIFIED"] = "RELEASE_UNMODIFIED";
+})(UploadReleaseResult = exports.UploadReleaseResult || (exports.UploadReleaseResult = {}));
+class AppDistributionClient {
+    constructor() {
+        this.appDistroV2Client = new apiv2_1.Client({
+            urlPrefix: api_1.appDistributionOrigin,
+            apiVersion: "v1",
+        });
+    }
+    async getAabInfo(appName) {
+        const apiResponse = await this.appDistroV2Client.get(`/${appName}/aabInfo`);
+        return apiResponse.body;
+    }
+    async uploadRelease(appName, distribution) {
+        const client = new apiv2_1.Client({ urlPrefix: api_1.appDistributionOrigin });
+        const apiResponse = await client.request({
+            method: "POST",
+            path: `/upload/v1/${appName}/releases:upload`,
+            headers: {
+                "X-Goog-Upload-File-Name": distribution.getFileName(),
+                "X-Goog-Upload-Protocol": "raw",
+                "Content-Type": "application/octet-stream",
+            },
+            responseType: "json",
+            body: distribution.readStream(),
+        });
+        return apiResponse.body.name;
+    }
+    async pollUploadStatus(operationName) {
+        return operationPoller.pollOperation({
+            pollerName: "App Distribution Upload Poller",
+            apiOrigin: api_1.appDistributionOrigin,
+            apiVersion: "v1",
+            operationResourceName: operationName,
+            masterTimeout: 5 * 60 * 1000,
+            backoff: 1000,
+            maxBackoff: 10 * 1000,
+        });
+    }
+    async updateReleaseNotes(releaseName, releaseNotes) {
+        if (!releaseNotes) {
+            utils.logWarning("no release notes specified, skipping");
+            return;
+        }
+        utils.logBullet("updating release notes...");
+        const data = {
+            name: releaseName,
+            releaseNotes: {
+                text: releaseNotes,
+            },
+        };
+        const queryParams = { updateMask: "release_notes.text" };
+        try {
+            await this.appDistroV2Client.patch(`/${releaseName}`, data, { queryParams });
+        }
+        catch (err) {
+            throw new error_1.FirebaseError(`failed to update release notes with ${err === null || err === void 0 ? void 0 : err.message}`);
+        }
+        utils.logSuccess("added release notes successfully");
+    }
+    async distribute(releaseName, testerEmails = [], groupAliases = []) {
+        var _a, _b, _c;
+        if (testerEmails.length === 0 && groupAliases.length === 0) {
+            utils.logWarning("no testers or groups specified, skipping");
+            return;
+        }
+        utils.logBullet("distributing to testers/groups...");
+        const data = {
+            testerEmails,
+            groupAliases,
+        };
+        try {
+            await this.appDistroV2Client.post(`/${releaseName}:distribute`, data);
+        }
+        catch (err) {
+            let errorMessage = err.message;
+            const errorStatus = (_c = (_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.status;
+            if (errorStatus === "FAILED_PRECONDITION") {
+                errorMessage = "invalid testers";
+            }
+            else if (errorStatus === "INVALID_ARGUMENT") {
+                errorMessage = "invalid groups";
+            }
+            throw new error_1.FirebaseError(`failed to distribute to testers/groups: ${errorMessage}`, {
+                exit: 1,
+            });
+        }
+        utils.logSuccess("distributed to testers/groups successfully");
+    }
+    async addTesters(projectName, emails) {
+        try {
+            await this.appDistroV2Client.request({
+                method: "POST",
+                path: `${projectName}/testers:batchAdd`,
+                body: { emails: emails },
+            });
+        }
+        catch (err) {
+            throw new error_1.FirebaseError(`Failed to add testers ${err}`);
+        }
+        utils.logSuccess(`Testers created successfully`);
+    }
+    async removeTesters(projectName, emails) {
+        let apiResponse;
+        try {
+            apiResponse = await this.appDistroV2Client.request({
+                method: "POST",
+                path: `${projectName}/testers:batchRemove`,
+                body: { emails: emails },
+            });
+        }
+        catch (err) {
+            throw new error_1.FirebaseError(`Failed to remove testers ${err}`);
+        }
+        return apiResponse.body;
+    }
+}
+exports.AppDistributionClient = AppDistributionClient;

node_modules/firebase-tools/lib/appdistribution/distribution.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Distribution = exports.DistributionFileType = void 0;
+const fs = require("fs-extra");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const pathUtil = require("path");
+var DistributionFileType;
+(function (DistributionFileType) {
+    DistributionFileType["IPA"] = "ipa";
+    DistributionFileType["APK"] = "apk";
+    DistributionFileType["AAB"] = "aab";
+})(DistributionFileType = exports.DistributionFileType || (exports.DistributionFileType = {}));
+class Distribution {
+    constructor(path) {
+        this.path = path;
+        if (!path) {
+            throw new error_1.FirebaseError("must specify a release binary file");
+        }
+        const distributionType = path.split(".").pop();
+        if (distributionType !== DistributionFileType.IPA &&
+            distributionType !== DistributionFileType.APK &&
+            distributionType !== DistributionFileType.AAB) {
+            throw new error_1.FirebaseError("Unsupported file format, should be .ipa, .apk or .aab");
+        }
+        let stat;
+        try {
+            stat = fs.statSync(path);
+        }
+        catch (err) {
+            logger_1.logger.info(err);
+            throw new error_1.FirebaseError(`File ${path} does not exist: verify that file points to a binary`);
+        }
+        if (!stat.isFile()) {
+            throw new error_1.FirebaseError(`${path} is not a file. Verify that it points to a binary.`);
+        }
+        this.path = path;
+        this.fileType = distributionType;
+        this.fileName = pathUtil.basename(path);
+    }
+    distributionFileType() {
+        return this.fileType;
+    }
+    readStream() {
+        return fs.createReadStream(this.path);
+    }
+    getFileName() {
+        return this.fileName;
+    }
+}
+exports.Distribution = Distribution;

node_modules/firebase-tools/lib/appdistribution/options-parser-util.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppName = exports.getProjectName = exports.ensureFileExists = exports.getEmails = exports.getTestersOrGroups = void 0;
+const fs = require("fs-extra");
+const error_1 = require("../error");
+const projectUtils_1 = require("../projectUtils");
+function getTestersOrGroups(value, file) {
+    if (!value && file) {
+        ensureFileExists(file);
+        value = fs.readFileSync(file, "utf8");
+    }
+    if (value) {
+        return splitter(value);
+    }
+    return [];
+}
+exports.getTestersOrGroups = getTestersOrGroups;
+function getEmails(emails, file) {
+    if (emails.length === 0) {
+        ensureFileExists(file);
+        const readFile = fs.readFileSync(file, "utf8");
+        return splitter(readFile);
+    }
+    return emails;
+}
+exports.getEmails = getEmails;
+function ensureFileExists(file, message = "") {
+    if (!fs.existsSync(file)) {
+        throw new error_1.FirebaseError(`File ${file} does not exist: ${message}`);
+    }
+}
+exports.ensureFileExists = ensureFileExists;
+function splitter(value) {
+    return value
+        .split(/[,\n]/)
+        .map((entry) => entry.trim())
+        .filter((entry) => !!entry);
+}
+async function getProjectName(options) {
+    const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
+    return `projects/${projectNumber}`;
+}
+exports.getProjectName = getProjectName;
+function getAppName(options) {
+    if (!options.app) {
+        throw new error_1.FirebaseError("set the --app option to a valid Firebase app id and try again");
+    }
+    const appId = options.app;
+    return `projects/${appId.split(":")[1]}/apps/${appId}`;
+}
+exports.getAppName = getAppName;

node_modules/firebase-tools/lib/archiveDirectory.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveDirectory = void 0;
+const archiver = require("archiver");
+const filesize = require("filesize");
+const fs = require("fs");
+const path = require("path");
+const tar = require("tar");
+const tmp = require("tmp");
+const error_1 = require("./error");
+const listFiles_1 = require("./listFiles");
+const logger_1 = require("./logger");
+const fsAsync = require("./fsAsync");
+async function archiveDirectory(sourceDirectory, options = {}) {
+    let postfix = ".tar.gz";
+    if (options.type === "zip") {
+        postfix = ".zip";
+    }
+    const tempFile = tmp.fileSync({
+        prefix: "firebase-archive-",
+        postfix,
+    });
+    if (!options.ignore) {
+        options.ignore = [];
+    }
+    let makeArchive;
+    if (options.type === "zip") {
+        makeArchive = zipDirectory(sourceDirectory, tempFile, options);
+    }
+    else {
+        makeArchive = tarDirectory(sourceDirectory, tempFile, options);
+    }
+    try {
+        const archive = await makeArchive;
+        logger_1.logger.debug(`Archived ${filesize(archive.size)} in ${sourceDirectory}.`);
+        return archive;
+    }
+    catch (err) {
+        if (err instanceof error_1.FirebaseError) {
+            throw err;
+        }
+        throw new error_1.FirebaseError("Failed to create archive.", { original: err });
+    }
+}
+exports.archiveDirectory = archiveDirectory;
+async function tarDirectory(sourceDirectory, tempFile, options) {
+    const allFiles = (0, listFiles_1.listFiles)(sourceDirectory, options.ignore);
+    try {
+        fs.statSync(sourceDirectory);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new error_1.FirebaseError(`Could not read directory "${sourceDirectory}"`);
+        }
+        throw err;
+    }
+    if (!allFiles.length) {
+        throw new error_1.FirebaseError(`Cannot create a tar archive with 0 files from directory "${sourceDirectory}"`);
+    }
+    await tar.create({
+        gzip: true,
+        file: tempFile.name,
+        cwd: sourceDirectory,
+        follow: true,
+        noDirRecurse: true,
+        portable: true,
+    }, allFiles);
+    const stats = fs.statSync(tempFile.name);
+    return {
+        file: tempFile.name,
+        stream: fs.createReadStream(tempFile.name),
+        manifest: allFiles,
+        size: stats.size,
+        source: sourceDirectory,
+    };
+}
+async function zipDirectory(sourceDirectory, tempFile, options) {
+    const archiveFileStream = fs.createWriteStream(tempFile.name, {
+        flags: "w",
+        encoding: "binary",
+    });
+    const archive = archiver("zip");
+    const archiveDone = pipeAsync(archive, archiveFileStream);
+    const allFiles = [];
+    let files;
+    try {
+        files = await fsAsync.readdirRecursive({ path: sourceDirectory, ignore: options.ignore });
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new error_1.FirebaseError(`Could not read directory "${sourceDirectory}"`, { original: err });
+        }
+        throw err;
+    }
+    for (const file of files) {
+        const name = path.relative(sourceDirectory, file.name);
+        allFiles.push(name);
+        archive.file(file.name, {
+            name,
+            mode: file.mode,
+        });
+    }
+    void archive.finalize();
+    await archiveDone;
+    const stats = fs.statSync(tempFile.name);
+    return {
+        file: tempFile.name,
+        stream: fs.createReadStream(tempFile.name),
+        manifest: allFiles,
+        size: stats.size,
+        source: sourceDirectory,
+    };
+}
+async function pipeAsync(from, to) {
+    return new Promise((resolve, reject) => {
+        to.on("finish", resolve);
+        to.on("error", reject);
+        from.pipe(to);
+    });
+}

node_modules/firebase-tools/lib/auth.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = exports.getAccessToken = exports.findAccountByEmail = exports.loginGithub = exports.loginGoogle = exports.setGlobalDefaultAccount = exports.setProjectAccount = exports.loginAdditionalAccount = exports.selectAccount = exports.setRefreshToken = exports.setActiveAccount = exports.getAllAccounts = exports.getAdditionalAccounts = exports.getProjectDefaultAccount = exports.getGlobalDefaultAccount = void 0;
+const clc = require("colorette");
+const FormData = require("form-data");
+const fs = require("fs");
+const http = require("http");
+const jwt = require("jsonwebtoken");
+const opn = require("open");
+const path = require("path");
+const portfinder = require("portfinder");
+const url = require("url");
+const util = require("util");
+const apiv2 = require("./apiv2");
+const configstore_1 = require("./configstore");
+const error_1 = require("./error");
+const utils = require("./utils");
+const logger_1 = require("./logger");
+const prompt_1 = require("./prompt");
+const scopes = require("./scopes");
+const defaultCredentials_1 = require("./defaultCredentials");
+const uuid_1 = require("uuid");
+const crypto_1 = require("crypto");
+const track_1 = require("./track");
+const api_1 = require("./api");
+portfinder.setBasePort(9005);
+function getGlobalDefaultAccount() {
+    const user = configstore_1.configstore.get("user");
+    const tokens = configstore_1.configstore.get("tokens");
+    if (!user || !tokens) {
+        return undefined;
+    }
+    return {
+        user,
+        tokens,
+    };
+}
+exports.getGlobalDefaultAccount = getGlobalDefaultAccount;
+function getProjectDefaultAccount(projectDir) {
+    if (!projectDir) {
+        return getGlobalDefaultAccount();
+    }
+    const activeAccounts = configstore_1.configstore.get("activeAccounts") || {};
+    const email = activeAccounts[projectDir];
+    if (!email) {
+        return getGlobalDefaultAccount();
+    }
+    const allAccounts = getAllAccounts();
+    return allAccounts.find((a) => a.user.email === email);
+}
+exports.getProjectDefaultAccount = getProjectDefaultAccount;
+function getAdditionalAccounts() {
+    return configstore_1.configstore.get("additionalAccounts") || [];
+}
+exports.getAdditionalAccounts = getAdditionalAccounts;
+function getAllAccounts() {
+    const res = [];
+    const defaultUser = getGlobalDefaultAccount();
+    if (defaultUser) {
+        res.push(defaultUser);
+    }
+    res.push(...getAdditionalAccounts());
+    return res;
+}
+exports.getAllAccounts = getAllAccounts;
+function setActiveAccount(options, account) {
+    if (account.tokens.refresh_token) {
+        setRefreshToken(account.tokens.refresh_token);
+    }
+    options.user = account.user;
+    options.tokens = account.tokens;
+}
+exports.setActiveAccount = setActiveAccount;
+function setRefreshToken(token) {
+    apiv2.setRefreshToken(token);
+}
+exports.setRefreshToken = setRefreshToken;
+function selectAccount(account, projectRoot) {
+    const defaultUser = getProjectDefaultAccount(projectRoot);
+    if (!account) {
+        return defaultUser;
+    }
+    if (!defaultUser) {
+        throw new error_1.FirebaseError(`Account ${account} not found, have you run "firebase login"?`);
+    }
+    const matchingAccount = getAllAccounts().find((a) => a.user.email === account);
+    if (matchingAccount) {
+        return matchingAccount;
+    }
+    throw new error_1.FirebaseError(`Account ${account} not found, run "firebase login:list" to see existing accounts or "firebase login:add" to add a new one`);
+}
+exports.selectAccount = selectAccount;
+async function loginAdditionalAccount(useLocalhost, email) {
+    const result = await loginGoogle(useLocalhost, email);
+    if (typeof result.user === "string") {
+        throw new error_1.FirebaseError("Failed to parse auth response, see debug log.");
+    }
+    const resultEmail = result.user.email;
+    if (email && resultEmail !== email) {
+        utils.logWarning(`Chosen account ${resultEmail} does not match account hint ${email}`);
+    }
+    const allAccounts = getAllAccounts();
+    const newAccount = {
+        user: result.user,
+        tokens: result.tokens,
+    };
+    const existingAccount = allAccounts.find((a) => a.user.email === resultEmail);
+    if (existingAccount) {
+        utils.logWarning(`Already logged in as ${resultEmail}.`);
+        updateAccount(newAccount);
+    }
+    else {
+        const additionalAccounts = getAdditionalAccounts();
+        additionalAccounts.push(newAccount);
+        configstore_1.configstore.set("additionalAccounts", additionalAccounts);
+    }
+    return newAccount;
+}
+exports.loginAdditionalAccount = loginAdditionalAccount;
+function setProjectAccount(projectDir, email) {
+    logger_1.logger.debug(`setProjectAccount(${projectDir}, ${email})`);
+    const activeAccounts = configstore_1.configstore.get("activeAccounts") || {};
+    activeAccounts[projectDir] = email;
+    configstore_1.configstore.set("activeAccounts", activeAccounts);
+}
+exports.setProjectAccount = setProjectAccount;
+function setGlobalDefaultAccount(account) {
+    configstore_1.configstore.set("user", account.user);
+    configstore_1.configstore.set("tokens", account.tokens);
+    const additionalAccounts = getAdditionalAccounts();
+    const index = additionalAccounts.findIndex((a) => a.user.email === account.user.email);
+    if (index >= 0) {
+        additionalAccounts.splice(index, 1);
+        configstore_1.configstore.set("additionalAccounts", additionalAccounts);
+    }
+}
+exports.setGlobalDefaultAccount = setGlobalDefaultAccount;
+function open(url) {
+    opn(url).catch((err) => {
+        logger_1.logger.debug("Unable to open URL: " + err.stack);
+    });
+}
+function invalidCredentialError() {
+    return new error_1.FirebaseError("Authentication Error: Your credentials are no longer valid. Please run " +
+        clc.bold("firebase login --reauth") +
+        "\n\n" +
+        "For CI servers and headless environments, generate a new token with " +
+        clc.bold("firebase login:ci"), { exit: 1 });
+}
+const FIFTEEN_MINUTES_IN_MS = 15 * 60 * 1000;
+const SCOPES = [
+    scopes.EMAIL,
+    scopes.OPENID,
+    scopes.CLOUD_PROJECTS_READONLY,
+    scopes.FIREBASE_PLATFORM,
+    scopes.CLOUD_PLATFORM,
+];
+const _nonce = Math.floor(Math.random() * (2 << 29) + 1).toString();
+const getPort = portfinder.getPortPromise;
+let lastAccessToken;
+function getCallbackUrl(port) {
+    if (typeof port === "undefined") {
+        return "urn:ietf:wg:oauth:2.0:oob";
+    }
+    return `http://localhost:${port}`;
+}
+function queryParamString(args) {
+    const tokens = [];
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value === "string") {
+            tokens.push(key + "=" + encodeURIComponent(value));
+        }
+    }
+    return tokens.join("&");
+}
+function getLoginUrl(callbackUrl, userHint) {
+    return (api_1.authOrigin +
+        "/o/oauth2/auth?" +
+        queryParamString({
+            client_id: api_1.clientId,
+            scope: SCOPES.join(" "),
+            response_type: "code",
+            state: _nonce,
+            redirect_uri: callbackUrl,
+            login_hint: userHint,
+        }));
+}
+async function getTokensFromAuthorizationCode(code, callbackUrl, verifier) {
+    const params = {
+        code: code,
+        client_id: api_1.clientId,
+        client_secret: api_1.clientSecret,
+        redirect_uri: callbackUrl,
+        grant_type: "authorization_code",
+    };
+    if (verifier) {
+        params["code_verifier"] = verifier;
+    }
+    let res;
+    try {
+        const client = new apiv2.Client({ urlPrefix: api_1.authOrigin, auth: false });
+        const form = new FormData();
+        for (const [k, v] of Object.entries(params)) {
+            form.append(k, v);
+        }
+        res = await client.request({
+            method: "POST",
+            path: "/o/oauth2/token",
+            body: form,
+            headers: form.getHeaders(),
+            skipLog: { body: true, queryParams: true, resBody: true },
+        });
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            logger_1.logger.debug("Token Fetch Error:", err.stack || "");
+        }
+        else {
+            logger_1.logger.debug("Token Fetch Error");
+        }
+        throw invalidCredentialError();
+    }
+    if (!res.body.access_token && !res.body.refresh_token) {
+        logger_1.logger.debug("Token Fetch Error:", res.status, res.body);
+        throw invalidCredentialError();
+    }
+    lastAccessToken = Object.assign({
+        expires_at: Date.now() + res.body.expires_in * 1000,
+    }, res.body);
+    return lastAccessToken;
+}
+const GITHUB_SCOPES = ["read:user", "repo", "public_repo"];
+function getGithubLoginUrl(callbackUrl) {
+    return (api_1.githubOrigin +
+        "/login/oauth/authorize?" +
+        queryParamString({
+            client_id: api_1.githubClientId,
+            state: _nonce,
+            redirect_uri: callbackUrl,
+            scope: GITHUB_SCOPES.join(" "),
+        }));
+}
+async function getGithubTokensFromAuthorizationCode(code, callbackUrl) {
+    const client = new apiv2.Client({ urlPrefix: api_1.githubOrigin, auth: false });
+    const data = {
+        client_id: api_1.githubClientId,
+        client_secret: api_1.githubClientSecret,
+        code,
+        redirect_uri: callbackUrl,
+        state: _nonce,
+    };
+    const form = new FormData();
+    for (const [k, v] of Object.entries(data)) {
+        form.append(k, v);
+    }
+    const headers = form.getHeaders();
+    headers.accept = "application/json";
+    const res = await client.request({
+        method: "POST",
+        path: "/login/oauth/access_token",
+        body: form,
+        headers,
+    });
+    return res.body.access_token;
+}
+async function respondWithFile(req, res, statusCode, filename) {
+    const response = await util.promisify(fs.readFile)(path.join(__dirname, filename));
+    res.writeHead(statusCode, {
+        "Content-Length": response.length,
+        "Content-Type": "text/html",
+    });
+    res.end(response);
+    req.socket.destroy();
+}
+function urlsafeBase64(base64string) {
+    return base64string.replace(/\+/g, "-").replace(/=+$/, "").replace(/\//g, "_");
+}
+async function loginRemotely() {
+    var _a;
+    const authProxyClient = new apiv2.Client({
+        urlPrefix: api_1.authProxyOrigin,
+        auth: false,
+    });
+    const sessionId = (0, uuid_1.v4)();
+    const codeVerifier = (0, crypto_1.randomBytes)(32).toString("hex");
+    const codeChallenge = urlsafeBase64((0, crypto_1.createHash)("sha256").update(codeVerifier).digest("base64"));
+    const attestToken = (_a = (await authProxyClient.post("/attest", {
+        session_id: sessionId,
+    })).body) === null || _a === void 0 ? void 0 : _a.token;
+    const loginUrl = `${api_1.authProxyOrigin}/login?code_challenge=${codeChallenge}&session=${sessionId}&attest=${attestToken}`;
+    logger_1.logger.info();
+    logger_1.logger.info("To sign in to the Firebase CLI:");
+    logger_1.logger.info();
+    logger_1.logger.info("1. Take note of your session ID:");
+    logger_1.logger.info();
+    logger_1.logger.info(`   ${clc.bold(sessionId.substring(0, 5).toUpperCase())}`);
+    logger_1.logger.info();
+    logger_1.logger.info("2. Visit the URL below on any device and follow the instructions to get your code:");
+    logger_1.logger.info();
+    logger_1.logger.info(`   ${loginUrl}`);
+    logger_1.logger.info();
+    logger_1.logger.info("3. Paste or enter the authorization code below once you have it:");
+    logger_1.logger.info();
+    const code = await (0, prompt_1.promptOnce)({
+        type: "input",
+        message: "Enter authorization code:",
+    });
+    try {
+        const tokens = await getTokensFromAuthorizationCode(code, `${api_1.authProxyOrigin}/complete`, codeVerifier);
+        void (0, track_1.track)("login", "google_remote");
+        return {
+            user: jwt.decode(tokens.id_token),
+            tokens: tokens,
+            scopes: SCOPES,
+        };
+    }
+    catch (e) {
+        throw new error_1.FirebaseError("Unable to authenticate using the provided code. Please try again.");
+    }
+}
+async function loginWithLocalhostGoogle(port, userHint) {
+    const callbackUrl = getCallbackUrl(port);
+    const authUrl = getLoginUrl(callbackUrl, userHint);
+    const successTemplate = "../templates/loginSuccess.html";
+    const tokens = await loginWithLocalhost(port, callbackUrl, authUrl, successTemplate, getTokensFromAuthorizationCode);
+    void (0, track_1.track)("login", "google_localhost");
+    return {
+        user: jwt.decode(tokens.id_token),
+        tokens: tokens,
+        scopes: tokens.scopes,
+    };
+}
+async function loginWithLocalhostGitHub(port) {
+    const callbackUrl = getCallbackUrl(port);
+    const authUrl = getGithubLoginUrl(callbackUrl);
+    const successTemplate = "../templates/loginSuccessGithub.html";
+    const tokens = await loginWithLocalhost(port, callbackUrl, authUrl, successTemplate, getGithubTokensFromAuthorizationCode);
+    void (0, track_1.track)("login", "google_localhost");
+    return tokens;
+}
+async function loginWithLocalhost(port, callbackUrl, authUrl, successTemplate, getTokens) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            const query = url.parse(`${req.url}`, true).query || {};
+            const queryState = query.state;
+            const queryCode = query.code;
+            if (queryState !== _nonce || typeof queryCode !== "string") {
+                await respondWithFile(req, res, 400, "../templates/loginFailure.html");
+                reject(new error_1.FirebaseError("Unexpected error while logging in"));
+                server.close();
+                return;
+            }
+            try {
+                const tokens = await getTokens(queryCode, callbackUrl);
+                await respondWithFile(req, res, 200, successTemplate);
+                resolve(tokens);
+            }
+            catch (err) {
+                await respondWithFile(req, res, 400, "../templates/loginFailure.html");
+                reject(err);
+            }
+            server.close();
+            return;
+        });
+        server.listen(port, () => {
+            logger_1.logger.info();
+            logger_1.logger.info("Visit this URL on this device to log in:");
+            logger_1.logger.info(clc.bold(clc.underline(authUrl)));
+            logger_1.logger.info();
+            logger_1.logger.info("Waiting for authentication...");
+            open(authUrl);
+        });
+        server.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+async function loginGoogle(localhost, userHint) {
+    if (localhost) {
+        try {
+            const port = await getPort();
+            return await loginWithLocalhostGoogle(port, userHint);
+        }
+        catch (_a) {
+            return await loginRemotely();
+        }
+    }
+    return await loginRemotely();
+}
+exports.loginGoogle = loginGoogle;
+async function loginGithub() {
+    const port = await getPort();
+    return loginWithLocalhostGitHub(port);
+}
+exports.loginGithub = loginGithub;
+function findAccountByEmail(email) {
+    return getAllAccounts().find((a) => a.user.email === email);
+}
+exports.findAccountByEmail = findAccountByEmail;
+function haveValidTokens(refreshToken, authScopes) {
+    var _a;
+    if (!(lastAccessToken === null || lastAccessToken === void 0 ? void 0 : lastAccessToken.access_token)) {
+        const tokens = configstore_1.configstore.get("tokens");
+        if (refreshToken === (tokens === null || tokens === void 0 ? void 0 : tokens.refresh_token)) {
+            lastAccessToken = tokens;
+        }
+    }
+    const hasTokens = !!(lastAccessToken === null || lastAccessToken === void 0 ? void 0 : lastAccessToken.access_token);
+    const oldScopesJSON = JSON.stringify(((_a = lastAccessToken === null || lastAccessToken === void 0 ? void 0 : lastAccessToken.scopes) === null || _a === void 0 ? void 0 : _a.sort()) || []);
+    const newScopesJSON = JSON.stringify(authScopes.sort());
+    const hasSameScopes = oldScopesJSON === newScopesJSON;
+    const isExpired = ((lastAccessToken === null || lastAccessToken === void 0 ? void 0 : lastAccessToken.expires_at) || 0) < Date.now() + FIFTEEN_MINUTES_IN_MS;
+    return hasTokens && hasSameScopes && !isExpired;
+}
+function deleteAccount(account) {
+    const defaultAccount = getGlobalDefaultAccount();
+    if (account.user.email === (defaultAccount === null || defaultAccount === void 0 ? void 0 : defaultAccount.user.email)) {
+        configstore_1.configstore.delete("user");
+        configstore_1.configstore.delete("tokens");
+        configstore_1.configstore.delete("usage");
+        configstore_1.configstore.delete("analytics-uuid");
+    }
+    const additionalAccounts = getAdditionalAccounts();
+    const remainingAccounts = additionalAccounts.filter((a) => a.user.email !== account.user.email);
+    configstore_1.configstore.set("additionalAccounts", remainingAccounts);
+    const activeAccounts = configstore_1.configstore.get("activeAccounts") || {};
+    for (const [projectDir, projectAccount] of Object.entries(activeAccounts)) {
+        if (projectAccount === account.user.email) {
+            delete activeAccounts[projectDir];
+        }
+    }
+    configstore_1.configstore.set("activeAccounts", activeAccounts);
+}
+function updateAccount(account) {
+    const defaultAccount = getGlobalDefaultAccount();
+    if (account.user.email === (defaultAccount === null || defaultAccount === void 0 ? void 0 : defaultAccount.user.email)) {
+        configstore_1.configstore.set("user", account.user);
+        configstore_1.configstore.set("tokens", account.tokens);
+    }
+    const additionalAccounts = getAdditionalAccounts();
+    const accountIndex = additionalAccounts.findIndex((a) => a.user.email === account.user.email);
+    if (accountIndex >= 0) {
+        additionalAccounts.splice(accountIndex, 1, account);
+        configstore_1.configstore.set("additionalAccounts", additionalAccounts);
+    }
+}
+function findAccountByRefreshToken(refreshToken) {
+    return getAllAccounts().find((a) => a.tokens.refresh_token === refreshToken);
+}
+function logoutCurrentSession(refreshToken) {
+    const account = findAccountByRefreshToken(refreshToken);
+    if (!account) {
+        return;
+    }
+    (0, defaultCredentials_1.clearCredentials)(account);
+    deleteAccount(account);
+}
+async function refreshTokens(refreshToken, authScopes) {
+    var _a, _b;
+    logger_1.logger.debug("> refreshing access token with scopes:", JSON.stringify(authScopes));
+    try {
+        const client = new apiv2.Client({ urlPrefix: api_1.googleOrigin, auth: false });
+        const data = {
+            refresh_token: refreshToken,
+            client_id: api_1.clientId,
+            client_secret: api_1.clientSecret,
+            grant_type: "refresh_token",
+            scope: (authScopes || []).join(" "),
+        };
+        const form = new FormData();
+        for (const [k, v] of Object.entries(data)) {
+            form.append(k, v);
+        }
+        const res = await client.request({
+            method: "POST",
+            path: "/oauth2/v3/token",
+            body: form,
+            headers: form.getHeaders(),
+            skipLog: { body: true, queryParams: true, resBody: true },
+            resolveOnHTTPError: true,
+        });
+        if (res.status === 401 || res.status === 400) {
+            return { access_token: refreshToken };
+        }
+        if (typeof res.body.access_token !== "string") {
+            throw invalidCredentialError();
+        }
+        lastAccessToken = Object.assign({
+            expires_at: Date.now() + res.body.expires_in * 1000,
+            refresh_token: refreshToken,
+            scopes: authScopes,
+        }, res.body);
+        const account = findAccountByRefreshToken(refreshToken);
+        if (account && lastAccessToken) {
+            account.tokens = lastAccessToken;
+            updateAccount(account);
+        }
+        return lastAccessToken;
+    }
+    catch (err) {
+        if (((_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) === "invalid_scope") {
+            throw new error_1.FirebaseError("This command requires new authorization scopes not granted to your current session. Please run " +
+                clc.bold("firebase login --reauth") +
+                "\n\n" +
+                "For CI servers and headless environments, generate a new token with " +
+                clc.bold("firebase login:ci"), { exit: 1 });
+        }
+        throw invalidCredentialError();
+    }
+}
+async function getAccessToken(refreshToken, authScopes) {
+    if (haveValidTokens(refreshToken, authScopes)) {
+        return lastAccessToken;
+    }
+    return refreshTokens(refreshToken, authScopes);
+}
+exports.getAccessToken = getAccessToken;
+async function logout(refreshToken) {
+    if ((lastAccessToken === null || lastAccessToken === void 0 ? void 0 : lastAccessToken.refresh_token) === refreshToken) {
+        lastAccessToken = undefined;
+    }
+    logoutCurrentSession(refreshToken);
+    try {
+        const client = new apiv2.Client({ urlPrefix: api_1.authOrigin, auth: false });
+        await client.get("/o/oauth2/revoke", { queryParams: { token: refreshToken } });
+    }
+    catch (thrown) {
+        const err = thrown instanceof Error ? thrown : new Error(thrown);
+        throw new error_1.FirebaseError("Authentication Error.", {
+            exit: 1,
+            original: err,
+        });
+    }
+}
+exports.logout = logout;

node_modules/firebase-tools/lib/bin/firebase.js

+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver = require("semver");
+const pkg = require("../../package.json");
+const nodeVersion = process.version;
+if (!semver.satisfies(nodeVersion, pkg.engines.node)) {
+    console.error(`Firebase CLI v${pkg.version} is incompatible with Node.js ${nodeVersion} Please upgrade Node.js to version ${pkg.engines.node}`);
+    process.exit(1);
+}
+const updateNotifierPkg = require("update-notifier");
+const clc = require("colorette");
+const TerminalRenderer = require("marked-terminal");
+const updateNotifier = updateNotifierPkg({ pkg });
+const marked_1 = require("marked");
+marked_1.marked.setOptions({
+    renderer: new TerminalRenderer(),
+});
+const node_path_1 = require("node:path");
+const triple_beam_1 = require("triple-beam");
+const stripAnsi = require("strip-ansi");
+const fs = require("node:fs");
+const configstore_1 = require("../configstore");
+const errorOut_1 = require("../errorOut");
+const handlePreviewToggles_1 = require("../handlePreviewToggles");
+const logger_1 = require("../logger");
+const client = require("..");
+const fsutils = require("../fsutils");
+const utils = require("../utils");
+const winston = require("winston");
+let args = process.argv.slice(2);
+let cmd;
+function findAvailableLogFile() {
+    const candidates = ["firebase-debug.log"];
+    for (let i = 1; i < 10; i++) {
+        candidates.push(`firebase-debug.${i}.log`);
+    }
+    for (const c of candidates) {
+        const logFilename = (0, node_path_1.join)(process.cwd(), c);
+        try {
+            const fd = fs.openSync(logFilename, "r+");
+            fs.closeSync(fd);
+            return logFilename;
+        }
+        catch (e) {
+            if (e.code === "ENOENT") {
+                return logFilename;
+            }
+        }
+    }
+    throw new Error("Unable to obtain permissions for firebase-debug.log");
+}
+const logFilename = findAvailableLogFile();
+if (!process.env.DEBUG && args.includes("--debug")) {
+    process.env.DEBUG = "true";
+}
+process.env.IS_FIREBASE_CLI = "true";
+logger_1.logger.add(new winston.transports.File({
+    level: "debug",
+    filename: logFilename,
+    format: winston.format.printf((info) => {
+        const segments = [info.message, ...(info[triple_beam_1.SPLAT] || [])].map(utils.tryStringify);
+        return `[${info.level}] ${stripAnsi(segments.join(" "))}`;
+    }),
+}));
+logger_1.logger.debug("-".repeat(70));
+logger_1.logger.debug("Command:      ", process.argv.join(" "));
+logger_1.logger.debug("CLI Version:  ", pkg.version);
+logger_1.logger.debug("Platform:     ", process.platform);
+logger_1.logger.debug("Node Version: ", process.version);
+logger_1.logger.debug("Time:         ", new Date().toString());
+if (utils.envOverrides.length) {
+    logger_1.logger.debug("Env Overrides:", utils.envOverrides.join(", "));
+}
+logger_1.logger.debug("-".repeat(70));
+logger_1.logger.debug();
+const experiments_1 = require("../experiments");
+const fetchMOTD_1 = require("../fetchMOTD");
+(0, experiments_1.enableExperimentsFromCliEnvVariable)();
+(0, fetchMOTD_1.fetchMOTD)();
+process.on("exit", (code) => {
+    code = process.exitCode || code;
+    if (!process.env.DEBUG && code < 2 && fsutils.fileExistsSync(logFilename)) {
+        fs.unlinkSync(logFilename);
+    }
+    if (code > 0 && process.stdout.isTTY) {
+        const lastError = configstore_1.configstore.get("lastError") || 0;
+        const timestamp = Date.now();
+        if (lastError > timestamp - 120000) {
+            let help;
+            if (code === 1 && cmd) {
+                help = "Having trouble? Try " + clc.bold("firebase [command] --help");
+            }
+            else {
+                help = "Having trouble? Try again or contact support with contents of firebase-debug.log";
+            }
+            if (cmd) {
+                console.log();
+                console.log(help);
+            }
+        }
+        configstore_1.configstore.set("lastError", timestamp);
+    }
+    else {
+        configstore_1.configstore.delete("lastError");
+    }
+    try {
+        const updateMessage = `Update available ${clc.gray("{currentVersion}")} → ${clc.green("{latestVersion}")}\n` +
+            `To update to the latest version using npm, run\n${clc.cyan("npm install -g firebase-tools")}\n` +
+            `For other CLI management options, visit the ${(0, marked_1.marked)("[CLI documentation](https://firebase.google.com/docs/cli#update-cli)")}`;
+        updateNotifier.notify({ defer: false, isGlobal: true, message: updateMessage });
+    }
+    catch (err) {
+        logger_1.logger.debug("Error when notifying about new CLI updates:");
+        if (err instanceof Error) {
+            logger_1.logger.debug(err);
+        }
+        else {
+            logger_1.logger.debug(`${err}`);
+        }
+    }
+});
+process.on("uncaughtException", (err) => {
+    (0, errorOut_1.errorOut)(err);
+});
+if (!(0, handlePreviewToggles_1.handlePreviewToggles)(args)) {
+    cmd = client.cli.parse(process.argv);
+    args = args.filter((arg) => !arg.includes("-"));
+    if (!args.length) {
+        client.cli.help();
+    }
+}

node_modules/firebase-tools/lib/checkMinRequiredVersion.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMinRequiredVersion = void 0;
+const semver = require("semver");
+const configstore_1 = require("./configstore");
+const error_1 = require("./error");
+const pkg = require("../package.json");
+function checkMinRequiredVersion(options, key) {
+    const minVersion = configstore_1.configstore.get(`motd.${key}`);
+    if (minVersion && semver.gt(minVersion, pkg.version)) {
+        throw new error_1.FirebaseError(`This command requires at least version ${minVersion} of the CLI to use. To update to the latest version using npm, run \`npm install -g firebase-tools\`. For other CLI management options, see https://firebase.google.com/docs/cli#update-cli`);
+    }
+}
+exports.checkMinRequiredVersion = checkMinRequiredVersion;

node_modules/firebase-tools/lib/checkValidTargetFilters.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkValidTargetFilters = void 0;
+const deploy_1 = require("./commands/deploy");
+const error_1 = require("./error");
+function targetsForTypes(only, ...types) {
+    return only.filter((t) => {
+        if (t.includes(":")) {
+            return types.includes(t.split(":")[0]);
+        }
+        else {
+            return types.includes(t);
+        }
+    });
+}
+function targetsHaveFilters(...targets) {
+    return targets.some((t) => t.includes(":"));
+}
+function targetsHaveNoFilters(...targets) {
+    return targets.some((t) => !t.includes(":"));
+}
+const FILTERABLE_TARGETS = new Set(["hosting", "functions", "firestore", "storage", "database"]);
+async function checkValidTargetFilters(options) {
+    const only = !options.only ? [] : options.only.split(",");
+    return new Promise((resolve, reject) => {
+        if (!only.length) {
+            return resolve();
+        }
+        if (options.except) {
+            return reject(new error_1.FirebaseError("Cannot specify both --only and --except"));
+        }
+        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !FILTERABLE_TARGETS.has(t));
+        const targetsForNonFilteredTypes = targetsForTypes(only, ...nonFilteredTypes);
+        if (targetsForNonFilteredTypes.length && targetsHaveFilters(...targetsForNonFilteredTypes)) {
+            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions, hosting, storage, and firestore"));
+        }
+        const targetsForFunctions = targetsForTypes(only, "functions");
+        if (targetsForFunctions.length &&
+            targetsHaveFilters(...targetsForFunctions) &&
+            targetsHaveNoFilters(...targetsForFunctions)) {
+            return reject(new error_1.FirebaseError('Cannot specify "--only functions" and "--only functions:<filter>" at the same time'));
+        }
+        return resolve();
+    });
+}
+exports.checkValidTargetFilters = checkValidTargetFilters;

node_modules/firebase-tools/lib/command.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProjectId = exports.Command = void 0;
+const clc = require("colorette");
+const lodash_1 = require("lodash");
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+const rc_1 = require("./rc");
+const config_1 = require("./config");
+const configstore_1 = require("./configstore");
+const detectProjectRoot_1 = require("./detectProjectRoot");
+const track_1 = require("./track");
+const auth_1 = require("./auth");
+const projects_1 = require("./management/projects");
+const requireAuth_1 = require("./requireAuth");
+class Command {
+    constructor(cmd) {
+        this.cmd = cmd;
+        this.name = "";
+        this.descriptionText = "";
+        this.options = [];
+        this.actionFn = () => {
+        };
+        this.befores = [];
+        this.helpText = "";
+        this.positionalArgs = [];
+        this.name = (0, lodash_1.first)(cmd.split(" ")) || "";
+    }
+    description(t) {
+        this.descriptionText = t;
+        return this;
+    }
+    option(...args) {
+        this.options.push(args);
+        return this;
+    }
+    withForce(message) {
+        this.options.push(["-f, --force", message || "automatically accept all interactive prompts"]);
+        return this;
+    }
+    before(fn, ...args) {
+        this.befores.push({ fn: fn, args: args });
+        return this;
+    }
+    help(t) {
+        this.helpText = t;
+        return this;
+    }
+    action(fn) {
+        this.actionFn = fn;
+        return this;
+    }
+    register(client) {
+        this.client = client;
+        const program = client.cli;
+        const cmd = program.command(this.cmd);
+        if (this.descriptionText) {
+            cmd.description(this.descriptionText);
+        }
+        this.options.forEach((args) => {
+            const flags = args.shift();
+            cmd.option(flags, ...args);
+        });
+        if (this.helpText) {
+            cmd.on("--help", () => {
+                console.log();
+                console.log(this.helpText);
+            });
+        }
+        this.positionalArgs = cmd._args;
+        cmd.action((...args) => {
+            const runner = this.runner();
+            const start = process.uptime();
+            const options = (0, lodash_1.last)(args);
+            if (args.length - 1 > cmd._args.length) {
+                client.errorOut(new error_1.FirebaseError(`Too many arguments. Run ${clc.bold("firebase help " + this.name)} for usage instructions`, { exit: 1 }));
+                return;
+            }
+            const isEmulator = this.name.includes("emulator") || this.name === "serve";
+            if (isEmulator) {
+                void (0, track_1.trackEmulator)("command_start", { command_name: this.name });
+            }
+            runner(...args)
+                .then(async (result) => {
+                if ((0, utils_1.getInheritedOption)(options, "json")) {
+                    console.log(JSON.stringify({
+                        status: "success",
+                        result: result,
+                    }, null, 2));
+                }
+                const duration = Math.floor((process.uptime() - start) * 1000);
+                const trackSuccess = (0, track_1.track)(this.name, "success", duration);
+                if (!isEmulator) {
+                    await (0, utils_1.withTimeout)(5000, trackSuccess);
+                }
+                else {
+                    await (0, utils_1.withTimeout)(5000, Promise.all([
+                        trackSuccess,
+                        (0, track_1.trackEmulator)("command_success", {
+                            command_name: this.name,
+                            duration,
+                        }),
+                    ]));
+                }
+                process.exit();
+            })
+                .catch(async (err) => {
+                if ((0, utils_1.getInheritedOption)(options, "json")) {
+                    console.log(JSON.stringify({
+                        status: "error",
+                        error: err.message,
+                    }, null, 2));
+                }
+                const duration = Math.floor((process.uptime() - start) * 1000);
+                await (0, utils_1.withTimeout)(5000, Promise.all([
+                    (0, track_1.track)(this.name, "error", duration),
+                    (0, track_1.track)(err.exit === 1 ? "Error (User)" : "Error (Unexpected)", "", duration),
+                    isEmulator
+                        ? (0, track_1.trackEmulator)("command_error", {
+                            command_name: this.name,
+                            duration,
+                            error_type: err.exit === 1 ? "user" : "unexpected",
+                        })
+                        : Promise.resolve(),
+                ]));
+                client.errorOut(err);
+            });
+        });
+    }
+    async prepare(options) {
+        options = options || {};
+        options.project = (0, utils_1.getInheritedOption)(options, "project");
+        if (!process.stdin.isTTY || (0, utils_1.getInheritedOption)(options, "nonInteractive")) {
+            options.nonInteractive = true;
+        }
+        if ((0, utils_1.getInheritedOption)(options, "interactive")) {
+            options.interactive = true;
+            options.nonInteractive = false;
+        }
+        if ((0, utils_1.getInheritedOption)(options, "debug")) {
+            options.debug = true;
+        }
+        if ((0, utils_1.getInheritedOption)(options, "json")) {
+            options.nonInteractive = true;
+        }
+        else {
+            (0, utils_1.setupLoggers)();
+        }
+        if ((0, utils_1.getInheritedOption)(options, "config")) {
+            options.configPath = (0, utils_1.getInheritedOption)(options, "config");
+        }
+        try {
+            options.config = config_1.Config.load(options);
+        }
+        catch (e) {
+            options.configError = e;
+        }
+        const account = (0, utils_1.getInheritedOption)(options, "account");
+        options.account = account;
+        options.projectRoot = (0, detectProjectRoot_1.detectProjectRoot)(options);
+        const projectRoot = options.projectRoot;
+        const activeAccount = (0, auth_1.selectAccount)(account, projectRoot);
+        if (activeAccount) {
+            (0, auth_1.setActiveAccount)(options, activeAccount);
+        }
+        this.applyRC(options);
+        if (options.project) {
+            await this.resolveProjectIdentifiers(options);
+            validateProjectId(options.projectId);
+        }
+    }
+    applyRC(options) {
+        const rc = (0, rc_1.loadRC)(options);
+        options.rc = rc;
+        options.project =
+            options.project || (configstore_1.configstore.get("activeProjects") || {})[options.projectRoot];
+        if (options.config && !options.project) {
+            options.project = options.config.defaults.project;
+        }
+        const aliases = rc.projects;
+        const rcProject = (0, lodash_1.get)(aliases, options.project);
+        if (rcProject) {
+            options.projectAlias = options.project;
+            options.project = rcProject;
+        }
+        else if (!options.project && (0, lodash_1.size)(aliases) === 1) {
+            options.projectAlias = (0, lodash_1.head)((0, lodash_1.keys)(aliases));
+            options.project = (0, lodash_1.head)((0, lodash_1.values)(aliases));
+        }
+    }
+    async resolveProjectIdentifiers(options) {
+        var _a;
+        if ((_a = options.project) === null || _a === void 0 ? void 0 : _a.match(/^\d+$/)) {
+            await (0, requireAuth_1.requireAuth)(options);
+            const { projectId, projectNumber } = await (0, projects_1.getFirebaseProject)(options.project);
+            options.projectId = projectId;
+            options.projectNumber = projectNumber;
+        }
+        else {
+            options.projectId = options.project;
+        }
+    }
+    runner() {
+        return async (...args) => {
+            if (typeof (0, lodash_1.last)(args) !== "object" || (0, lodash_1.last)(args) === null) {
+                args.push({});
+            }
+            while (args.length < this.positionalArgs.length + 1) {
+                args.splice(args.length - 1, 0, "");
+            }
+            const options = (0, lodash_1.last)(args);
+            await this.prepare(options);
+            for (const before of this.befores) {
+                await before.fn(options, ...before.args);
+            }
+            return this.actionFn(...args);
+        };
+    }
+}
+exports.Command = Command;
+const PROJECT_ID_REGEX = /^(?:[^:]+:)?[a-z0-9-]+$/;
+function validateProjectId(project) {
+    if (PROJECT_ID_REGEX.test(project)) {
+        return;
+    }
+    (0, track_1.track)("Project ID Check", "invalid");
+    const invalidMessage = "Invalid project id: " + clc.bold(project) + ".";
+    if (project.toLowerCase() !== project) {
+        throw new error_1.FirebaseError(invalidMessage + "\nNote: Project id must be all lowercase.");
+    }
+    else {
+        throw new error_1.FirebaseError(invalidMessage);
+    }
+}
+exports.validateProjectId = validateProjectId;

node_modules/firebase-tools/lib/commands/appdistribution-distribute.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const fs = require("fs-extra");
+const command_1 = require("../command");
+const utils = require("../utils");
+const requireAuth_1 = require("../requireAuth");
+const client_1 = require("../appdistribution/client");
+const error_1 = require("../error");
+const distribution_1 = require("../appdistribution/distribution");
+const options_parser_util_1 = require("../appdistribution/options-parser-util");
+function getReleaseNotes(releaseNotes, releaseNotesFile) {
+    if (releaseNotes) {
+        return releaseNotes.replace(/\\n/g, "\n");
+    }
+    else if (releaseNotesFile) {
+        (0, options_parser_util_1.ensureFileExists)(releaseNotesFile);
+        return fs.readFileSync(releaseNotesFile, "utf8");
+    }
+    return "";
+}
+exports.command = new command_1.Command("appdistribution:distribute <release-binary-file>")
+    .description("upload a release binary")
+    .option("--app <app_id>", "the app id of your Firebase app")
+    .option("--release-notes <string>", "release notes to include")
+    .option("--release-notes-file <file>", "path to file with release notes")
+    .option("--testers <string>", "a comma separated list of tester emails to distribute to")
+    .option("--testers-file <file>", "path to file with a comma separated list of tester emails to distribute to")
+    .option("--groups <string>", "a comma separated list of group aliases to distribute to")
+    .option("--groups-file <file>", "path to file with a comma separated list of group aliases to distribute to")
+    .before(requireAuth_1.requireAuth)
+    .action(async (file, options) => {
+    const appName = (0, options_parser_util_1.getAppName)(options);
+    const distribution = new distribution_1.Distribution(file);
+    const releaseNotes = getReleaseNotes(options.releaseNotes, options.releaseNotesFile);
+    const testers = (0, options_parser_util_1.getTestersOrGroups)(options.testers, options.testersFile);
+    const groups = (0, options_parser_util_1.getTestersOrGroups)(options.groups, options.groupsFile);
+    const requests = new client_1.AppDistributionClient();
+    let aabInfo;
+    if (distribution.distributionFileType() === distribution_1.DistributionFileType.AAB) {
+        try {
+            aabInfo = await requests.getAabInfo(appName);
+        }
+        catch (err) {
+            if (err.status === 404) {
+                throw new error_1.FirebaseError(`App Distribution could not find your app ${options.app}. ` +
+                    `Make sure to onboard your app by pressing the "Get started" ` +
+                    "button on the App Distribution page in the Firebase console: " +
+                    "https://console.firebase.google.com/project/_/appdistribution", { exit: 1 });
+            }
+            throw new error_1.FirebaseError(`failed to determine AAB info. ${err.message}`, { exit: 1 });
+        }
+        if (aabInfo.integrationState !== client_1.IntegrationState.INTEGRATED &&
+            aabInfo.integrationState !== client_1.IntegrationState.AAB_STATE_UNAVAILABLE) {
+            switch (aabInfo.integrationState) {
+                case client_1.IntegrationState.PLAY_ACCOUNT_NOT_LINKED: {
+                    throw new error_1.FirebaseError("This project is not linked to a Google Play account.");
+                }
+                case client_1.IntegrationState.APP_NOT_PUBLISHED: {
+                    throw new error_1.FirebaseError('"This app is not published in the Google Play console.');
+                }
+                case client_1.IntegrationState.NO_APP_WITH_GIVEN_BUNDLE_ID_IN_PLAY_ACCOUNT: {
+                    throw new error_1.FirebaseError("App with matching package name does not exist in Google Play.");
+                }
+                case client_1.IntegrationState.PLAY_IAS_TERMS_NOT_ACCEPTED: {
+                    throw new error_1.FirebaseError("You must accept the Play Internal App Sharing (IAS) terms to upload AABs.");
+                }
+                default: {
+                    throw new error_1.FirebaseError("App Distribution failed to process the AAB: " + aabInfo.integrationState);
+                }
+            }
+        }
+    }
+    utils.logBullet("uploading binary...");
+    let releaseName;
+    try {
+        const operationName = await requests.uploadRelease(appName, distribution);
+        const uploadResponse = await requests.pollUploadStatus(operationName);
+        const release = uploadResponse.release;
+        switch (uploadResponse.result) {
+            case client_1.UploadReleaseResult.RELEASE_CREATED:
+                utils.logSuccess(`uploaded new release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            case client_1.UploadReleaseResult.RELEASE_UPDATED:
+                utils.logSuccess(`uploaded update to existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            case client_1.UploadReleaseResult.RELEASE_UNMODIFIED:
+                utils.logSuccess(`re-uploaded already existing release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+                break;
+            default:
+                utils.logSuccess(`uploaded release ${release.displayVersion} (${release.buildVersion}) successfully!`);
+        }
+        releaseName = uploadResponse.release.name;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            throw new error_1.FirebaseError(`App Distribution could not find your app ${options.app}. ` +
+                `Make sure to onboard your app by pressing the "Get started" ` +
+                "button on the App Distribution page in the Firebase console: " +
+                "https://console.firebase.google.com/project/_/appdistribution", { exit: 1 });
+        }
+        throw new error_1.FirebaseError(`failed to upload release. ${err.message}`, { exit: 1 });
+    }
+    if (aabInfo && !aabInfo.testCertificate) {
+        aabInfo = await requests.getAabInfo(appName);
+        if (aabInfo.testCertificate) {
+            utils.logBullet("After you upload an AAB for the first time, App Distribution " +
+                "generates a new test certificate. All AAB uploads are re-signed with this test " +
+                "certificate. Use the certificate fingerprints below to register your app " +
+                "signing key with API providers, such as Google Sign-In and Google Maps.\n" +
+                `MD-1 certificate fingerprint: ${aabInfo.testCertificate.hashMd5}\n` +
+                `SHA-1 certificate fingerprint: ${aabInfo.testCertificate.hashSha1}\n` +
+                `SHA-256 certificate fingerprint: ${aabInfo.testCertificate.hashSha256}`);
+        }
+    }
+    await requests.updateReleaseNotes(releaseName, releaseNotes);
+    await requests.distribute(releaseName, testers, groups);
+});

node_modules/firebase-tools/lib/commands/appdistribution-testers-add.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const utils = require("../utils");
+const requireAuth_1 = require("../requireAuth");
+const client_1 = require("../appdistribution/client");
+const options_parser_util_1 = require("../appdistribution/options-parser-util");
+exports.command = new command_1.Command("appdistribution:testers:add [emails...]")
+    .description("add testers to project")
+    .option("--file <file>", "a path to a file containing a list of tester emails to be added")
+    .before(requireAuth_1.requireAuth)
+    .action(async (emails, options) => {
+    const projectName = await (0, options_parser_util_1.getProjectName)(options);
+    const appDistroClient = new client_1.AppDistributionClient();
+    const emailsToAdd = (0, options_parser_util_1.getEmails)(emails, options.file);
+    utils.logBullet(`Adding ${emailsToAdd.length} testers to project`);
+    await appDistroClient.addTesters(projectName, emailsToAdd);
+});

node_modules/firebase-tools/lib/commands/appdistribution-testers-remove.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const utils = require("../utils");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+const client_1 = require("../appdistribution/client");
+const options_parser_util_1 = require("../appdistribution/options-parser-util");
+const logger_1 = require("../logger");
+exports.command = new command_1.Command("appdistribution:testers:remove [emails...]")
+    .description("remove testers from a project")
+    .option("--file <file>", "a path to a file containing a list of tester emails to be removed")
+    .before(requireAuth_1.requireAuth)
+    .action(async (emails, options) => {
+    const projectName = await (0, options_parser_util_1.getProjectName)(options);
+    const appDistroClient = new client_1.AppDistributionClient();
+    const emailsArr = (0, options_parser_util_1.getEmails)(emails, options.file);
+    let deleteResponse;
+    try {
+        utils.logBullet(`Deleting ${emailsArr.length} testers from project`);
+        deleteResponse = await appDistroClient.removeTesters(projectName, emailsArr);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to remove testers ${err}`);
+    }
+    if (!deleteResponse.emails) {
+        utils.logSuccess(`Testers did not exist`);
+        return;
+    }
+    logger_1.logger.debug(`Testers: ${deleteResponse.emails}, have been successfully deleted`);
+    utils.logSuccess(`${deleteResponse.emails.length} testers have successfully been deleted`);
+});

node_modules/firebase-tools/lib/commands/apps-android-sha-create.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const apps_1 = require("../management/apps");
+const requireAuth_1 = require("../requireAuth");
+const utils_1 = require("../utils");
+function getCertHashType(shaHash) {
+    shaHash = shaHash.replace(/:/g, "");
+    const shaHashCount = shaHash.length;
+    if (shaHashCount === 40)
+        return apps_1.ShaCertificateType.SHA_1.toString();
+    if (shaHashCount === 64)
+        return apps_1.ShaCertificateType.SHA_256.toString();
+    return apps_1.ShaCertificateType.SHA_CERTIFICATE_TYPE_UNSPECIFIED.toString();
+}
+exports.command = new command_1.Command("apps:android:sha:create <appId> <shaHash>")
+    .description("add a SHA certificate hash for a given app id.")
+    .before(requireAuth_1.requireAuth)
+    .action(async (appId = "", shaHash = "", options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const shaCertificate = await (0, utils_1.promiseWithSpinner)(async () => await (0, apps_1.createAppAndroidSha)(projectId, appId, {
+        shaHash: shaHash,
+        certType: getCertHashType(shaHash),
+    }), `Creating Android SHA certificate ${clc.bold(options.shaHash)}with Android app Id ${clc.bold(appId)}`);
+    return shaCertificate;
+});

node_modules/firebase-tools/lib/commands/apps-android-sha-delete.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const apps_1 = require("../management/apps");
+const requireAuth_1 = require("../requireAuth");
+const utils_1 = require("../utils");
+exports.command = new command_1.Command("apps:android:sha:delete <appId> <shaId>")
+    .description("delete a SHA certificate hash for a given app id.")
+    .before(requireAuth_1.requireAuth)
+    .action(async (appId = "", shaId = "", options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, utils_1.promiseWithSpinner)(async () => await (0, apps_1.deleteAppAndroidSha)(projectId, appId, shaId), `Deleting Android SHA certificate hash with SHA id ${clc.bold(shaId)} and Android app Id ${clc.bold(appId)}`);
+});

node_modules/firebase-tools/lib/commands/apps-android-sha-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const Table = require("cli-table");
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const apps_1 = require("../management/apps");
+const requireAuth_1 = require("../requireAuth");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+function logCertificatesList(certificates) {
+    if (certificates.length === 0) {
+        logger_1.logger.info("No SHA certificate hashes found.");
+        return;
+    }
+    const tableHead = ["App Id", "SHA Id", "SHA Hash", "SHA Hash Type"];
+    const table = new Table({ head: tableHead, style: { head: ["green"] } });
+    certificates.forEach(({ name, shaHash, certType }) => {
+        const splitted = name.split("/");
+        const appId = splitted[3];
+        const shaId = splitted[5];
+        table.push([appId, shaId, shaHash, certType]);
+    });
+    logger_1.logger.info(table.toString());
+}
+function logCertificatesCount(count = 0) {
+    if (count === 0) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info(`${count} SHA hash(es) total.`);
+}
+exports.command = new command_1.Command("apps:android:sha:list <appId>")
+    .description("list the SHA certificate hashes for a given app id. ")
+    .before(requireAuth_1.requireAuth)
+    .action(async (appId = "", options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const shaCertificates = await (0, utils_1.promiseWithSpinner)(async () => await (0, apps_1.listAppAndroidSha)(projectId, appId), "Preparing the list of your Firebase Android app SHA certificate hashes");
+    logCertificatesList(shaCertificates);
+    logCertificatesCount(shaCertificates.length);
+    return shaCertificates;
+});

node_modules/firebase-tools/lib/commands/apps-create.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const ora = require("ora");
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const error_1 = require("../error");
+const apps_1 = require("../management/apps");
+const prompt_1 = require("../prompt");
+const requireAuth_1 = require("../requireAuth");
+const logger_1 = require("../logger");
+const DISPLAY_NAME_QUESTION = {
+    type: "input",
+    name: "displayName",
+    default: "",
+    message: "What would you like to call your app?",
+};
+function logPostAppCreationInformation(appMetadata, appPlatform) {
+    logger_1.logger.info("");
+    logger_1.logger.info(`🎉🎉🎉 Your Firebase ${appPlatform} App is ready! 🎉🎉🎉`);
+    logger_1.logger.info("");
+    logger_1.logger.info("App information:");
+    logger_1.logger.info(`  - App ID: ${appMetadata.appId}`);
+    if (appMetadata.displayName) {
+        logger_1.logger.info(`  - Display name: ${appMetadata.displayName}`);
+    }
+    if (appPlatform === apps_1.AppPlatform.IOS) {
+        const iosAppMetadata = appMetadata;
+        logger_1.logger.info(`  - Bundle ID: ${iosAppMetadata.bundleId}`);
+        if (iosAppMetadata.appStoreId) {
+            logger_1.logger.info(`  - App Store ID: ${iosAppMetadata.appStoreId}`);
+        }
+    }
+    else if (appPlatform === apps_1.AppPlatform.ANDROID) {
+        logger_1.logger.info(`  - Package name: ${appMetadata.packageName}`);
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("You can run this command to print out your new app's Google Services config:");
+    logger_1.logger.info(`  firebase apps:sdkconfig ${appPlatform} ${appMetadata.appId}`);
+}
+async function initiateIosAppCreation(options) {
+    if (!options.nonInteractive) {
+        await (0, prompt_1.prompt)(options, [
+            DISPLAY_NAME_QUESTION,
+            {
+                type: "input",
+                default: "",
+                name: "bundleId",
+                message: "Please specify your iOS app bundle ID:",
+            },
+            {
+                type: "input",
+                default: "",
+                name: "appStoreId",
+                message: "Please specify your iOS app App Store ID:",
+            },
+        ]);
+    }
+    if (!options.bundleId) {
+        throw new error_1.FirebaseError("Bundle ID for iOS app cannot be empty");
+    }
+    const spinner = ora("Creating your iOS app").start();
+    try {
+        const appData = await (0, apps_1.createIosApp)(options.project, {
+            displayName: options.displayName,
+            bundleId: options.bundleId,
+            appStoreId: options.appStoreId,
+        });
+        spinner.succeed();
+        return appData;
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}
+async function initiateAndroidAppCreation(options) {
+    if (!options.nonInteractive) {
+        await (0, prompt_1.prompt)(options, [
+            DISPLAY_NAME_QUESTION,
+            {
+                type: "input",
+                default: "",
+                name: "packageName",
+                message: "Please specify your Android app package name:",
+            },
+        ]);
+    }
+    if (!options.packageName) {
+        throw new error_1.FirebaseError("Package name for Android app cannot be empty");
+    }
+    const spinner = ora("Creating your Android app").start();
+    try {
+        const appData = await (0, apps_1.createAndroidApp)(options.project, {
+            displayName: options.displayName,
+            packageName: options.packageName,
+        });
+        spinner.succeed();
+        return appData;
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}
+async function initiateWebAppCreation(options) {
+    if (!options.nonInteractive) {
+        await (0, prompt_1.prompt)(options, [DISPLAY_NAME_QUESTION]);
+    }
+    if (!options.displayName) {
+        throw new error_1.FirebaseError("Display name for Web app cannot be empty");
+    }
+    const spinner = ora("Creating your Web app").start();
+    try {
+        const appData = await (0, apps_1.createWebApp)(options.project, { displayName: options.displayName });
+        spinner.succeed();
+        return appData;
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+}
+exports.command = new command_1.Command("apps:create [platform] [displayName]")
+    .description("create a new Firebase app. [platform] can be IOS, ANDROID or WEB (case insensitive).")
+    .option("-a, --package-name <packageName>", "required package name for the Android app")
+    .option("-b, --bundle-id <bundleId>", "required bundle id for the iOS app")
+    .option("-s, --app-store-id <appStoreId>", "(optional) app store id for the iOS app")
+    .before(requireAuth_1.requireAuth)
+    .action(async (platform = "", displayName, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    if (!options.nonInteractive && !platform) {
+        platform = await (0, prompt_1.promptOnce)({
+            type: "list",
+            message: "Please choose the platform of the app:",
+            choices: [
+                { name: "iOS", value: apps_1.AppPlatform.IOS },
+                { name: "Android", value: apps_1.AppPlatform.ANDROID },
+                { name: "Web", value: apps_1.AppPlatform.WEB },
+            ],
+        });
+    }
+    const appPlatform = (0, apps_1.getAppPlatform)(platform);
+    if (appPlatform === apps_1.AppPlatform.ANY) {
+        throw new error_1.FirebaseError("App platform must be provided");
+    }
+    logger_1.logger.info(`Create your ${appPlatform} app in project ${clc.bold(projectId)}:`);
+    options.displayName = displayName;
+    let appData;
+    switch (appPlatform) {
+        case apps_1.AppPlatform.IOS:
+            appData = await initiateIosAppCreation(options);
+            break;
+        case apps_1.AppPlatform.ANDROID:
+            appData = await initiateAndroidAppCreation(options);
+            break;
+        case apps_1.AppPlatform.WEB:
+            appData = await initiateWebAppCreation(options);
+            break;
+        default:
+            throw new error_1.FirebaseError("Unexpected error. This should not happen");
+    }
+    logPostAppCreationInformation(appData, appPlatform);
+    return appData;
+});

node_modules/firebase-tools/lib/commands/apps-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const ora = require("ora");
+const Table = require("cli-table");
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const apps_1 = require("../management/apps");
+const requireAuth_1 = require("../requireAuth");
+const logger_1 = require("../logger");
+const NOT_SPECIFIED = clc.yellow("[Not specified]");
+function logAppsList(apps) {
+    if (apps.length === 0) {
+        logger_1.logger.info(clc.bold("No apps found."));
+        return;
+    }
+    const tableHead = ["App Display Name", "App ID", "Platform"];
+    const table = new Table({ head: tableHead, style: { head: ["green"] } });
+    apps.forEach(({ appId, displayName, platform }) => {
+        table.push([displayName || NOT_SPECIFIED, appId, platform]);
+    });
+    logger_1.logger.info(table.toString());
+}
+function logAppCount(count = 0) {
+    if (count === 0) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info(`${count} app(s) total.`);
+}
+exports.command = new command_1.Command("apps:list [platform]")
+    .description("list the registered apps of a Firebase project. " +
+    "Optionally filter apps by [platform]: IOS, ANDROID or WEB (case insensitive)")
+    .before(requireAuth_1.requireAuth)
+    .action(async (platform, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const appPlatform = (0, apps_1.getAppPlatform)(platform || "");
+    let apps;
+    const spinner = ora("Preparing the list of your Firebase " +
+        `${appPlatform === apps_1.AppPlatform.ANY ? "" : appPlatform + " "}apps`).start();
+    try {
+        apps = await (0, apps_1.listFirebaseApps)(projectId, appPlatform);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+    logAppsList(apps);
+    logAppCount(apps.length);
+    return apps;
+});

node_modules/firebase-tools/lib/commands/apps-sdkconfig.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const ora = require("ora");
+const fs = require("fs-extra");
+const command_1 = require("../command");
+const apps_1 = require("../management/apps");
+const projectUtils_1 = require("../projectUtils");
+const projects_1 = require("../management/projects");
+const error_1 = require("../error");
+const requireAuth_1 = require("../requireAuth");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+function checkForApps(apps, appPlatform) {
+    if (!apps.length) {
+        throw new error_1.FirebaseError(`There are no ${appPlatform === apps_1.AppPlatform.ANY ? "" : appPlatform + " "}apps ` +
+            "associated with this Firebase project");
+    }
+}
+async function selectAppInteractively(apps, appPlatform) {
+    checkForApps(apps, appPlatform);
+    const choices = apps.map((app) => {
+        return {
+            name: `${app.displayName || app.bundleId || app.packageName}` +
+                ` - ${app.appId} (${app.platform})`,
+            value: app,
+        };
+    });
+    return await (0, prompt_1.promptOnce)({
+        type: "list",
+        message: `Select the ${appPlatform === apps_1.AppPlatform.ANY ? "" : appPlatform + " "}` +
+            "app to get the configuration data:",
+        choices,
+    });
+}
+exports.command = new command_1.Command("apps:sdkconfig [platform] [appId]")
+    .description("print the Google Services config of a Firebase app. " +
+    "[platform] can be IOS, ANDROID or WEB (case insensitive)")
+    .option("-o, --out [file]", "(optional) write config output to a file")
+    .before(requireAuth_1.requireAuth)
+    .action(async (platform = "", appId = "", options) => {
+    let appPlatform = (0, apps_1.getAppPlatform)(platform);
+    if (!appId) {
+        let projectId = (0, projectUtils_1.needProjectId)(options);
+        if (options.nonInteractive && !projectId) {
+            throw new error_1.FirebaseError("Must supply app and project ids in non-interactive mode.");
+        }
+        else if (!projectId) {
+            const result = await (0, projects_1.getOrPromptProject)(options);
+            projectId = result.projectId;
+        }
+        const apps = await (0, apps_1.listFirebaseApps)(projectId, appPlatform);
+        checkForApps(apps, appPlatform);
+        if (apps.length === 1) {
+            appId = apps[0].appId;
+            appPlatform = apps[0].platform;
+        }
+        else if (options.nonInteractive) {
+            throw new error_1.FirebaseError(`Project ${projectId} has multiple apps, must specify an app id.`);
+        }
+        else {
+            const appMetadata = await selectAppInteractively(apps, appPlatform);
+            appId = appMetadata.appId;
+            appPlatform = appMetadata.platform;
+        }
+    }
+    let configData;
+    const spinner = ora(`Downloading configuration data of your Firebase ${appPlatform} app`).start();
+    try {
+        configData = await (0, apps_1.getAppConfig)(appId, appPlatform);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+    const fileInfo = (0, apps_1.getAppConfigFile)(configData, appPlatform);
+    if (appPlatform === apps_1.AppPlatform.WEB) {
+        fileInfo.sdkConfig = configData;
+    }
+    if (options.out === undefined) {
+        logger_1.logger.info(fileInfo.fileContents);
+        return fileInfo;
+    }
+    const shouldUseDefaultFilename = options.out === true || options.out === "";
+    const filename = shouldUseDefaultFilename ? configData.fileName : options.out;
+    if (fs.existsSync(filename)) {
+        if (options.nonInteractive) {
+            throw new error_1.FirebaseError(`${filename} already exists`);
+        }
+        const overwrite = await (0, prompt_1.promptOnce)({
+            type: "confirm",
+            default: false,
+            message: `${filename} already exists. Do you want to overwrite?`,
+        });
+        if (!overwrite) {
+            return configData;
+        }
+    }
+    fs.writeFileSync(filename, fileInfo.fileContents);
+    logger_1.logger.info(`App configuration is written in ${filename}`);
+    return configData;
+});

node_modules/firebase-tools/lib/commands/auth-export.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const fs = require("fs");
+const os = require("os");
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const requirePermissions_1 = require("../requirePermissions");
+const accountExporter_1 = require("../accountExporter");
+const MAX_BATCH_SIZE = 1000;
+exports.command = new command_1.Command("auth:export [dataFile]")
+    .description("Export accounts from your Firebase project into a data file")
+    .option("--format <format>", "Format of exported data (csv, json). Ignored if <dataFile> has format extension.")
+    .before(requirePermissions_1.requirePermissions, ["firebaseauth.users.get"])
+    .action((dataFile, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const checkRes = (0, accountExporter_1.validateOptions)(options, dataFile);
+    if (!checkRes.format) {
+        return checkRes;
+    }
+    const writeStream = fs.createWriteStream(dataFile);
+    if (checkRes.format === "json") {
+        writeStream.write('{"users": [' + os.EOL);
+    }
+    const exportOptions = {
+        format: checkRes.format,
+        writeStream,
+        batchSize: MAX_BATCH_SIZE,
+    };
+    logger_1.logger.info("Exporting accounts to " + clc.bold(dataFile));
+    return (0, accountExporter_1.serialExportUsers)(projectId, exportOptions).then(() => {
+        if (exportOptions.format === "json") {
+            writeStream.write("]}");
+        }
+        writeStream.end();
+        return new Promise((resolve, reject) => {
+            writeStream.on("finish", resolve);
+            writeStream.on("close", resolve);
+            writeStream.on("error", reject);
+        });
+    });
+});

node_modules/firebase-tools/lib/commands/auth-import.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const csv_parse_1 = require("csv-parse");
+const Chain = require("stream-chain");
+const clc = require("colorette");
+const fs = require("fs-extra");
+const Pick = require("stream-json/filters/Pick");
+const StreamArray = require("stream-json/streamers/StreamArray");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const requirePermissions_1 = require("../requirePermissions");
+const accountImporter_1 = require("../accountImporter");
+const MAX_BATCH_SIZE = 1000;
+exports.command = new command_1.Command("auth:import [dataFile]")
+    .description("import users into your Firebase project from a data file(.csv or .json)")
+    .option("--hash-algo <hashAlgo>", "specify the hash algorithm used in password for these accounts")
+    .option("--hash-key <hashKey>", "specify the key used in hash algorithm")
+    .option("--salt-separator <saltSeparator>", "specify the salt separator which will be appended to salt when verifying password. only used by SCRYPT now.")
+    .option("--rounds <rounds>", "specify how many rounds for hash calculation.")
+    .option("--mem-cost <memCost>", "specify the memory cost for firebase scrypt, or cpu/memory cost for standard scrypt")
+    .option("--parallelization <parallelization>", "specify the parallelization for standard scrypt.")
+    .option("--block-size <blockSize>", "specify the block size (normally is 8) for standard scrypt.")
+    .option("--dk-len <dkLen>", "specify derived key length for standard scrypt.")
+    .option("--hash-input-order <hashInputOrder>", "specify the order of password and salt. Possible values are SALT_FIRST and PASSWORD_FIRST. " +
+    "MD5, SHA1, SHA256, SHA512, HMAC_MD5, HMAC_SHA1, HMAC_SHA256, HMAC_SHA512 support this flag.")
+    .before(requirePermissions_1.requirePermissions, ["firebaseauth.users.create", "firebaseauth.users.update"])
+    .action(async (dataFile, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const checkRes = (0, accountImporter_1.validateOptions)(options);
+    if (!checkRes.valid) {
+        return checkRes;
+    }
+    const hashOptions = checkRes;
+    if (!dataFile.endsWith(".csv") && !dataFile.endsWith(".json")) {
+        throw new error_1.FirebaseError("Data file must end with .csv or .json");
+    }
+    const stats = await fs.stat(dataFile);
+    const fileSizeInBytes = stats.size;
+    logger_1.logger.info(`Processing ${clc.bold(dataFile)} (${fileSizeInBytes} bytes)`);
+    const batches = [];
+    let currentBatch = [];
+    let counter = 0;
+    let userListArr = [];
+    const inStream = fs.createReadStream(dataFile);
+    if (dataFile.endsWith(".csv")) {
+        userListArr = await new Promise((resolve, reject) => {
+            const parser = (0, csv_parse_1.parse)();
+            parser
+                .on("readable", () => {
+                let record = [];
+                while ((record = parser.read()) !== null) {
+                    counter++;
+                    const trimmed = record.map((s) => {
+                        const str = s.trim().replace(/^["|'](.*)["|']$/, "$1");
+                        return str === "" ? undefined : str;
+                    });
+                    const user = (0, accountImporter_1.transArrayToUser)(trimmed);
+                    const err = user.error;
+                    if (err) {
+                        return reject(new error_1.FirebaseError(`Line ${counter} (${record.join(",")}) has invalid data format: ${err}`));
+                    }
+                    currentBatch.push(user);
+                    if (currentBatch.length === MAX_BATCH_SIZE) {
+                        batches.push(currentBatch);
+                        currentBatch = [];
+                    }
+                }
+            })
+                .on("end", () => {
+                if (currentBatch.length) {
+                    batches.push(currentBatch);
+                }
+                resolve(batches);
+            });
+            inStream.pipe(parser);
+        });
+    }
+    else {
+        userListArr = await new Promise((resolve, reject) => {
+            const pipeline = new Chain([
+                Pick.withParser({ filter: /^users$/ }),
+                StreamArray.streamArray(),
+                ({ value }) => {
+                    counter++;
+                    const user = (0, accountImporter_1.validateUserJson)(value);
+                    const err = user.error;
+                    if (err) {
+                        throw new error_1.FirebaseError(`Validation Error: ${err}`);
+                    }
+                    currentBatch.push(value);
+                    if (currentBatch.length === MAX_BATCH_SIZE) {
+                        batches.push(currentBatch);
+                        currentBatch = [];
+                    }
+                },
+            ]);
+            pipeline.once("error", reject);
+            pipeline.on("finish", () => {
+                if (currentBatch.length) {
+                    batches.push(currentBatch);
+                }
+                resolve(batches);
+            });
+            inStream.pipe(pipeline);
+        });
+    }
+    logger_1.logger.debug(`Preparing to import ${counter} user records in ${userListArr.length} batches.`);
+    if (userListArr.length) {
+        return (0, accountImporter_1.serialImportUsers)(projectId, hashOptions, userListArr, 0);
+    }
+});

node_modules/firebase-tools/lib/commands/crashlytics-mappingfile-generateid.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const utils = require("../utils");
+const buildToolsJarHelper_1 = require("../crashlytics/buildToolsJarHelper");
+const error_1 = require("../error");
+exports.command = new command_1.Command("crashlytics:mappingfile:generateid")
+    .description("generate a mapping file id and write it to an Android resource file, which will be built into the app")
+    .option("--resource-file <resourceFile>", "path to the Android resource XML file that will be created or updated.")
+    .action(async (options) => {
+    const debug = !!options.debug;
+    const resourceFilePath = options.resourceFile;
+    if (!resourceFilePath) {
+        throw new error_1.FirebaseError("set --resource-file <resourceFile> to an Android resource file path, e.g. app/src/main/res/values/crashlytics.xml");
+    }
+    const jarFile = await (0, buildToolsJarHelper_1.fetchBuildtoolsJar)();
+    const jarOptions = { resourceFilePath };
+    utils.logBullet(`Updating resource file: ${resourceFilePath}`);
+    const generateIdArgs = buildArgs(jarOptions);
+    (0, buildToolsJarHelper_1.runBuildtoolsCommand)(jarFile, generateIdArgs, debug);
+    utils.logBullet("Successfully updated mapping file id");
+});
+function buildArgs(options) {
+    return ["-injectMappingFileIdIntoResource", options.resourceFilePath, "-verbose"];
+}

node_modules/firebase-tools/lib/commands/crashlytics-mappingfile-upload.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const error_1 = require("../error");
+const utils = require("../utils");
+const buildToolsJarHelper_1 = require("../crashlytics/buildToolsJarHelper");
+exports.command = new command_1.Command("crashlytics:mappingfile:upload <mappingFile>")
+    .description("upload a ProGuard/R8-compatible mapping file to deobfuscate stack traces")
+    .option("--app <appID>", "the app id of your Firebase app")
+    .option("--resource-file <resourceFile>", "path to the Android resource XML file that includes the mapping file id")
+    .action(async (mappingFile, options) => {
+    const app = getGoogleAppID(options);
+    const debug = !!options.debug;
+    if (!mappingFile) {
+        throw new error_1.FirebaseError("set `--mapping-file <mappingFile>` to a valid mapping file path, e.g. app/build/outputs/mapping.txt");
+    }
+    const mappingFilePath = mappingFile;
+    const resourceFilePath = options.resourceFile;
+    if (!resourceFilePath) {
+        throw new error_1.FirebaseError("set --resource-file <resourceFile> to a valid Android resource file path, e.g. app/main/res/values/strings.xml");
+    }
+    const jarFile = await (0, buildToolsJarHelper_1.fetchBuildtoolsJar)();
+    const jarOptions = { app, mappingFilePath, resourceFilePath };
+    utils.logBullet(`Uploading mapping file: ${mappingFilePath}`);
+    const uploadArgs = buildArgs(jarOptions);
+    (0, buildToolsJarHelper_1.runBuildtoolsCommand)(jarFile, uploadArgs, debug);
+    utils.logBullet("Successfully uploaded mapping file");
+});
+function getGoogleAppID(options) {
+    if (!options.app) {
+        throw new error_1.FirebaseError("set --app <appId> to a valid Firebase application id, e.g. 1:00000000:android:0000000");
+    }
+    return options.app;
+}
+function buildArgs(options) {
+    return [
+        "-uploadMappingFile",
+        options.mappingFilePath,
+        "-resourceFile",
+        options.resourceFilePath,
+        "-googleAppId",
+        options.app,
+        "-verbose",
+    ];
+}

node_modules/firebase-tools/lib/commands/crashlytics-symbols-upload.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const os = require("os");
+const path = require("path");
+const uuid = require("uuid");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const utils = require("../utils");
+const buildToolsJarHelper_1 = require("../crashlytics/buildToolsJarHelper");
+var SymbolGenerator;
+(function (SymbolGenerator) {
+    SymbolGenerator["breakpad"] = "breakpad";
+    SymbolGenerator["csym"] = "csym";
+})(SymbolGenerator || (SymbolGenerator = {}));
+const SYMBOL_CACHE_ROOT_DIR = process.env.FIREBASE_CRASHLYTICS_CACHE_PATH || os.tmpdir();
+exports.command = new command_1.Command("crashlytics:symbols:upload <symbolFiles...>")
+    .description("upload symbols for native code, to symbolicate stack traces")
+    .option("--app <appID>", "the app id of your Firebase app")
+    .option("--generator [breakpad|csym]", "the symbol generator being used, default is breakpad")
+    .option("--dry-run", "generate symbols without uploading them")
+    .action(async (symbolFiles, options) => {
+    const app = getGoogleAppID(options);
+    const generator = getSymbolGenerator(options);
+    const dryRun = !!options.dryRun;
+    const debug = !!options.debug;
+    const jarFile = await (0, buildToolsJarHelper_1.fetchBuildtoolsJar)();
+    const jarOptions = {
+        app,
+        generator,
+        cachePath: path.join(SYMBOL_CACHE_ROOT_DIR, `crashlytics-${uuid.v4()}`, "nativeSymbols", app.replace(/:/g, "-"), generator),
+        symbolFile: "",
+        generate: true,
+    };
+    for (const symbolFile of symbolFiles) {
+        utils.logBullet(`Generating symbols for ${symbolFile}`);
+        const generateArgs = buildArgs(Object.assign(Object.assign({}, jarOptions), { symbolFile }));
+        (0, buildToolsJarHelper_1.runBuildtoolsCommand)(jarFile, generateArgs, debug);
+        utils.logBullet(`Generated symbols for ${symbolFile}`);
+        utils.logBullet(`Output Path: ${jarOptions.cachePath}`);
+    }
+    if (dryRun) {
+        utils.logBullet("Skipping upload because --dry-run was passed");
+        return;
+    }
+    utils.logBullet(`Uploading all generated symbols...`);
+    const uploadArgs = buildArgs(Object.assign(Object.assign({}, jarOptions), { generate: false }));
+    (0, buildToolsJarHelper_1.runBuildtoolsCommand)(jarFile, uploadArgs, debug);
+    utils.logBullet("Successfully uploaded all symbols");
+});
+function getGoogleAppID(options) {
+    if (!options.app) {
+        throw new error_1.FirebaseError("set --app <appId> to a valid Firebase application id, e.g. 1:00000000:android:0000000");
+    }
+    return options.app;
+}
+function getSymbolGenerator(options) {
+    if (!options.generator) {
+        return SymbolGenerator.breakpad;
+    }
+    if (!Object.values(SymbolGenerator).includes(options.generator)) {
+        throw new error_1.FirebaseError('--symbol-generator should be set to either "breakpad" or "csym"');
+    }
+    return options.generator;
+}
+function buildArgs(options) {
+    const baseArgs = [
+        "-symbolGenerator",
+        options.generator,
+        "-symbolFileCacheDir",
+        options.cachePath,
+        "-verbose",
+    ];
+    if (options.generate) {
+        return baseArgs.concat(["-generateNativeSymbols", "-unstrippedLibrary", options.symbolFile]);
+    }
+    return baseArgs.concat(["-uploadNativeSymbols", "-googleAppId", options.app]);
+}

node_modules/firebase-tools/lib/commands/database-get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const fs = require("fs");
+const url = require("url");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const commandUtils_1 = require("../emulator/commandUtils");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const responseToError_1 = require("../responseToError");
+const utils = require("../utils");
+function applyStringOpts(dest, src, keys, jsonKeys) {
+    for (const key of keys) {
+        if (src[key]) {
+            dest[key] = src[key];
+        }
+    }
+    for (const key of jsonKeys) {
+        let jsonVal;
+        try {
+            jsonVal = JSON.parse(src[key]);
+        }
+        catch (_) {
+            jsonVal = src[key];
+        }
+        if (src[key]) {
+            dest[key] = JSON.stringify(jsonVal);
+        }
+    }
+}
+exports.command = new command_1.Command("database:get <path>")
+    .description("fetch and print JSON data at the specified path")
+    .option("-o, --output <filename>", "save output to the specified file")
+    .option("--pretty", "pretty print response")
+    .option("--shallow", "return shallow response")
+    .option("--export", "include priorities in the output response")
+    .option("--order-by <key>", "select a child key by which to order results")
+    .option("--order-by-key", "order by key name")
+    .option("--order-by-value", "order by primitive value")
+    .option("--limit-to-first <num>", "limit to the first <num> results")
+    .option("--limit-to-last <num>", "limit to the last <num> results")
+    .option("--start-at <val>", "start results at <val> (based on specified ordering)")
+    .option("--end-at <val>", "end results at <val> (based on specified ordering)")
+    .option("--equal-to <val>", "restrict results to <val> (based on specified ordering)")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.get"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.DATABASE)
+    .action(async (path, options) => {
+    if (!path.startsWith("/")) {
+        return utils.reject("Path must begin with /", { exit: 1 });
+    }
+    const dbHost = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const dbUrl = utils.getDatabaseUrl(dbHost, options.instance, path + ".json");
+    const query = {};
+    if (options.shallow) {
+        query.shallow = "true";
+    }
+    if (options.pretty) {
+        query.print = "pretty";
+    }
+    if (options.export) {
+        query.format = "export";
+    }
+    if (options.orderByKey) {
+        options.orderBy = "$key";
+    }
+    if (options.orderByValue) {
+        options.orderBy = "$value";
+    }
+    applyStringOpts(query, options, ["limitToFirst", "limitToLast"], ["orderBy", "startAt", "endAt", "equalTo"]);
+    const urlObj = new url.URL(dbUrl);
+    const client = new apiv2_1.Client({
+        urlPrefix: urlObj.origin,
+        auth: true,
+    });
+    const res = await client.request({
+        method: "GET",
+        path: urlObj.pathname,
+        queryParams: query,
+        responseType: "stream",
+        resolveOnHTTPError: true,
+    });
+    const fileOut = !!options.output;
+    const outStream = fileOut ? fs.createWriteStream(options.output) : process.stdout;
+    if (res.status >= 400) {
+        const r = await res.response.text();
+        let d;
+        try {
+            d = JSON.parse(r);
+        }
+        catch (e) {
+            throw new error_1.FirebaseError("Malformed JSON response", { original: e, exit: 2 });
+        }
+        throw (0, responseToError_1.responseToError)({ statusCode: res.status }, d);
+    }
+    res.body.pipe(outStream, { end: false });
+    return new Promise((resolve) => {
+        res.body.once("end", () => {
+            if (outStream === process.stdout) {
+                outStream.write("\n");
+                resolve();
+            }
+            else if (outStream instanceof fs.WriteStream) {
+                outStream.write("\n");
+                outStream.on("close", () => resolve());
+                outStream.close();
+            }
+            else {
+                logger_1.logger.debug("[database:get] Could not write line break to outStream");
+                resolve();
+            }
+        });
+    });
+});

node_modules/firebase-tools/lib/commands/database-instances-create.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const requirePermissions_1 = require("../requirePermissions");
+const commandUtils_1 = require("../emulator/commandUtils");
+const types_1 = require("../emulator/types");
+const database_1 = require("../management/database");
+const projectUtils_1 = require("../projectUtils");
+const getDefaultDatabaseInstance_1 = require("../getDefaultDatabaseInstance");
+const error_1 = require("../error");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+exports.command = new command_1.Command("database:instances:create <instanceName>")
+    .description("create a realtime database instance")
+    .option("-l, --location <location>", "(optional) location for the database instance, defaults to us-central1")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.create"])
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (instanceName, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const defaultDatabaseInstance = await (0, getDefaultDatabaseInstance_1.getDefaultDatabaseInstance)({ project: projectId });
+    if (defaultDatabaseInstance === "") {
+        throw new error_1.FirebaseError(requireDatabaseInstance_1.MISSING_DEFAULT_INSTANCE_ERROR_MESSAGE);
+    }
+    const location = (0, database_1.parseDatabaseLocation)(options.location, database_1.DatabaseLocation.US_CENTRAL1);
+    const instance = await (0, database_1.createInstance)(projectId, instanceName, location, database_1.DatabaseInstanceType.USER_DATABASE);
+    logger_1.logger.info(`created database instance ${instance.name}`);
+    return instance;
+});

node_modules/firebase-tools/lib/commands/database-instances-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const Table = require("cli-table");
+const clc = require("colorette");
+const ora = require("ora");
+const logger_1 = require("../logger");
+const requirePermissions_1 = require("../requirePermissions");
+const projectUtils_1 = require("../projectUtils");
+const firedata = require("../gcp/firedata");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const experiments = require("../experiments");
+const projectUtils_2 = require("../projectUtils");
+const database_1 = require("../management/database");
+function logInstances(instances) {
+    if (instances.length === 0) {
+        logger_1.logger.info(clc.bold("No database instances found."));
+        return;
+    }
+    const tableHead = ["Database Instance Name", "Location", "Type", "State"];
+    const table = new Table({ head: tableHead, style: { head: ["green"] } });
+    instances.forEach((db) => {
+        table.push([db.name, db.location, db.type, db.state]);
+    });
+    logger_1.logger.info(table.toString());
+}
+function logInstancesCount(count = 0) {
+    if (count === 0) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info(`${count} database instance(s) total.`);
+}
+exports.command = new command_1.Command("database:instances:list")
+    .description("list realtime database instances, optionally filtered by a specified location")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.list"])
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (options) => {
+    const location = (0, database_1.parseDatabaseLocation)(options.location, database_1.DatabaseLocation.ANY);
+    const spinner = ora("Preparing the list of your Firebase Realtime Database instances" +
+        `${location === database_1.DatabaseLocation.ANY ? "" : ` for location: ${location}`}`).start();
+    let instances;
+    if (experiments.isEnabled("rtdbmanagement")) {
+        const projectId = (0, projectUtils_2.needProjectId)(options);
+        try {
+            instances = await (0, database_1.listDatabaseInstances)(projectId, location);
+        }
+        catch (err) {
+            spinner.fail();
+            throw err;
+        }
+        spinner.succeed();
+        logInstances(instances);
+        logInstancesCount(instances.length);
+        return instances;
+    }
+    const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
+    try {
+        instances = await firedata.listDatabaseInstances(projectNumber);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+    for (const instance of instances) {
+        logger_1.logger.info(instance.instance);
+    }
+    logger_1.logger.info(`Project ${options.project} has ${instances.length} database instances`);
+    return instances;
+});
+if (experiments.isEnabled("rtdbmanagement")) {
+    exports.command = exports.command.option("-l, --location <location>", "(optional) location for the database instance, defaults to us-central1");
+}

node_modules/firebase-tools/lib/commands/database-profile.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const database_1 = require("../management/database");
+const requirePermissions_1 = require("../requirePermissions");
+const utils = require("../utils");
+const profiler_1 = require("../profiler");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const description = "profile the Realtime Database and generate a usage report";
+exports.command = new command_1.Command("database:profile")
+    .description(description)
+    .option("-o, --output <filename>", "save the output to the specified file")
+    .option("-d, --duration <seconds>", "collect database usage information for the specified number of seconds")
+    .option("--raw", "output the raw stats collected as newline delimited json")
+    .option("--no-collapse", "prevent collapsing similar paths into $wildcard locations")
+    .option("-i, --input <filename>", "generate the report based on the specified file instead " +
+    "of streaming logs from the database")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action((options) => {
+    if (options.raw && options.input) {
+        return utils.reject("Cannot specify both an input file and raw format", {
+            exit: 1,
+        });
+    }
+    else if (options.parent.json && options.raw) {
+        return utils.reject("Cannot output raw data in json format", { exit: 1 });
+    }
+    else if (options.input && options.duration !== undefined) {
+        return utils.reject("Cannot specify a duration for input files", {
+            exit: 1,
+        });
+    }
+    else if (options.duration !== undefined && options.duration <= 0) {
+        return utils.reject("Must specify a positive number of seconds", {
+            exit: 1,
+        });
+    }
+    return (0, profiler_1.profiler)(options);
+});

node_modules/firebase-tools/lib/commands/database-push.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const fs = require("fs");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const commandUtils_1 = require("../emulator/commandUtils");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const url_1 = require("url");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const utils = require("../utils");
+exports.command = new command_1.Command("database:push <path> [infile]")
+    .description("add a new JSON object to a list of data in your Firebase")
+    .option("-d, --data <data>", "specify escaped JSON directly")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .option("--disable-triggers", "suppress any Cloud functions triggered by this operation")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.DATABASE)
+    .action(async (path, infile, options) => {
+    if (!path.startsWith("/")) {
+        throw new error_1.FirebaseError("Path must begin with /");
+    }
+    const inStream = utils.stringToStream(options.data) || (infile ? fs.createReadStream(infile) : process.stdin);
+    const origin = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const u = new url_1.URL(utils.getDatabaseUrl(origin, options.instance, path + ".json"));
+    if (options.disableTriggers) {
+        u.searchParams.set("disableTriggers", "true");
+    }
+    if (!infile && !options.data) {
+        utils.explainStdin();
+    }
+    logger_1.logger.debug(`Database URL: ${u}`);
+    const c = new apiv2_1.Client({ urlPrefix: u.origin, auth: true });
+    let res;
+    try {
+        res = await c.request({
+            method: "POST",
+            path: u.pathname,
+            body: inStream,
+            queryParams: u.searchParams,
+        });
+    }
+    catch (err) {
+        logger_1.logger.debug(err);
+        throw new error_1.FirebaseError(`Unexpected error while pushing data: ${err}`, { exit: 2 });
+    }
+    if (!path.endsWith("/")) {
+        path += "/";
+    }
+    const consoleUrl = utils.getDatabaseViewDataUrl(origin, options.project, options.instance, path + res.body.name);
+    utils.logSuccess("Data pushed successfully");
+    logger_1.logger.info();
+    logger_1.logger.info(clc.bold("View data at:"), consoleUrl);
+    return { key: res.body.name };
+});

node_modules/firebase-tools/lib/commands/database-remove.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const remove_1 = require("../database/remove");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const database_1 = require("../management/database");
+const api_1 = require("../database/api");
+const utils = require("../utils");
+const prompt_1 = require("../prompt");
+const clc = require("colorette");
+exports.command = new command_1.Command("database:remove <path>")
+    .description("remove data from your Firebase at the specified path")
+    .option("-f, --force", "pass this option to bypass confirmation prompt")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .option("--disable-triggers", "suppress any Cloud functions triggered by this operation")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (path, options) => {
+    if (!path.startsWith("/")) {
+        return utils.reject("Path must begin with /", { exit: 1 });
+    }
+    const origin = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const databaseUrl = utils.getDatabaseUrl(origin, options.instance, path);
+    const confirm = await (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "force",
+        default: false,
+        message: "You are about to remove all data at " + clc.cyan(databaseUrl) + ". Are you sure?",
+    }, options);
+    if (!confirm) {
+        return utils.reject("Command aborted.", { exit: 1 });
+    }
+    const removeOps = new remove_1.default(options.instance, path, origin, !!options.disableTriggers);
+    await removeOps.execute();
+    utils.logSuccess("Data removed successfully");
+});

node_modules/firebase-tools/lib/commands/database-rules-canary.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const requirePermissions_1 = require("../requirePermissions");
+const metadata = require("../database/metadata");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+exports.command = new command_1.Command("database:rules:canary <rulesetId>")
+    .description("mark a staged ruleset as the canary ruleset")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (rulesetId, options) => {
+    const oldLabels = await metadata.getRulesetLabels(options.instance);
+    const newLabels = {
+        stable: oldLabels.stable,
+        canary: rulesetId,
+    };
+    await metadata.setRulesetLabels(options.instance, newLabels);
+    return newLabels;
+});

node_modules/firebase-tools/lib/commands/database-rules-get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const metadata = require("../database/metadata");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+exports.command = new command_1.Command("database:rules:get <rulesetId>")
+    .description("get a realtime database ruleset by id")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.get"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (rulesetId, options) => {
+    const ruleset = await metadata.getRuleset(options.instance, rulesetId);
+    logger_1.logger.info(`Ruleset ${ruleset.id} was created at ${ruleset.createdAt}`);
+    logger_1.logger.info(ruleset.source);
+    return ruleset;
+});

node_modules/firebase-tools/lib/commands/database-rules-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const metadata = require("../database/metadata");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+exports.command = new command_1.Command("database:rules:list")
+    .description("list realtime database rulesets")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.get"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (options) => {
+    const labeled = await metadata.getRulesetLabels(options.instance);
+    const rulesets = await metadata.listAllRulesets(options.instance);
+    for (const ruleset of rulesets) {
+        const labels = [];
+        if (ruleset.id === labeled.stable) {
+            labels.push("stable");
+        }
+        if (ruleset.id === labeled.canary) {
+            labels.push("canary");
+        }
+        logger_1.logger.info(`${ruleset.id}  ${ruleset.createdAt}  ${labels.join(",")}`);
+    }
+    logger_1.logger.info("Labels:");
+    logger_1.logger.info(`  stable: ${labeled.stable}`);
+    if (labeled.canary) {
+        logger_1.logger.info(`  canary: ${labeled.canary}`);
+    }
+    return { rulesets, labeled };
+});

node_modules/firebase-tools/lib/commands/database-rules-release.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const metadata = require("../database/metadata");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+exports.command = new command_1.Command("database:rules:release <rulesetId>")
+    .description("mark a staged ruleset as the stable ruleset")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (rulesetId, options) => {
+    const oldLabels = await metadata.getRulesetLabels(options.instance);
+    const newLabels = {
+        stable: rulesetId,
+        canary: oldLabels.canary,
+    };
+    await metadata.setRulesetLabels(options.instance, newLabels);
+    return newLabels;
+});

node_modules/firebase-tools/lib/commands/database-rules-stage.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const metadata = require("../database/metadata");
+const fs = require("fs-extra");
+const path = require("path");
+const types_1 = require("../emulator/types");
+const commandUtils_1 = require("../emulator/commandUtils");
+exports.command = new command_1.Command("database:rules:stage")
+    .description("create a new realtime database ruleset")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (options) => {
+    const filepath = options.config.data.database.rules;
+    logger_1.logger.info(`staging ruleset from ${filepath}`);
+    const source = fs.readFileSync(path.resolve(filepath), "utf8");
+    const rulesetId = await metadata.createRuleset(options.instance, source);
+    logger_1.logger.info(`staged ruleset ${rulesetId}`);
+    return rulesetId;
+});

node_modules/firebase-tools/lib/commands/database-set.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const fs = require("fs");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const commandUtils_1 = require("../emulator/commandUtils");
+const prompt_1 = require("../prompt");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const url_1 = require("url");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const utils = require("../utils");
+exports.command = new command_1.Command("database:set <path> [infile]")
+    .description("store JSON data at the specified path via STDIN, arg, or file")
+    .option("-d, --data <data>", "specify escaped JSON directly")
+    .option("-f, --force", "pass this option to bypass confirmation prompt")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .option("--disable-triggers", "suppress any Cloud functions triggered by this operation")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.DATABASE)
+    .action(async (path, infile, options) => {
+    if (!path.startsWith("/")) {
+        throw new error_1.FirebaseError("Path must begin with /");
+    }
+    const origin = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const dbPath = utils.getDatabaseUrl(origin, options.instance, path);
+    const dbJsonURL = new url_1.URL(utils.getDatabaseUrl(origin, options.instance, path + ".json"));
+    if (options.disableTriggers) {
+        dbJsonURL.searchParams.set("disableTriggers", "true");
+    }
+    const confirm = await (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "force",
+        default: false,
+        message: "You are about to overwrite all data at " + clc.cyan(dbPath) + ". Are you sure?",
+    }, options);
+    if (!confirm) {
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const inStream = utils.stringToStream(options.data) || (infile ? fs.createReadStream(infile) : process.stdin);
+    if (!infile && !options.data) {
+        utils.explainStdin();
+    }
+    const c = new apiv2_1.Client({ urlPrefix: dbJsonURL.origin, auth: true });
+    try {
+        await c.request({
+            method: "PUT",
+            path: dbJsonURL.pathname,
+            body: inStream,
+            queryParams: dbJsonURL.searchParams,
+        });
+    }
+    catch (err) {
+        logger_1.logger.debug(err);
+        throw new error_1.FirebaseError(`Unexpected error while setting data: ${err}`, { exit: 2 });
+    }
+    utils.logSuccess("Data persisted successfully");
+    logger_1.logger.info();
+    logger_1.logger.info(clc.bold("View data at:"), utils.getDatabaseViewDataUrl(origin, options.project, options.instance, path));
+});

node_modules/firebase-tools/lib/commands/database-settings-get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const url_1 = require("url");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const settings_1 = require("../database/settings");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const commandUtils_1 = require("../emulator/commandUtils");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const utils = require("../utils");
+exports.command = new command_1.Command("database:settings:get <path>")
+    .description("read the realtime database setting at path")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, uses default database instance)")
+    .help(settings_1.HELP_TEXT)
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.get"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (path, options) => {
+    if (!settings_1.DATABASE_SETTINGS.has(path)) {
+        throw new error_1.FirebaseError(settings_1.INVALID_PATH_ERROR, { exit: 1 });
+    }
+    const u = new url_1.URL(utils.getDatabaseUrl((0, api_1.realtimeOriginOrCustomUrl)(options.instanceDetails.databaseUrl), options.instance, `/.settings/${path}.json`));
+    const c = new apiv2_1.Client({ urlPrefix: u.origin, auth: true });
+    let res;
+    try {
+        res = await c.get(u.pathname);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Unexpected error fetching configs at ${path}`, {
+            exit: 2,
+            original: err,
+        });
+    }
+    if (typeof res.body === "object") {
+        res.body = res.body.value;
+    }
+    utils.logSuccess(`For database instance ${options.instance}\n\t ${path} = ${res.body}`);
+});

node_modules/firebase-tools/lib/commands/database-settings-set.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const url_1 = require("url");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const settings_1 = require("../database/settings");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const commandUtils_1 = require("../emulator/commandUtils");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const utils = require("../utils");
+exports.command = new command_1.Command("database:settings:set <path> <value>")
+    .description("set the realtime database setting at path.")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .help(settings_1.HELP_TEXT)
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.DATABASE)
+    .action(async (path, value, options) => {
+    const setting = settings_1.DATABASE_SETTINGS.get(path);
+    if (setting === undefined) {
+        return utils.reject(settings_1.INVALID_PATH_ERROR, { exit: 1 });
+    }
+    const parsedValue = setting.parseInput(value);
+    if (parsedValue === undefined) {
+        return utils.reject(setting.parseInputErrorMessge, { exit: 1 });
+    }
+    const u = new url_1.URL(utils.getDatabaseUrl((0, api_1.realtimeOriginOrCustomUrl)(options.instanceDetails.databaseUrl), options.instance, `/.settings/${path}.json`));
+    const c = new apiv2_1.Client({ urlPrefix: u.origin, auth: true });
+    try {
+        await c.put(u.pathname, JSON.stringify(parsedValue));
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Unexpected error fetching configs at ${path}`, {
+            exit: 2,
+            original: err,
+        });
+    }
+    utils.logSuccess("Successfully set setting.");
+    utils.logSuccess(`For database instance ${options.instance}\n\t ${path} = ${JSON.stringify(parsedValue)}`);
+});

node_modules/firebase-tools/lib/commands/database-update.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const url_1 = require("url");
+const clc = require("colorette");
+const fs = require("fs");
+const apiv2_1 = require("../apiv2");
+const command_1 = require("../command");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const database_1 = require("../management/database");
+const commandUtils_1 = require("../emulator/commandUtils");
+const prompt_1 = require("../prompt");
+const api_1 = require("../database/api");
+const requirePermissions_1 = require("../requirePermissions");
+const logger_1 = require("../logger");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const utils = require("../utils");
+exports.command = new command_1.Command("database:update <path> [infile]")
+    .description("update some of the keys for the defined path in your Firebase")
+    .option("-d, --data <data>", "specify escaped JSON directly")
+    .option("-f, --force", "pass this option to bypass confirmation prompt")
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .option("--disable-triggers", "suppress any Cloud functions triggered by this operation")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.DATABASE)
+    .action(async (path, infile, options) => {
+    if (!path.startsWith("/")) {
+        throw new error_1.FirebaseError("Path must begin with /");
+    }
+    const origin = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const url = utils.getDatabaseUrl(origin, options.instance, path);
+    const confirmed = await (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "force",
+        default: false,
+        message: `You are about to modify data at ${clc.cyan(url)}. Are you sure?`,
+    }, options);
+    if (!confirmed) {
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const inStream = utils.stringToStream(options.data) ||
+        (infile && fs.createReadStream(infile)) ||
+        process.stdin;
+    const jsonUrl = new url_1.URL(utils.getDatabaseUrl(origin, options.instance, path + ".json"));
+    if (options.disableTriggers) {
+        jsonUrl.searchParams.set("disableTriggers", "true");
+    }
+    if (!infile && !options.data) {
+        utils.explainStdin();
+    }
+    const c = new apiv2_1.Client({ urlPrefix: jsonUrl.origin, auth: true });
+    try {
+        await c.request({
+            method: "PATCH",
+            path: jsonUrl.pathname,
+            body: inStream,
+            queryParams: jsonUrl.searchParams,
+        });
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Unexpected error while setting data");
+    }
+    utils.logSuccess("Data updated successfully");
+    logger_1.logger.info();
+    logger_1.logger.info(clc.bold("View data at:"), utils.getDatabaseViewDataUrl(origin, options.project, options.instance, path));
+});

node_modules/firebase-tools/lib/commands/deploy.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = exports.TARGET_PERMISSIONS = exports.VALID_DEPLOY_TARGETS = void 0;
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+const checkIam_1 = require("../deploy/functions/checkIam");
+const checkValidTargetFilters_1 = require("../checkValidTargetFilters");
+const command_1 = require("../command");
+const deploy_1 = require("../deploy");
+const requireConfig_1 = require("../requireConfig");
+const filterTargets_1 = require("../filterTargets");
+const requireHostingSite_1 = require("../requireHostingSite");
+exports.VALID_DEPLOY_TARGETS = [
+    "database",
+    "storage",
+    "firestore",
+    "functions",
+    "hosting",
+    "remoteconfig",
+    "extensions",
+];
+exports.TARGET_PERMISSIONS = {
+    database: ["firebasedatabase.instances.update"],
+    hosting: ["firebasehosting.sites.update"],
+    functions: [
+        "cloudfunctions.functions.list",
+        "cloudfunctions.functions.create",
+        "cloudfunctions.functions.get",
+        "cloudfunctions.functions.update",
+        "cloudfunctions.functions.delete",
+        "cloudfunctions.operations.get",
+    ],
+    firestore: [
+        "datastore.indexes.list",
+        "datastore.indexes.create",
+        "datastore.indexes.update",
+        "datastore.indexes.delete",
+    ],
+    storage: [
+        "firebaserules.releases.create",
+        "firebaserules.rulesets.create",
+        "firebaserules.releases.update",
+    ],
+    remoteconfig: ["cloudconfig.configs.get", "cloudconfig.configs.update"],
+};
+exports.command = new command_1.Command("deploy")
+    .description("deploy code and assets to your Firebase project")
+    .withForce("delete Cloud Functions missing from the current working directory without confirmation")
+    .option("-p, --public <path>", "override the Hosting public directory specified in firebase.json")
+    .option("-m, --message <message>", "an optional message describing this deploy")
+    .option("--only <targets>", 'only deploy to specified, comma-separated targets (e.g. "hosting,storage"). For functions, ' +
+    'can specify filters with colons to scope function deploys to only those functions (e.g. "--only functions:func1,functions:func2"). ' +
+    "When filtering based on export groups (the exported module object keys), use dots to specify group names " +
+    '(e.g. "--only functions:group1.subgroup1,functions:group2)"')
+    .option("--except <targets>", 'deploy to all targets except specified (e.g. "database")')
+    .before(requireConfig_1.requireConfig)
+    .before((options) => {
+    options.filteredTargets = (0, filterTargets_1.filterTargets)(options, exports.VALID_DEPLOY_TARGETS);
+    const permissions = options.filteredTargets.reduce((perms, target) => {
+        return perms.concat(exports.TARGET_PERMISSIONS[target]);
+    }, []);
+    return (0, requirePermissions_1.requirePermissions)(options, permissions);
+})
+    .before((options) => {
+    if (options.filteredTargets.includes("functions")) {
+        return (0, checkIam_1.checkServiceAccountIam)(options.project);
+    }
+})
+    .before(async (options) => {
+    if (options.filteredTargets.includes("database")) {
+        await (0, requireDatabaseInstance_1.requireDatabaseInstance)(options);
+    }
+    if (options.filteredTargets.includes("hosting")) {
+        await (0, requireHostingSite_1.requireHostingSite)(options);
+    }
+})
+    .before(checkValidTargetFilters_1.checkValidTargetFilters)
+    .action((options) => {
+    return (0, deploy_1.deploy)(options.filteredTargets, options);
+});

node_modules/firebase-tools/lib/commands/emulators-exec.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const commandUtils = require("../emulator/commandUtils");
+const commandUtils_1 = require("../emulator/commandUtils");
+exports.command = new command_1.Command("emulators:exec <script>")
+    .before(commandUtils.setExportOnExitOptions)
+    .before(commandUtils.beforeEmulatorCommand)
+    .description("start the local Firebase emulators, " + "run a test script, then shut down the emulators")
+    .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
+    .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
+    .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+    .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
+    .option(commandUtils.FLAG_UI, commandUtils.DESC_UI)
+    .action((script, options) => {
+    return Promise.race([(0, commandUtils_1.shutdownWhenKilled)(options), (0, commandUtils_1.emulatorExec)(script, options)]);
+});

node_modules/firebase-tools/lib/commands/emulators-export.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const controller = require("../emulator/controller");
+const commandUtils = require("../emulator/commandUtils");
+const COMMAND_NAME = "emulators:export";
+exports.command = new command_1.Command(`${COMMAND_NAME} <path>`)
+    .description("export data from running emulators")
+    .withForce("overwrite any export data in the target directory")
+    .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
+    .action((exportPath, options) => {
+    return controller.exportEmulatorData(exportPath, options, COMMAND_NAME);
+});

node_modules/firebase-tools/lib/commands/emulators-start.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const controller = require("../emulator/controller");
+const commandUtils = require("../emulator/commandUtils");
+const logger_1 = require("../logger");
+const registry_1 = require("../emulator/registry");
+const types_1 = require("../emulator/types");
+const clc = require("colorette");
+const constants_1 = require("../emulator/constants");
+const utils_1 = require("../utils");
+const Table = require("cli-table");
+function stylizeLink(url) {
+    return clc.underline(clc.bold(url));
+}
+exports.command = new command_1.Command("emulators:start")
+    .before(commandUtils.setExportOnExitOptions)
+    .before(commandUtils.beforeEmulatorCommand)
+    .description("start the local Firebase emulators")
+    .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
+    .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
+    .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+    .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
+    .action((options) => {
+    const killSignalPromise = commandUtils.shutdownWhenKilled(options);
+    return Promise.race([
+        killSignalPromise,
+        (async () => {
+            let deprecationNotices;
+            try {
+                ({ deprecationNotices } = await controller.startAll(options));
+            }
+            catch (e) {
+                await controller.cleanShutdown();
+                throw e;
+            }
+            printEmulatorOverview(options);
+            for (const notice of deprecationNotices) {
+                (0, utils_1.logLabeledWarning)("emulators", notice, "warn");
+            }
+            return killSignalPromise;
+        })(),
+    ]);
+});
+function printEmulatorOverview(options) {
+    const reservedPorts = [];
+    for (const internalEmulator of [types_1.Emulators.LOGGING]) {
+        const info = registry_1.EmulatorRegistry.getInfo(internalEmulator);
+        if (info) {
+            reservedPorts.push(info.port);
+        }
+        controller.filterEmulatorTargets(options).forEach((emulator) => {
+            var _a;
+            reservedPorts.push(...(((_a = registry_1.EmulatorRegistry.getInfo(emulator)) === null || _a === void 0 ? void 0 : _a.reservedPorts) || []));
+        });
+    }
+    const reservedPortsString = reservedPorts.length > 0 ? reservedPorts.join(", ") : "None";
+    const uiRunning = registry_1.EmulatorRegistry.isRunning(types_1.Emulators.UI);
+    const head = ["Emulator", "Host:Port"];
+    if (uiRunning) {
+        head.push(`View in ${constants_1.Constants.description(types_1.Emulators.UI)}`);
+    }
+    const successMessageTable = new Table();
+    let successMsg = `${clc.green("✔")}  ${clc.bold("All emulators ready! It is now safe to connect your app.")}`;
+    if (uiRunning) {
+        successMsg += `\n${clc.cyan("i")}  View Emulator UI at ${stylizeLink(registry_1.EmulatorRegistry.url(types_1.Emulators.UI).toString())}`;
+    }
+    successMessageTable.push([successMsg]);
+    const emulatorsTable = new Table({
+        head: head,
+        style: {
+            head: ["yellow"],
+        },
+    });
+    emulatorsTable.push(...controller
+        .filterEmulatorTargets(options)
+        .map((emulator) => {
+        const emulatorName = constants_1.Constants.description(emulator).replace(/ emulator/i, "");
+        const isSupportedByUi = types_1.EMULATORS_SUPPORTED_BY_UI.includes(emulator);
+        const listen = commandUtils.getListenOverview(emulator);
+        if (!listen) {
+            const row = [emulatorName, "Failed to initialize (see above)"];
+            if (uiRunning) {
+                row.push("");
+            }
+            return row;
+        }
+        let uiLink = "n/a";
+        if (isSupportedByUi && uiRunning) {
+            const url = registry_1.EmulatorRegistry.url(types_1.Emulators.UI);
+            url.pathname = `/${emulator}`;
+            uiLink = stylizeLink(url.toString());
+        }
+        return [emulatorName, listen, uiLink];
+    })
+        .map((col) => col.slice(0, head.length))
+        .filter((v) => v));
+    let extensionsTable = "";
+    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.EXTENSIONS)) {
+        const extensionsEmulatorInstance = registry_1.EmulatorRegistry.get(types_1.Emulators.EXTENSIONS);
+        extensionsTable = extensionsEmulatorInstance.extensionsInfoTable(options);
+    }
+    logger_1.logger.info(`\n${successMessageTable}
+
+${emulatorsTable}
+${registry_1.EmulatorRegistry.isRunning(types_1.Emulators.HUB)
+        ? clc.blackBright("  Emulator Hub running at ") + registry_1.EmulatorRegistry.url(types_1.Emulators.HUB).host
+        : clc.blackBright("  Emulator Hub not running.")}
+${clc.blackBright("  Other reserved ports:")} ${reservedPortsString}
+${extensionsTable}
+Issues? Report them at ${stylizeLink("https://github.com/firebase/firebase-tools/issues")} and attach the *-debug.log files.
+ `);
+}

node_modules/firebase-tools/lib/commands/experimental-functions-shell.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const functionsShellCommandAction_1 = require("../functionsShellCommandAction");
+const command_1 = require("../command");
+const requireConfig_1 = require("../requireConfig");
+const requirePermissions_1 = require("../requirePermissions");
+exports.command = new command_1.Command("experimental:functions:shell")
+    .description("launch full Node shell with emulated functions. (Alias for `firebase functions:shell.)")
+    .option("-p, --port <port>", "the port on which to emulate functions (default: 5000)", 5000)
+    .before(requireConfig_1.requireConfig)
+    .before(requirePermissions_1.requirePermissions)
+    .action(functionsShellCommandAction_1.actionFunction);

node_modules/firebase-tools/lib/commands/experiments-describe.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const colorette_1 = require("colorette");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const experiments = require("../experiments");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+exports.command = new command_1.Command("experiments:describe <experiment>")
+    .description("enable an experiment on this machine")
+    .action((experiment) => {
+    if (!experiments.isValidExperiment(experiment)) {
+        let message = `Cannot find experiment ${(0, colorette_1.bold)(experiment)}`;
+        const potentials = experiments.experimentNameAutocorrect(experiment);
+        if (potentials.length === 1) {
+            message = `${message}\nDid you mean ${potentials[0]}?`;
+        }
+        else if (potentials.length) {
+            message = `${message}\nDid you mean ${potentials.slice(0, -1).join(",")} or ${(0, utils_1.last)(potentials)}?`;
+        }
+        throw new error_1.FirebaseError(message);
+    }
+    const spec = experiments.ALL_EXPERIMENTS[experiment];
+    logger_1.logger.info(`${(0, colorette_1.bold)("Name")}: ${experiment}`);
+    logger_1.logger.info(`${(0, colorette_1.bold)("Enabled")}: ${experiments.isEnabled(experiment) ? "yes" : "no"}`);
+    if (spec.docsUri) {
+        logger_1.logger.info(`${(0, colorette_1.bold)("Documentation")}: ${spec.docsUri}`);
+    }
+    logger_1.logger.info(`${(0, colorette_1.bold)("Description")}: ${spec.fullDescription || spec.shortDescription}`);
+});

node_modules/firebase-tools/lib/commands/experiments-disable.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const colorette_1 = require("colorette");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const experiments = require("../experiments");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+exports.command = new command_1.Command("experiments:disable <experiment>")
+    .description("disable an experiment on this machine")
+    .action((experiment) => {
+    if (experiments.isValidExperiment(experiment)) {
+        experiments.setEnabled(experiment, false);
+        experiments.flushToDisk();
+        logger_1.logger.info(`Disabled experiment ${(0, colorette_1.bold)(experiment)}`);
+        return;
+    }
+    let message = `Cannot find experiment ${(0, colorette_1.bold)(experiment)}`;
+    const potentials = experiments.experimentNameAutocorrect(experiment);
+    if (potentials.length === 1) {
+        message = `${message}\nDid you mean ${potentials[0]}?`;
+    }
+    else if (potentials.length) {
+        message = `${message}\nDid you mean ${potentials.slice(0, -1).join(",")} or ${(0, utils_1.last)(potentials)}?`;
+    }
+    throw new error_1.FirebaseError(message);
+});

node_modules/firebase-tools/lib/commands/experiments-enable.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const colorette_1 = require("colorette");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const experiments = require("../experiments");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+exports.command = new command_1.Command("experiments:enable <experiment>")
+    .description("enable an experiment on this machine")
+    .action((experiment) => {
+    if (experiments.isValidExperiment(experiment)) {
+        experiments.setEnabled(experiment, true);
+        experiments.flushToDisk();
+        logger_1.logger.info(`Enabled experiment ${(0, colorette_1.bold)(experiment)}`);
+        return;
+    }
+    let message = `Cannot find experiment ${(0, colorette_1.bold)(experiment)}`;
+    const potentials = experiments.experimentNameAutocorrect(experiment);
+    if (potentials.length === 1) {
+        message = `${message}\nDid you mean ${potentials[0]}?`;
+    }
+    else if (potentials.length) {
+        message = `${message}\nDid you mean ${potentials.slice(0, -1).join(",")} or ${(0, utils_1.last)(potentials)}?`;
+    }
+    throw new error_1.FirebaseError(message);
+});

node_modules/firebase-tools/lib/commands/experiments-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const Table = require("cli-table");
+const experiments = require("../experiments");
+const functional_1 = require("../functional");
+const logger_1 = require("../logger");
+exports.command = new command_1.Command("experiments:list").action(() => {
+    const table = new Table({
+        head: ["Enabled", "Name", "Description"],
+        style: { head: ["yellow"] },
+    });
+    const [enabled, disabled] = (0, functional_1.partition)(Object.entries(experiments.ALL_EXPERIMENTS), ([name]) => {
+        return experiments.isEnabled(name);
+    });
+    for (const [name, exp] of enabled) {
+        table.push(["y", name, exp.shortDescription]);
+    }
+    for (const [name, exp] of disabled) {
+        if (!exp.public) {
+            continue;
+        }
+        table.push(["n", name, exp.shortDescription]);
+    }
+    logger_1.logger.info(table.toString());
+});

node_modules/firebase-tools/lib/commands/ext-configure.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const { marked } = require("marked");
+const TerminalRenderer = require("marked-terminal");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const projectUtils_1 = require("../projectUtils");
+const extensionsApi = require("../extensions/extensionsApi");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const paramHelper = require("../extensions/paramHelper");
+const requirePermissions_1 = require("../requirePermissions");
+const utils = require("../utils");
+const logger_1 = require("../logger");
+const refs = require("../extensions/refs");
+const manifest = require("../extensions/manifest");
+const functional_1 = require("../functional");
+const paramHelper_1 = require("../extensions/paramHelper");
+const askUserForEventsConfig = require("../extensions/askUserForEventsConfig");
+marked.setOptions({
+    renderer: new TerminalRenderer(),
+});
+exports.command = new command_1.Command("ext:configure <extensionInstanceId>")
+    .description("configure an existing extension instance")
+    .withForce()
+    .option("--local", "deprecated")
+    .before(requirePermissions_1.requirePermissions, [
+    "firebaseextensions.instances.update",
+    "firebaseextensions.instances.get",
+])
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extMinVersion")
+    .before(extensionsHelper_1.diagnoseAndFixProject)
+    .action(async (instanceId, options) => {
+    const projectId = (0, projectUtils_1.getProjectId)(options);
+    if (options.nonInteractive) {
+        throw new error_1.FirebaseError(`Command not supported in non-interactive mode, edit ./extensions/${instanceId}.env directly instead. ` +
+            `See https://firebase.google.com/docs/extensions/manifest for more details.`);
+    }
+    if (options.local) {
+        utils.logLabeledWarning(extensionsHelper_1.logPrefix, "As of firebase-tools@11.0.0, the `--local` flag is no longer required, as it is the default behavior.");
+    }
+    const config = manifest.loadConfig(options);
+    const refOrPath = manifest.getInstanceTarget(instanceId, config);
+    const isLocalSource = (0, extensionsHelper_1.isLocalPath)(refOrPath);
+    let spec;
+    if (isLocalSource) {
+        const source = await (0, extensionsHelper_1.createSourceFromLocation)((0, projectUtils_1.needProjectId)({ projectId }), refOrPath);
+        spec = source.spec;
+    }
+    else {
+        const extensionVersion = await extensionsApi.getExtensionVersion(refOrPath);
+        spec = extensionVersion.spec;
+    }
+    const oldParamValues = manifest.readInstanceParam({
+        instanceId,
+        projectDir: config.projectDir,
+    });
+    const [immutableParams, tbdParams] = (0, functional_1.partition)(spec.params, (param) => { var _a; return (_a = param.immutable) !== null && _a !== void 0 ? _a : false; });
+    infoImmutableParams(immutableParams, oldParamValues);
+    paramHelper.setNewDefaults(tbdParams, oldParamValues);
+    const mutableParamsBindingOptions = await paramHelper.getParams({
+        projectId,
+        paramSpecs: tbdParams,
+        nonInteractive: false,
+        paramsEnvPath: "",
+        instanceId,
+        reconfiguring: true,
+    });
+    const eventsConfig = spec.events
+        ? await askUserForEventsConfig.askForEventsConfig(spec.events, "${param:PROJECT_ID}", instanceId)
+        : undefined;
+    if (eventsConfig) {
+        mutableParamsBindingOptions.EVENTARC_CHANNEL = { baseValue: eventsConfig.channel };
+        mutableParamsBindingOptions.ALLOWED_EVENT_TYPES = {
+            baseValue: eventsConfig.allowedEventTypes.join(","),
+        };
+    }
+    const newParamOptions = Object.assign(Object.assign({}, (0, paramHelper_1.buildBindingOptionsWithBaseValue)(oldParamValues)), mutableParamsBindingOptions);
+    await manifest.writeToManifest([
+        {
+            instanceId,
+            ref: !isLocalSource ? refs.parse(refOrPath) : undefined,
+            localPath: isLocalSource ? refOrPath : undefined,
+            params: newParamOptions,
+            extensionSpec: spec,
+        },
+    ], config, {
+        nonInteractive: false,
+        force: true,
+    });
+    manifest.showPostDeprecationNotice();
+    return;
+});
+function infoImmutableParams(immutableParams, paramValues) {
+    if (!immutableParams.length) {
+        return;
+    }
+    const plural = immutableParams.length > 1;
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, marked(`The following param${plural ? "s are" : " is"} immutable and won't be changed:`));
+    for (const { param } of immutableParams) {
+        logger_1.logger.info(`param: ${param}, value: ${paramValues[param]}`);
+    }
+    logger_1.logger.info((plural
+        ? "To set different values for these params"
+        : "To set a different value for this param") +
+        ", uninstall the extension, then install a new instance of this extension.");
+}

node_modules/firebase-tools/lib/commands/ext-dev-deprecate.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const semver = require("semver");
+const refs = require("../extensions/refs");
+const utils = require("../utils");
+const command_1 = require("../command");
+const prompt_1 = require("../prompt");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const versionHelper_1 = require("../extensions/versionHelper");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+exports.command = new command_1.Command("ext:dev:deprecate <extensionRef> <versionPredicate>")
+    .description("deprecate extension versions that match the version predicate")
+    .option("-m, --message <deprecationMessage>", "deprecation message")
+    .option("-f, --force", "override deprecation message for existing deprecated extension versions that match")
+    .before(requireAuth_1.requireAuth)
+    .before(extensionsHelper_1.ensureExtensionsApiEnabled)
+    .action(async (extensionRef, versionPredicate, options) => {
+    const { publisherId, extensionId, version } = refs.parse(extensionRef);
+    if (version) {
+        throw new error_1.FirebaseError(`The input extension reference must be of the format ${clc.bold("<publisherId>/<extensionId>")}. Version should be supplied in the version predicate argument.`);
+    }
+    if (!publisherId || !extensionId) {
+        throw new error_1.FirebaseError(`Error parsing publisher ID and extension ID from extension reference '${clc.bold(extensionRef)}'. Please use the format '${clc.bold("<publisherId>/<extensionId>")}'.`);
+    }
+    const { comparator, targetSemVer } = (0, versionHelper_1.parseVersionPredicate)(versionPredicate);
+    const filter = `id${comparator}"${targetSemVer}"`;
+    const extensionVersions = await (0, extensionsApi_1.listExtensionVersions)(extensionRef, filter);
+    const filteredExtensionVersions = extensionVersions
+        .sort((ev1, ev2) => {
+        return -semver.compare(ev1.spec.version, ev2.spec.version);
+    })
+        .filter((extensionVersion) => {
+        if (extensionVersion.state === "DEPRECATED" && !options.force) {
+            return false;
+        }
+        const message = extensionVersion.state === "DEPRECATED" ? ", will overwrite deprecation message" : "";
+        utils.logLabeledBullet(extensionVersion.ref, extensionVersion.state + message);
+        return true;
+    });
+    if (filteredExtensionVersions.length > 0) {
+        if (!options.force) {
+            const confirmMessage = "You are about to deprecate these extension version(s). Do you wish to continue?";
+            const consent = await (0, prompt_1.promptOnce)({
+                type: "confirm",
+                message: confirmMessage,
+                default: false,
+            });
+            if (!consent) {
+                throw new error_1.FirebaseError("Deprecation canceled.");
+            }
+        }
+    }
+    else {
+        throw new error_1.FirebaseError("No extension versions matched the version predicate.");
+    }
+    await utils.allSettled(filteredExtensionVersions.map(async (extensionVersion) => {
+        await (0, extensionsApi_1.deprecateExtensionVersion)(extensionVersion.ref, options.deprecationMessage);
+    }));
+    utils.logLabeledSuccess(extensionsHelper_1.logPrefix, "successfully deprecated extension version(s).");
+});

node_modules/firebase-tools/lib/commands/ext-dev-emulators-exec.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const commandUtils = require("../emulator/commandUtils");
+exports.command = new command_1.Command("ext:dev:emulators:exec <script>")
+    .description("deprecated: please use `firebase emulators:exec` instead")
+    .before(commandUtils.setExportOnExitOptions)
+    .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
+    .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
+    .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
+    .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+    .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
+    .option(commandUtils.FLAG_UI, commandUtils.DESC_UI)
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
+    .action((script) => {
+    const localInstallCommand = `firebase ext:install ${process.cwd()}`;
+    const emulatorsExecCommand = `firebase emulators:exec '${script}`;
+    throw new error_1.FirebaseError("ext:dev:emulators:exec is no longer supported. " +
+        "Instead, navigate to a Firebase project directory and add this extension to the extensions manifest by running:\n" +
+        clc.bold(localInstallCommand) +
+        "\nThen, you can emulate this extension as part of that project by running:\n" +
+        clc.bold(emulatorsExecCommand));
+});

node_modules/firebase-tools/lib/commands/ext-dev-emulators-start.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const command_1 = require("../command");
+const commandUtils = require("../emulator/commandUtils");
+const error_1 = require("../error");
+exports.command = new command_1.Command("ext:dev:emulators:start")
+    .description("deprecated: please use `firebase emulators:start`")
+    .before(commandUtils.setExportOnExitOptions)
+    .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
+    .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
+    .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
+    .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+    .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
+    .action(() => {
+    const localInstallCommand = `firebase ext:install ${process.cwd()}`;
+    const emulatorsStartCommand = "firebase emulators:start";
+    throw new error_1.FirebaseError("ext:dev:emulators:start is no longer supported. " +
+        "Instead, navigate to a Firebase project directory and add this extension to the extensions manifest by running:\n" +
+        clc.bold(localInstallCommand) +
+        "\nThen, you can emulate this extension as part of that project by running:\n" +
+        clc.bold(emulatorsStartCommand));
+});

node_modules/firebase-tools/lib/commands/ext-dev-extension-delete.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const utils = require("../utils");
+const clc = require("colorette");
+const command_1 = require("../command");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const refs = require("../extensions/refs");
+const prompt_1 = require("../prompt");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+exports.command = new command_1.Command("ext:dev:delete <extensionRef>")
+    .description("delete an extension")
+    .help("use this command to delete an extension, and make it unavailable for developers to install or reconfigure. " +
+    "Specify the extension you want to delete using the format '<publisherId>/<extensionId>.")
+    .before(requireAuth_1.requireAuth)
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
+    .action(async (extensionRef) => {
+    const { publisherId, extensionId, version } = refs.parse(extensionRef);
+    if (version) {
+        throw new error_1.FirebaseError(`Deleting a single version is not currently supported. You can only delete ${clc.bold("ALL versions")} of an extension. To delete all versions, please remove the version from the reference.`);
+    }
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "If you delete this extension, developers won't be able to install it. " +
+        "For developers who currently have this extension installed, " +
+        "it will continue to run and will appear as unpublished when " +
+        "listed in the Firebase console or Firebase CLI.");
+    utils.logLabeledWarning("This is a permanent action", `Once deleted, you may never use the extension name '${clc.bold(extensionId)}' again.`);
+    await (0, extensionsApi_1.getExtension)(extensionRef);
+    const consent = await confirmDelete(publisherId, extensionId);
+    if (!consent) {
+        throw new error_1.FirebaseError("deletion cancelled.");
+    }
+    await (0, extensionsApi_1.deleteExtension)(extensionRef);
+    utils.logLabeledSuccess(extensionsHelper_1.logPrefix, "successfully deleted all versions of this extension.");
+});
+async function confirmDelete(publisherId, extensionId) {
+    const message = `You are about to delete ALL versions of ${clc.green(`${publisherId}/${extensionId}`)}.\nDo you wish to continue? `;
+    return (0, prompt_1.promptOnce)({
+        type: "confirm",
+        message,
+        default: false,
+    });
+}

node_modules/firebase-tools/lib/commands/ext-dev-init.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const fs = require("fs");
+const path = require("path");
+const { marked } = require("marked");
+const TerminalRenderer = require("marked-terminal");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const command_1 = require("../command");
+const config_1 = require("../config");
+const error_1 = require("../error");
+const prompt_1 = require("../prompt");
+const logger_1 = require("../logger");
+const npmDependencies = require("../init/features/functions/npm-dependencies");
+marked.setOptions({
+    renderer: new TerminalRenderer(),
+});
+const TEMPLATE_ROOT = path.resolve(__dirname, "../../templates/extensions/");
+const FUNCTIONS_ROOT = path.resolve(__dirname, "../../templates/init/functions/");
+function readCommonTemplates() {
+    return {
+        extSpecTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "extension.yaml"), "utf8"),
+        preinstallTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "PREINSTALL.md"), "utf8"),
+        postinstallTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "POSTINSTALL.md"), "utf8"),
+        changelogTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "CHANGELOG.md"), "utf8"),
+    };
+}
+exports.command = new command_1.Command("ext:dev:init")
+    .description("initialize files for writing an extension in the current directory")
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
+    .action(async (options) => {
+    const cwd = options.cwd || process.cwd();
+    const config = new config_1.Config({}, { projectDir: cwd, cwd: cwd });
+    try {
+        const lang = await (0, prompt_1.promptOnce)({
+            type: "list",
+            name: "language",
+            message: "In which language do you want to write the Cloud Functions for your extension?",
+            default: "javascript",
+            choices: [
+                {
+                    name: "JavaScript",
+                    value: "javascript",
+                },
+                {
+                    name: "TypeScript",
+                    value: "typescript",
+                },
+            ],
+        });
+        switch (lang) {
+            case "javascript": {
+                await javascriptSelected(config);
+                break;
+            }
+            case "typescript": {
+                await typescriptSelected(config);
+                break;
+            }
+            default: {
+                throw new error_1.FirebaseError(`${lang} is not supported.`);
+            }
+        }
+        await npmDependencies.askInstallDependencies({}, config);
+        const welcome = fs.readFileSync(path.join(TEMPLATE_ROOT, lang, "WELCOME.md"), "utf8");
+        return logger_1.logger.info("\n" + marked(welcome));
+    }
+    catch (err) {
+        if (!(err instanceof error_1.FirebaseError)) {
+            throw new error_1.FirebaseError(`Error occurred when initializing files for new extension: ${err.message}`, {
+                original: err,
+            });
+        }
+        throw err;
+    }
+});
+async function typescriptSelected(config) {
+    const packageLintingTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "package.lint.json"), "utf8");
+    const packageNoLintingTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "package.nolint.json"), "utf8");
+    const tsconfigTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "tsconfig.json"), "utf8");
+    const tsconfigDevTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "tsconfig.dev.json"), "utf8");
+    const indexTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "index.ts"), "utf8");
+    const gitignoreTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "typescript", "_gitignore"), "utf8");
+    const eslintTemplate = fs.readFileSync(path.join(FUNCTIONS_ROOT, "typescript", "_eslintrc"), "utf8");
+    const lint = await (0, prompt_1.promptOnce)({
+        name: "lint",
+        type: "confirm",
+        message: "Do you want to use ESLint to catch probable bugs and enforce style?",
+        default: true,
+    });
+    const templates = readCommonTemplates();
+    await config.askWriteProjectFile("extension.yaml", templates.extSpecTemplate);
+    await config.askWriteProjectFile("PREINSTALL.md", templates.preinstallTemplate);
+    await config.askWriteProjectFile("POSTINSTALL.md", templates.postinstallTemplate);
+    await config.askWriteProjectFile("CHANGELOG.md", templates.changelogTemplate);
+    await config.askWriteProjectFile("functions/src/index.ts", indexTemplate);
+    if (lint) {
+        await config.askWriteProjectFile("functions/package.json", packageLintingTemplate);
+        await config.askWriteProjectFile("functions/.eslintrc.js", eslintTemplate);
+    }
+    else {
+        await config.askWriteProjectFile("functions/package.json", packageNoLintingTemplate);
+    }
+    await config.askWriteProjectFile("functions/tsconfig.json", tsconfigTemplate);
+    if (lint) {
+        await config.askWriteProjectFile("functions/tsconfig.dev.json", tsconfigDevTemplate);
+    }
+    await config.askWriteProjectFile("functions/.gitignore", gitignoreTemplate);
+}
+async function javascriptSelected(config) {
+    const indexTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "javascript", "index.js"), "utf8");
+    const packageLintingTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "javascript", "package.lint.json"), "utf8");
+    const packageNoLintingTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "javascript", "package.nolint.json"), "utf8");
+    const gitignoreTemplate = fs.readFileSync(path.join(TEMPLATE_ROOT, "javascript", "_gitignore"), "utf8");
+    const eslintTemplate = fs.readFileSync(path.join(FUNCTIONS_ROOT, "javascript", "_eslintrc"), "utf8");
+    const lint = await (0, prompt_1.promptOnce)({
+        name: "lint",
+        type: "confirm",
+        message: "Do you want to use ESLint to catch probable bugs and enforce style?",
+        default: false,
+    });
+    const templates = readCommonTemplates();
+    await config.askWriteProjectFile("extension.yaml", templates.extSpecTemplate);
+    await config.askWriteProjectFile("PREINSTALL.md", templates.preinstallTemplate);
+    await config.askWriteProjectFile("POSTINSTALL.md", templates.postinstallTemplate);
+    await config.askWriteProjectFile("CHANGELOG.md", templates.changelogTemplate);
+    await config.askWriteProjectFile("functions/index.js", indexTemplate);
+    if (lint) {
+        await config.askWriteProjectFile("functions/package.json", packageLintingTemplate);
+        await config.askWriteProjectFile("functions/.eslintrc.js", eslintTemplate);
+    }
+    else {
+        await config.askWriteProjectFile("functions/package.json", packageNoLintingTemplate);
+    }
+    await config.askWriteProjectFile("functions/.gitignore", gitignoreTemplate);
+}

node_modules/firebase-tools/lib/commands/ext-dev-list.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const Table = require("cli-table");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const logger_1 = require("../logger");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const requireAuth_1 = require("../requireAuth");
+const extensionsUtils = require("../extensions/utils");
+exports.command = new command_1.Command("ext:dev:list <publisherId>")
+    .description("list all published extensions associated with this publisher ID")
+    .before(requireAuth_1.requireAuth)
+    .action(async (publisherId) => {
+    let extensions;
+    try {
+        extensions = await (0, extensionsApi_1.listExtensions)(publisherId);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(err);
+    }
+    if (extensions.length < 1) {
+        throw new error_1.FirebaseError(`There are no published extensions associated with publisher ID ${clc.bold(publisherId)}. This could happen for two reasons:\n` +
+            "  - The publisher ID doesn't exist or could be misspelled\n" +
+            "  - This publisher has not published any extensions\n\n" +
+            "If you are expecting some extensions to appear, please make sure you have the correct publisher ID and try again.");
+    }
+    const table = new Table({
+        head: ["Extension ID", "Version", "Published"],
+        style: { head: ["yellow"] },
+    });
+    const sorted = extensions.sort((a, b) => new Date(b.createTime).valueOf() - new Date(a.createTime).valueOf());
+    sorted.forEach((extension) => {
+        table.push([
+            (0, utils_1.last)(extension.ref.split("/")),
+            extension.latestVersion,
+            extension.createTime ? extensionsUtils.formatTimestamp(extension.createTime) : "",
+        ]);
+    });
+    (0, utils_1.logLabeledBullet)(extensionsHelper_1.logPrefix, `list of published extensions for publisher ${clc.bold(publisherId)}:`);
+    logger_1.logger.info(table.toString());
+    return { extensions: sorted };
+});

node_modules/firebase-tools/lib/commands/ext-dev-publish.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const { marked } = require("marked");
+const TerminalRenderer = require("marked-terminal");
+const command_1 = require("../command");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const refs = require("../extensions/refs");
+const localHelper_1 = require("../extensions/localHelper");
+const publishHelpers_1 = require("../extensions/publishHelpers");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+const utils = require("../utils");
+marked.setOptions({
+    renderer: new TerminalRenderer(),
+});
+exports.command = new command_1.Command("ext:dev:publish <extensionRef>")
+    .description(`publish a new version of an extension`)
+    .option(`-s, --stage <stage>`, `release stage (supports "rc", "alpha", "beta", and "stable")`)
+    .withForce()
+    .help("if you have not previously published a version of this extension, this will " +
+    "create the extension. If you have previously published a version of this extension, this version must " +
+    "be greater than previous versions.")
+    .before(requireAuth_1.requireAuth)
+    .action(async (extensionRef, options) => {
+    var _a;
+    const { publisherId, extensionId, version } = refs.parse(extensionRef);
+    if (version) {
+        throw new error_1.FirebaseError(`The input extension reference must be of the format ${clc.bold("<publisherId>/<extensionId>")}. Version should not be supplied and will be inferred directly from extension.yaml. Please increment the version in extension.yaml if you would like to bump/specify a version.`);
+    }
+    if (!publisherId || !extensionId) {
+        throw new error_1.FirebaseError(`Error parsing publisher ID and extension ID from extension reference '${clc.bold(extensionRef)}'. Please use the format '${clc.bold("<publisherId>/<extensionId>")}'.`);
+    }
+    const extensionYamlDirectory = (0, localHelper_1.findExtensionYaml)(process.cwd());
+    const res = await (0, extensionsHelper_1.publishExtensionVersionFromLocalSource)({
+        publisherId,
+        extensionId,
+        rootDirectory: extensionYamlDirectory,
+        nonInteractive: options.nonInteractive,
+        force: options.force,
+        stage: (_a = options.stage) !== null && _a !== void 0 ? _a : "stable",
+    });
+    if (res) {
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`[Install Link](${(0, publishHelpers_1.consoleInstallLink)(res.ref)})`));
+    }
+    return res;
+});

node_modules/firebase-tools/lib/commands/ext-dev-register.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const { marked } = require("marked");
+const command_1 = require("../command");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const projectUtils_1 = require("../projectUtils");
+const prompt_1 = require("../prompt");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const askUserForConsent_1 = require("../extensions/askUserForConsent");
+const requirePermissions_1 = require("../requirePermissions");
+const error_1 = require("../error");
+const utils = require("../utils");
+exports.command = new command_1.Command("ext:dev:register")
+    .description("register a publisher ID; run this before publishing your first extension.")
+    .before(requirePermissions_1.requirePermissions, ["firebaseextensions.sources.create"])
+    .before(extensionsHelper_1.ensureExtensionsApiEnabled)
+    .action(async (options) => {
+    await (0, askUserForConsent_1.promptForPublisherTOS)();
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const msg = "What would you like to register as your publisher ID? " +
+        "This value identifies you in Firebase's registry of extensions as the author of your extensions. " +
+        "Examples: my-company-name, MyGitHubUsername.\n\n" +
+        "You can only do this once for each project.";
+    const publisherId = await (0, prompt_1.promptOnce)({
+        name: "publisherId",
+        type: "input",
+        message: msg,
+        default: projectId,
+    });
+    try {
+        await (0, extensionsApi_1.registerPublisherProfile)(projectId, publisherId);
+    }
+    catch (err) {
+        if (err.status === 409) {
+            const error = `Couldn't register the publisher ID '${clc.bold(publisherId)}' to the project '${clc.bold(projectId)}'.` +
+                " This can happen for either of two reasons:\n\n" +
+                ` - Publisher ID '${clc.bold(publisherId)}' is registered to another project\n` +
+                ` - Project '${clc.bold(projectId)}' already has a publisher ID\n\n` +
+                ` Try again with a unique publisher ID or a new project. If your business’s name has been registered to another project, contact Firebase support ${marked("(https://firebase.google.com/support/troubleshooter/contact).")}`;
+            throw new error_1.FirebaseError(error, { exit: 1 });
+        }
+        throw new error_1.FirebaseError(`Failed to register publisher ID ${clc.bold(publisherId)} for project ${clc.bold(projectId)}: ${err.message}`);
+    }
+    return utils.logLabeledSuccess(extensionsHelper_1.logPrefix, `Publisher ID '${clc.bold(publisherId)}' has been registered to project ${clc.bold(projectId)}`);
+});

node_modules/firebase-tools/lib/commands/ext-dev-undeprecate.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const semver = require("semver");
+const refs = require("../extensions/refs");
+const utils = require("../utils");
+const command_1 = require("../command");
+const prompt_1 = require("../prompt");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const versionHelper_1 = require("../extensions/versionHelper");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+exports.command = new command_1.Command("ext:dev:undeprecate <extensionRef> <versionPredicate>")
+    .description("undeprecate extension versions that match the version predicate")
+    .before(requireAuth_1.requireAuth)
+    .before(extensionsHelper_1.ensureExtensionsApiEnabled)
+    .action(async (extensionRef, versionPredicate, options) => {
+    const { publisherId, extensionId, version } = refs.parse(extensionRef);
+    if (version) {
+        throw new error_1.FirebaseError(`The input extension reference must be of the format ${clc.bold("<publisherId>/<extensionId>")}. Version should be supplied in the version predicate argument.`);
+    }
+    if (!publisherId || !extensionId) {
+        throw new error_1.FirebaseError(`Error parsing publisher ID and extension ID from extension reference '${clc.bold(extensionRef)}'. Please use the format '${clc.bold("<publisherId>/<extensionId>")}'.`);
+    }
+    const { comparator, targetSemVer } = (0, versionHelper_1.parseVersionPredicate)(versionPredicate);
+    const filter = `id${comparator}"${targetSemVer}"`;
+    const extensionVersions = await (0, extensionsApi_1.listExtensionVersions)(extensionRef, filter);
+    extensionVersions
+        .sort((ev1, ev2) => {
+        return -semver.compare(ev1.spec.version, ev2.spec.version);
+    })
+        .forEach((extensionVersion) => {
+        utils.logLabeledBullet(extensionVersion.ref, extensionVersion.state);
+    });
+    if (extensionVersions.length > 0) {
+        if (!options.force) {
+            const confirmMessage = "You are about to undeprecate these extension version(s). Do you wish to continue?";
+            const consent = await (0, prompt_1.promptOnce)({
+                type: "confirm",
+                message: confirmMessage,
+                default: false,
+            });
+            if (!consent) {
+                throw new error_1.FirebaseError("Undeprecation canceled.");
+            }
+        }
+    }
+    else {
+        throw new error_1.FirebaseError("No extension versions matched the version predicate.");
+    }
+    await utils.allSettled(extensionVersions.map(async (extensionVersion) => {
+        await (0, extensionsApi_1.undeprecateExtensionVersion)(extensionVersion.ref);
+    }));
+    utils.logLabeledSuccess(extensionsHelper_1.logPrefix, "successfully undeprecated extension version(s).");
+});

node_modules/firebase-tools/lib/commands/ext-dev-unpublish.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const utils = require("../utils");
+const refs = require("../extensions/refs");
+const prompt_1 = require("../prompt");
+const clc = require("colorette");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+exports.command = new command_1.Command("ext:dev:unpublish <extensionRef>")
+    .description("unpublish an extension")
+    .withForce()
+    .help("use this command to unpublish an extension, and make it unavailable for developers to install or reconfigure. " +
+    "Specify the extension you want to unpublish using the format '<publisherId>/<extensionId>.")
+    .before(requireAuth_1.requireAuth)
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
+    .action(async (extensionRef, options) => {
+    const { publisherId, extensionId, version } = refs.parse(extensionRef);
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "If you unpublish this extension, developers won't be able to install it. For developers who currently have this extension installed, it will continue to run and will appear as unpublished when listed in the Firebase console or Firebase CLI.");
+    utils.logLabeledWarning("This is a permanent action", `Once unpublished, you may never use the extension name '${clc.bold(extensionId)}' again.`);
+    if (version) {
+        throw new error_1.FirebaseError(`Unpublishing a single version is not currently supported. You can only unpublish ${clc.bold("ALL versions")} of an extension. To unpublish all versions, please remove the version from the reference.`);
+    }
+    await (0, extensionsApi_1.getExtension)(extensionRef);
+    const consent = await comfirmUnpublish(publisherId, extensionId, options);
+    if (!consent) {
+        throw new error_1.FirebaseError("unpublishing cancelled.");
+    }
+    await (0, extensionsApi_1.unpublishExtension)(extensionRef);
+    utils.logLabeledSuccess(extensionsHelper_1.logPrefix, "successfully unpublished all versions of this extension.");
+});
+async function comfirmUnpublish(publisherId, extensionId, options) {
+    if (options.nonInteractive && !options.force) {
+        throw new error_1.FirebaseError("Pass the --force flag to use this command in non-interactive mode");
+    }
+    if (options.nonInteractive && options.force) {
+        return true;
+    }
+    const message = `You are about to unpublish ALL versions of ${clc.green(`${publisherId}/${extensionId}`)}.\nDo you wish to continue? `;
+    return (0, prompt_1.promptOnce)({
+        type: "confirm",
+        message,
+        default: false,
+    });
+}

node_modules/firebase-tools/lib/commands/ext-dev-usage.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const Table = require("cli-table");
+const clc = require("colorette");
+const utils = require("../utils");
+const command_1 = require("../command");
+const cloudmonitoring_1 = require("../gcp/cloudmonitoring");
+const requireAuth_1 = require("../requireAuth");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const metricsUtils_1 = require("../extensions/metricsUtils");
+const extensionsApi_1 = require("../extensions/extensionsApi");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+const shortenUrl_1 = require("../shortenUrl");
+exports.command = new command_1.Command("ext:dev:usage <publisherId>")
+    .description("get usage for an extension")
+    .help("use this command to get the usage of extensions you published. " +
+    "Specify the publisher ID you used to publish your extensions, " +
+    "or the extension ref of your published extension.")
+    .before(requireAuth_1.requireAuth)
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extDevMinVersion")
+    .action(async (input) => {
+    const extensionRefRegex = /^[\w\d-]+\/[\w\d-]+$/;
+    let extensionName;
+    let publisherId;
+    if (extensionRefRegex.test(input)) {
+        [publisherId, extensionName] = input.split("/");
+    }
+    else {
+        publisherId = input;
+        let extensions;
+        try {
+            extensions = await (0, extensionsApi_1.listExtensions)(publisherId);
+        }
+        catch (err) {
+            throw new error_1.FirebaseError(err);
+        }
+        if (extensions.length < 1) {
+            throw new error_1.FirebaseError(`There are no published extensions associated with publisher ID ${clc.bold(publisherId)}. This could happen for two reasons:\n` +
+                "  - The publisher ID doesn't exist or could be misspelled\n" +
+                "  - This publisher has not published any extensions\n\n" +
+                "If you are expecting some extensions to appear, please make sure you have the correct publisher ID and try again.");
+        }
+        extensionName = await (0, prompt_1.promptOnce)({
+            type: "list",
+            name: "extension",
+            message: "Which published extension do you want to view the stats for?",
+            choices: extensions.map((e) => {
+                const [_, name] = e.ref.split("/");
+                return {
+                    name,
+                    value: name,
+                };
+            }),
+        });
+    }
+    const profile = await (0, extensionsApi_1.getPublisherProfile)("-", publisherId);
+    const projectNumber = (0, extensionsHelper_1.getPublisherProjectFromName)(profile.name);
+    const past45d = new Date();
+    past45d.setDate(past45d.getDate() - 45);
+    const query = {
+        filter: `metric.type="firebaseextensions.googleapis.com/extension/version/active_instances" ` +
+            `resource.type="firebaseextensions.googleapis.com/ExtensionVersion" ` +
+            `resource.labels.extension="${extensionName}"`,
+        "interval.endTime": new Date().toJSON(),
+        "interval.startTime": past45d.toJSON(),
+        view: cloudmonitoring_1.TimeSeriesView.FULL,
+        "aggregation.alignmentPeriod": (60 * 60 * 24).toString() + "s",
+        "aggregation.perSeriesAligner": cloudmonitoring_1.Aligner.ALIGN_MAX,
+    };
+    let response;
+    try {
+        response = await (0, cloudmonitoring_1.queryTimeSeries)(query, projectNumber);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Error occurred when fetching usage data for extension ${extensionName}`, {
+            original: err,
+        });
+    }
+    if (!response) {
+        throw new error_1.FirebaseError(`Couldn't find any usage data for extension ${extensionName}`);
+    }
+    const metrics = (0, metricsUtils_1.parseTimeseriesResponse)(response);
+    const table = new Table({
+        head: ["Version", "Active Instances", "Changes last 7 Days", "Changes last 28 Days"],
+        style: {
+            head: ["yellow"],
+        },
+        colAligns: ["left", "right", "right", "right"],
+    });
+    metrics.forEach((m) => {
+        table.push((0, metricsUtils_1.buildMetricsTableRow)(m));
+    });
+    utils.logLabeledBullet(extensionsHelper_1.logPrefix, `showing usage stats for ${clc.bold(extensionName)}:`);
+    logger_1.logger.info(table.toString());
+    utils.logLabeledBullet(extensionsHelper_1.logPrefix, `How to read this table:`);
+    logger_1.logger.info(`* Due to privacy considerations, numbers are reported as ranges.`);
+    logger_1.logger.info(`* In the absence of significant changes, we will render a '-' symbol.`);
+    logger_1.logger.info(`* You will need more than 10 installs over a period of more than 28 days to render sufficient data.`);
+});
+async function buildCloudMonitoringLink(args) {
+    const pageState = {
+        xyChart: {
+            dataSets: [
+                {
+                    timeSeriesFilter: {
+                        filter: `metric.type="firebaseextensions.googleapis.com/extension/version/active_instances"` +
+                            ` resource.type="firebaseextensions.googleapis.com/ExtensionVersion"` +
+                            ` resource.label.extension="${args.extensionName}"`,
+                        minAlignmentPeriod: "86400s",
+                        aggregations: [
+                            {
+                                perSeriesAligner: "ALIGN_MEAN",
+                                crossSeriesReducer: "REDUCE_MAX",
+                                alignmentPeriod: "86400s",
+                                groupByFields: ['resource.label."extension"', 'resource.label."version"'],
+                            },
+                            {
+                                crossSeriesReducer: "REDUCE_NONE",
+                                alignmentPeriod: "60s",
+                                groupByFields: [],
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+        isAutoRefresh: true,
+        timeSelection: {
+            timeRange: "4w",
+        },
+    };
+    let uri = `https://console.cloud.google.com/monitoring/metrics-explorer?project=${args.projectNumber}` +
+        `&pageState=${JSON.stringify(pageState)}`;
+    uri = encodeURI(uri);
+    uri = await (0, shortenUrl_1.shortenUrl)(uri);
+    return uri;
+}

node_modules/firebase-tools/lib/commands/ext-export.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const command_1 = require("../command");
+const planner = require("../deploy/extensions/planner");
+const etags_1 = require("../extensions/etags");
+const export_1 = require("../extensions/export");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const manifest = require("../extensions/manifest");
+const paramHelper_1 = require("../extensions/paramHelper");
+const functional_1 = require("../functional");
+const getProjectNumber_1 = require("../getProjectNumber");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const prompt_1 = require("../prompt");
+const requirePermissions_1 = require("../requirePermissions");
+exports.command = new command_1.Command("ext:export")
+    .description("export all Extension instances installed on a project to a local Firebase directory")
+    .before(requirePermissions_1.requirePermissions, ["firebaseextensions.instances.list"])
+    .before(extensionsHelper_1.ensureExtensionsApiEnabled)
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extMinVersion")
+    .withForce()
+    .action(async (options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const projectNumber = await (0, getProjectNumber_1.getProjectNumber)(options);
+    const have = await Promise.all(await planner.have(projectId));
+    if (have.length === 0) {
+        logger_1.logger.info(`No extension instances installed on ${projectId}, so there is nothing to export.`);
+        return;
+    }
+    const [withRef, withoutRef] = (0, functional_1.partition)(have, (s) => !!s.ref);
+    const withRefSubbed = await Promise.all(withRef.map(async (i) => {
+        const subbed = await (0, export_1.setSecretParamsToLatest)(i);
+        return (0, export_1.parameterizeProject)(projectId, projectNumber, subbed);
+    }));
+    (0, export_1.displayExportInfo)(withRefSubbed, withoutRef);
+    if (!options.nonInteractive &&
+        !options.force &&
+        !(await (0, prompt_1.promptOnce)({
+            message: "Do you wish to add these Extension instances to firebase.json?",
+            type: "confirm",
+            default: true,
+        }))) {
+        logger_1.logger.info("Exiting. No changes made.");
+        return;
+    }
+    const manifestSpecs = withRefSubbed.map((spec) => {
+        const paramCopy = Object.assign({}, spec.params);
+        if (spec.eventarcChannel) {
+            paramCopy.EVENTARC_CHANNEL = spec.eventarcChannel;
+        }
+        if (spec.allowedEventTypes) {
+            paramCopy.ALLOWED_EVENT_TYPES = spec.allowedEventTypes.join(",");
+        }
+        return {
+            instanceId: spec.instanceId,
+            ref: spec.ref,
+            params: (0, paramHelper_1.buildBindingOptionsWithBaseValue)(paramCopy),
+        };
+    });
+    const existingConfig = manifest.loadConfig(options);
+    await manifest.writeToManifest(manifestSpecs, existingConfig, {
+        nonInteractive: options.nonInteractive,
+        force: options.force,
+    }, true);
+    (0, etags_1.saveEtags)(options.rc, projectId, have);
+});

node_modules/firebase-tools/lib/commands/ext-info.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
+const command_1 = require("../command");
+const extensionsApi = require("../extensions/extensionsApi");
+const extensionsHelper_1 = require("../extensions/extensionsHelper");
+const localHelper_1 = require("../extensions/localHelper");
+const logger_1 = require("../logger");
+const requirePermissions_1 = require("../requirePermissions");
+const utils = require("../utils");
+const { marked } = require("marked");
+const TerminalRenderer = require("marked-terminal");
+const FUNCTION_TYPE_REGEX = /\..+\.function/;
+exports.command = new command_1.Command("ext:info <extensionName>")
+    .description("display information about an extension by name (extensionName@x.y.z for a specific version)")
+    .option("--markdown", "output info in Markdown suitable for constructing a README file")
+    .before(checkMinRequiredVersion_1.checkMinRequiredVersion, "extMinVersion")
+    .action(async (extensionName, options) => {
+    var _a, _b;
+    let spec;
+    if ((0, localHelper_1.isLocalExtension)(extensionName)) {
+        if (!options.markdown) {
+            utils.logLabeledBullet(extensionsHelper_1.logPrefix, `reading extension from directory: ${extensionName}`);
+        }
+        spec = await (0, localHelper_1.getLocalExtensionSpec)(extensionName);
+    }
+    else {
+        await (0, requirePermissions_1.requirePermissions)(options, ["firebaseextensions.sources.get"]);
+        await (0, extensionsHelper_1.ensureExtensionsApiEnabled)(options);
+        const hasPublisherId = extensionName.split("/").length >= 2;
+        if (hasPublisherId) {
+            const nameAndVersion = extensionName.split("/")[1];
+            if (nameAndVersion.split("@").length < 2) {
+                extensionName = extensionName + "@latest";
+            }
+        }
+        else {
+            const [name, version] = extensionName.split("@");
+            extensionName = `firebase/${name}@${version || "latest"}`;
+        }
+        const version = await extensionsApi.getExtensionVersion(extensionName);
+        spec = version.spec;
+    }
+    if (!options.markdown) {
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, `information about ${extensionName}:\n`);
+    }
+    const lines = [];
+    if (options.markdown) {
+        lines.push(`# ${spec.displayName}`);
+    }
+    else {
+        lines.push(`**Name**: ${spec.displayName}`);
+    }
+    const authorName = (_a = spec.author) === null || _a === void 0 ? void 0 : _a.authorName;
+    const url = (_b = spec.author) === null || _b === void 0 ? void 0 : _b.url;
+    const urlMarkdown = url ? `(**[${url}](${url})**)` : "";
+    lines.push(`**Author**: ${authorName} ${urlMarkdown}`);
+    if (spec.description) {
+        lines.push(`**Description**: ${spec.description}`);
+    }
+    if (spec.preinstallContent) {
+        lines.push("", `**Details**: ${spec.preinstallContent}`);
+    }
+    if (spec.params && Array.isArray(spec.params) && spec.params.length > 0) {
+        lines.push("", "**Configuration Parameters:**");
+        for (const param of spec.params) {
+            lines.push(`* ${param.label}` + (param.description ? `: ${param.description}` : ""));
+        }
+    }
+    const functions = [];
+    const otherResources = [];
+    for (const resource of spec.resources) {
+        if (FUNCTION_TYPE_REGEX.test(resource.type)) {
+            functions.push(resource);
+        }
+        else {
+            otherResources.push(resource);
+        }
+    }
+    if (functions.length > 0) {
+        lines.push("", "**Cloud Functions:**");
+        for (const func of functions) {
+            lines.push(`* **${func.name}:** ${func.description}`);
+        }
+    }
+    if (otherResources.length > 0) {
+        lines.push("", "**Other Resources**:");
+        for (const resource of otherResources) {
+            lines.push(`* ${resource.name} (${resource.type})`);
+        }
+    }
+    if (spec.apis) {
+        lines.push("", "**APIs Used**:");
+        for (const api of spec.apis) {
+            lines.push(`* ${api.apiName}` + (api.reason ? ` (Reason: ${api.reason})` : ""));
+        }
+    }
+    if (spec.roles) {
+        lines.push("", "**Access Required**:");
+        lines.push("", "This extension will operate with the following project IAM roles:");
+        for (const role of spec.roles) {
+            lines.push(`* ${role.role}` + (role.reason ? ` (Reason: ${role.reason})` : ""));
+        }
+    }
+    if (options.markdown) {
+        logger_1.logger.info(lines.join("\n\n"));
+    }
+    else {
+        marked.setOptions({
+            renderer: new TerminalRenderer(),
+        });
+        logger_1.logger.info(marked(lines.join("\n")));
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, `to install this extension, type ` +
+            clc.bold(`firebase ext:install ${extensionName} --project=YOUR_PROJECT`));
+    }
+});