read-excel-file 9.1.0 → 9.2.0

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+9.2.0 / 11.06.2026
+==================
+
+* Reverted the shift from `unzipper` to `fflate` in Node.js code.
+  * The reason is that `unzipper` turns out to be 2x faster than `fflate` because `fflate` reimplements decompression in pure javascript while `unzipper` uses Node.js's "native" module `zlib` which is written in C.
+
+* Replaced `unzipper` with `unzipper-esm`.
+  * This fixes the long-present [bug](https://github.com/ZJONSSON/node-unzipper/issues/330) when bundlers can't bundle an app that uses `unzipper` package because of that dynamic `require()` statement.
+
 9.1.0 / 07.06.2026
 ==================
 

package/commonjs/export/convertInputToNodeStream.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = convertInputToNodeStream;
-var _fs = _interopRequireDefault(require("fs"));
-var _buffer = require("buffer");
-var _stream = _interopRequireWildcard(require("stream"));
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodeBuffer = require("node:buffer");
+var _nodeStream = _interopRequireWildcard(require("node:stream"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
@@ -17,7 +17,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
  * @returns {Stream}
  */
 function convertInputToNodeStream(input) {
-  return input instanceof _stream["default"] ? input : input instanceof Buffer ? createReadableStreamFromBuffer(input) : input instanceof _buffer.Blob ? createReadableStreamFromBlob(input) : _fs["default"].createReadStream(input);
+  return input instanceof _nodeStream["default"] ? input : input instanceof Buffer ? createReadableStreamFromBuffer(input) : input instanceof _nodeBuffer.Blob ? createReadableStreamFromBlob(input) : _nodeFs["default"].createReadStream(input);
 }
 
 // Creates a readable stream from a `Buffer`.
@@ -28,7 +28,7 @@ function createReadableStreamFromBuffer(buffer) {
   if (buffer.length === 0) {
     throw new Error('No data');
   }
-  return _stream.Readable.from(buffer);
+  return _nodeStream.Readable.from(buffer);
 }
 
 // Creates a readable stream from a `Blob`.
@@ -40,6 +40,6 @@ function createReadableStreamFromBlob(blob) {
     throw new Error('No data');
   }
   // Convert a web `ReadableStream` to a Node.js `Readable` `Stream`.
-  return _stream.Readable.fromWeb(blob.stream());
+  return _nodeStream.Readable.fromWeb(blob.stream());
 }
 //# sourceMappingURL=convertInputToNodeStream.js.map

package/commonjs/export/convertInputToNodeStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"convertInputToNodeStream.js","names":["_fs","_interopRequireDefault","require","_buffer","_stream","_interopRequireWildcard","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","convertInputToNodeStream","input","Stream","Buffer","createReadableStreamFromBuffer","Blob","createReadableStreamFromBlob","fs","createReadStream","buffer","length","Error","Readable","from","blob","size","fromWeb","stream"],"sources":["../../source/export/convertInputToNodeStream.js"],"sourcesContent":["import fs from 'fs'\r\nimport { Blob } from 'buffer'\r\nimport Stream, { Readable } from 'stream'\r\n\r\n/**\r\n * Converts Node.js input argument to a stream.\r\n * @param  {(string|Stream|Buffer|Blob)} input - A Node.js readable stream or a `Buffer` or a `Blob` or a path to a file.\r\n * @returns {Stream}\r\n */\r\nexport default function convertInputToNodeStream(input) {\r\n  return input instanceof Stream\r\n    ? input\r\n    : (\r\n      input instanceof Buffer\r\n        ? createReadableStreamFromBuffer(input)\r\n        : (\r\n          input instanceof Blob\r\n            ? createReadableStreamFromBlob(input)\r\n            : fs.createReadStream(input)\r\n        )\r\n    )\r\n}\r\n\r\n// Creates a readable stream from a `Buffer`.\r\nfunction createReadableStreamFromBuffer(buffer) {\r\n  // Node.js seems to have a bug in `Readable.from()` function:\r\n  // it doesn't correctly handle empty buffers, i.e. it doesn't return a correct stream.\r\n  // https://gitlab.com/catamphetamine/read-excel-file/-/issues/106\r\n  if (buffer.length === 0) {\r\n    throw new Error('No data')\r\n  }\r\n  return Readable.from(buffer)\r\n}\r\n\r\n// Creates a readable stream from a `Blob`.\r\nfunction createReadableStreamFromBlob(blob) {\r\n  // I didn't test but I'd presume that Node.js would throw on an empty `Blob`\r\n  // same way it does on an empty `Buffer`.\r\n  // https://gitlab.com/catamphetamine/read-excel-file/-/issues/106\r\n  if (blob.size === 0) {\r\n    throw new Error('No data')\r\n  }\r\n  // Convert a web `ReadableStream` to a Node.js `Readable` `Stream`.\r\n  return Readable.fromWeb(blob.stream())\r\n}"],"mappings":";;;;;;;AAAA,IAAAA,GAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAC,uBAAA,CAAAH,OAAA;AAAyC,SAAAI,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAF,wBAAAM,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,aAAAE,OAAA,CAAAF,GAAA,yBAAAA,GAAA,uCAAAA,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,cAAAN,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAAA,SAAAhB,uBAAAU,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA;AAEzC;AACA;AACA;AACA;AACA;AACe,SAASiB,wBAAwBA,CAACC,KAAK,EAAE;EACtD,OAAOA,KAAK,YAAYC,kBAAM,GAC1BD,KAAK,GAELA,KAAK,YAAYE,MAAM,GACnBC,8BAA8B,CAACH,KAAK,CAAC,GAErCA,KAAK,YAAYI,YAAI,GACjBC,4BAA4B,CAACL,KAAK,CAAC,GACnCM,cAAE,CAACC,gBAAgB,CAACP,KAAK,CAElC;AACL;;AAEA;AACA,SAASG,8BAA8BA,CAACK,MAAM,EAAE;EAC9C;EACA;EACA;EACA,IAAIA,MAAM,CAACC,MAAM,KAAK,CAAC,EAAE;IACvB,MAAM,IAAIC,KAAK,CAAC,SAAS,CAAC;EAC5B;EACA,OAAOC,gBAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC;AAC9B;;AAEA;AACA,SAASH,4BAA4BA,CAACQ,IAAI,EAAE;EAC1C;EACA;EACA;EACA,IAAIA,IAAI,CAACC,IAAI,KAAK,CAAC,EAAE;IACnB,MAAM,IAAIJ,KAAK,CAAC,SAAS,CAAC;EAC5B;EACA;EACA,OAAOC,gBAAQ,CAACI,OAAO,CAACF,IAAI,CAACG,MAAM,CAAC,CAAC,CAAC;AACxC"}
+{"version":3,"file":"convertInputToNodeStream.js","names":["_nodeFs","_interopRequireDefault","require","_nodeBuffer","_nodeStream","_interopRequireWildcard","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","convertInputToNodeStream","input","Stream","Buffer","createReadableStreamFromBuffer","Blob","createReadableStreamFromBlob","fs","createReadStream","buffer","length","Error","Readable","from","blob","size","fromWeb","stream"],"sources":["../../source/export/convertInputToNodeStream.js"],"sourcesContent":["import fs from 'node:fs'\r\nimport { Blob } from 'node:buffer'\r\nimport Stream, { Readable } from 'node:stream'\r\n\r\n/**\r\n * Converts Node.js input argument to a stream.\r\n * @param  {(string|Stream|Buffer|Blob)} input - A Node.js readable stream or a `Buffer` or a `Blob` or a path to a file.\r\n * @returns {Stream}\r\n */\r\nexport default function convertInputToNodeStream(input) {\r\n  return input instanceof Stream\r\n    ? input\r\n    : (\r\n      input instanceof Buffer\r\n        ? createReadableStreamFromBuffer(input)\r\n        : (\r\n          input instanceof Blob\r\n            ? createReadableStreamFromBlob(input)\r\n            : fs.createReadStream(input)\r\n        )\r\n    )\r\n}\r\n\r\n// Creates a readable stream from a `Buffer`.\r\nfunction createReadableStreamFromBuffer(buffer) {\r\n  // Node.js seems to have a bug in `Readable.from()` function:\r\n  // it doesn't correctly handle empty buffers, i.e. it doesn't return a correct stream.\r\n  // https://gitlab.com/catamphetamine/read-excel-file/-/issues/106\r\n  if (buffer.length === 0) {\r\n    throw new Error('No data')\r\n  }\r\n  return Readable.from(buffer)\r\n}\r\n\r\n// Creates a readable stream from a `Blob`.\r\nfunction createReadableStreamFromBlob(blob) {\r\n  // I didn't test but I'd presume that Node.js would throw on an empty `Blob`\r\n  // same way it does on an empty `Buffer`.\r\n  // https://gitlab.com/catamphetamine/read-excel-file/-/issues/106\r\n  if (blob.size === 0) {\r\n    throw new Error('No data')\r\n  }\r\n  // Convert a web `ReadableStream` to a Node.js `Readable` `Stream`.\r\n  return Readable.fromWeb(blob.stream())\r\n}"],"mappings":";;;;;;;AAAA,IAAAA,OAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAC,uBAAA,CAAAH,OAAA;AAA8C,SAAAI,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAF,wBAAAM,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,aAAAE,OAAA,CAAAF,GAAA,yBAAAA,GAAA,uCAAAA,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,cAAAN,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAAA,SAAAhB,uBAAAU,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA;AAE9C;AACA;AACA;AACA;AACA;AACe,SAASiB,wBAAwBA,CAACC,KAAK,EAAE;EACtD,OAAOA,KAAK,YAAYC,sBAAM,GAC1BD,KAAK,GAELA,KAAK,YAAYE,MAAM,GACnBC,8BAA8B,CAACH,KAAK,CAAC,GAErCA,KAAK,YAAYI,gBAAI,GACjBC,4BAA4B,CAACL,KAAK,CAAC,GACnCM,kBAAE,CAACC,gBAAgB,CAACP,KAAK,CAElC;AACL;;AAEA;AACA,SAASG,8BAA8BA,CAACK,MAAM,EAAE;EAC9C;EACA;EACA;EACA,IAAIA,MAAM,CAACC,MAAM,KAAK,CAAC,EAAE;IACvB,MAAM,IAAIC,KAAK,CAAC,SAAS,CAAC;EAC5B;EACA,OAAOC,oBAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC;AAC9B;;AAEA;AACA,SAASH,4BAA4BA,CAACQ,IAAI,EAAE;EAC1C;EACA;EACA;EACA,IAAIA,IAAI,CAACC,IAAI,KAAK,CAAC,EAAE;IACnB,MAAM,IAAIJ,KAAK,CAAC,SAAS,CAAC;EAC5B;EACA;EACA,OAAOC,oBAAQ,CAACI,OAAO,CAACF,IAAI,CAACG,MAAM,CAAC,CAAC,CAAC;AACxC"}

package/commonjs/zip/unzipFromStream.fflate.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = unzipFromStream;
+var _fflate = require("fflate");
+var _nodeBuffer = require("node:buffer");
+// `fflate` uses a javascript-only implementation of `.zip` compression/decompression.
+// This means that it could likely be less performant than Node.js's "native" `zlib` module`.
+
+// This code was originally submitted by Stian Jensen.
+// https://github.com/catamphetamine/read-excel-file/pull/122
+
+// A `*.zip` file consists of individual file entries with the "total" summary section
+// placed at the end of the file rather than at the start of it, which was originally done
+// to allow for easy append of data to a given `.zip` file.
+// https://en.wikipedia.org/wiki/ZIP_(file_format)
+//
+// But this also means that reading a `*.zip` file from a stream can't really be done
+// using the "officially recommended" way of first reading the "total" summary section
+// and only then reading the individual file entries specified in that summary section.
+//
+// So in order to be able to read a `*.zip` file from a stream, some corners have to be cut.
+// For example, the "total" summary section is completely ignored and instead the reader
+// should adopt "data recovery" software approach — it should proactively "scan" the input stream
+// for individual file entries and handle them one-by-one as they come.
+//
+// Such approach doesn't seem to contradict with the XLSX specification
+// because an `*.xlsx` files is supposed to be a normal `.zip` archive
+// without any "trickery" such as "deleted" files or "garbage" data
+// hiding under the hood.
+//
+// So when handling `*.xlsx` file, we assume that each such file must start
+// with an individual file entry followed by another individual file entry, etc.
+//
+// When the "summary" section is reached, we assume that the archive has ended.
+//
+// To read a `.zip` archive, the code uses `fflate`'s `Unzip` class
+// with `UnzipInflate` decompression implementation to decompress the data
+// that was previously compressed using `DEFLATE` compressing algorithm,
+// which is what `*.xlsx` files use.
+//
+// The `Unzip` class doesn't speak the Node.js stream interface, and `fflate`'s readme
+// doesn't include a clear "reading a `.zip` file from a Node.js stream" section.
+// https://github.com/101arrowz/fflate/issues/251
+// Instead, the `Unzip` class has its own `push(chunk)` / `onfile` / `entry.ondata` protocol.
+// This code reads the binary input stream and forwards each chunk of it to `unzip.push()`,
+// and then collects the decompressed file entries.
+//
+// P.S. In the comments to `UnzipInflate` in `fflate` package, it says:
+// "Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for better performance."
+// But there seems to be no `AsyncZipInflate` class in the `fflate` package.
+// https://github.com/101arrowz/fflate/issues/277
+// So just the regular `UnzipInflate` is used here.
+//
+
+/**
+ * Reads `*.zip` file contents.
+ * @param  {Stream} stream
+ * @return {Promise<Record<string,Buffer>>} Resolves to an object holding `*.zip` file entries. P.S. `Buffer` is a `Uint8Array`.
+ */
+function unzipFromStream(stream) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    filter = _ref.filter;
+  // The `files` object stores the files and their contents.
+  var files = {};
+  return new Promise(function (resolve, reject) {
+    var errored = false;
+    var onError = function onError(error) {
+      if (!errored) {
+        errored = true;
+        reject(error);
+      }
+    };
+    var _createZipFileValidat = createZipFileValidator(function (isValid) {
+        if (!isValid) {
+          onError(new Error('Invalid `.zip` archive'));
+        }
+      }),
+      validateChunk = _createZipFileValidat.validateChunk;
+
+    // `Unzip` discovers each individual file entry in the input data stream
+    // and then calls the callback function for each such entry.
+    var unzip = new _fflate.Unzip(function (entry) {
+      // If there already was an error while reading this `.zip` file,
+      // ignore any follow-up entries.
+      if (errored) {
+        return;
+      }
+
+      // Skip directory entries (their names end with a slash).
+      // Only files are of any interest.
+      if (entry.name.endsWith('/')) {
+        return;
+      }
+
+      // See if this file should be ignored.
+      // If it should, this entry won't be processed, i.e. `Unzip` will not try
+      // to decompress its data, and will just discard it.
+      if (filter && !filter({
+        path: entry.name
+      })) {
+        return;
+      }
+      var chunks = [];
+
+      // `entry.ondata` is called with each decompressed chunk of the entry,
+      // and a final time with `isLast === true` once the entry is complete.
+      entry.ondata = function (error, chunk, isLast) {
+        if (error) {
+          return onError(error);
+        }
+        chunks.push(chunk);
+        if (isLast) {
+          files[entry.name] = _nodeBuffer.Buffer.concat(chunks);
+        }
+      };
+
+      // Start decompressing this entry.
+      entry.start();
+    });
+
+    // Register the decompressor for the data that was compressed using
+    // `DEFLATE` compression algorithm (compression method `8`),
+    // which is what `.xlsx` files use.
+    unzip.register(_fflate.UnzipInflate);
+    stream
+    // Catch errors emitted from the input stream (for example, a file read error).
+    .on('error', onError)
+    // When another chunk of data is read from the input stream.
+    .on('data', function (chunk) {
+      // If there already was an error while reading this `.zip` file,
+      // ignore any follow-up data chunks.
+      if (errored) {
+        return;
+      }
+      // Validate the `.zip` archive as its data comes through.
+      validateChunk(chunk);
+      // If the `.zip` archive is found to be invalid, stop any further
+      // processing of it.
+      if (errored) {
+        return;
+      }
+      // Push the next data chunk to `fflate`'s `Unzip` class instance.
+      // The `.push()` function is synchronous, meaning that by the time it returns,
+      // any complete files entries encountered so far have already been decompressed
+      // and populated in the `files` object.
+      try {
+        unzip.push(chunk, false);
+      } catch (error) {
+        onError(error);
+      }
+    })
+    // When there's no more data in the input stream to consume,
+    // finish reading the `.zip` archive.
+    .on('end', function () {
+      // If there were any errors when reading the `.zip` archive,
+      // don't `resolve()` with anything.
+      if (errored) {
+        return;
+      }
+      try {
+        // Signal the end of the archive to `fflate`'s `Unzip` class instance.
+        // It will flush any remaining state in it.
+        unzip.push(new Uint8Array(0), true);
+        // Resolve with the unzipped files.
+        resolve(files);
+      } catch (error) {
+        onError(error);
+      }
+    });
+  });
+}
+
+// Every section in a `.zip` archive is marked with 4 bytes, the first two of which
+// are `0x50` and `0x4B`, which reads "PK", referencing the initials of the inventor Phil Katz.
+//
+// It looks like `fflate`'s `Unzip` doesn't ever complain about whatever data is thrown at it.
+// Due to how `.zip` file format is defined, "garbage" data could be placed at various
+// places in it and it'd still be a valid `.zip` archive. It's likely that for this reason
+// `fflate` doesn't ever complain and simply emits no entries when fed any kind of invalid data.
+//
+// In order to introduce some basic validation, here we specifically demand
+// that a `.zip` archive must at least start with an individual file entry
+// because an `.xlsx` file creator softwared really shouldn't attempt doing
+// anything "funny" when writing a file, hence this adherence requirement.
+//
+function createZipFileValidator(onValidationResult) {
+  var firstBytesCount = 2;
+  var firstBytes = [];
+  var firstBytesCheckResult;
+  return {
+    validateChunk: function validateChunk(chunk) {
+      if (firstBytes.length < 2) {
+        var i = 0;
+        while (i < chunk.length && i < firstBytesCount) {
+          firstBytes.push(chunk[i]);
+          i++;
+        }
+        if (firstBytes.length === 2) {
+          var isValid = firstBytes[0] === 0x50 && firstBytes[1] === 0x4B;
+          onValidationResult(isValid);
+        }
+      }
+    }
+  };
+}
+//# sourceMappingURL=unzipFromStream.fflate.js.map

