unzipper-esm/lib/parse.js

Unzip cross-platform streaming API

import zlib from 'zlib'; // 'node:zlib'
import { PassThrough, pipeline } from 'stream'; // 'node:stream'

import PullStream from './PullStream.js';
import NoopStream from './NoopStream.js';
import BufferStream from './BufferStream.js';
import parseExtraField from './parseExtraField.js';
import parseDateTime from './parseDateTime.js';
import parseBuffer from './parseBuffer.js';

const endDirectorySignature = Buffer.alloc(4);
endDirectorySignature.writeUInt32LE(0x06054b50, 0);

export default function Parse(opts) {
  return new Parser(opts);
}

class Parser extends PullStream {
  constructor(opts = { verbose: false }) {
    super(opts);
    this._opts = opts;
    const self = this;
    self.on('finish', function() {
      self.emit('end');
      self.emit('close');
    });
    self._readRecord().catch(function(e) {
      if (!self.__emittedError || self.__emittedError !== e)
        self.emit('error', e);
    });
  }

  _readRecord() {
    const self = this;

    return self.pull(4).then(function(data) {
      if (data.length === 0)
        return;

      const signature = data.readUInt32LE(0);

      if (signature === 0x34327243) {
        return self._readCrxHeader();
      }
      if (signature === 0x04034b50) {
        return self._readFile();
      }
      else if (signature === 0x02014b50) {
        self.reachedCD = true;
        return self._readCentralDirectoryFileHeader();
      }
      else if (signature === 0x06054b50) {
        return self._readEndOfCentralDirectoryRecord();
      }
      else if (self.reachedCD) {
        // _readEndOfCentralDirectoryRecord expects the EOCD
        // signature to be consumed so set includeEof=true
        const includeEof = true;
        return self.pull(endDirectorySignature, includeEof).then(function() {
          return self._readEndOfCentralDirectoryRecord();
        });
      }
      else
        self.emit('error', new Error('invalid signature: 0x' + signature.toString(16)));
    }).then((function(loop) {
      if(loop) {
        return self._readRecord();
      }
    }));
  };

  _readCrxHeader() {
    const self = this;
    return self.pull(12).then(function(data) {
      self.crxHeader = parseBuffer(data, [
        ['version', 4],
        ['pubKeyLength', 4],
        ['signatureLength', 4],
      ]);
      return self.pull(self.crxHeader.pubKeyLength + self.crxHeader.signatureLength);
    }).then(function(data) {
      self.crxHeader.publicKey = data.slice(0, self.crxHeader.pubKeyLength);
      self.crxHeader.signature = data.slice(self.crxHeader.pubKeyLength);
      self.emit('crx-header', self.crxHeader);
      return true;
    });
  };

