read-excel-file 9.3.4 → 9.3.5

package/modules/zip/unzipFromStream.fflate.js

@@ -74,6 +74,7 @@ import { Unzip } from 'fflate';
 
 import { Buffer } from 'node:buffer';
 import zlib from 'node:zlib';
+import UnzipError, { createUnzipError } from './UnzipError.js';
 
 // Native `zlib` is faster than `UnzipInflate`.
 // * When decompressing a `1 MB` `.xlsx` file, the decompression time is `100 ms`
@@ -92,45 +93,29 @@ var USE_ZLIB_DECOMPRESSOR = true;
 // * When decompressing a `50 MB` `.xlsx` file, the decompression time is `3600 ms`
 //   when using "sync" decompressor and `3200 ms` when using "async" decompressor.
 var USE_ASYNC_FFLATE_DECOMPRESSOR = false;
+var PROMISE_RESOLVE_VALUE = undefined;
 
 /**
  * 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`.
+ * @param  {function} onFile
+ * @param  {function} onFileData
+ * @param  {function} onFileDataEnd
+ * @return {Promise<void>}
  */
-export default 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 = {};
-  var filesChunks = {};
-  var onFile = function onFile(filePath) {
-    // 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: filePath
-    })) {
-      return false;
-    }
-    filesChunks[filePath] = [];
-  };
-  var onFileData = function onFileData(filePath, chunk) {
-    filesChunks[filePath].push(chunk);
-  };
-  var onFileDataEnd = function onFileDataEnd(filePath) {
-    files[filePath] = Buffer.concat(filesChunks[filePath]);
-    delete filesChunks[filePath];
-  };
-  return unzipFromStream_(stream, onFile, onFileData, onFileDataEnd).then(function () {
-    return files;
-  });
-}
-var PROMISE_RESOLVE_VALUE = undefined;
-function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
+export default function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
   return new Promise(function (resolve, reject) {
     var errored = false;
     var onError = function onError(error) {
+      // If `fflate` throws its specific error then it implies that the `.zip` file is not valid.
+      //
+      // By default, `fflate` uses it's own pure-js unzipper.
+      // It could also be configured to use `node:zlib` native module instead.
+      // In that case, it could throw a `code: "Z_DATA_ERROR"` too.
+      //
+      if (isFlateError(error) || error.code === 'Z_DATA_ERROR') {
+        error = createUnzipError(error);
+      }
       if (!errored) {
         errored = true;
         reject(error);
@@ -151,7 +136,7 @@ function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
     };
     var _createZipFileValidat = createZipFileValidator(function (isValid) {
         if (!isValid) {
-          onError(new Error('Invalid `.zip` archive'));
+          onError(new UnzipError('INVALID_ZIP'));
         }
       }),
       validateChunk = _createZipFileValidat.validateChunk;
@@ -170,7 +155,10 @@ function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
       if (entry.name.endsWith('/')) {
         return;
       }
-      if (onFile(entry.name) === false) {
+
+      // `entry.originalSize` property will not be present for `.zip` archives
+      // that were created in a streaming fashion.
+      if (onFile(entry.name, entry.originalSize) === false) {
         return;
       }
       stillDecompressingEntriesCount++;
@@ -181,7 +169,17 @@ function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
         if (error) {
           return onError(error);
         }
-        onFileData(entry.name, chunk);
+        // Sometimes, `chunk` is a `Buffer`. Other times, it's a `Uint8Array`.
+        // It's not really clear in which exact circumstances it's one or the other.
+        if (chunk instanceof Buffer) {
+          onFileData(entry.name, chunk);
+        } else if (chunk instanceof Uint8Array) {
+          onFileData(entry.name, Buffer.from(chunk));
+        } else {
+          // This error is not technically possible.
+          // In case it is thrown, it means that there's a bug in the code.
+          throw new Error('Unsupported type of chunk', chunk);
+        }
         if (isLast) {
           stillDecompressingEntriesCount--;
           onFileDataEnd(entry.name);
@@ -331,6 +329,14 @@ var NativeZlibInflate = /*#__PURE__*/function () {
     }
   }]);
   return NativeZlibInflate;
-}();
+}(); // This function attempts to guess if a given `error` was thrown by `fflate`.
 _defineProperty(NativeZlibInflate, "compression", 8);