package/commonjs/zip/unzipFromStream.fflate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzipFromStream.fflate.js","names":["_fflate","require","_nodeBuffer","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","Promise","resolve","reject","errored","onError","error","_createZipFileValidat","createZipFileValidator","isValid","Error","validateChunk","unzip","Unzip","entry","name","endsWith","path","chunks","ondata","chunk","isLast","push","Buffer","concat","start","register","UnzipInflate","on","Uint8Array","onValidationResult","firstBytesCount","firstBytes","firstBytesCheckResult","i"],"sources":["../../source/zip/unzipFromStream.fflate.js"],"sourcesContent":["// `fflate` uses a javascript-only implementation of `.zip` compression/decompression.\r\n// This means that it could likely be less performant than Node.js's \"native\" `zlib` module`.\r\n\r\n// This code was originally submitted by Stian Jensen.\r\n// https://github.com/catamphetamine/read-excel-file/pull/122\r\n\r\n// A `*.zip` file consists of individual file entries with the \"total\" summary section\r\n// placed at the end of the file rather than at the start of it, which was originally done\r\n// to allow for easy append of data to a given `.zip` file.\r\n// https://en.wikipedia.org/wiki/ZIP_(file_format)\r\n//\r\n// But this also means that reading a `*.zip` file from a stream can't really be done\r\n// using the \"officially recommended\" way of first reading the \"total\" summary section\r\n// and only then reading the individual file entries specified in that summary section.\r\n//\r\n// So in order to be able to read a `*.zip` file from a stream, some corners have to be cut.\r\n// For example, the \"total\" summary section is completely ignored and instead the reader\r\n// should adopt \"data recovery\" software approach — it should proactively \"scan\" the input stream\r\n// for individual file entries and handle them one-by-one as they come.\r\n//\r\n// Such approach doesn't seem to contradict with the XLSX specification\r\n// because an `*.xlsx` files is supposed to be a normal `.zip` archive\r\n// without any \"trickery\" such as \"deleted\" files or \"garbage\" data\r\n// hiding under the hood.\r\n//\r\n// So when handling `*.xlsx` file, we assume that each such file must start\r\n// with an individual file entry followed by another individual file entry, etc.\r\n//\r\n// When the \"summary\" section is reached, we assume that the archive has ended.\r\n//\r\n// To read a `.zip` archive, the code uses `fflate`'s `Unzip` class\r\n// with `UnzipInflate` decompression implementation to decompress the data\r\n// that was previously compressed using `DEFLATE` compressing algorithm,\r\n// which is what `*.xlsx` files use.\r\n//\r\n// The `Unzip` class doesn't speak the Node.js stream interface, and `fflate`'s readme\r\n// doesn't include a clear \"reading a `.zip` file from a Node.js stream\" section.\r\n// https://github.com/101arrowz/fflate/issues/251\r\n// Instead, the `Unzip` class has its own `push(chunk)` / `onfile` / `entry.ondata` protocol.\r\n// This code reads the binary input stream and forwards each chunk of it to `unzip.push()`,\r\n// and then collects the decompressed file entries.\r\n//\r\n// P.S. In the comments to `UnzipInflate` in `fflate` package, it says:\r\n// \"Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for better performance.\"\r\n// But there seems to be no `AsyncZipInflate` class in the `fflate` package.\r\n// https://github.com/101arrowz/fflate/issues/277\r\n// So just the regular `UnzipInflate` is used here.\r\n//\r\nimport { Unzip, UnzipInflate } from 'fflate'\r\n\r\nimport { Buffer } from 'node:buffer'\r\n\r\n/**\r\n * Reads `*.zip` file contents.\r\n * @param  {Stream} stream\r\n * @return {Promise<Record<string,Buffer>>} Resolves to an object holding `*.zip` file entries. P.S. `Buffer` is a `Uint8Array`.\r\n */\r\nexport default function unzipFromStream(stream, { filter } = {}) {\r\n\t// The `files` object stores the files and their contents.\r\n\tconst files = {}\r\n\r\n\treturn new Promise((resolve, reject) => {\r\n\t\tlet errored = false\r\n\r\n\t\tconst onError = (error) => {\r\n\t\t\tif (!errored) {\r\n\t\t\t\terrored = true\r\n\t\t\t\treject(error)\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst { validateChunk } = createZipFileValidator((isValid) => {\r\n\t\t\tif (!isValid) {\r\n\t\t\t\tonError(new Error('Invalid `.zip` archive'))\r\n\t\t\t}\r\n\t\t})\r\n\r\n\t\t// `Unzip` discovers each individual file entry in the input data stream\r\n\t\t// and then calls the callback function for each such entry.\r\n\t\tconst unzip = new Unzip((entry) => {\r\n\t\t\t// If there already was an error while reading this `.zip` file,\r\n\t\t\t// ignore any follow-up entries.\r\n\t\t\tif (errored) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\t// Skip directory entries (their names end with a slash).\r\n\t\t\t// Only files are of any interest.\r\n\t\t\tif (entry.name.endsWith('/')) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\t// See if this file should be ignored.\r\n\t\t\t// If it should, this entry won't be processed, i.e. `Unzip` will not try\r\n\t\t\t// to decompress its data, and will just discard it.\r\n\t\t\tif (filter && !filter({ path: entry.name })) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\tconst chunks = []\r\n\r\n\t\t\t// `entry.ondata` is called with each decompressed chunk of the entry,\r\n\t\t\t// and a final time with `isLast === true` once the entry is complete.\r\n\t\t\tentry.ondata = (error, chunk, isLast) => {\r\n\t\t\t\tif (error) {\r\n\t\t\t\t\treturn onError(error)\r\n\t\t\t\t}\r\n\t\t\t\tchunks.push(chunk)\r\n\t\t\t\tif (isLast) {\r\n\t\t\t\t\tfiles[entry.name] = Buffer.concat(chunks)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Start decompressing this entry.\r\n\t\t\tentry.start()\r\n\t\t})\r\n\r\n\t\t// Register the decompressor for the data that was compressed using\r\n\t\t// `DEFLATE` compression algorithm (compression method `8`),\r\n\t\t// which is what `.xlsx` files use.\r\n\t\tunzip.register(UnzipInflate)\r\n\r\n\t\tstream\r\n\t\t\t// Catch errors emitted from the input stream (for example, a file read error).\r\n\t\t\t.on('error', onError)\r\n\t\t\t// When another chunk of data is read from the input stream.\r\n\t\t\t.on('data', (chunk) => {\r\n\t\t\t\t// If there already was an error while reading this `.zip` file,\r\n\t\t\t\t// ignore any follow-up data chunks.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\t// Validate the `.zip` archive as its data comes through.\r\n\t\t\t\tvalidateChunk(chunk)\r\n\t\t\t\t// If the `.zip` archive is found to be invalid, stop any further\r\n\t\t\t\t// processing of it.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\t// Push the next data chunk to `fflate`'s `Unzip` class instance.\r\n\t\t\t\t// The `.push()` function is synchronous, meaning that by the time it returns,\r\n\t\t\t\t// any complete files entries encountered so far have already been decompressed\r\n\t\t\t\t// and populated in the `files` object.\r\n\t\t\t\ttry {\r\n\t\t\t\t\tunzip.push(chunk, false)\r\n\t\t\t\t} catch (error) {\r\n\t\t\t\t\tonError(error)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t// When there's no more data in the input stream to consume,\r\n\t\t\t// finish reading the `.zip` archive.\r\n\t\t\t.on('end', () => {\r\n\t\t\t\t// If there were any errors when reading the `.zip` archive,\r\n\t\t\t\t// don't `resolve()` with anything.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\ttry {\r\n\t\t\t\t\t// Signal the end of the archive to `fflate`'s `Unzip` class instance.\r\n\t\t\t\t\t// It will flush any remaining state in it.\r\n\t\t\t\t\tunzip.push(new Uint8Array(0), true)\r\n\t\t\t\t\t// Resolve with the unzipped files.\r\n\t\t\t\t\tresolve(files)\r\n\t\t\t\t} catch (error) {\r\n\t\t\t\t\tonError(error)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t})\r\n}\r\n\r\n// Every section in a `.zip` archive is marked with 4 bytes, the first two of which\r\n// are `0x50` and `0x4B`, which reads \"PK\", referencing the initials of the inventor Phil Katz.\r\n//\r\n// It looks like `fflate`'s `Unzip` doesn't ever complain about whatever data is thrown at it.\r\n// Due to how `.zip` file format is defined, \"garbage\" data could be placed at various\r\n// places in it and it'd still be a valid `.zip` archive. It's likely that for this reason\r\n// `fflate` doesn't ever complain and simply emits no entries when fed any kind of invalid data.\r\n//\r\n// In order to introduce some basic validation, here we specifically demand\r\n// that a `.zip` archive must at least start with an individual file entry\r\n// because an `.xlsx` file creator softwared really shouldn't attempt doing\r\n// anything \"funny\" when writing a file, hence this adherence requirement.\r\n//\r\nfunction createZipFileValidator(onValidationResult) {\r\n\tconst firstBytesCount = 2\r\n\tconst firstBytes = []\r\n\tlet firstBytesCheckResult\r\n\treturn {\r\n\t\tvalidateChunk(chunk) {\r\n\t\t\tif (firstBytes.length < 2) {\r\n\t\t\t\tlet i = 0\r\n\t\t\t\twhile (i < chunk.length && i < firstBytesCount) {\r\n\t\t\t\t\tfirstBytes.push(chunk[i])\r\n\t\t\t\t\ti++\r\n\t\t\t\t}\r\n\t\t\t\tif (firstBytes.length === 2) {\r\n\t\t\t\t\tconst isValid = firstBytes[0] === 0x50 && firstBytes[1] === 0x4B\r\n\t\t\t\t\tonValidationResult(isValid)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}"],"mappings":"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"}