  _readFile() {
    const self = this;
    return self.pull(26).then(function(data) {
      const vars = parseBuffer(data, [
        ['versionsNeededToExtract', 2],
        ['flags', 2],
        ['compressionMethod', 2],
        ['lastModifiedTime', 2],
        ['lastModifiedDate', 2],
        ['crc32', 4],
        ['compressedSize', 4],
        ['uncompressedSize', 4],
        ['fileNameLength', 2],
        ['extraFieldLength', 2],
      ]);

      vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate, vars.lastModifiedTime);

      if (self.crxHeader) vars.crxHeader = self.crxHeader;

      return self.pull(vars.fileNameLength).then(function(fileNameBuffer) {
        const fileName = fileNameBuffer.toString('utf8');
        const entry = new PassThrough();
        let __autodraining = false;

        entry.autodrain = function() {
          __autodraining = true;
          const draining = entry.pipe(new NoopStream());
          draining.promise = function() {
            return new Promise(function(resolve, reject) {
              draining.on('finish', resolve);
              draining.on('error', reject);
            });
          };
          return draining;
        };

        entry.buffer = function() {
          return BufferStream(entry);
        };

        entry.path = fileName;
        entry.props = {};
        entry.props.path = fileName;
        entry.props.pathBuffer = fileNameBuffer;
        entry.props.flags = {
          "isUnicode": (vars.flags & 0x800) != 0
        };
        entry.type = (vars.uncompressedSize === 0 && /[/\\]$/.test(fileName)) ? 'Directory' : 'File';

        if (self._opts.verbose) {
          if (entry.type === 'Directory') {
            console.log('   creating:', fileName);
          } else if (entry.type === 'File') {
            if (vars.compressionMethod === 0) {
              console.log(' extracting:', fileName);
            } else {
              console.log('  inflating:', fileName);
            }
          }
        }

        return self.pull(vars.extraFieldLength).then(function(extraField) {
          const extra = parseExtraField(extraField, vars);

          entry.vars = vars;
          entry.extra = extra;

          if (self._opts.forceStream) {
            self.push(entry);
          } else {
            self.emit('entry', entry);

            if (self._readableState.pipesCount || (self._readableState.pipes && self._readableState.pipes.length))
              self.push(entry);
          }

          if (self._opts.verbose)
            console.log({
              filename:fileName,
              vars: vars,
              extra: extra
            });

          const fileSizeKnown = !(vars.flags & 0x08) || vars.compressedSize > 0;
          let eof;

          entry.__autodraining = __autodraining; // expose __autodraining for test purposes
          const inflater = (vars.compressionMethod && !__autodraining) ? zlib.createInflateRaw() : PassThrough();

          if (fileSizeKnown) {
            entry.size = vars.uncompressedSize;
            eof = vars.compressedSize;
          } else {
            eof = Buffer.alloc(4);
            eof.writeUInt32LE(0x08074b50, 0);
          }

          return new Promise(function(resolve, reject) {
            pipeline(
              self.stream(eof),
              inflater,
              entry,
              function (err) {
                if (err) {
                  return reject(err);
                }

                return fileSizeKnown ? resolve(fileSizeKnown) : self._processDataDescriptor(entry).then(resolve).catch(reject);
              }
            );
          });
        });
      });
    });
  };

  _processDataDescriptor(entry) {
    const self = this;
    return self.pull(16).then(function(data) {
      const vars = parseBuffer(data, [
        ['dataDescriptorSignature', 4],
        ['crc32', 4],
        ['compressedSize', 4],
        ['uncompressedSize', 4],
      ]);

      entry.size = vars.uncompressedSize;
      return true;
    });
  };

  _readCentralDirectoryFileHeader() {
    const self = this;
    return self.pull(42).then(function(data) {
      const vars = parseBuffer(data, [
        ['versionMadeBy', 2],
        ['versionsNeededToExtract', 2],
        ['flags', 2],
        ['compressionMethod', 2],
        ['lastModifiedTime', 2],
        ['lastModifiedDate', 2],
        ['crc32', 4],
        ['compressedSize', 4],
        ['uncompressedSize', 4],
        ['fileNameLength', 2],
        ['extraFieldLength', 2],
        ['fileCommentLength', 2],
        ['diskNumber', 2],
        ['internalFileAttributes', 2],
        ['externalFileAttributes', 4],
        ['offsetToLocalFileHeader', 4],
      ]);

      return self.pull(vars.fileNameLength).then(function(fileName) {
        vars.fileName = fileName.toString('utf8');
        return self.pull(vars.extraFieldLength);
      })
        .then(function() {
          return self.pull(vars.fileCommentLength);
        })
        .then(function() {
          return true;
        });
    });
  };

  _readEndOfCentralDirectoryRecord() {
    const self = this;
    return self.pull(18).then(function(data) {

      const vars = parseBuffer(data, [
        ['diskNumber', 2],
        ['diskStart', 2],
        ['numberOfRecordsOnDisk', 2],
        ['numberOfRecords', 2],
        ['sizeOfCentralDirectory', 4],
        ['offsetToStartOfCentralDirectory', 4],
        ['commentLength', 2],
      ]);

      return self.pull(vars.commentLength).then(function() {
        self.end();
        self.push(null);
      });

    });
  };

  promise() {
    const self = this;
    return new Promise(function(resolve, reject) {
      self.on('finish', resolve);
      self.on('error', reject);
    });
  };
}