read-excel-file 9.2.0 → 9.3.1

package/commonjs/zip/unzipFromStream.fflate.js

@@ -6,12 +6,32 @@ Object.defineProperty(exports, "__esModule", {
 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`.
-
+var _nodeZlib = _interopRequireDefault(require("node:zlib"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } // Considerations:
+//
+// * `fflate` uses a pure-javascript implementation of `.zip` compression/decompression by default.
+//   This pure-javascript implementation is about 2x slower than Node.js's "native" `zlib` module.
+//   This issue is worked around by "marrying" `fflate` with Node.js's `zlib` "native" module through some tinkering.
+//   https://github.com/101arrowz/fflate/issues/284
+//
+// * Even though `fflate` implements a "streaming" mode of its own,
+//   it does not implement Node.js streams "contract", i.e. it just unzips the archive
+//   as fast as it can consume it from the input stream, without throttling the data throughput
+//   in cases when the input data flows faster than `fflate` can process it. This means that
+//   in the "worst case" scenario when `fflate`'s decompressor is unable to keep up with the
+//   data influx, it would "buffer" the entire `.zip` archive in RAM until it's processed.
+//   And while this is no big deal by any means, it's still not as elegant as adhering to
+//   Node.js streaming protocol.
 // This code was originally submitted by Stian Jensen.
 // https://github.com/catamphetamine/read-excel-file/pull/122
-
+// https://github.com/catamphetamine/read-excel-file/pull/123
 // 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.
@@ -36,10 +56,12 @@ var _nodeBuffer = require("node:buffer");
 //
 // 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.
+// To read a `.zip` archive, the code uses `fflate`'s `Unzip` class.
+// The actual decompression could be performed either by using
+// `fflate`'s pure-javascript `UnzipInflate` implementation, which is
+// about 2x slower than Node.js's "native" module `zlib`,
+// or it could use the aforementioned `zlib` module as a drop-in replacement
+// (with some tinkering).
 //
 // 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.
@@ -54,6 +76,24 @@ var _nodeBuffer = require("node:buffer");
 // https://github.com/101arrowz/fflate/issues/277
 // So just the regular `UnzipInflate` is used here.
 //
+// import { AsyncUnzipInflate, UnzipInflate } from 'fflate'
+// Native `zlib` is faster than `UnzipInflate`.
+// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `100 ms`
+//   when using `zlib` decompressor and `150 ms` when using `fflate` "sync" decompressor.
+// * When decompressing a `10 MB` `.xlsx` file, the decompression time is `500 ms`
+//   when using `zlib` decompressor and `650 ms` when using `fflate` "sync" decompressor.
+// * When decompressing a `50 MB` `.xlsx` file, the decompression time is `2800 ms`
+//   when using `zlib` decompressor and `3600 ms` when using `fflate` "sync" decompressor.
+var USE_ZLIB_DECOMPRESSOR = true;
+
+// `AsyncZipInflate` is faster than `UnzipInflate` for `.xlsx` files that're larger
+// than a few megabytes.
+// * When decompressing a `1 MB` `.xlsx` file, the decompression time is `150 ms`
+//   when using "sync" decompressor and `170 ms` when using "async" decompressor.
+// * When decompressing a `10 MB` `.xlsx` file, the decompression time is about the same.
+// * 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;
 
 /**
  * Reads `*.zip` file contents.
@@ -65,6 +105,31 @@ function unzipFromStream(stream) {
     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] = _nodeBuffer.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) {
   return new Promise(function (resolve, reject) {
     var errored = false;
     var onError = function onError(error) {
@@ -73,6 +138,19 @@ function unzipFromStream(stream) {
         reject(error);
       }
     };
+
+    // The native `zlib` decoder finishes inflating an entry asynchronously, so
+    // the archive's `end` event can fire while entries are still decompressing.
+    // It counts "decompression still in-progress" entries the decompression for which
+    // has started but not yet finished, and the main promise only resolves once
+    // the input stream has ended *and* every entry is done decompressing.
+    var stillDecompressingEntriesCount = 0;
+    var noMoreEntries = false;
+    var resolveIfDone = function resolveIfDone() {
+      if (!errored && noMoreEntries && stillDecompressingEntriesCount === 0) {
+        resolve(PROMISE_RESOLVE_VALUE);
+      }
+    };
     var _createZipFileValidat = createZipFileValidator(function (isValid) {
         if (!isValid) {
           onError(new Error('Invalid `.zip` archive'));
@@ -94,26 +172,22 @@ function unzipFromStream(stream) {
       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
-      })) {
+      if (onFile(entry.name) === false) {
         return;
       }
-      var chunks = [];
+      stillDecompressingEntriesCount++;
 
       // `entry.ondata` is called with each decompressed chunk of the entry,
-      // and a final time with `isLast === true` once the entry is complete.
+      // and then 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);
+        onFileData(entry.name, chunk);
         if (isLast) {
-          files[entry.name] = _nodeBuffer.Buffer.concat(chunks);
+          stillDecompressingEntriesCount--;
+          onFileDataEnd(entry.name);
+          resolveIfDone();
         }
       };
 
@@ -124,7 +198,7 @@ function unzipFromStream(stream) {
     // 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);
+    unzip.register(USE_ZLIB_DECOMPRESSOR ? NativeZlibInflate : USE_ASYNC_FFLATE_DECOMPRESSOR ? AsyncUnzipInflate : UnzipInflate);
     stream
     // Catch errors emitted from the input stream (for example, a file read error).
     .on('error', onError)
@@ -143,9 +217,15 @@ function unzipFromStream(stream) {
         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.
+      //
+      // The `.push()` function of `fflate`'s own `ZipInflate` decompressor 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.
+      //
+      // The `.push()` function of `NativeZlibInflate` decompressor is asynchronous,
+      // so it requires hacking around with the counter of "still being decompressed" entries
+      // in order to detect the actual finish of the archive's decompression process.
+      //
       try {
         unzip.push(chunk, false);
       } catch (error) {
@@ -164,8 +244,12 @@ function unzipFromStream(stream) {
         // 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);
+        // The input stream has ended.
+        noMoreEntries = true;
+        // The entries may still be decompressing asynchronously.
+        // In that case, resolve once they all finish decompresssing.
+        // Or, resolve if all entries have already finished decompressing by now.
+        resolveIfDone();
       } catch (error) {
         onError(error);
       }
@@ -206,4 +290,49 @@ function createZipFileValidator(onValidationResult) {
     }
   };
 }
+
+// An implemenation of a `DEFLATE` decompressor for `fflate`'s `Unzip` class
+// that uses Node.js's "native" module `zlib`.
+//
+// It implements `fflate`'s decoder interface: `Unzip` constructs one decoder
+// per each entry, sets `ondata(error, chunk, isLast)` callback on it, and feeds it
+// the entry's compressed bytes by calling `push(chunk, isLast)` method.
+//
+// Unlike `fflate`'s synchronous `UnzipInflate` decoder, `zlib` decompresses asynchronously,
+// so an entry only finishes some "ticks" after its last chunk of its data is `push()`ed
+// by `fflate`'s `Unzip` class. To work around this issue, pending entries counter is used
+// to track when the archive really finishes unpacking.
+//
+var NativeZlibInflate = /*#__PURE__*/function () {
+  function NativeZlibInflate() {
+    var _this = this;
+    _classCallCheck(this, NativeZlibInflate);
+    this.inflate = _nodeZlib["default"].createInflateRaw();
+    this.inflate.on('data', function (chunk) {
+      return _this.ondata(null, chunk, false);
+    });
+    this.inflate.on('end', function () {
+      return _this.ondata(null, new Uint8Array(0), true);
+    });
+    this.inflate.on('error', function (error) {
+      return _this.ondata(error, null, false);
+    });
+  }
+  _createClass(NativeZlibInflate, [{
+    key: "push",
+    value: function push(chunk, isLast) {
+      this.inflate.write(_nodeBuffer.Buffer.from(chunk));
+      if (isLast) {
+        this.inflate.end();
+      }
+    }
+  }, {
+    key: "terminate",
+    value: function terminate() {
+      this.inflate.destroy();
+    }
+  }]);
+  return NativeZlibInflate;
+}();
+_defineProperty(NativeZlibInflate, "compression", 8);
 //# sourceMappingURL=unzipFromStream.fflate.js.map

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

@@ -1 +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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"}
+{"version":3,"file":"unzipFromStream.fflate.js","names":["_fflate","require","_nodeBuffer","_nodeZlib","_interopRequireDefault","obj","__esModule","_typeof","o","Symbol","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","_toPropertyKey","key","_createClass","protoProps","staticProps","_defineProperty","value","arg","_toPrimitive","String","input","hint","prim","toPrimitive","undefined","res","call","Number","USE_ZLIB_DECOMPRESSOR","USE_ASYNC_FFLATE_DECOMPRESSOR","unzipFromStream","stream","_ref","arguments","filter","files","filesChunks","onFile","filePath","path","onFileData","chunk","push","onFileDataEnd","Buffer","concat","unzipFromStream_","then","PROMISE_RESOLVE_VALUE","Promise","resolve","reject","errored","onError","error","stillDecompressingEntriesCount","noMoreEntries","resolveIfDone","_createZipFileValidat","createZipFileValidator","isValid","Error","validateChunk","unzip","Unzip","entry","name","endsWith","ondata","isLast","start","register","NativeZlibInflate","AsyncUnzipInflate","UnzipInflate","on","Uint8Array","onValidationResult","firstBytesCount","firstBytes","firstBytesCheckResult","_this","inflate","zlib","createInflateRaw","write","from","end","terminate","destroy"],"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":";;;;;;AAgEA,IAAAA,OAAA,GAAAC,OAAA;AAGA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAC,sBAAA,CAAAH,OAAA;AAA4B,SAAAG,uBAAAC,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA;AAAA,SAAAE,QAAAC,CAAA,sCAAAD,OAAA,wBAAAE,MAAA,uBAAAA,MAAA,CAAAC,QAAA,aAAAF,CAAA,kBAAAA,CAAA,gBAAAA,CAAA,WAAAA,CAAA,yBAAAC,MAAA,IAAAD,CAAA,CAAAG,WAAA,KAAAF,MAAA,IAAAD,CAAA,KAAAC,MAAA,CAAAG,SAAA,qBAAAJ,CAAA,KAAAD,OAAA,CAAAC,CAAA;AAAA,SAAAK,gBAAAC,QAAA,EAAAC,WAAA,UAAAD,QAAA,YAAAC,WAAA,eAAAC,SAAA;AAAA,SAAAC,kBAAAC,MAAA,EAAAC,KAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAD,KAAA,CAAAE,MAAA,EAAAD,CAAA,UAAAE,UAAA,GAAAH,KAAA,CAAAC,CAAA,GAAAE,UAAA,CAAAC,UAAA,GAAAD,UAAA,CAAAC,UAAA,WAAAD,UAAA,CAAAE,YAAA,wBAAAF,UAAA,EAAAA,UAAA,CAAAG,QAAA,SAAAC,MAAA,CAAAC,cAAA,CAAAT,MAAA,EAAAU,cAAA,CAAAN,UAAA,CAAAO,GAAA,GAAAP,UAAA;AAAA,SAAAQ,aAAAf,WAAA,EAAAgB,UAAA,EAAAC,WAAA,QAAAD,UAAA,EAAAd,iBAAA,CAAAF,WAAA,CAAAH,SAAA,EAAAmB,UAAA,OAAAC,WAAA,EAAAf,iBAAA,CAAAF,WAAA,EAAAiB,WAAA,GAAAN,MAAA,CAAAC,cAAA,CAAAZ,WAAA,iBAAAU,QAAA,mBAAAV,WAAA;AAAA,SAAAkB,gBAAA5B,GAAA,EAAAwB,GAAA,EAAAK,KAAA,IAAAL,GAAA,GAAAD,cAAA,CAAAC,GAAA,OAAAA,GAAA,IAAAxB,GAAA,IAAAqB,MAAA,CAAAC,cAAA,CAAAtB,GAAA,EAAAwB,GAAA,IAAAK,KAAA,EAAAA,KAAA,EAAAX,UAAA,QAAAC,YAAA,QAAAC,QAAA,oBAAApB,GAAA,CAAAwB,GAAA,IAAAK,KAAA,WAAA7B,GAAA;AAAA,SAAAuB,eAAAO,GAAA,QAAAN,GAAA,GAAAO,YAAA,CAAAD,GAAA,oBAAA5B,OAAA,CAAAsB,GAAA,iBAAAA,GAAA,GAAAQ,MAAA,CAAAR,GAAA;AAAA,SAAAO,aAAAE,KAAA,EAAAC,IAAA,QAAAhC,OAAA,CAAA+B,KAAA,kBAAAA,KAAA,kBAAAA,KAAA,MAAAE,IAAA,GAAAF,KAAA,CAAA7B,MAAA,CAAAgC,WAAA,OAAAD,IAAA,KAAAE,SAAA,QAAAC,GAAA,GAAAH,IAAA,CAAAI,IAAA,CAAAN,KAAA,EAAAC,IAAA,oBAAAhC,OAAA,CAAAoC,GAAA,uBAAAA,GAAA,YAAA3B,SAAA,4DAAAuB,IAAA,gBAAAF,MAAA,GAAAQ,MAAA,EAAAP,KAAA,KApE5B;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;AAEA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMQ,qBAAqB,GAAG,IAAI;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMC,6BAA6B,GAAG,KAAK;;AAE3C;AACA;AACA;AACA;AACA;AACe,SAASC,eAAeA,CAACC,MAAM,EAAmB;EAAA,IAAAC,IAAA,GAAAC,SAAA,CAAA9B,MAAA,QAAA8B,SAAA,QAAAT,SAAA,GAAAS,SAAA,MAAJ,CAAC,CAAC;IAAbC,MAAM,GAAAF,IAAA,CAANE,MAAM;EACvD;EACA,IAAMC,KAAK,GAAG,CAAC,CAAC;EAChB,IAAMC,WAAW,GAAG,CAAC,CAAC;EAEtB,IAAMC,MAAM,GAAG,SAATA,MAAMA,CAAIC,QAAQ,EAAK;IAC5B;IACA;IACA;IACA,IAAIJ,MAAM,IAAI,CAACA,MAAM,CAAC;MAAEK,IAAI,EAAED;IAAS,CAAC,CAAC,EAAE;MAC1C,OAAO,KAAK;IACb;IACAF,WAAW,CAACE,QAAQ,CAAC,GAAG,EAAE;EAC3B,CAAC;EAED,IAAME,UAAU,GAAG,SAAbA,UAAUA,CAAIF,QAAQ,EAAEG,KAAK,EAAK;IACvCL,WAAW,CAACE,QAAQ,CAAC,CAACI,IAAI,CAACD,KAAK,CAAC;EAClC,CAAC;EAED,IAAME,aAAa,GAAG,SAAhBA,aAAaA,CAAIL,QAAQ,EAAK;IACnCH,KAAK,CAACG,QAAQ,CAAC,GAAGM,kBAAM,CAACC,MAAM,CAACT,WAAW,CAACE,QAAQ,CAAC,CAAC;IACtD,OAAOF,WAAW,CAACE,QAAQ,CAAC;EAC7B,CAAC;EAED,OAAOQ,gBAAgB,CAACf,MAAM,EAAEM,MAAM,EAAEG,UAAU,EAAEG,aAAa,CAAC,CAACI,IAAI,CAAC,YAAM;IAC7E,OAAOZ,KAAK;EACb,CAAC,CAAC;AACH;AAEA,IAAMa,qBAAqB,GAAGxB,SAAS;AAEvC,SAASsB,gBAAgBA,CAACf,MAAM,EAAEM,MAAM,EAAEG,UAAU,EAAEG,aAAa,EAAE;EACpE,OAAO,IAAIM,OAAO,CAAC,UAACC,OAAO,EAAEC,MAAM,EAAK;IACvC,IAAIC,OAAO,GAAG,KAAK;IAEnB,IAAMC,OAAO,GAAG,SAAVA,OAAOA,CAAIC,KAAK,EAAK;MAC1B,IAAI,CAACF,OAAO,EAAE;QACbA,OAAO,GAAG,IAAI;QACdD,MAAM,CAACG,KAAK,CAAC;MACd;IACD,CAAC;;IAED;IACA;IACA;IACA;IACA;IACA,IAAIC,8BAA8B,GAAG,CAAC;IACtC,IAAIC,aAAa,GAAG,KAAK;IACzB,IAAMC,aAAa,GAAG,SAAhBA,aAAaA,CAAA,EAAS;MAC3B,IAAI,CAACL,OAAO,IAAII,aAAa,IAAID,8BAA8B,KAAK,CAAC,EAAE;QACtEL,OAAO,CAACF,qBAAqB,CAAC;MAC/B;IACD,CAAC;IAED,IAAAU,qBAAA,GAA0BC,sBAAsB,CAAC,UAACC,OAAO,EAAK;QAC7D,IAAI,CAACA,OAAO,EAAE;UACbP,OAAO,CAAC,IAAIQ,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC7C;MACD,CAAC,CAAC;MAJMC,aAAa,GAAAJ,qBAAA,CAAbI,aAAa;;IAMrB;IACA;IACA,IAAMC,KAAK,GAAG,IAAIC,aAAK,CAAC,UAACC,KAAK,EAAK;MAClC;MACA;MACA,IAAIb,OAAO,EAAE;QACZ;MACD;;MAEA;MACA;MACA,IAAIa,KAAK,CAACC,IAAI,CAACC,QAAQ,CAAC,GAAG,CAAC,EAAE;QAC7B;MACD;MAEA,IAAI9B,MAAM,CAAC4B,KAAK,CAACC,IAAI,CAAC,KAAK,KAAK,EAAE;QACjC;MACD;MAEAX,8BAA8B,EAAE;;MAEhC;MACA;MACAU,KAAK,CAACG,MAAM,GAAG,UAACd,KAAK,EAAEb,KAAK,EAAE4B,MAAM,EAAK;QACxC,IAAIf,KAAK,EAAE;UACV,OAAOD,OAAO,CAACC,KAAK,CAAC;QACtB;QACAd,UAAU,CAACyB,KAAK,CAACC,IAAI,EAAEzB,KAAK,CAAC;QAC7B,IAAI4B,MAAM,EAAE;UACXd,8BAA8B,EAAE;UAChCZ,aAAa,CAACsB,KAAK,CAACC,IAAI,CAAC;UACzBT,aAAa,CAAC,CAAC;QAChB;MACD,CAAC;;MAED;MACAQ,KAAK,CAACK,KAAK,CAAC,CAAC;IACd,CAAC,CAAC;;IAEF;IACA;IACA;IACAP,KAAK,CAACQ,QAAQ,CAAC3C,qBAAqB,GAAG4C,iBAAiB,GAAI3C,6BAA6B,GAAG4C,iBAAiB,GAAGC,YAAa,CAAC;IAE9H3C;IACC;IAAA,CACC4C,EAAE,CAAC,OAAO,EAAEtB,OAAO;IACpB;IAAA,CACCsB,EAAE,CAAC,MAAM,EAAE,UAAClC,KAAK,EAAK;MACtB;MACA;MACA,IAAIW,OAAO,EAAE;QACZ;MACD;MACA;MACAU,aAAa,CAACrB,KAAK,CAAC;MACpB;MACA;MACA,IAAIW,OAAO,EAAE;QACZ;MACD;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAI;QACHW,KAAK,CAACrB,IAAI,CAACD,KAAK,EAAE,KAAK,CAAC;MACzB,CAAC,CAAC,OAAOa,KAAK,EAAE;QACfD,OAAO,CAACC,KAAK,CAAC;MACf;IACD,CAAC;IACD;IACA;IAAA,CACCqB,EAAE,CAAC,KAAK,EAAE,YAAM;MAChB;MACA;MACA,IAAIvB,OAAO,EAAE;QACZ;MACD;MACA,IAAI;QACH;QACA;QACAW,KAAK,CAACrB,IAAI,CAAC,IAAIkC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;QACnC;QACApB,aAAa,GAAG,IAAI;QACpB;QACA;QACA;QACAC,aAAa,CAAC,CAAC;MAChB,CAAC,CAAC,OAAOH,KAAK,EAAE;QACfD,OAAO,CAACC,KAAK,CAAC;MACf;IACD,CAAC,CAAC;EACJ,CAAC,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASK,sBAAsBA,CAACkB,kBAAkB,EAAE;EACnD,IAAMC,eAAe,GAAG,CAAC;EACzB,IAAMC,UAAU,GAAG,EAAE;EACrB,IAAIC,qBAAqB;EACzB,OAAO;IACNlB,aAAa,WAAAA,cAACrB,KAAK,EAAE;MACpB,IAAIsC,UAAU,CAAC5E,MAAM,GAAG,CAAC,EAAE;QAC1B,IAAID,CAAC,GAAG,CAAC;QACT,OAAOA,CAAC,GAAGuC,KAAK,CAACtC,MAAM,IAAID,CAAC,GAAG4E,eAAe,EAAE;UAC/CC,UAAU,CAACrC,IAAI,CAACD,KAAK,CAACvC,CAAC,CAAC,CAAC;UACzBA,CAAC,EAAE;QACJ;QACA,IAAI6E,UAAU,CAAC5E,MAAM,KAAK,CAAC,EAAE;UAC5B,IAAMyD,OAAO,GAAGmB,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,IAAIA,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI;UAChEF,kBAAkB,CAACjB,OAAO,CAAC;QAC5B;MACD;IACD;EACD,CAAC;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA,IACMY,iBAAiB;EAGtB,SAAAA,kBAAA,EAAc;IAAA,IAAAS,KAAA;IAAAtF,eAAA,OAAA6E,iBAAA;IACb,IAAI,CAACU,OAAO,GAAGC,oBAAI,CAACC,gBAAgB,CAAC,CAAC;IACtC,IAAI,CAACF,OAAO,CAACP,EAAE,CAAC,MAAM,EAAE,UAAClC,KAAK;MAAA,OAAKwC,KAAI,CAACb,MAAM,CAAC,IAAI,EAAE3B,KAAK,EAAE,KAAK,CAAC;IAAA,EAAC;IACnE,IAAI,CAACyC,OAAO,CAACP,EAAE,CAAC,KAAK,EAAE;MAAA,OAAMM,KAAI,CAACb,MAAM,CAAC,IAAI,EAAE,IAAIQ,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;IAAA,EAAC;IACxE,IAAI,CAACM,OAAO,CAACP,EAAE,CAAC,OAAO,EAAE,UAACrB,KAAK;MAAA,OAAK2B,KAAI,CAACb,MAAM,CAACd,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAAA,EAAC;EACrE;EAAC1C,YAAA,CAAA4D,iBAAA;IAAA7D,GAAA;IAAAK,KAAA,EAED,SAAA0B,KAAKD,KAAK,EAAE4B,MAAM,EAAE;MACnB,IAAI,CAACa,OAAO,CAACG,KAAK,CAACzC,kBAAM,CAAC0C,IAAI,CAAC7C,KAAK,CAAC,CAAC;MACtC,IAAI4B,MAAM,EAAE;QACX,IAAI,CAACa,OAAO,CAACK,GAAG,CAAC,CAAC;MACnB;IACD;EAAC;IAAA5E,GAAA;IAAAK,KAAA,EAED,SAAAwE,UAAA,EAAY;MACX,IAAI,CAACN,OAAO,CAACO,OAAO,CAAC,CAAC;IACvB;EAAC;EAAA,OAAAjB,iBAAA;AAAA;AAAAzD,eAAA,CAnBIyD,iBAAiB,iBACD,CAAC"}

package/commonjs/zip/unzipFromStream.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"unzipFromStream.js","names":["_unzipFromStreamUnzipper","_interopRequireDefault","require","obj","__esModule"],"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":";;;;;;;;;;;AAkEA,IAAAA,wBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAkE,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA"}

package/commonjs/zip/unzipFromStream.unzipper.js

@@ -6,25 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = unzipFromStream;
 var _unzipperEsm = require("unzipper-esm");
 var _buffer = require("buffer");
-// `unzipper` uses Node.js native `zlib` module.
-// This means that most likely it's more performant than an equivalent javascript-only implementation.
-
-// `unzipper` has a bug — it is written in CommonJS and uses a conditional `require()` call
-// to create an AWS S3 client instance: `require('@aws-sdk/client-s3')`.
-// https://github.com/ZJONSSON/node-unzipper/issues/330
-// The author of the package refuses to acknowledge the issue and apply a simple fix.
-// The package, therefore, looks like an "abandonware".
-// Someone could easily fix the issue though by forking the package.
+// Considerations:
 //
-// When not forking to apply the fix, a workaround could be to install "@aws-sdk/client-s3"
-// package manually, which introduces unnecessary complexity and "esoteric knowledge" to the application setup.
+// * `unzipper` unpacks a `.zip` file using Node.js's "native" `zlib` module.
+//   This means that it's more performant than any equivalent pure-javascript decompressor.
 //
-// Another workaround could be to "alias" "@aws-sdk/client-s3" package in a "bundler" configuration file
-// with a path to a `*.js` file containing just "export default null". But that kind of a workaround would also
-// result in errors when using other packages that happen to `import` anything from "@aws-sdk/client-s3" package,
-// so it's not really a workaround but more of a ticking bomb. Not to mention that it introduces
-// unnecessary complexity and "esoteric knowledge" to the application setup.
+// * `unzipper` is a true "streaming" unpacker: it works in a "pull" fashion rather than a "push" one.
+//   New chunks of archived data are only read and decompressed as the receiver is ready to process them.
 //
+// * `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.
 
 /**
  * Reads `*.zip` file contents.
@@ -36,6 +27,31 @@ function unzipFromStream(stream) {
     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.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) {
   return new Promise(function (resolve, reject) {
     var promises = [];
     var errored = false;
@@ -76,7 +92,7 @@ function unzipFromStream(stream) {
         // but I didn't remove it just to potentially prevent any potential silly bugs
         // in case of some potential changes in some potential future.
         Promise.all(promises).then(function () {
-          resolve(files);
+          resolve(PROMISE_RESOLVE_VALUE);
         }, onError);
       }
     }).on('entry', function (entry) {
@@ -90,12 +106,8 @@ function unzipFromStream(stream) {
       if (errored) {
         ignore = true;
       }
-      if (filter) {
-        if (!filter({
-          path: entry.path
-        })) {
-          ignore = true;
-        }
+      if (onFile(entry.path) === false) {
+        ignore = true;
       }
 
       // If this file should be ignored.
@@ -106,18 +118,17 @@ function unzipFromStream(stream) {
         entry.autodrain().on('error', onError);
         return;
       }
-      var chunks = [];
       promises.push(new Promise(function (resolve) {
         // `entry` seems to be a generic Node.js stream.
         // `entry.pipe()` pipes the file contents to a stream.
         // `entry.stream()` returns a readable stream.
         // `entry.buffer()` returns a promise that resolves to a `Buffer` with the file contents.
         entry.on('data', function (data) {
-          chunks.push(data);
+          onFileData(entry.path, data);
         }).on('error', function (error) {
           onError(error);
         }).on('finish', function () {
-          files[entry.path] = _buffer.Buffer.concat(chunks);
+          onFileDataEnd(entry.path);
           resolve();
         });
       }));

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

@@ -1 +1 @@
-{"version":3,"file":"unzipFromStream.unzipper.js","names":["_unzipperEsm","require","_buffer","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","Promise","resolve","reject","promises","errored","onError","error","on","pipe","Parse","all","then","entry","ignore","type","path","autodrain","chunks","push","data","Buffer","concat"],"sources":["../../source/zip/unzipFromStream.unzipper.js"],"sourcesContent":["// `unzipper` uses Node.js native `zlib` module.\r\n// This means that most likely it's more performant than an equivalent javascript-only implementation.\r\n\r\n// `unzipper` has a bug — it is written in CommonJS and uses a conditional `require()` call\r\n// to create an AWS S3 client instance: `require('@aws-sdk/client-s3')`.\r\n// https://github.com/ZJONSSON/node-unzipper/issues/330\r\n// The author of the package refuses to acknowledge the issue and apply a simple fix.\r\n// The package, therefore, looks like an \"abandonware\".\r\n// Someone could easily fix the issue though by forking the package.\r\n//\r\n// When not forking to apply the fix, a workaround could be to install \"@aws-sdk/client-s3\"\r\n// package manually, which introduces unnecessary complexity and \"esoteric knowledge\" to the application setup.\r\n//\r\n// Another workaround could be to \"alias\" \"@aws-sdk/client-s3\" package in a \"bundler\" configuration file\r\n// with a path to a `*.js` file containing just \"export default null\". But that kind of a workaround would also\r\n// result in errors when using other packages that happen to `import` anything from \"@aws-sdk/client-s3\" package,\r\n// so it's not really a workaround but more of a ticking bomb. Not to mention that it introduces\r\n// unnecessary complexity and \"esoteric knowledge\" to the application setup.\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\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(files)\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 (filter) {\r\n\t\t\t\t\tif (!filter({ path: entry.path })) {\r\n\t\t\t\t\t\tignore = true\r\n\t\t\t\t\t}\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\tconst chunks = []\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\tchunks.push(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\tfiles[entry.path] = Buffer.concat(chunks)\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":["_unzipperEsm","require","_buffer","unzipFromStream","stream","_ref","arguments","length","undefined","filter","files","filesChunks","onFile","filePath","path","onFileData","chunk","push","onFileDataEnd","Buffer","concat","unzipFromStream_","then","PROMISE_RESOLVE_VALUE","Promise","resolve","reject","promises","errored","onError","error","on","pipe","Parse","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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"}

package/modules/export/convertValuesFromUint8ArraysToStrings.js

@@ -1,10 +1,12 @@
 import { strFromU8 } from 'fflate';
+import checkpoint from '../utility/checkpoint.js';
 
 /**
  * @param {Record<string,Uint8Array} entries
  * @returns {Record<string,string>}
  */
 export default function convertValuesFromUint8ArraysToStrings(entries) {
+  checkpoint('convert files to strings');
   var convertedEntries = {};
   for (var _i = 0, _Object$keys = Object.keys(entries); _i < _Object$keys.length; _i++) {
     var key = _Object$keys[_i];

package/modules/export/convertValuesFromUint8ArraysToStrings.js.map

@@ -1 +1 @@
-{"version":3,"file":"convertValuesFromUint8ArraysToStrings.js","names":["strFromU8","convertValuesFromUint8ArraysToStrings","entries","convertedEntries","_i","_Object$keys","Object","keys","length","key"],"sources":["../../source/export/convertValuesFromUint8ArraysToStrings.js"],"sourcesContent":["import { strFromU8 } from 'fflate'\r\n\r\n/**\r\n * @param {Record<string,Uint8Array} entries\r\n * @returns {Record<string,string>}\r\n */\r\nexport default function convertValuesFromUint8ArraysToStrings(entries) {\r\n\tconst convertedEntries = {}\r\n\tfor (const key of Object.keys(entries)) {\r\n\t\tconvertedEntries[key] = strFromU8(entries[key])\r\n\t}\r\n\treturn convertedEntries\r\n}"],"mappings":"AAAA,SAASA,SAAS,QAAQ,QAAQ;;AAElC;AACA;AACA;AACA;AACA,eAAe,SAASC,qCAAqCA,CAACC,OAAO,EAAE;EACtE,IAAMC,gBAAgB,GAAG,CAAC,CAAC;EAC3B,SAAAC,EAAA,MAAAC,YAAA,GAAkBC,MAAM,CAACC,IAAI,CAACL,OAAO,CAAC,EAAAE,EAAA,GAAAC,YAAA,CAAAG,MAAA,EAAAJ,EAAA,IAAE;IAAnC,IAAMK,GAAG,GAAAJ,YAAA,CAAAD,EAAA;IACbD,gBAAgB,CAACM,GAAG,CAAC,GAAGT,SAAS,CAACE,OAAO,CAACO,GAAG,CAAC,CAAC;EAChD;EACA,OAAON,gBAAgB;AACxB"}
+{"version":3,"file":"convertValuesFromUint8ArraysToStrings.js","names":["strFromU8","checkpoint","convertValuesFromUint8ArraysToStrings","entries","convertedEntries","_i","_Object$keys","Object","keys","length","key"],"sources":["../../source/export/convertValuesFromUint8ArraysToStrings.js"],"sourcesContent":["import { strFromU8 } from 'fflate'\r\n\r\nimport checkpoint from '../utility/checkpoint.js'\r\n\r\n/**\r\n * @param {Record<string,Uint8Array} entries\r\n * @returns {Record<string,string>}\r\n */\r\nexport default function convertValuesFromUint8ArraysToStrings(entries) {\r\n\tcheckpoint('convert files to strings')\r\n\tconst convertedEntries = {}\r\n\tfor (const key of Object.keys(entries)) {\r\n\t\tconvertedEntries[key] = strFromU8(entries[key])\r\n\t}\r\n\treturn convertedEntries\r\n}"],"mappings":"AAAA,SAASA,SAAS,QAAQ,QAAQ;AAElC,OAAOC,UAAU,MAAM,0BAA0B;;AAEjD;AACA;AACA;AACA;AACA,eAAe,SAASC,qCAAqCA,CAACC,OAAO,EAAE;EACtEF,UAAU,CAAC,0BAA0B,CAAC;EACtC,IAAMG,gBAAgB,GAAG,CAAC,CAAC;EAC3B,SAAAC,EAAA,MAAAC,YAAA,GAAkBC,MAAM,CAACC,IAAI,CAACL,OAAO,CAAC,EAAAE,EAAA,GAAAC,YAAA,CAAAG,MAAA,EAAAJ,EAAA,IAAE;IAAnC,IAAMK,GAAG,GAAAJ,YAAA,CAAAD,EAAA;IACbD,gBAAgB,CAACM,GAAG,CAAC,GAAGV,SAAS,CAACG,OAAO,CAACO,GAAG,CAAC,CAAC;EAChD;EACA,OAAON,gBAAgB;AACxB"}

package/modules/export/parseSheet.js

@@ -9,19 +9,22 @@ import parseSheetData from '../parseSheetData/parseSheetData.js';
 
 /**
  * Reads data from a single sheet of an `.xlsx` file as an array of rows (which are arrays of cells) or as an array of objects (if `options.schema` was passed).
+ * @param  {function} [createWorkerFunction] — Creates a worker function.
+ * @param  {function} parseXmlStream — SAX XML parser.
  * @param  {Record<string,string>} contents - A map of `.xml` files inside the `.xlsx` file (which itself is just a zipped directory).
- * @param  {object} xml — An object having a single property — `createDocument(string)` function.
  * @param  {string|number} [sheet] — Sheet name or number.
  * @param  {object} [options]
- * @return {Sheet[]}
+ * @return {Promise<SheetData>}
  */
-export default function parseSheet(contents, xml, sheet, options) {
-  var data = parseSpreadsheetContents(contents, xml, _objectSpread(_objectSpread({}, options), {}, {
+export default function parseSheet(createWorkerFunction, parseXmlStream, contents, sheet, options) {
+  return parseSpreadsheetContents(createWorkerFunction, parseXmlStream, contents, _objectSpread(_objectSpread({}, options), {}, {
     sheets: [sheet === undefined ? 1 : sheet]
-  }))[0].data;
-  if (options && options.schema) {
-    return parseSheetData(data, options.schema);
-  }
-  return data;
+  })).then(function (sheets) {
+    var sheetData = sheets[0].data;
+    if (options && options.schema) {
+      return parseSheetData(sheetData, options.schema);
+    }
+    return sheetData;
+  });
 }
 //# sourceMappingURL=parseSheet.js.map

package/modules/export/parseSheet.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseSheet.js","names":["parseSpreadsheetContents","parseSheetData","parseSheet","contents","xml","sheet","options","data","_objectSpread","sheets","undefined","schema"],"sources":["../../source/export/parseSheet.js"],"sourcesContent":["import parseSpreadsheetContents from '../xlsx/parseSpreadsheetContents.js'\r\nimport parseSheetData from '../parseSheetData/parseSheetData.js'\r\n\r\n/**\r\n * Reads data from a single sheet of an `.xlsx` file as an array of rows (which are arrays of cells) or as an array of objects (if `options.schema` was passed).\r\n * @param  {Record<string,string>} contents - A map of `.xml` files inside the `.xlsx` file (which itself is just a zipped directory).\r\n * @param  {object} xml — An object having a single property — `createDocument(string)` function.\r\n * @param  {string|number} [sheet] — Sheet name or number.\r\n * @param  {object} [options]\r\n * @return {Sheet[]}\r\n */\r\nexport default function parseSheet(contents, xml, sheet, options) {\r\n\tconst { data } = parseSpreadsheetContents(contents, xml, {\r\n\t\t...options,\r\n\t\tsheets: [sheet === undefined ? 1 : sheet]\r\n\t})[0]\r\n\r\n\tif (options && options.schema) {\r\n\t\treturn parseSheetData(data, options.schema)\r\n\t}\r\n\r\n\treturn data\r\n}"],"mappings":";;;;;;AAAA,OAAOA,wBAAwB,MAAM,qCAAqC;AAC1E,OAAOC,cAAc,MAAM,qCAAqC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,UAAUA,CAACC,QAAQ,EAAEC,GAAG,EAAEC,KAAK,EAAEC,OAAO,EAAE;EACjE,IAAQC,IAAI,GAAKP,wBAAwB,CAACG,QAAQ,EAAEC,GAAG,EAAAI,aAAA,CAAAA,aAAA,KACnDF,OAAO;IACVG,MAAM,EAAE,CAACJ,KAAK,KAAKK,SAAS,GAAG,CAAC,GAAGL,KAAK;EAAC,EACzC,CAAC,CAAC,CAAC,CAAC,CAHGE,IAAI;EAKZ,IAAID,OAAO,IAAIA,OAAO,CAACK,MAAM,EAAE;IAC9B,OAAOV,cAAc,CAACM,IAAI,EAAED,OAAO,CAACK,MAAM,CAAC;EAC5C;EAEA,OAAOJ,IAAI;AACZ"}
+{"version":3,"file":"parseSheet.js","names":["parseSpreadsheetContents","parseSheetData","parseSheet","createWorkerFunction","parseXmlStream","contents","sheet","options","_objectSpread","sheets","undefined","then","sheetData","data","schema"],"sources":["../../source/export/parseSheet.js"],"sourcesContent":["import parseSpreadsheetContents from '../xlsx/parseSpreadsheetContents.js'\r\nimport parseSheetData from '../parseSheetData/parseSheetData.js'\r\n\r\n/**\r\n * Reads data from a single sheet of an `.xlsx` file as an array of rows (which are arrays of cells) or as an array of objects (if `options.schema` was passed).\r\n * @param  {function} [createWorkerFunction] — Creates a worker function.\r\n * @param  {function} parseXmlStream — SAX XML parser.\r\n * @param  {Record<string,string>} contents - A map of `.xml` files inside the `.xlsx` file (which itself is just a zipped directory).\r\n * @param  {string|number} [sheet] — Sheet name or number.\r\n * @param  {object} [options]\r\n * @return {Promise<SheetData>}\r\n */\r\nexport default function parseSheet(createWorkerFunction, parseXmlStream, contents, sheet, options) {\r\n\treturn parseSpreadsheetContents(createWorkerFunction, parseXmlStream, contents, {\r\n\t\t...options,\r\n\t\tsheets: [sheet === undefined ? 1 : sheet],\r\n\t}).then((sheets) => {\r\n\t\tconst sheetData = sheets[0].data\r\n\t\tif (options && options.schema) {\r\n\t\t\treturn parseSheetData(sheetData, options.schema)\r\n\t\t}\r\n\t\treturn sheetData\r\n\t})\r\n}"],"mappings":";;;;;;AAAA,OAAOA,wBAAwB,MAAM,qCAAqC;AAC1E,OAAOC,cAAc,MAAM,qCAAqC;;AAEhE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,UAAUA,CAACC,oBAAoB,EAAEC,cAAc,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,OAAO,EAAE;EAClG,OAAOP,wBAAwB,CAACG,oBAAoB,EAAEC,cAAc,EAAEC,QAAQ,EAAAG,aAAA,CAAAA,aAAA,KAC1ED,OAAO;IACVE,MAAM,EAAE,CAACH,KAAK,KAAKI,SAAS,GAAG,CAAC,GAAGJ,KAAK;EAAC,EACzC,CAAC,CAACK,IAAI,CAAC,UAACF,MAAM,EAAK;IACnB,IAAMG,SAAS,GAAGH,MAAM,CAAC,CAAC,CAAC,CAACI,IAAI;IAChC,IAAIN,OAAO,IAAIA,OAAO,CAACO,MAAM,EAAE;MAC9B,OAAOb,cAAc,CAACW,SAAS,EAAEL,OAAO,CAACO,MAAM,CAAC;IACjD;IACA,OAAOF,SAAS;EACjB,CAAC,CAAC;AACH"}