+function isFlateError(error) {
+  // `fflate` doesn't export a `FlateError` class.
+  // https://github.com/101arrowz/fflate/issues/290
+  // return error instanceof FlateError
+
+  // Here, it attempts to guess if an `error` is a `FlateError` by checking if `error.code` is a `number`.
+  return typeof error.code === 'number';
+}
 //# sourceMappingURL=unzipFromStream.fflate.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"unzipFromStream.fflate.js","names":["Unzip","Buffer","zlib","USE_ZLIB_DECOMPRESSOR","USE_ASYNC_FFLATE_DECOMPRESSOR","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","filesChunks","onFile","filePath","path","onFileData","chunk","push","onFileDataEnd","concat","unzipFromStream_","then","PROMISE_RESOLVE_VALUE","Promise","resolve","reject","errored","onError","error","stillDecompressingEntriesCount","noMoreEntries","resolveIfDone","_createZipFileValidat","createZipFileValidator","isValid","Error","validateChunk","unzip","entry","name","endsWith","ondata","isLast","start","register","NativeZlibInflate","AsyncUnzipInflate","UnzipInflate","on","Uint8Array","onValidationResult","firstBytesCount","firstBytes","firstBytesCheckResult","i","_this","_classCallCheck","inflate","createInflateRaw","_createClass","key","value","write","from","end","terminate","destroy","_defineProperty"],"sources":["../../source/zip/unzipFromStream.fflate.js"],"sourcesContent":["// Considerations:\r\n//\r\n// * `fflate` uses a pure-javascript implementation of `.zip` compression/decompression by default.\r\n//   This pure-javascript implementation is about 2x slower than Node.js's \"native\" `zlib` module.\r\n//   This issue is worked around by \"marrying\" `fflate` with Node.js's `zlib` \"native\" module through some tinkering.\r\n//   https://github.com/101arrowz/fflate/issues/284\r\n//\r\n// * Even though `fflate` implements a \"streaming\" mode of its own,\r\n//   it does not implement Node.js streams \"contract\", i.e. it just unzips the archive\r\n//   as fast as it can consume it from the input stream, without throttling the data throughput\r\n//   in cases when the input data flows faster than `fflate` can process it. This means that\r\n//   in the \"worst case\" scenario when `fflate`'s decompressor is unable to keep up with the\r\n//   data influx, it would \"buffer\" the entire `.zip` archive in RAM until it's processed.\r\n//   And while this is no big deal by any means, it's still not as elegant as adhering to\r\n//   Node.js streaming protocol.\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// https://github.com/catamphetamine/read-excel-file/pull/123\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// The actual decompression could be performed either by using\r\n// `fflate`'s pure-javascript `UnzipInflate` implementation, which is\r\n// about 2x slower than Node.js's \"native\" module `zlib`,\r\n// or it could use the aforementioned `zlib` module as a drop-in replacement\r\n// (with some tinkering).\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 } from 'fflate'\r\n// import { AsyncUnzipInflate, UnzipInflate } from 'fflate'\r\n\r\nimport { Buffer } from 'node:buffer'\r\nimport zlib from 'node:zlib'\r\n\r\n// Native `zlib` is faster than `UnzipInflate`.\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `100 ms`\r\n//   when using `zlib` decompressor and `150 ms` when using `fflate` \"sync\" decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is `500 ms`\r\n//   when using `zlib` decompressor and `650 ms` when using `fflate` \"sync\" decompressor.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `2800 ms`\r\n//   when using `zlib` decompressor and `3600 ms` when using `fflate` \"sync\" decompressor.\r\nconst USE_ZLIB_DECOMPRESSOR = true\r\n\r\n// `AsyncZipInflate` is faster than `UnzipInflate` for `.xlsx` files that're larger\r\n// than a few megabytes.\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `150 ms`\r\n//   when using \"sync\" decompressor and `170 ms` when using \"async\" decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is about the same.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `3600 ms`\r\n//   when using \"sync\" decompressor and `3200 ms` when using \"async\" decompressor.\r\nconst USE_ASYNC_FFLATE_DECOMPRESSOR = false\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\tconst filesChunks = {}\r\n\r\n\tconst onFile = (filePath) => {\r\n\t\t// See if this file should be ignored.\r\n\t\t// If it should, this entry won't be processed, i.e. `Unzip` will not try\r\n\t\t// to decompress its data, and will just discard it.\r\n\t\tif (filter && !filter({ path: filePath })) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\tfilesChunks[filePath] = []\r\n\t}\r\n\r\n\tconst onFileData = (filePath, chunk) => {\r\n\t\tfilesChunks[filePath].push(chunk)\r\n\t}\r\n\r\n\tconst onFileDataEnd = (filePath) => {\r\n\t\tfiles[filePath] = Buffer.concat(filesChunks[filePath])\r\n\t\tdelete filesChunks[filePath]\r\n\t}\r\n\r\n\treturn unzipFromStream_(stream, onFile, onFileData, onFileDataEnd).then(() => {\r\n\t\treturn files\r\n\t})\r\n}\r\n\r\nconst PROMISE_RESOLVE_VALUE = undefined\r\n\r\nfunction unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {\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\t// The native `zlib` decoder finishes inflating an entry asynchronously, so\r\n\t\t// the archive's `end` event can fire while entries are still decompressing.\r\n\t\t// It counts \"decompression still in-progress\" entries the decompression for which\r\n\t\t// has started but not yet finished, and the main promise only resolves once\r\n\t\t// the input stream has ended *and* every entry is done decompressing.\r\n\t\tlet stillDecompressingEntriesCount = 0\r\n\t\tlet noMoreEntries = false\r\n\t\tconst resolveIfDone = () => {\r\n\t\t\tif (!errored && noMoreEntries && stillDecompressingEntriesCount === 0) {\r\n\t\t\t\tresolve(PROMISE_RESOLVE_VALUE)\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\tif (onFile(entry.name) === false) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\tstillDecompressingEntriesCount++\r\n\r\n\t\t\t// `entry.ondata` is called with each decompressed chunk of the entry,\r\n\t\t\t// and then 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\tonFileData(entry.name, chunk)\r\n\t\t\t\tif (isLast) {\r\n\t\t\t\t\tstillDecompressingEntriesCount--\r\n\t\t\t\t\tonFileDataEnd(entry.name)\r\n\t\t\t\t\tresolveIfDone()\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(USE_ZLIB_DECOMPRESSOR ? NativeZlibInflate : (USE_ASYNC_FFLATE_DECOMPRESSOR ? AsyncUnzipInflate : 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//\r\n\t\t\t\t// The `.push()` function of `fflate`'s own `ZipInflate` decompressor is synchronous,\r\n\t\t\t\t// meaning that by the time it returns, any complete files entries encountered so far\r\n\t\t\t\t// have already been decompressed and populated in the `files` object.\r\n\t\t\t\t//\r\n\t\t\t\t// The `.push()` function of `NativeZlibInflate` decompressor is asynchronous,\r\n\t\t\t\t// so it requires hacking around with the counter of \"still being decompressed\" entries\r\n\t\t\t\t// in order to detect the actual finish of the archive's decompression process.\r\n\t\t\t\t//\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// The input stream has ended.\r\n\t\t\t\t\tnoMoreEntries = true\r\n\t\t\t\t\t// The entries may still be decompressing asynchronously.\r\n\t\t\t\t\t// In that case, resolve once they all finish decompresssing.\r\n\t\t\t\t\t// Or, resolve if all entries have already finished decompressing by now.\r\n\t\t\t\t\tresolveIfDone()\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}\r\n\r\n// An implemenation of a `DEFLATE` decompressor for `fflate`'s `Unzip` class\r\n// that uses Node.js's \"native\" module `zlib`.\r\n//\r\n// It implements `fflate`'s decoder interface: `Unzip` constructs one decoder\r\n// per each entry, sets `ondata(error, chunk, isLast)` callback on it, and feeds it\r\n// the entry's compressed bytes by calling `push(chunk, isLast)` method.\r\n//\r\n// Unlike `fflate`'s synchronous `UnzipInflate` decoder, `zlib` decompresses asynchronously,\r\n// so an entry only finishes some \"ticks\" after its last chunk of its data is `push()`ed\r\n// by `fflate`'s `Unzip` class. To work around this issue, pending entries counter is used\r\n// to track when the archive really finishes unpacking.\r\n//\r\nclass NativeZlibInflate {\r\n\tstatic compression = 8\r\n\r\n\tconstructor() {\r\n\t\tthis.inflate = zlib.createInflateRaw()\r\n\t\tthis.inflate.on('data', (chunk) => this.ondata(null, chunk, false))\r\n\t\tthis.inflate.on('end', () => this.ondata(null, new Uint8Array(0), true))\r\n\t\tthis.inflate.on('error', (error) => this.ondata(error, null, false))\r\n\t}\r\n\r\n\tpush(chunk, isLast) {\r\n\t\tthis.inflate.write(Buffer.from(chunk))\r\n\t\tif (isLast) {\r\n\t\t\tthis.inflate.end()\r\n\t\t}\r\n\t}\r\n\r\n\tterminate() {\r\n\t\tthis.inflate.destroy()\r\n\t}\r\n}\r\n"],"mappings":"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"}
