How to use the unzipper.Parse function in unzipper

function unzipFile(response, locales, path ) {
    return response && response.pipe(unZipper.Parse())
        .on('entry', function (entry) {
            const fileName = entry.path;
            const type = entry.type; // 'Directory' or 'File'

            const existLocales = locales.filter(lang => fileName.includes(`${lang}/`));

            if (!existLocales.length) {
                console.warn('[skip lang]', fileName);
                return entry;
            }

            if (type === 'Directory') {
                const name = `${path}/${fileName}`;

                if (!fs.existsSync(name)) {
                    fs.mkdirSync(name);

initialPromise.then(() => {
                fs.createReadStream(filepath)
                    .pipe(unzip.Parse())
                    .pipe(etl.map(entry => {
                        // 适配iconPath为ic_launcher.xml的情况
                        const entryPath = entry.path
                        const isXml = entryPath.indexOf('.xml') >= 0
                        if ( (!isXml && entryPath.indexOf(iconPath) != -1) || (isXml && entry.path.indexOf(maxSizePath) != -1)) {
                            console.log(entry.path)
                            entry.pipe(etl.toFile(tempOut))
                            resolve({ 'success': true, fileName: realPath })
                        } else {
                            resolve({ 'success': true, fileName: realPath })
                            entry.autodrain()
                        }
                    }))
            })
        })

return new Promise((resolve, reject) => {
    const filePromises = [];

    stream
      .pipe(unzip.Parse())
      .on('error', reject)
      .on('close', () => {
        Promise.all(filePromises).then(() => resolve(files));
      })
      // For some reason `end` event is not emitted.
      // .on('end', () => {
      //   Promise.all(filePromises).then(() => resolve(files));
      // })
      .on('entry', (entry) => {
        const file = files[entry.path];
        if (file) {
          let contents = '';
          filePromises.push(new Promise((resolve) => {
            entry
              .on('data', data => contents += data.toString())
              .on('end', () => {

resolve()
    }
    if (src.endsWith('.tar.gz')) {
      targz.decompress(
        {
          src,
          dest: destFolder,
          tar: {
            strip: 1,
          },
        },
        err => (err ? reject(err) : finish()),
      )
    } else if (src.endsWith('.zip')) {
      fs.createReadStream(src)
        .pipe(unzipper.Parse())
        .on('entry', function(entry) {
          if (entry.type === 'Directory') {
            return
          }
          // Do strip and resolve
          const strip = entry.path.replace(/.*?\//, '')
          entry.pipe(Writer(path.resolve(destFolder, strip)))
        })
        .on('error', reject)
        .on('close', finish)
    }
  })
}

self.on('pipe', function (srcPipe) {
    srcPipe.pipe(unzipper.Parse())
      .on('error', function (err) {
        self.emit('error', err)
      })
      .on('entry', function (entry) {
        if (self.abortBook) {
          entry.autodrain()
          return
        }
        switch (entry.path) {
          case 'xl/workbook.xml':
            self._parseXML(entry, self._parseWorkBookInfo, function () {
              self.parsedWorkBookInfo = true
              self.emit('workBookInfo')
            })
            break
          case 'xl/_rels/workbook.xml.rels':

var lookup = null;
		if (caller.options.sheet_name) {
			sheet = workbook.getByName(caller.options.sheet_name);
		} else if (caller.options.sheet_id) {
			sheet = workbook.getById(caller.options.sheet_id);
		} else if (caller.options.sheet_nr) {
			sheet = workbook.getByNr(caller.options.sheet_nr);
		}
		if ((sheet) && (sheet.filename)) {
			lookup = 'xl/' + sheet.filename;
			cb({sheet: sheet});
		} else {
			lookup = 'xl/worksheets/sheet' + caller.options.sheet_nr + '.xml';
		}
		fs.createReadStream(caller.filename)
			.pipe(unzip.Parse())
			.on('error', function (error) {
				cb({ err: error });
				finish();
			})
			.on('entry', function (entry) {
				if (entry.path === lookup) {
					running++;
					var count = 1;
					caller.parseXMLSheet(entry, formatstyles, strings, function (err, row, cell) {
						if (err) {
							cb({err: err});
						} else if (cell) {
							if (count > caller.options.ignore_header) {
								cb({cell: cell});
							}
						} else if (row) {

let end: () => Promise
  const p = new Promise(res => {
    end = res as () => Promise
  })
  const url = await resolveDriverUrl({ browser, platform, arch, version })
  const downloadDestination = path.join(
    downloadDirectory,
    artifactName || resolveDriverName({ browser, platform, version })
  )
  const res = await fetch(url)
  if (!res.ok) {
    throw new Error('Failed to download driver')
  }

  if (url.endsWith('.zip')) {
    res.body.pipe(unzipper.Parse()).pipe(
      new stream.Transform({
        objectMode: true,
        transform: function(entry, _e, cb) {
          const fileName = entry.path
          if (
            fileName === 'chromedriver' ||
            fileName === 'chromedriver.exe' ||
            fileName === 'geckodriver' ||
            fileName === 'geckodriver.exe'
          ) {
            entry
              .pipe(fs.createWriteStream(downloadDestination))
              .on('finish', end)
          } else {
            entry.autodrain()
            cb()

function process(request: express.Request, response: express.Response, filePath: string) {
  fs.createReadStream(filePath)
    .pipe(unzipper.Parse())
    .on('close', () => {
      if (response.headersSent) return;
      response.sendStatus(404);
    })
    .on('entry', (entry: unzipper.Entry) => {
      if (entry.path !== request.params.pageName) return entry.autodrain();
      response.set('Content-Type', mime.getType(entry.path) || 'application/octet-stream');
      return entry.pipe(response);
    });
}

return new Promise((resolve, reject) => {
    fs.createReadStream(archive)
    .on('error', reject)
    .pipe(unzipper.Parse())
    .on('error', reject)
    .on('entry', function (entry) {
      _.pull(filesCopy, entry.path)
      entry.autodrain()
    })
    .on('finish', () => {
      resolve(filesCopy.length === 0)
    })
  })
}