package/commonjs/zip/unzipFromStream.js

@@ -3,198 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = unzipFromStream;
-var _fflate = require("fflate");
-var _buffer = require("buffer");
-// This code was originally submitted by Stian Jensen.
-// https://github.com/catamphetamine/read-excel-file/pull/122
-
-// A `*.zip` file consists of individual file entries with the "total" summary section
-// placed at the end of the file rather than at the start of it, which was originally done
-// to allow for easy append of data to a given `.zip` file.
-// https://en.wikipedia.org/wiki/ZIP_(file_format)
-//
-// But this also means that reading a `*.zip` file from a stream can't really be done
-// using the "officially recommended" way of first reading the "total" summary section
-// and only then reading the individual file entries specified in that summary section.
-//
-// So in order to be able to read a `*.zip` file from a stream, some corners have to be cut.
-// For example, the "total" summary section is completely ignored and instead the reader
-// should adopt "data recovery" software approach — it should proactively "scan" the input stream
-// for individual file entries and handle them one-by-one as they come.
-//
-// Such approach doesn't seem to contradict with the XLSX specification
-// because an `*.xlsx` files is supposed to be a normal `.zip` archive
-// without any "trickery" such as "deleted" files or "garbage" data
-// hiding under the hood.
-//
-// So when handling `*.xlsx` file, we assume that each such file must start
-// with an individual file entry followed by another individual file entry, etc.
-//
-// When the "summary" section is reached, we assume that the archive has ended.
-//
-// To read a `.zip` archive, the code uses `fflate`'s `Unzip` class
-// with `UnzipInflate` decompression implementation to decompress the data
-// that was previously compressed using `DEFLATE` compressing algorithm,
-// which is what `*.xlsx` files use.
-//
-// The `Unzip` class doesn't speak the Node.js stream interface, and `fflate`'s readme
-// doesn't include a clear "reading a `.zip` file from a Node.js stream" section.
-// https://github.com/101arrowz/fflate/issues/251
-// Instead, the `Unzip` class has its own `push(chunk)` / `onfile` / `entry.ondata` protocol.
-// This code reads the binary input stream and forwards each chunk of it to `unzip.push()`,
-// and then collects the decompressed file entries.
-//
-
-/**
- * Reads `*.zip` file contents.
- * @param  {Stream} stream
- * @return {Promise<Record<string,Buffer>>} Resolves to an object holding `*.zip` file entries. P.S. `Buffer` is a `Uint8Array`.
- */
-function unzipFromStream(stream) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    filter = _ref.filter;
-  // The `files` object stores the files and their contents.
-  var files = {};
-  return new Promise(function (resolve, reject) {
-    var errored = false;
-    var onError = function onError(error) {
-      if (!errored) {
-        errored = true;
-        reject(error);
-      }
-    };
-    var _createZipFileValidat = createZipFileValidator(function (isValid) {
-        if (!isValid) {
-          onError(new Error('Invalid `.zip` archive'));
-        }
-      }),
-      validateChunk = _createZipFileValidat.validateChunk;
-
-    // `Unzip` discovers each individual file entry in the input data stream
-    // and then calls the callback function for each such entry.
-    var unzip = new _fflate.Unzip(function (entry) {
-      // If there already was an error while reading this `.zip` file,
-      // ignore any follow-up entries.
-      if (errored) {
-        return;
-      }
-
-      // Skip directory entries (their names end with a slash).
-      // Only files are of any interest.
-      if (entry.name.endsWith('/')) {
-        return;
-      }
-
-      // See if this file should be ignored.
-      // If it should, this entry won't be processed, i.e. `Unzip` will not try
-      // to decompress its data, and will just discard it.
-      if (filter && !filter({
-        path: entry.name
-      })) {
-        return;
-      }
-      var chunks = [];
-
-      // `entry.ondata` is called with each decompressed chunk of the entry,
-      // and a final time with `isLast === true` once the entry is complete.
-      entry.ondata = function (error, chunk, isLast) {
-        if (error) {
-          return onError(error);
-        }
-        chunks.push(chunk);
-        if (isLast) {
-          files[entry.name] = _buffer.Buffer.concat(chunks);
-        }
-      };
-
-      // Start decompressing this entry.
-      entry.start();
-    });
-
-    // Register the decompressor for the data that was compressed using
-    // `DEFLATE` compression algorithm (compression method `8`),
-    // which is what `.xlsx` files use.
-    unzip.register(_fflate.UnzipInflate);
-    stream
-    // Catch errors emitted from the input stream (for example, a file read error).
-    .on('error', onError)
-    // When another chunk of data is read from the input stream.
-    .on('data', function (chunk) {
-      // If there already was an error while reading this `.zip` file,
-      // ignore any follow-up data chunks.
-      if (errored) {
-        return;
-      }
-      // Validate the `.zip` archive as its data comes through.
-      validateChunk(chunk);
-      // If the `.zip` archive is found to be invalid, stop any further
-      // processing of it.
-      if (errored) {
-        return;
-      }
-      // Push the next data chunk to `fflate`'s `Unzip` class instance.
-      // The `.push()` function is synchronous, meaning that by the time it returns,
-      // any complete files entries encountered so far have already been decompressed
-      // and populated in the `files` object.
-      try {
-        unzip.push(chunk, false);
-      } catch (error) {
-        onError(error);
-      }
-    })
-    // When there's no more data in the input stream to consume,
-    // finish reading the `.zip` archive.
-    .on('end', function () {
-      // If there were any errors when reading the `.zip` archive,
-      // don't `resolve()` with anything.
-      if (errored) {
-        return;
-      }
-      try {
-        // Signal the end of the archive to `fflate`'s `Unzip` class instance.
-        // It will flush any remaining state in it.
-        unzip.push(new Uint8Array(0), true);
-        // Resolve with the unzipped files.
-        resolve(files);
-      } catch (error) {
-        onError(error);
-      }
-    });
-  });
-}
-
-// Every section in a `.zip` archive is marked with 4 bytes, the first two of which
-// are `0x50` and `0x4B`, which reads "PK", referencing the initials of the inventor Phil Katz.
-//
-// It looks like `fflate`'s `Unzip` doesn't ever complain about whatever data is thrown at it.
-// Due to how `.zip` file format is defined, "garbage" data could be placed at various
-// places in it and it'd still be a valid `.zip` archive. It's likely that for this reason
-// `fflate` doesn't ever complain and simply emits no entries when fed any kind of invalid data.
-//
-// In order to introduce some basic validation, here we specifically demand
-// that a `.zip` archive must at least start with an individual file entry
-// because an `.xlsx` file creator softwared really shouldn't attempt doing
-// anything "funny" when writing a file, hence this adherence requirement.
-//
-function createZipFileValidator(onValidationResult) {
-  var firstBytesCount = 2;
-  var firstBytes = [];
-  var firstBytesCheckResult;
-  return {
-    validateChunk: function validateChunk(chunk) {
-      if (firstBytes.length < 2) {
-        var i = 0;
-        while (i < chunk.length && i < firstBytesCount) {
-          firstBytes.push(chunk[i]);
-          i++;
-        }
-        if (firstBytes.length === 2) {
-          var isValid = firstBytes[0] === 0x50 && firstBytes[1] === 0x4B;
-          onValidationResult(isValid);
-        }
-      }
-    }
-  };
-}
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _unzipFromStreamUnzipper["default"];
+  }
+});
+var _unzipFromStreamUnzipper = _interopRequireDefault(require("./unzipFromStream.unzipper.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 //# sourceMappingURL=unzipFromStream.js.map

package/commonjs/zip/unzipFromStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"unzipFromStream.js","names":["_fflate","require","_buffer","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","Promise","resolve","reject","errored","onError","error","_createZipFileValidat","createZipFileValidator","isValid","Error","validateChunk","unzip","Unzip","entry","name","endsWith","path","chunks","ondata","chunk","isLast","push","Buffer","concat","start","register","UnzipInflate","on","Uint8Array","onValidationResult","firstBytesCount","firstBytes","firstBytesCheckResult","i"],"sources":["../../source/zip/unzipFromStream.js"],"sourcesContent":["// This code was originally submitted by Stian Jensen.\r\n// https://github.com/catamphetamine/read-excel-file/pull/122\r\n\r\n// A `*.zip` file consists of individual file entries with the \"total\" summary section\r\n// placed at the end of the file rather than at the start of it, which was originally done\r\n// to allow for easy append of data to a given `.zip` file.\r\n// https://en.wikipedia.org/wiki/ZIP_(file_format)\r\n//\r\n// But this also means that reading a `*.zip` file from a stream can't really be done\r\n// using the \"officially recommended\" way of first reading the \"total\" summary section\r\n// and only then reading the individual file entries specified in that summary section.\r\n//\r\n// So in order to be able to read a `*.zip` file from a stream, some corners have to be cut.\r\n// For example, the \"total\" summary section is completely ignored and instead the reader\r\n// should adopt \"data recovery\" software approach — it should proactively \"scan\" the input stream\r\n// for individual file entries and handle them one-by-one as they come.\r\n//\r\n// Such approach doesn't seem to contradict with the XLSX specification\r\n// because an `*.xlsx` files is supposed to be a normal `.zip` archive\r\n// without any \"trickery\" such as \"deleted\" files or \"garbage\" data\r\n// hiding under the hood.\r\n//\r\n// So when handling `*.xlsx` file, we assume that each such file must start\r\n// with an individual file entry followed by another individual file entry, etc.\r\n//\r\n// When the \"summary\" section is reached, we assume that the archive has ended.\r\n//\r\n// To read a `.zip` archive, the code uses `fflate`'s `Unzip` class\r\n// with `UnzipInflate` decompression implementation to decompress the data\r\n// that was previously compressed using `DEFLATE` compressing algorithm,\r\n// which is what `*.xlsx` files use.\r\n//\r\n// The `Unzip` class doesn't speak the Node.js stream interface, and `fflate`'s readme\r\n// doesn't include a clear \"reading a `.zip` file from a Node.js stream\" section.\r\n// https://github.com/101arrowz/fflate/issues/251\r\n// Instead, the `Unzip` class has its own `push(chunk)` / `onfile` / `entry.ondata` protocol.\r\n// This code reads the binary input stream and forwards each chunk of it to `unzip.push()`,\r\n// and then collects the decompressed file entries.\r\n//\r\nimport { Unzip, UnzipInflate } from 'fflate'\r\n\r\nimport { Buffer } from 'buffer'\r\n\r\n/**\r\n * Reads `*.zip` file contents.\r\n * @param  {Stream} stream\r\n * @return {Promise<Record<string,Buffer>>} Resolves to an object holding `*.zip` file entries. P.S. `Buffer` is a `Uint8Array`.\r\n */\r\nexport default function unzipFromStream(stream, { filter } = {}) {\r\n\t// The `files` object stores the files and their contents.\r\n\tconst files = {}\r\n\r\n\treturn new Promise((resolve, reject) => {\r\n\t\tlet errored = false\r\n\r\n\t\tconst onError = (error) => {\r\n\t\t\tif (!errored) {\r\n\t\t\t\terrored = true\r\n\t\t\t\treject(error)\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst { validateChunk } = createZipFileValidator((isValid) => {\r\n\t\t\tif (!isValid) {\r\n\t\t\t\tonError(new Error('Invalid `.zip` archive'))\r\n\t\t\t}\r\n\t\t})\r\n\r\n\t\t// `Unzip` discovers each individual file entry in the input data stream\r\n\t\t// and then calls the callback function for each such entry.\r\n\t\tconst unzip = new Unzip((entry) => {\r\n\t\t\t// If there already was an error while reading this `.zip` file,\r\n\t\t\t// ignore any follow-up entries.\r\n\t\t\tif (errored) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\t// Skip directory entries (their names end with a slash).\r\n\t\t\t// Only files are of any interest.\r\n\t\t\tif (entry.name.endsWith('/')) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\t// See if this file should be ignored.\r\n\t\t\t// If it should, this entry won't be processed, i.e. `Unzip` will not try\r\n\t\t\t// to decompress its data, and will just discard it.\r\n\t\t\tif (filter && !filter({ path: entry.name })) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\tconst chunks = []\r\n\r\n\t\t\t// `entry.ondata` is called with each decompressed chunk of the entry,\r\n\t\t\t// and a final time with `isLast === true` once the entry is complete.\r\n\t\t\tentry.ondata = (error, chunk, isLast) => {\r\n\t\t\t\tif (error) {\r\n\t\t\t\t\treturn onError(error)\r\n\t\t\t\t}\r\n\t\t\t\tchunks.push(chunk)\r\n\t\t\t\tif (isLast) {\r\n\t\t\t\t\tfiles[entry.name] = Buffer.concat(chunks)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Start decompressing this entry.\r\n\t\t\tentry.start()\r\n\t\t})\r\n\r\n\t\t// Register the decompressor for the data that was compressed using\r\n\t\t// `DEFLATE` compression algorithm (compression method `8`),\r\n\t\t// which is what `.xlsx` files use.\r\n\t\tunzip.register(UnzipInflate)\r\n\r\n\t\tstream\r\n\t\t\t// Catch errors emitted from the input stream (for example, a file read error).\r\n\t\t\t.on('error', onError)\r\n\t\t\t// When another chunk of data is read from the input stream.\r\n\t\t\t.on('data', (chunk) => {\r\n\t\t\t\t// If there already was an error while reading this `.zip` file,\r\n\t\t\t\t// ignore any follow-up data chunks.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\t// Validate the `.zip` archive as its data comes through.\r\n\t\t\t\tvalidateChunk(chunk)\r\n\t\t\t\t// If the `.zip` archive is found to be invalid, stop any further\r\n\t\t\t\t// processing of it.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\t// Push the next data chunk to `fflate`'s `Unzip` class instance.\r\n\t\t\t\t// The `.push()` function is synchronous, meaning that by the time it returns,\r\n\t\t\t\t// any complete files entries encountered so far have already been decompressed\r\n\t\t\t\t// and populated in the `files` object.\r\n\t\t\t\ttry {\r\n\t\t\t\t\tunzip.push(chunk, false)\r\n\t\t\t\t} catch (error) {\r\n\t\t\t\t\tonError(error)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t// When there's no more data in the input stream to consume,\r\n\t\t\t// finish reading the `.zip` archive.\r\n\t\t\t.on('end', () => {\r\n\t\t\t\t// If there were any errors when reading the `.zip` archive,\r\n\t\t\t\t// don't `resolve()` with anything.\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\t\t\t\ttry {\r\n\t\t\t\t\t// Signal the end of the archive to `fflate`'s `Unzip` class instance.\r\n\t\t\t\t\t// It will flush any remaining state in it.\r\n\t\t\t\t\tunzip.push(new Uint8Array(0), true)\r\n\t\t\t\t\t// Resolve with the unzipped files.\r\n\t\t\t\t\tresolve(files)\r\n\t\t\t\t} catch (error) {\r\n\t\t\t\t\tonError(error)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t})\r\n}\r\n\r\n// Every section in a `.zip` archive is marked with 4 bytes, the first two of which\r\n// are `0x50` and `0x4B`, which reads \"PK\", referencing the initials of the inventor Phil Katz.\r\n//\r\n// It looks like `fflate`'s `Unzip` doesn't ever complain about whatever data is thrown at it.\r\n// Due to how `.zip` file format is defined, \"garbage\" data could be placed at various\r\n// places in it and it'd still be a valid `.zip` archive. It's likely that for this reason\r\n// `fflate` doesn't ever complain and simply emits no entries when fed any kind of invalid data.\r\n//\r\n// In order to introduce some basic validation, here we specifically demand\r\n// that a `.zip` archive must at least start with an individual file entry\r\n// because an `.xlsx` file creator softwared really shouldn't attempt doing\r\n// anything \"funny\" when writing a file, hence this adherence requirement.\r\n//\r\nfunction createZipFileValidator(onValidationResult) {\r\n\tconst firstBytesCount = 2\r\n\tconst firstBytes = []\r\n\tlet firstBytesCheckResult\r\n\treturn {\r\n\t\tvalidateChunk(chunk) {\r\n\t\t\tif (firstBytes.length < 2) {\r\n\t\t\t\tlet i = 0\r\n\t\t\t\twhile (i < chunk.length && i < firstBytesCount) {\r\n\t\t\t\t\tfirstBytes.push(chunk[i])\r\n\t\t\t\t\ti++\r\n\t\t\t\t}\r\n\t\t\t\tif (firstBytes.length === 2) {\r\n\t\t\t\t\tconst isValid = firstBytes[0] === 0x50 && firstBytes[1] === 0x4B\r\n\t\t\t\t\tonValidationResult(isValid)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}"],"mappings":"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"}
+{"version":3,"file":"unzipFromStream.js","names":["_unzipFromStreamUnzipper","_interopRequireDefault","require","obj","__esModule"],"sources":["../../source/zip/unzipFromStream.js"],"sourcesContent":["// Currently, there're two implementations:\r\n// * `fflate` — a pure-javascript implementation that uses `fflate` package.\r\n// * `unzipper` — a \"native\" Node.js module that uses Node's `zlib` which is written in C.\r\n//\r\n// The implementations are compared in a benchmark:\r\n//\r\n// ```\r\n// npm run test:benchmark:unzipFromStream\r\n// ```\r\n//\r\n// The benchmark tells that `unzipper` is 2x faster than `fflate`.\r\n//\r\nexport { default as default } from './unzipFromStream.unzipper.js'"],"mappings":";;;;;;;;;;;AAYA,IAAAA,wBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAkE,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA"}