+{"version":3,"file":"unzipFromStream.fflate.js","names":["Unzip","Buffer","zlib","UnzipError","createUnzipError","USE_ZLIB_DECOMPRESSOR","USE_ASYNC_FFLATE_DECOMPRESSOR","PROMISE_RESOLVE_VALUE","undefined","unzipFromStream_","stream","onFile","onFileData","onFileDataEnd","Promise","resolve","reject","errored","onError","error","isFlateError","code","stillDecompressingEntriesCount","noMoreEntries","resolveIfDone","_createZipFileValidat","createZipFileValidator","isValid","validateChunk","unzip","entry","name","endsWith","originalSize","ondata","chunk","isLast","Uint8Array","from","Error","start","register","NativeZlibInflate","AsyncUnzipInflate","UnzipInflate","on","push","onValidationResult","firstBytesCount","firstBytes","firstBytesCheckResult","length","i","_this","_classCallCheck","inflate","createInflateRaw","_createClass","key","value","write","end","terminate","destroy","_defineProperty"],"sources":["../../source/zip/unzipFromStream.fflate.js"],"sourcesContent":["// Considerations:\r\n//\r\n// * `fflate` uses a pure-javascript implementation of `.zip` compression/decompression by default.\r\n//   This pure-javascript implementation is about 2x slower than Node.js's \"native\" `zlib` module.\r\n//   This issue is worked around by \"marrying\" `fflate` with Node.js's `zlib` \"native\" module through some tinkering.\r\n//   https://github.com/101arrowz/fflate/issues/284\r\n//\r\n// * Even though `fflate` implements a \"streaming\" mode of its own,\r\n//   it does not implement Node.js streams \"contract\", i.e. it just unzips the archive\r\n//   as fast as it can consume it from the input stream, without throttling the data throughput\r\n//   in cases when the input data flows faster than `fflate` can process it. This means that\r\n//   in the \"worst case\" scenario when `fflate`'s decompressor is unable to keep up with the\r\n//   data influx, it would \"buffer\" the entire `.zip` archive in RAM until it's processed.\r\n//   And while this is no big deal by any means, it's still not as elegant as adhering to\r\n//   Node.js streaming protocol.\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// https://github.com/catamphetamine/read-excel-file/pull/123\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// The actual decompression could be performed either by using\r\n// `fflate`'s pure-javascript `UnzipInflate` implementation, which is\r\n// about 2x slower than Node.js's \"native\" module `zlib`,\r\n// or it could use the aforementioned `zlib` module as a drop-in replacement\r\n// (with some tinkering).\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 } from 'fflate'\r\n// import { AsyncUnzipInflate, UnzipInflate } from 'fflate'\r\n\r\nimport { Buffer } from 'node:buffer'\r\nimport zlib from 'node:zlib'\r\n\r\nimport UnzipError, { createUnzipError } from './UnzipError.js'\r\n\r\n// Native `zlib` is faster than `UnzipInflate`.\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `100 ms`\r\n//   when using `zlib` decompressor and `150 ms` when using `fflate` \"sync\" decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is `500 ms`\r\n//   when using `zlib` decompressor and `650 ms` when using `fflate` \"sync\" decompressor.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `2800 ms`\r\n//   when using `zlib` decompressor and `3600 ms` when using `fflate` \"sync\" decompressor.\r\nconst USE_ZLIB_DECOMPRESSOR = true\r\n\r\n// `AsyncZipInflate` is faster than `UnzipInflate` for `.xlsx` files that're larger\r\n// than a few megabytes.\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `150 ms`\r\n//   when using \"sync\" decompressor and `170 ms` when using \"async\" decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is about the same.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `3600 ms`\r\n//   when using \"sync\" decompressor and `3200 ms` when using \"async\" decompressor.\r\nconst USE_ASYNC_FFLATE_DECOMPRESSOR = false\r\n\r\nconst PROMISE_RESOLVE_VALUE = undefined\r\n\r\n/**\r\n * Reads `*.zip` file contents.\r\n * @param  {Stream} stream\r\n * @param  {function} onFile\r\n * @param  {function} onFileData\r\n * @param  {function} onFileDataEnd\r\n * @return {Promise<void>}\r\n */\r\nexport default function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {\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\t// If `fflate` throws its specific error then it implies that the `.zip` file is not valid.\r\n\t\t\t//\r\n\t\t\t// By default, `fflate` uses it's own pure-js unzipper.\r\n\t\t\t// It could also be configured to use `node:zlib` native module instead.\r\n\t\t\t// In that case, it could throw a `code: \"Z_DATA_ERROR\"` too.\r\n\t\t\t//\r\n\t\t\tif (isFlateError(error) || error.code === 'Z_DATA_ERROR') {\r\n\t\t\t\terror = createUnzipError(error)\r\n\t\t\t}\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\t// The native `zlib` decoder finishes inflating an entry asynchronously, so\r\n\t\t// the archive's `end` event can fire while entries are still decompressing.\r\n\t\t// It counts \"decompression still in-progress\" entries the decompression for which\r\n\t\t// has started but not yet finished, and the main promise only resolves once\r\n\t\t// the input stream has ended *and* every entry is done decompressing.\r\n\t\tlet stillDecompressingEntriesCount = 0\r\n\t\tlet noMoreEntries = false\r\n\t\tconst resolveIfDone = () => {\r\n\t\t\tif (!errored && noMoreEntries && stillDecompressingEntriesCount === 0) {\r\n\t\t\t\tresolve(PROMISE_RESOLVE_VALUE)\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 UnzipError('INVALID_ZIP'))\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// `entry.originalSize` property will not be present for `.zip` archives\r\n\t\t\t// that were created in a streaming fashion.\r\n\t\t\tif (onFile(entry.name, entry.originalSize) === false) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\tstillDecompressingEntriesCount++\r\n\r\n\t\t\t// `entry.ondata` is called with each decompressed chunk of the entry,\r\n\t\t\t// and then 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\t// Sometimes, `chunk` is a `Buffer`. Other times, it's a `Uint8Array`.\r\n\t\t\t\t// It's not really clear in which exact circumstances it's one or the other.\r\n\t\t\t\tif (chunk instanceof Buffer) {\r\n\t\t\t\t\tonFileData(entry.name, chunk)\r\n\t\t\t\t} else if (chunk instanceof Uint8Array) {\r\n\t\t\t\t\tonFileData(entry.name, Buffer.from(chunk))\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// This error is not technically possible.\r\n\t\t\t\t\t// In case it is thrown, it means that there's a bug in the code.\r\n\t\t\t\t\tthrow new Error('Unsupported type of chunk', chunk)\r\n\t\t\t\t}\r\n\t\t\t\tif (isLast) {\r\n\t\t\t\t\tstillDecompressingEntriesCount--\r\n\t\t\t\t\tonFileDataEnd(entry.name)\r\n\t\t\t\t\tresolveIfDone()\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(USE_ZLIB_DECOMPRESSOR ? NativeZlibInflate : (USE_ASYNC_FFLATE_DECOMPRESSOR ? AsyncUnzipInflate : 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//\r\n\t\t\t\t// The `.push()` function of `fflate`'s own `ZipInflate` decompressor is synchronous,\r\n\t\t\t\t// meaning that by the time it returns, any complete files entries encountered so far\r\n\t\t\t\t// have already been decompressed and populated in the `files` object.\r\n\t\t\t\t//\r\n\t\t\t\t// The `.push()` function of `NativeZlibInflate` decompressor is asynchronous,\r\n\t\t\t\t// so it requires hacking around with the counter of \"still being decompressed\" entries\r\n\t\t\t\t// in order to detect the actual finish of the archive's decompression process.\r\n\t\t\t\t//\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// The input stream has ended.\r\n\t\t\t\t\tnoMoreEntries = true\r\n\t\t\t\t\t// The entries may still be decompressing asynchronously.\r\n\t\t\t\t\t// In that case, resolve once they all finish decompresssing.\r\n\t\t\t\t\t// Or, resolve if all entries have already finished decompressing by now.\r\n\t\t\t\t\tresolveIfDone()\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}\r\n\r\n// An implemenation of a `DEFLATE` decompressor for `fflate`'s `Unzip` class\r\n// that uses Node.js's \"native\" module `zlib`.\r\n//\r\n// It implements `fflate`'s decoder interface: `Unzip` constructs one decoder\r\n// per each entry, sets `ondata(error, chunk, isLast)` callback on it, and feeds it\r\n// the entry's compressed bytes by calling `push(chunk, isLast)` method.\r\n//\r\n// Unlike `fflate`'s synchronous `UnzipInflate` decoder, `zlib` decompresses asynchronously,\r\n// so an entry only finishes some \"ticks\" after its last chunk of its data is `push()`ed\r\n// by `fflate`'s `Unzip` class. To work around this issue, pending entries counter is used\r\n// to track when the archive really finishes unpacking.\r\n//\r\nclass NativeZlibInflate {\r\n\tstatic compression = 8\r\n\r\n\tconstructor() {\r\n\t\tthis.inflate = zlib.createInflateRaw()\r\n\t\tthis.inflate.on('data', (chunk) => this.ondata(null, chunk, false))\r\n\t\tthis.inflate.on('end', () => this.ondata(null, new Uint8Array(0), true))\r\n\t\tthis.inflate.on('error', (error) => this.ondata(error, null, false))\r\n\t}\r\n\r\n\tpush(chunk, isLast) {\r\n\t\tthis.inflate.write(Buffer.from(chunk))\r\n\t\tif (isLast) {\r\n\t\t\tthis.inflate.end()\r\n\t\t}\r\n\t}\r\n\r\n\tterminate() {\r\n\t\tthis.inflate.destroy()\r\n\t}\r\n}\r\n\r\n// This function attempts to guess if a given `error` was thrown by `fflate`.\r\nfunction isFlateError(error) {\r\n\t// `fflate` doesn't export a `FlateError` class.\r\n\t// https://github.com/101arrowz/fflate/issues/290\r\n\t// return error instanceof FlateError\r\n\r\n\t// Here, it attempts to guess if an `error` is a `FlateError` by checking if `error.code` is a `number`.\r\n\treturn typeof error.code === 'number'\r\n}\r\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,KAAK,QAAQ,QAAQ;AAC9B;;AAEA,SAASC,MAAM,QAAQ,aAAa;AACpC,OAAOC,IAAI,MAAM,WAAW;AAE5B,OAAOC,UAAU,IAAIC,gBAAgB,QAAQ,iBAAiB;;AAE9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMC,qBAAqB,GAAG,IAAI;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMC,6BAA6B,GAAG,KAAK;AAE3C,IAAMC,qBAAqB,GAAGC,SAAS;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,gBAAgBA,CAACC,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,aAAa,EAAE;EACnF,OAAO,IAAIC,OAAO,CAAC,UAACC,OAAO,EAAEC,MAAM,EAAK;IACvC,IAAIC,OAAO,GAAG,KAAK;IAEnB,IAAMC,OAAO,GAAG,SAAVA,OAAOA,CAAIC,KAAK,EAAK;MAC1B;MACA;MACA;MACA;MACA;MACA;MACA,IAAIC,YAAY,CAACD,KAAK,CAAC,IAAIA,KAAK,CAACE,IAAI,KAAK,cAAc,EAAE;QACzDF,KAAK,GAAGf,gBAAgB,CAACe,KAAK,CAAC;MAChC;MACA,IAAI,CAACF,OAAO,EAAE;QACbA,OAAO,GAAG,IAAI;QACdD,MAAM,CAACG,KAAK,CAAC;MACd;IACD,CAAC;;IAED;IACA;IACA;IACA;IACA;IACA,IAAIG,8BAA8B,GAAG,CAAC;IACtC,IAAIC,aAAa,GAAG,KAAK;IACzB,IAAMC,aAAa,GAAG,SAAhBA,a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"}

package/modules/zip/unzipFromStream.js

@@ -1,3 +1,6 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 // `unzipFromStream` function reads `.zip` archive data from a Node.js stream.
 //
 // Even though it receives a Node.js stream as an input, it doesn't return the results
@@ -64,5 +67,125 @@
 //   when compared to `zipSync`/`unzipSync`/`zip`/`unzip` functions.
 //   https://github.com/101arrowz/fflate/issues/282
 //
-export { default } from './unzipFromStream.unzipper.js';
+import unzipFromStream_ from './unzipFromStream.unzipper.js';
+
+/**
+ * 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`.
+ */
+export default 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 = {};
+  var filesData = {};
+
+  // `fileSize` is optional and will not be present for `.zip` archives
+  // that were created in a streaming fashion.
+  var onFile = function onFile(filePath, fileSize) {
+    // 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: filePath
+    })) {
+      return false;
+    }
+    // filesData[filePath] = []
+    filesData[filePath] = {
+      size: fileSize,
+      chunks: [],
+      buffer: fileSize === undefined ? undefined : Buffer.alloc(fileSize),
+      position: 0
+    };
+  };
+  var onFileData = function onFileData(filePath, chunk) {
+    // filesData[filePath].push(chunk)
+    if (filesData[filePath].size === undefined) {
+      filesData[filePath].chunks.push(chunk);
+    } else {
+      filesData[filePath].position += chunk.copy(filesData[filePath].buffer, filesData[filePath].position);
+    }
+  };
+  var onFileDataEnd = function onFileDataEnd(filePath) {
+    if (filesData[filePath].size === undefined) {
+      // // `Buffer.concat()` will produce a pooled buffer if it's <= 4KB.
+      // let buffer = Buffer.concat(filesData[filePath].chunks)
+      // if (isBufferPooled(buffer)) {
+      // 	// Here it uses `Buffer.allocUnsafeSlow()` instead of the regular `Buffer.alloc()`.
+      // 	// The reason is that `Buffer.allocUnsafeSlow()` doesn't bother resetting the memory
+      // 	// that is being allocated, which is fine because it will be overwritten anyway.
+      // 	// It could also have used `Buffer.allocUnsafe()` if it wasn't returning pooled buffers,
+      // 	// which is what is being avoided here in the first place.
+      // 	const pooledBuffer = buffer
+      // 	buffer = Buffer.allocUnsafeSlow(buffer.byteLength)
+      // 	pooledBuffer.copy(buffer)
+      // }
+      // files[filePath] = buffer
+      files[filePath] = concatChunksToNonPooledBuffer(filesData[filePath].chunks);
+    } else {
+      files[filePath] = filesData[filePath].buffer;
+    }
+    delete filesData[filePath];
+  };
+  return unzipFromStream_(stream, onFile, onFileData, onFileDataEnd).then(function () {
+    return files;
+  });
+}
+
+// // Node.js allocates small buffers (<= 4KB) in a shared 8KB pool.
+// // This interferes with passing such buffers to another worker thread.
+// // In order for a buffer to be transferrable to another worker thread,
+// // it has to be non-pooled.
+// function isBufferPooled(buffer) {
+// 	// If it doesn't utilize the full underlying `ArrayBuffer`, it's sliced out of a pool.
+// 	if (buffer.byteOffset > 0) {
+// 		return true
+// 	}
+//
+// 	// If it starts at `0`, but the underlying allocation is larger than the buffer itself, it's pooled/
+// 	if (buffer.buffer.byteLength > buffer.byteLength) {
+// 		return true
+// 	}
+//
+// 	return false
+// }
+
+// Concatenates chunks into a non-"pooled" buffer.
+//
+// It could've simply used `Buffer.concat(chunks)` to concatenate chunks into a buffer.
+// But, while using `Buffer.concat()` is simple, it results in a Node.js optimization
+// when it uses a "shared" memory region of about `8KB` to co-locate this array buffer
+// with other small array buffers if this array buffer is small too (i.e. <= `4KB`).
+//
+// Such co-location results in the inability to "transfer" this buffer
+// to a worker thread.
+//
+// A workaround is to manually allocate a separate memory region of a certain size.
+// This way, the resulting buffer will be non-"pooled".
+//
+function concatChunksToNonPooledBuffer(chunks) {
+  // Calculate the total byte length of all the chunks combined.
+  var totalLength = chunks.reduce(function (sum, chunk) {
+    return sum + chunk.length;
+  }, 0);
+
+  // Allocate a non-pooled buffer.
+  // Here it uses `Buffer.allocUnsafeSlow()` instead of the regular `Buffer.alloc()`.
+  // The reason is that `Buffer.allocUnsafeSlow()` doesn't bother resetting the memory
+  // that is being allocated, which is fine because it will be overwritten anyway.
+  // It could also have used `Buffer.allocUnsafe()` if it wasn't returning pooled buffers,
+  // which is what is being avoided here in the first place.
+  var buffer = Buffer.allocUnsafeSlow(totalLength);
+
+  // Manually copy each chunk into the buffer.
+  var offset = 0;
+  for (var _iterator = _createForOfIteratorHelperLoose(chunks), _step; !(_step = _iterator()).done;) {
+    var chunk = _step.value;
+    chunk.copy(buffer, offset);
+    offset += chunk.length;
+  }
+  return buffer;
+}
 //# sourceMappingURL=unzipFromStream.js.map

