How to use the follow-redirects.https.get function in follow-redirects

// because initiall imageHD shows output in array ['150', '150'] and null
				console.log(colors.cyan.bold('\n ❱ Image Resolution      :    ✔\n'));

				// if case is null
			} else if (notHDArray[0] === imageHD[0]) {
				console.log(colors.red.bold('\n ❱ Image Resolution      :    ✖\n'));
			}

			// using previously made function
			const remChars = parsedImages(imageLink);

			// saving image
			const imageFile = fs.createWriteStream(removeSlash + argv.n + '.jpg');

			// downloading image
			https.get(remChars, res => {
				res.pipe(imageFile);

				console.log(colors.cyan.bold(' ❱ Image Saved In        : '), ' ', colors.green.bold(savedIn), colors.cyan.bold('❱'), colors.green.bold(argv.n + '.jpg\n'));
			}).on('error', err => {
				console.log(err);

				console.log('❱ Failed to Save the image');

				process.exit(1);
			});
		}
	});
});

checkUpdate() {
        // get all tags from repository
        let url = '/repos/cosmo0/arcade-manager/tags';
        https.get({ protocol, 'host': api, 'path': url, 'headers': { 'User-Agent': 'arcade-manager' } }, (res) => {
            res.setEncoding('utf8');
            let rawData = '';
            res.on('data', (chunk) => { rawData += chunk; });
            res.on('end', () => {
                // parse version number
                let data = JSON.parse(rawData);
                let latest = data[0].name.replace('v', '');
                console.log('latest version: %s', latest);

                // version has been ignored
                if (settings.has('ignoreVersion') && settings.get('ignoreVersion') === latest) {
                    console.log('Version has been ignored: %s', latest);
                    return;
                }

                // if a newer version is available, ask user to download it

res.on('end', () => {
                let siblingFolders = JSON.parse(rawDataFolders);
                for (let f of siblingFolders) {
                    if (f.path === folder) {
                        // get full list of files from this folder
                        let urlFullFilesList = '/repos/' + repository + '/git/trees/' + f.sha;
                        console.log('Listing files for tree %s', f.sha);
                        https.get({ protocol, 'host': api, 'path': urlFullFilesList, 'headers': { 'User-Agent': 'arcade-manager' } }, (res) => {
                            res.setEncoding('utf8');
                            let rawDataFiles = '';
                            res.on('data', (chunk) => { rawDataFiles += chunk; });
                            res.on('end', () => {
                                callback(JSON.parse(rawDataFiles).tree);
                            });
                        });
                        break;
                    }
                }
            });
        });

if (!fs.existsSync(versionFolder)) {
            fs.mkdirSync(versionFolder);
        }
        if (!fs.existsSync(versionFolder + '/linux32')) {
            fs.mkdirSync(`${versionFolder}/linux32`);
        }
        var downloadedArchivePath = `${versionFolder}/nwjs${flavorPostfix}-v${nwArmVersion}-linux-arm.tar.gz`;
        var downloadUrl = `https://github.com/LeonardLaszlo/nw.js-armv7-binaries/releases/download/v${nwArmVersion}/nwjs${flavorDownloadPostfix}-v${nwArmVersion}-linux-arm.tar.gz`;
        if (fs.existsSync(downloadedArchivePath)) {
            console.log('Prebuilt ARMv7 binaries found in /tmp');
            downloadDone(flavorDownloadPostfix, downloadedArchivePath, versionFolder);
        } else {
            console.log(`Downloading prebuilt ARMv7 binaries from "${downloadUrl}"...`);
            process.stdout.write('> Starting download...\r');
            var armBuildBinary = fs.createWriteStream(downloadedArchivePath);
            var request = https.get(downloadUrl, function(res) {
                var totalBytes = res.headers['content-length'];
                var downloadedBytes = 0;
                res.pipe(armBuildBinary);
                res.on('data', function (chunk) {
                    downloadedBytes += chunk.length;
                    process.stdout.write(`> ${parseInt((downloadedBytes * 100) / totalBytes)}% done             \r`);
                });
                armBuildBinary.on('finish', function() {
                    process.stdout.write('> 100% done             \n');
                    armBuildBinary.close(function() {
                        downloadDone(flavorDownloadPostfix, downloadedArchivePath, versionFolder);
                    });
                });
            });
        }
    });

return new Promise((resolve, reject) => {
      this.emit('notify', `Downloading PGP keys from ${url}`);

      let buf = '';
      https.get(url, (response) => {
        response.on('error', (respError) => {
          reject(respError);
        });
        response.on('data', (chunk) => {
          buf += chunk.toString();
        });
        response.on('end', () => {
          resolve(buf);
        });
      }).on('error', (err) => {
        reject(err);
      });
    });
  }

return new Promise((accept, reject) => {
    const url = getUrl(package, confType);
    const options = {
      headers: { "User-Agent": "vim-package-info (github.com/meain/vim-package-info)" },
    };
    if (url)
      https
        .get(url, options, resp => {
          let data = "";
          resp.on("data", chunk => {
            data += chunk;
          });
          resp.on("end", () => {
            accept(data);
          });
        })
        .on("error", err => {
          console.log("Error: " + err.message);
          global.vimnpmcache[confType][package] = false;
          reject(false);
        });
    else reject(false);
  });

export function getCoreDownloadURL(callback: (err: Error, downloadURL?: string) => any) {
  const registryUrl = "https://raw.githubusercontent.com/superpowers/superpowers-registry/master/registry.json";
  const request = https.get(registryUrl, (res) => {
    if (res.statusCode !== 200) {
      callback(new Error(`Unexpected status code: ${res.statusCode}`));
      return;
    }

    let content = "";
    res.on("data", (chunk: string) => { content += chunk; });
    res.on("end", () => {
      let registry: any;
      try { registry = JSON.parse(content); }
      catch (err) {
        callback(new Error(`Could not parse registry as JSON`));
        return;
      }

      callback(null, registry.core.downloadURL);

const downloadMedia = (arg, ext, message) => {
	const saveImages = fs.createWriteStream(`${dir}${fileName}.${ext}`);
	https.get(arg, (res, cb) => {
		res.pipe(saveImages);
		saveImages.on('finish', () => {
			logUpdate(`\n${pre} ${message} Saved! ${chalk.dim(`[${fileName}.${ext}]`)} \n`);
			saveImages.close(cb);
			spinner.stop();
			saveImages.on('error', () => {
				end(1);
			});
		});
	});
};

downloadFile (repository, file, callback) {
        let url = raw + '/' + repository + '/master/' + file;
        https.get(url, (res) => {
            if (res.statusCode !== 200) {
                res.resume();
                throw 'Unable to download file ' + res.req.path;
            }

            let isbinary = res.headers["content-type"].indexOf('text/plain') < 0;

            if (!isbinary) {
                res.setEncoding('utf8');
            }

            let rawData = [];
            res.on('data', (chunk) => {
                rawData.push(chunk);
            }).on('end', () => {
                if (isbinary) {