package/modules/zip/unzipFromStream.js.map

@@ -1 +1 @@
-{"version":3,"file":"unzipFromStream.js","names":["default"],"sources":["../../source/zip/unzipFromStream.js"],"sourcesContent":["// `unzipFromStream` function reads `.zip` archive data from a Node.js stream.\r\n//\r\n// Even though it receives a Node.js stream as an input, it doesn't return the results\r\n// as a Node.js output stream (with `objectMode: true` setting). The reason is that\r\n// the result of this function is then passed to the XML parser which currently\r\n// doesn't support consuming a Node.js stream and instead consumes the entire XML document\r\n// as a single string. This means that implementing streaming output in this function\r\n// wouldn't result in any performance improvements, so currently it simply returns\r\n// a \"map\" of all files in the input `.zip` archive, and that seems to be enough.\r\n//\r\n// Currently, there're two decompressor 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` with the default `ZipInflate` decompressor.\r\n//\r\n// However, when swapping `fflate`'s default `ZipInflate` decompressor with a custom\r\n// \"native\" `zlib` one, `fflate` happens to be about 20% faster than `unzipper`.\r\n//\r\n// Still, when measuring the total time of parsing `.xlsx` files,\r\n// the time difference becomes unmeasurable between `unzipper`\r\n// and `fflate` with \"native\" `zlib` decompressor,\r\n// as could be seen by running `npm run test:benchmark` command\r\n// where `fflate` is slightly faster than `unzipper`.\r\n//\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `90 ms`\r\n//   when using `fflate` with `zlib` decompressor and `100 ms` when using `unzipper` decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is `530 ms`\r\n//   when using `fflate` with `zlib` decompressor and `550 ms` when using `unzipper` decompressor.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `2800 ms`\r\n//   when using `fflate` with `zlib` decompressor and `3000 ms` when using `unzipper` decompressor.\r\n//\r\n// So, at the end of the day, there's no substantial difference between the two\r\n// when it comes to parsing `.xlsx` files, and one may choose depending on personal preference.\r\n//\r\n// And my personal preference leans towards `unzipper` because:\r\n//\r\n// * I personally refactored it into `unzipper-esm` in about 5-6 hours.\r\n//   https://github.com/ZJONSSON/node-unzipper/pull/356\r\n//\r\n// * It is designed as a Node.js-first module, i.e. it is designed around the concept\r\n//   of Node.js streams \"from the ground up\". Meanwhile, `fflate` is a \"universal\" module\r\n//   and it does not implement Node.js streams \"contract\", i.e. it just unzips the archive\r\n//   as fast as it can consume it from the input stream, without throttling the data throughput\r\n//   in cases when the input data flows faster than `fflate` can process it. This means that\r\n//   in the \"worst case\" scenario when `fflate`'s decompressor is unable to keep up with the\r\n//   data influx, it would \"buffer\" the entire `.zip` archive in RAM until it's processed.\r\n//   And while this is no big deal by any means, it's still not as elegant as adhering to\r\n//   Node.js streaming protocol.\r\n//\r\n// * `unzipper` uses native `zlib` decompressor which `fflate` doesn't officially include\r\n//   and it had to be hacked into it using a couple of tricks. That's also no big deal,\r\n//   but still a slightly weird experience.\r\n//\r\n// * Rumors are circulating that `fflate`'s \"streaming\" `Zip`/`Unzip` classes have a few\r\n//   implementation issues when compared to non-\"streaming\" `zipSync`/`unzipSync`/`zip`/`unzip` functions.\r\n//   Some people even suggested in the comments that `Zip`/`Unzip` classes are not really production-ready\r\n//   when compared to `zipSync`/`unzipSync`/`zip`/`unzip` functions.\r\n//   https://github.com/101arrowz/fflate/issues/282\r\n//\r\nexport { default as default } from './unzipFromStream.unzipper.js'"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,OAAkB,QAAQ,+BAA+B"}
+{"version":3,"file":"unzipFromStream.js","names":["unzipFromStream_","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","filesData","onFile","filePath","fileSize","path","size","chunks","buffer","Buffer","alloc","position","onFileData","chunk","push","copy","onFileDataEnd","concatChunksToNonPooledBuffer","then","totalLength","reduce","sum","allocUnsafeSlow","offset","_iterator","_createForOfIteratorHelperLoose","_step","done","value"],"sources":["../../source/zip/unzipFromStream.js"],"sourcesContent":["// `unzipFromStream` function reads `.zip` archive data from a Node.js stream.\r\n//\r\n// Even though it receives a Node.js stream as an input, it doesn't return the results\r\n// as a Node.js output stream (with `objectMode: true` setting). The reason is that\r\n// the result of this function is then passed to the XML parser which currently\r\n// doesn't support consuming a Node.js stream and instead consumes the entire XML document\r\n// as a single string. This means that implementing streaming output in this function\r\n// wouldn't result in any performance improvements, so currently it simply returns\r\n// a \"map\" of all files in the input `.zip` archive, and that seems to be enough.\r\n//\r\n// Currently, there're two decompressor 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` with the default `ZipInflate` decompressor.\r\n//\r\n// However, when swapping `fflate`'s default `ZipInflate` decompressor with a custom\r\n// \"native\" `zlib` one, `fflate` happens to be about 20% faster than `unzipper`.\r\n//\r\n// Still, when measuring the total time of parsing `.xlsx` files,\r\n// the time difference becomes unmeasurable between `unzipper`\r\n// and `fflate` with \"native\" `zlib` decompressor,\r\n// as could be seen by running `npm run test:benchmark` command\r\n// where `fflate` is slightly faster than `unzipper`.\r\n//\r\n// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `90 ms`\r\n//   when using `fflate` with `zlib` decompressor and `100 ms` when using `unzipper` decompressor.\r\n// * When decompressing a `10 MB` `.xlsx` file, the decompression time is `530 ms`\r\n//   when using `fflate` with `zlib` decompressor and `550 ms` when using `unzipper` decompressor.\r\n// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `2800 ms`\r\n//   when using `fflate` with `zlib` decompressor and `3000 ms` when using `unzipper` decompressor.\r\n//\r\n// So, at the end of the day, there's no substantial difference between the two\r\n// when it comes to parsing `.xlsx` files, and one may choose depending on personal preference.\r\n//\r\n// And my personal preference leans towards `unzipper` because:\r\n//\r\n// * I personally refactored it into `unzipper-esm` in about 5-6 hours.\r\n//   https://github.com/ZJONSSON/node-unzipper/pull/356\r\n//\r\n// * It is designed as a Node.js-first module, i.e. it is designed around the concept\r\n//   of Node.js streams \"from the ground up\". Meanwhile, `fflate` is a \"universal\" module\r\n//   and it does not implement Node.js streams \"contract\", i.e. it just unzips the archive\r\n//   as fast as it can consume it from the input stream, without throttling the data throughput\r\n//   in cases when the input data flows faster than `fflate` can process it. This means that\r\n//   in the \"worst case\" scenario when `fflate`'s decompressor is unable to keep up with the\r\n//   data influx, it would \"buffer\" the entire `.zip` archive in RAM until it's processed.\r\n//   And while this is no big deal by any means, it's still not as elegant as adhering to\r\n//   Node.js streaming protocol.\r\n//\r\n// * `unzipper` uses native `zlib` decompressor which `fflate` doesn't officially include\r\n//   and it had to be hacked into it using a couple of tricks. That's also no big deal,\r\n//   but still a slightly weird experience.\r\n//\r\n// * Rumors are circulating that `fflate`'s \"streaming\" `Zip`/`Unzip` classes have a few\r\n//   implementation issues when compared to non-\"streaming\" `zipSync`/`unzipSync`/`zip`/`unzip` functions.\r\n//   Some people even suggested in the comments that `Zip`/`Unzip` classes are not really production-ready\r\n//   when compared to `zipSync`/`unzipSync`/`zip`/`unzip` functions.\r\n//   https://github.com/101arrowz/fflate/issues/282\r\n//\r\nimport unzipFromStream_ from './unzipFromStream.unzipper.js'\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\tconst filesData = {}\r\n\r\n\t// `fileSize` is optional and will not be present for `.zip` archives\r\n\t// that were created in a streaming fashion.\r\n\tconst onFile = (filePath, fileSize) => {\r\n\t\t// See if this file should be ignored.\r\n\t\t// If it should, this entry won't be processed, i.e. `Unzip` will not try\r\n\t\t// to decompress its data, and will just discard it.\r\n\t\tif (filter && !filter({ path: filePath })) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\t// filesData[filePath] = []\r\n\t\tfilesData[filePath] = {\r\n\t\t\tsize: fileSize,\r\n\t\t\tchunks: [],\r\n\t\t\tbuffer: fileSize === undefined ? undefined : Buffer.alloc(fileSize),\r\n\t\t\tposition: 0\r\n\t\t}\r\n\t}\r\n\r\n\tconst onFileData = (filePath, chunk) => {\r\n\t\t// filesData[filePath].push(chunk)\r\n\t\tif (filesData[filePath].size === undefined) {\r\n\t\t\tfilesData[filePath].chunks.push(chunk)\r\n\t\t} else {\r\n\t\t\tfilesData[filePath].position += chunk.copy(filesData[filePath].buffer, filesData[filePath].position)\r\n\t\t}\r\n\t}\r\n\r\n\tconst onFileDataEnd = (filePath) => {\r\n\t\tif (filesData[filePath].size === undefined) {\r\n\t\t\t// // `Buffer.concat()` will produce a pooled buffer if it's <= 4KB.\r\n\t\t\t// let buffer = Buffer.concat(filesData[filePath].chunks)\r\n\t\t\t// if (isBufferPooled(buffer)) {\r\n\t\t\t// \t// Here it uses `Buffer.allocUnsafeSlow()` instead of the regular `Buffer.alloc()`.\r\n\t\t\t// \t// The reason is that `Buffer.allocUnsafeSlow()` doesn't bother resetting the memory\r\n\t\t\t// \t// that is being allocated, which is fine because it will be overwritten anyway.\r\n\t\t\t// \t// It could also have used `Buffer.allocUnsafe()` if it wasn't returning pooled buffers,\r\n\t\t\t// \t// which is what is being avoided here in the first place.\r\n\t\t\t// \tconst pooledBuffer = buffer\r\n\t\t\t// \tbuffer = Buffer.allocUnsafeSlow(buffer.byteLength)\r\n\t\t\t// \tpooledBuffer.copy(buffer)\r\n\t\t\t// }\r\n\t\t\t// files[filePath] = buffer\r\n\t\t\tfiles[filePath] = concatChunksToNonPooledBuffer(filesData[filePath].chunks)\r\n\t\t} else {\r\n\t\t\tfiles[filePath] = filesData[filePath].buffer\r\n\t\t}\r\n\t\tdelete filesData[filePath]\r\n\t}\r\n\r\n\treturn unzipFromStream_(stream, onFile, onFileData, onFileDataEnd)\r\n\t\t.then(() => files)\r\n}\r\n\r\n// // Node.js allocates small buffers (<= 4KB) in a shared 8KB pool.\r\n// // This interferes with passing such buffers to another worker thread.\r\n// // In order for a buffer to be transferrable to another worker thread,\r\n// // it has to be non-pooled.\r\n// function isBufferPooled(buffer) {\r\n// \t// If it doesn't utilize the full underlying `ArrayBuffer`, it's sliced out of a pool.\r\n// \tif (buffer.byteOffset > 0) {\r\n// \t\treturn true\r\n// \t}\r\n//\r\n// \t// If it starts at `0`, but the underlying allocation is larger than the buffer itself, it's pooled/\r\n// \tif (buffer.buffer.byteLength > buffer.byteLength) {\r\n// \t\treturn true\r\n// \t}\r\n//\r\n// \treturn false\r\n// }\r\n\r\n// Concatenates chunks into a non-\"pooled\" buffer.\r\n//\r\n// It could've simply used `Buffer.concat(chunks)` to concatenate chunks into a buffer.\r\n// But, while using `Buffer.concat()` is simple, it results in a Node.js optimization\r\n// when it uses a \"shared\" memory region of about `8KB` to co-locate this array buffer\r\n// with other small array buffers if this array buffer is small too (i.e. <= `4KB`).\r\n//\r\n// Such co-location results in the inability to \"transfer\" this buffer\r\n// to a worker thread.\r\n//\r\n// A workaround is to manually allocate a separate memory region of a certain size.\r\n// This way, the resulting buffer will be non-\"pooled\".\r\n//\r\nfunction concatChunksToNonPooledBuffer(chunks) {\r\n\t// Calculate the total byte length of all the chunks combined.\r\n\tconst totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)\r\n\r\n\t// Allocate a non-pooled buffer.\r\n\t// Here it uses `Buffer.allocUnsafeSlow()` instead of the regular `Buffer.alloc()`.\r\n\t// The reason is that `Buffer.allocUnsafeSlow()` doesn't bother resetting the memory\r\n\t// that is being allocated, which is fine because it will be overwritten anyway.\r\n\t// It could also have used `Buffer.allocUnsafe()` if it wasn't returning pooled buffers,\r\n\t// which is what is being avoided here in the first place.\r\n\tconst buffer = Buffer.allocUnsafeSlow(totalLength)\r\n\r\n\t// Manually copy each chunk into the buffer.\r\n\tlet offset = 0\r\n\tfor (const chunk of chunks) {\r\n\t\tchunk.copy(buffer, offset)\r\n\t\toffset += chunk.length\r\n\t}\r\n\r\n\treturn buffer\r\n}"],"mappings":"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"}

package/modules/zip/unzipFromStream.unzipper.js

@@ -9,55 +9,33 @@
 // * `unzipper` can completely skip a given compressed file entry if it's of no interest.
 //   This means that a `.zip` archive could be read in multiple passes without performance penalty.
 
-import { Parse } from 'unzipper-esm';
-import { Buffer } from 'buffer';
+import { Parse, ZipFileError } from 'unzipper-esm';
+import { createUnzipError } from './UnzipError.js';
+var PROMISE_RESOLVE_VALUE = undefined;
 
 /**
  * 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`.
+ * @param  {function} onFile
+ * @param  {function} onFileData
+ * @param  {function} onFileDataEnd
+ * @return {Promise<void>}
  */
-export default 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 = {};
-  var filesChunks = {};
-  var onFile = function onFile(filePath) {
-    // 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: filePath
-    })) {
-      return false;
-    }
-    filesChunks[filePath] = [];
-  };
-  var onFileData = function onFileData(filePath, chunk) {
-    filesChunks[filePath].push(chunk);
-  };
-  var onFileDataEnd = function onFileDataEnd(filePath) {
-    files[filePath] = Buffer.concat(filesChunks[filePath]);
-    delete filesChunks[filePath];
-  };
-  return unzipFromStream_(stream, onFile, onFileData, onFileDataEnd).then(function () {
-    return files;
-  });
-}
-var PROMISE_RESOLVE_VALUE = undefined;
-function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
+export default function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
   return new Promise(function (resolve, reject) {
     var promises = [];
     var errored = false;
     var onError = function onError(error) {
+      if (error instanceof ZipFileError) {
+        error = createUnzipError(error);
+      }
       if (!errored) {
         errored = true;
         reject(error);
       }
     };
     stream
-    // This first "error" listener catches the original stream errors.
+    // This first "error" listener catches errors emitted from the input stream (for example, a file read error).
     //
     // That's because the .pipe() method does not automatically propagate errors
     // from a source (input) stream to the destination stream or the end of the pipeline.
@@ -101,7 +79,13 @@ function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {
       if (errored) {
         ignore = true;
       }
-      if (onFile(entry.path) === false) {
+      // `entry.vars.uncompressedSize` will be `0` for `.zip` archives
+      // that were created in a streaming fashion.
+      // The `const fileSizeKnown = ...` code was copy-pasted from `node-unzipper` source code:
+      // https://github.com/ZJONSSON/node-unzipper/blob/master/lib/Open/unzip.js
+      var uncompressedFileSizeIsKnown = !(entry.vars.flags & 0x08) || entry.vars.compressedSize > 0;
+      var uncompressedFileSize = uncompressedFileSizeIsKnown ? entry.vars.uncompressedSize : undefined;
+      if (onFile(entry.path, uncompressedFileSize) === false) {
         ignore = true;
       }
 

package/modules/zip/unzipFromStream.unzipper.js.map

@@ -1 +1 @@
-{"version":3,"file":"unzipFromStream.unzipper.js","names":["Parse","Buffer","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","filesChunks","onFile","filePath","path","onFileData","chunk","push","onFileDataEnd","concat","unzipFromStream_","then","PROMISE_RESOLVE_VALUE","Promise","resolve","reject","promises","errored","onError","error","on","pipe","all","entry","ignore","type","autodrain","data"],"sources":["../../source/zip/unzipFromStream.unzipper.js"],"sourcesContent":["// Considerations:\r\n//\r\n// * `unzipper` unpacks a `.zip` file using Node.js's \"native\" `zlib` module.\r\n//   This means that it's more performant than any equivalent pure-javascript decompressor.\r\n//\r\n// * `unzipper` is a true \"streaming\" unpacker: it works in a \"pull\" fashion rather than a \"push\" one.\r\n//   New chunks of archived data are only read and decompressed as the receiver is ready to process them.\r\n//\r\n// * `unzipper` can completely skip a given compressed file entry if it's of no interest.\r\n//   This means that a `.zip` archive could be read in multiple passes without performance penalty.\r\n\r\nimport { Parse } from 'unzipper-esm'\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\tconst filesChunks = {}\r\n\r\n\tconst onFile = (filePath) => {\r\n\t\t// See if this file should be ignored.\r\n\t\t// If it should, this entry won't be processed, i.e. `Unzip` will not try\r\n\t\t// to decompress its data, and will just discard it.\r\n\t\tif (filter && !filter({ path: filePath })) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\tfilesChunks[filePath] = []\r\n\t}\r\n\r\n\tconst onFileData = (filePath, chunk) => {\r\n\t\tfilesChunks[filePath].push(chunk)\r\n\t}\r\n\r\n\tconst onFileDataEnd = (filePath) => {\r\n\t\tfiles[filePath] = Buffer.concat(filesChunks[filePath])\r\n\t\tdelete filesChunks[filePath]\r\n\t}\r\n\r\n\treturn unzipFromStream_(stream, onFile, onFileData, onFileDataEnd).then(() => {\r\n\t\treturn files\r\n\t})\r\n}\r\n\r\nconst PROMISE_RESOLVE_VALUE = undefined\r\n\r\nfunction unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {\r\n\treturn new Promise((resolve, reject) => {\r\n\t\tconst promises = []\r\n\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\tstream\r\n\t\t\t// This first \"error\" listener catches the original stream errors.\r\n\t\t\t//\r\n\t\t\t// That's because the .pipe() method does not automatically propagate errors\r\n\t\t\t// from a source (input) stream to the destination stream or the end of the pipeline.\r\n\t\t\t// You would need to attach an 'error' event handler to each stream in the chain.\r\n\t\t\t//\r\n\t\t\t// A more convenient alternative would be to use `stream.pipeline()` function:\r\n\t\t\t// `pipeline(stream1, stream2, (error) => { ... })`\r\n\t\t\t//\r\n\t\t\t.on('error', onError)\r\n\t\t\t// Pipe the input stream through the unzipper stream.\r\n\t\t\t.pipe(Parse())\r\n\t\t\t// This second \"error\" listener catches the unzipper stream errors.\r\n\t\t\t//\r\n\t\t\t// That's because the .pipe() method does not automatically propagate errors\r\n\t\t\t// from a source (input) stream to the destination stream or the end of the pipeline.\r\n\t\t\t// You would need to attach an 'error' event handler to each stream in the chain.\r\n\t\t\t//\r\n\t\t\t// A more convenient alternative would be to use `stream.pipeline()` function:\r\n\t\t\t// `pipeline(stream1, stream2, (error) => { ... })`\r\n\t\t\t//\r\n\t\t\t.on('error', onError)\r\n\t\t\t// The unzipper stream is closed when all `entries` have been reported.\r\n\t\t\t.on('finish', () => {\r\n\t\t\t\tif (!errored) {\r\n\t\t\t\t\t// Wait for all `entries` to be read.\r\n\t\t\t\t\t// The second argument of `.then()` function is not required\r\n\t\t\t\t\t// but I didn't remove it just to potentially prevent any potential silly bugs\r\n\t\t\t\t\t// in case of some potential changes in some potential future.\r\n\t\t\t\t\tPromise.all(promises).then(() => {\r\n\t\t\t\t\t\tresolve(PROMISE_RESOLVE_VALUE)\r\n\t\t\t\t\t}, onError)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.on('entry', (entry) => {\r\n\t\t\t\t// See if this file should be ignored.\r\n\t\t\t\tlet ignore = false\r\n\t\t\t\t// `entry.type` could be 'Directory' or 'File'.\r\n\t\t\t\t// Ignore anything except files.\r\n\t\t\t\tif (entry.type === 'Directory') {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\t\t\t\tif (onFile(entry.path) === false) {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// If this file should be ignored.\r\n\t\t\t\tif (ignore) {\r\n\t\t\t\t\t// Call `entry.autodrain()` when you do not intend to process a specific `entry`'s raw data.\r\n\t\t\t\t\t// Otherwise, if an `entry` is not consumed (via .pipe(), .buffer(), or .autodrain()),\r\n\t\t\t\t\t// the stream will halt, preventing further file processing.\r\n\t\t\t\t\tentry.autodrain().on('error', onError)\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\r\n\t\t\t\tpromises.push(new Promise((resolve) => {\r\n\t\t\t\t\t// `entry` seems to be a generic Node.js stream.\r\n\t\t\t\t\t// `entry.pipe()` pipes the file contents to a stream.\r\n\t\t\t\t\t// `entry.stream()` returns a readable stream.\r\n\t\t\t\t\t// `entry.buffer()` returns a promise that resolves to a `Buffer` with the file contents.\r\n\t\t\t\t\tentry\r\n\t\t\t\t\t\t.on('data', (data) => {\r\n\t\t\t\t\t\t\tonFileData(entry.path, data)\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t\t.on('error', (error) => {\r\n\t\t\t\t\t\t\tonError(error)\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t\t.on('finish', () => {\r\n\t\t\t\t\t\t\tonFileDataEnd(entry.path)\r\n\t\t\t\t\t\t\tresolve()\r\n\t\t\t\t\t\t})\r\n\t\t\t\t}))\r\n\t\t\t})\r\n\t})\r\n}"],"mappings":"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"}
+{"version":3,"file":"unzipFromStream.unzipper.js","names":["Parse","ZipFileError","createUnzipError","PROMISE_RESOLVE_VALUE","undefined","unzipFromStream_","stream","onFile","onFileData","onFileDataEnd","Promise","resolve","reject","promises","errored","onError","error","on","pipe","all","then","entry","ignore","type","uncompressedFileSizeIsKnown","vars","flags","compressedSize","uncompressedFileSize","uncompressedSize","path","autodrain","push","data"],"sources":["../../source/zip/unzipFromStream.unzipper.js"],"sourcesContent":["// Considerations:\r\n//\r\n// * `unzipper` unpacks a `.zip` file using Node.js's \"native\" `zlib` module.\r\n//   This means that it's more performant than any equivalent pure-javascript decompressor.\r\n//\r\n// * `unzipper` is a true \"streaming\" unpacker: it works in a \"pull\" fashion rather than a \"push\" one.\r\n//   New chunks of archived data are only read and decompressed as the receiver is ready to process them.\r\n//\r\n// * `unzipper` can completely skip a given compressed file entry if it's of no interest.\r\n//   This means that a `.zip` archive could be read in multiple passes without performance penalty.\r\n\r\nimport { Parse, ZipFileError } from 'unzipper-esm'\r\n\r\nimport { createUnzipError } from './UnzipError.js'\r\n\r\nconst PROMISE_RESOLVE_VALUE = undefined\r\n\r\n/**\r\n * Reads `*.zip` file contents.\r\n * @param  {Stream} stream\r\n * @param  {function} onFile\r\n * @param  {function} onFileData\r\n * @param  {function} onFileDataEnd\r\n * @return {Promise<void>}\r\n */\r\nexport default function unzipFromStream_(stream, onFile, onFileData, onFileDataEnd) {\r\n\treturn new Promise((resolve, reject) => {\r\n\t\tconst promises = []\r\n\r\n\t\tlet errored = false\r\n\r\n\t\tconst onError = (error) => {\r\n\t\t\tif (error instanceof ZipFileError) {\r\n\t\t\t\terror = createUnzipError(error)\r\n\t\t\t}\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\tstream\r\n\t\t\t// This first \"error\" listener catches errors emitted from the input stream (for example, a file read error).\r\n\t\t\t//\r\n\t\t\t// That's because the .pipe() method does not automatically propagate errors\r\n\t\t\t// from a source (input) stream to the destination stream or the end of the pipeline.\r\n\t\t\t// You would need to attach an 'error' event handler to each stream in the chain.\r\n\t\t\t//\r\n\t\t\t// A more convenient alternative would be to use `stream.pipeline()` function:\r\n\t\t\t// `pipeline(stream1, stream2, (error) => { ... })`\r\n\t\t\t//\r\n\t\t\t.on('error', onError)\r\n\t\t\t// Pipe the input stream through the unzipper stream.\r\n\t\t\t.pipe(Parse())\r\n\t\t\t// This second \"error\" listener catches the unzipper stream errors.\r\n\t\t\t//\r\n\t\t\t// That's because the .pipe() method does not automatically propagate errors\r\n\t\t\t// from a source (input) stream to the destination stream or the end of the pipeline.\r\n\t\t\t// You would need to attach an 'error' event handler to each stream in the chain.\r\n\t\t\t//\r\n\t\t\t// A more convenient alternative would be to use `stream.pipeline()` function:\r\n\t\t\t// `pipeline(stream1, stream2, (error) => { ... })`\r\n\t\t\t//\r\n\t\t\t.on('error', onError)\r\n\t\t\t// The unzipper stream is closed when all `entries` have been reported.\r\n\t\t\t.on('finish', () => {\r\n\t\t\t\tif (!errored) {\r\n\t\t\t\t\t// Wait for all `entries` to be read.\r\n\t\t\t\t\t// The second argument of `.then()` function is not required\r\n\t\t\t\t\t// but I didn't remove it just to potentially prevent any potential silly bugs\r\n\t\t\t\t\t// in case of some potential changes in some potential future.\r\n\t\t\t\t\tPromise.all(promises).then(() => {\r\n\t\t\t\t\t\tresolve(PROMISE_RESOLVE_VALUE)\r\n\t\t\t\t\t}, onError)\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.on('entry', (entry) => {\r\n\t\t\t\t// See if this file should be ignored.\r\n\t\t\t\tlet ignore = false\r\n\t\t\t\t// `entry.type` could be 'Directory' or 'File'.\r\n\t\t\t\t// Ignore anything except files.\r\n\t\t\t\tif (entry.type === 'Directory') {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\t\t\t\tif (errored) {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\t\t\t\t// `entry.vars.uncompressedSize` will be `0` for `.zip` archives\r\n\t\t\t\t// that were created in a streaming fashion.\r\n\t\t\t\t// The `const fileSizeKnown = ...` code was copy-pasted from `node-unzipper` source code:\r\n\t\t\t\t// https://github.com/ZJONSSON/node-unzipper/blob/master/lib/Open/unzip.js\r\n\t\t\t\tconst uncompressedFileSizeIsKnown = !(entry.vars.flags & 0x08) || entry.vars.compressedSize > 0\r\n\t\t\t\tconst uncompressedFileSize = uncompressedFileSizeIsKnown ? entry.vars.uncompressedSize : undefined\r\n\t\t\t\tif (onFile(entry.path, uncompressedFileSize) === false) {\r\n\t\t\t\t\tignore = true\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// If this file should be ignored.\r\n\t\t\t\tif (ignore) {\r\n\t\t\t\t\t// Call `entry.autodrain()` when you do not intend to process a specific `entry`'s raw data.\r\n\t\t\t\t\t// Otherwise, if an `entry` is not consumed (via .pipe(), .buffer(), or .autodrain()),\r\n\t\t\t\t\t// the stream will halt, preventing further file processing.\r\n\t\t\t\t\tentry.autodrain().on('error', onError)\r\n\t\t\t\t\treturn\r\n\t\t\t\t}\r\n\r\n\t\t\t\tpromises.push(new Promise((resolve) => {\r\n\t\t\t\t\t// `entry` seems to be a generic Node.js stream.\r\n\t\t\t\t\t// `entry.pipe()` pipes the file contents to a stream.\r\n\t\t\t\t\t// `entry.stream()` returns a readable stream.\r\n\t\t\t\t\t// `entry.buffer()` returns a promise that resolves to a `Buffer` with the file contents.\r\n\t\t\t\t\tentry\r\n\t\t\t\t\t\t.on('data', (data) => {\r\n\t\t\t\t\t\t\tonFileData(entry.path, data)\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t\t.on('error', (error) => {\r\n\t\t\t\t\t\t\tonError(error)\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t\t.on('finish', () => {\r\n\t\t\t\t\t\t\tonFileDataEnd(entry.path)\r\n\t\t\t\t\t\t\tresolve()\r\n\t\t\t\t\t\t})\r\n\t\t\t\t}))\r\n\t\t\t})\r\n\t})\r\n}"],"mappings":"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"}

package/node/index.cjs

@@ -2,6 +2,9 @@ exports = module.exports = require('../commonjs/export/readXlsxFileNode.js').def
 exports['default'] = require('../commonjs/export/readXlsxFileNode.js').default
 
 exports.readSheet = require('../commonjs/export/readSheetNode.js').default
+exports.InvalidInputError = require('../commonjs/xlsx/file/InvalidInputError.js').default
+exports.InvalidSpreadsheetError = require('../commonjs/xlsx/InvalidSpreadsheetError.js').default
+exports.SheetNotFoundError = require('../commonjs/xlsx/SheetNotFoundError.js').default
 
 // `parseSheetData()`
 exports.parseSheetData = require('../commonjs/parseSheetData/parseSheetData.js').default

package/node/index.d.ts

@@ -70,6 +70,22 @@ export type {
 	Schema
 } from '../types/parseSheetData/parseSheetDataSchema.d.js'
 
+export {
+	InvalidInputError
+} from '../types/InvalidInputError.d.js'
+
+export type {
+	InvalidInputErrorCode
+} from '../types/InvalidInputError.d.js'
+
+export {
+	InvalidSpreadsheetError
+} from '../types/InvalidSpreadsheetError.d.js'
+
+export {
+	SheetNotFoundError
+} from '../types/SheetNotFoundError.d.js'
+
 export default function readXlsxFile<ParsedNumber = number>(
 	input: Input,
 	options?: Options<ParsedNumber>

package/node/index.js

@@ -1,5 +1,8 @@
 export { default as default } from '../modules/export/readXlsxFileNode.js'
 export { default as readSheet } from '../modules/export/readSheetNode.js'
+export { default as InvalidInputError } from '../modules/xlsx/file/InvalidInputError.js'
+export { default as InvalidSpreadsheetError } from '../modules/xlsx/InvalidSpreadsheetError.js'
+export { default as SheetNotFoundError } from '../modules/xlsx/SheetNotFoundError.js'
 
 // `parseSheetData()`
 export { default as parseSheetData } from '../modules/parseSheetData/parseSheetData.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "read-excel-file",
-  "version": "9.3.4",
+  "version": "9.3.5",
   "description": "Read `.xlsx` files in a web browser or in Node.js",
   "type": "module",
   "exports": {
@@ -46,8 +46,9 @@
   },
   "dependencies": {
     "fflate": "^0.8.3",
-    "unzipper-esm": "^0.13.2",
-    "saxen": "^11.0.2"
+    "saxen": "^11.1.0",
+    "unzipper-esm": "^0.13.3",
+    "worker-f": "^0.1.12"
   },
   "devDependencies": {
     "@babel/cli": "^7.17.10",
@@ -59,6 +60,7 @@
     "chai": "^4.3.6",
     "core-js": "^3.22.5",
     "cross-env": "^10.1.0",
+    "libphonenumber-js": "^1.13.8",
     "mocha": "^10.0.0",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.1.3",