read-excel-file 9.1.1 → 9.3.0

package/modules/xlsx/parseSharedStrings.js

@@ -1,8 +1,49 @@
-import { getSharedStrings } from '../xml/xlsx.js';
-export default function parseSharedStrings(content, xml) {
-  if (!content) {
-    return [];
+import { onOpenTagInSharedString, onCloseTagInSharedString, onTextInSharedString, createInitialStateInSharedString } from './parseSharedString.js';
+
+/**
+ * Parses `sharedStrings.xml` file.
+ * @param {string} content
+ * @param {function} parseXmlStream — SAX XML parser.
+ * @returns {Promise<string[]>}
+ */
+export default function parseSharedStrings(content, parseXmlStream) {
+  return parseXmlStream(content, {
+    createInitialState: createInitialStateInSharedStrings,
+    onOpenTag: onOpenTagInSharedStrings,
+    onCloseTag: onCloseTagInSharedStrings,
+    onText: onTextInSharedStrings
+  }).then(function (state) {
+    return state.strings;
+  });
+}
+function createInitialStateInSharedStrings() {
+  return {
+    si: undefined,
+    strings: []
+  };
+}
+
+// In an XLSX `sharedStrings.xml` file, a <si/> (string item) element can have
+// either a single child <t/> element (meaning that "rich formatting" is not used)
+// or multiple child <r/> elements (meaning that "rich formatting" is used).
+function onOpenTagInSharedStrings(tagName, attributes, state) {
+  if (tagName === 'si') {
+    state.si = createInitialStateInSharedString();
+  } else if (state.si) {
+    onOpenTagInSharedString(tagName, attributes, state.si);
+  }
+}
+function onCloseTagInSharedStrings(tagName, state) {
+  if (tagName === 'si') {
+    state.strings.push(state.si.string);
+    state.si = undefined;
+  } else if (state.si) {
+    onCloseTagInSharedString(tagName, state.si);
+  }
+}
+function onTextInSharedStrings(text, state) {
+  if (state.si) {
+    onTextInSharedString(text, state.si);
   }
-  return getSharedStrings(xml.createDocument(content));
 }
 //# sourceMappingURL=parseSharedStrings.js.map

package/modules/xlsx/parseSharedStrings.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseSharedStrings.js","names":["getSharedStrings","parseSharedStrings","content","xml","createDocument"],"sources":["../../source/xlsx/parseSharedStrings.js"],"sourcesContent":["import {\r\n  getSharedStrings\r\n} from '../xml/xlsx.js'\r\n\r\nexport default function parseSharedStrings(content, xml) {\r\n  if (!content) {\r\n    return []\r\n  }\r\n  return getSharedStrings(xml.createDocument(content))\r\n}"],"mappings":"AAAA,SACEA,gBAAgB,QACX,gBAAgB;AAEvB,eAAe,SAASC,kBAAkBA,CAACC,OAAO,EAAEC,GAAG,EAAE;EACvD,IAAI,CAACD,OAAO,EAAE;IACZ,OAAO,EAAE;EACX;EACA,OAAOF,gBAAgB,CAACG,GAAG,CAACC,cAAc,CAACF,OAAO,CAAC,CAAC;AACtD"}
+{"version":3,"file":"parseSharedStrings.js","names":["onOpenTagInSharedString","onCloseTagInSharedString","onTextInSharedString","createInitialStateInSharedString","parseSharedStrings","content","parseXmlStream","createInitialState","createInitialStateInSharedStrings","onOpenTag","onOpenTagInSharedStrings","onCloseTag","onCloseTagInSharedStrings","onText","onTextInSharedStrings","then","state","strings","si","undefined","tagName","attributes","push","string","text"],"sources":["../../source/xlsx/parseSharedStrings.js"],"sourcesContent":["import {\r\n  onOpenTagInSharedString,\r\n  onCloseTagInSharedString,\r\n  onTextInSharedString,\r\n  createInitialStateInSharedString\r\n} from './parseSharedString.js'\r\n\r\n/**\r\n * Parses `sharedStrings.xml` file.\r\n * @param {string} content\r\n * @param {function} parseXmlStream — SAX XML parser.\r\n * @returns {Promise<string[]>}\r\n */\r\nexport default function parseSharedStrings(content, parseXmlStream) {\r\n  return parseXmlStream(content, {\r\n    createInitialState: createInitialStateInSharedStrings,\r\n    onOpenTag: onOpenTagInSharedStrings,\r\n    onCloseTag: onCloseTagInSharedStrings,\r\n    onText: onTextInSharedStrings\r\n  }).then((state) => {\r\n    return state.strings\r\n  })\r\n}\r\n\r\nfunction createInitialStateInSharedStrings() {\r\n  return {\r\n    si: undefined,\r\n    strings: []\r\n  }\r\n}\r\n\r\n// In an XLSX `sharedStrings.xml` file, a <si/> (string item) element can have\r\n// either a single child <t/> element (meaning that \"rich formatting\" is not used)\r\n// or multiple child <r/> elements (meaning that \"rich formatting\" is used).\r\nfunction onOpenTagInSharedStrings(tagName, attributes, state) {\r\n  if (tagName === 'si') {\r\n    state.si = createInitialStateInSharedString()\r\n  } else if (state.si) {\r\n    onOpenTagInSharedString(tagName, attributes, state.si)\r\n  }\r\n}\r\n\r\nfunction onCloseTagInSharedStrings(tagName, state) {\r\n  if (tagName === 'si') {\r\n    state.strings.push(state.si.string)\r\n    state.si = undefined\r\n  } else if (state.si) {\r\n    onCloseTagInSharedString(tagName, state.si)\r\n  }\r\n}\r\n\r\nfunction onTextInSharedStrings(text, state) {\r\n  if (state.si) {\r\n    onTextInSharedString(text, state.si)\r\n  }\r\n}"],"mappings":"AAAA,SACEA,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,gCAAgC,QAC3B,wBAAwB;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,kBAAkBA,CAACC,OAAO,EAAEC,cAAc,EAAE;EAClE,OAAOA,cAAc,CAACD,OAAO,EAAE;IAC7BE,kBAAkB,EAAEC,iCAAiC;IACrDC,SAAS,EAAEC,wBAAwB;IACnCC,UAAU,EAAEC,yBAAyB;IACrCC,MAAM,EAAEC;EACV,CAAC,CAAC,CAACC,IAAI,CAAC,UAACC,KAAK,EAAK;IACjB,OAAOA,KAAK,CAACC,OAAO;EACtB,CAAC,CAAC;AACJ;AAEA,SAAST,iCAAiCA,CAAA,EAAG;EAC3C,OAAO;IACLU,EAAE,EAAEC,SAAS;IACbF,OAAO,EAAE;EACX,CAAC;AACH;;AAEA;AACA;AACA;AACA,SAASP,wBAAwBA,CAACU,OAAO,EAAEC,UAAU,EAAEL,KAAK,EAAE;EAC5D,IAAII,OAAO,KAAK,IAAI,EAAE;IACpBJ,KAAK,CAACE,EAAE,GAAGf,gCAAgC,CAAC,CAAC;EAC/C,CAAC,MAAM,IAAIa,KAAK,CAACE,EAAE,EAAE;IACnBlB,uBAAuB,CAACoB,OAAO,EAAEC,UAAU,EAAEL,KAAK,CAACE,EAAE,CAAC;EACxD;AACF;AAEA,SAASN,yBAAyBA,CAACQ,OAAO,EAAEJ,KAAK,EAAE;EACjD,IAAII,OAAO,KAAK,IAAI,EAAE;IACpBJ,KAAK,CAACC,OAAO,CAACK,IAAI,CAACN,KAAK,CAACE,EAAE,CAACK,MAAM,CAAC;IACnCP,KAAK,CAACE,EAAE,GAAGC,SAAS;EACtB,CAAC,MAAM,IAAIH,KAAK,CAACE,EAAE,EAAE;IACnBjB,wBAAwB,CAACmB,OAAO,EAAEJ,KAAK,CAACE,EAAE,CAAC;EAC7C;AACF;AAEA,SAASJ,qBAAqBA,CAACU,IAAI,EAAER,KAAK,EAAE;EAC1C,IAAIA,KAAK,CAACE,EAAE,EAAE;IACZhB,oBAAoB,CAACsB,IAAI,EAAER,KAAK,CAACE,EAAE,CAAC;EACtC;AACF"}

package/modules/xlsx/parseSheet.js

@@ -1,14 +1,96 @@
-import parseCells from './parseCells.js';
-import parseSheetDimensions from './parseSheetDimensions.js';
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import parseSheetData, { createInitialStateInSheetData, onOpenTagInSheetData, onCloseTagInSheetData, onTextInSheetData } from './parseSheetData.js';
+import parseCellAddress from './parseCellAddress.js';
 import reconstructSheetDimensionsFromSheetCells from './reconstructSheetDimensionsFromSheetCells.js';
 import convertSheetToData2dArray from './convertCellsToData2dArray.js';
-export default function parseSheet(content, xml, sharedStrings, styles, epoch1904, options) {
-  var sheetDocument = xml.createDocument(content);
-  var cells = parseCells(sheetDocument, sharedStrings, styles, epoch1904, options);
 
-  // `dimensions` defines the spreadsheet area enclosing all non-empty cells.
-  // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1
-  var dimensions = parseSheetDimensions(sheetDocument) || reconstructSheetDimensionsFromSheetCells(cells);
-  return convertSheetToData2dArray(cells, dimensions);
+/**
+ * Parses a `sheet.xml` file.
+ * @param {string} content
+ * @param {function} parseXmlStream — SAX XML parser.
+ * @param {object} options
+ * @returns {Promise<SheetData>}
+ */
+export default function parseSheet(content, parseXmlStream, _ref) {
+  var sharedStrings = _ref.sharedStrings,
+    styles = _ref.styles,
+    epoch1904 = _ref.epoch1904,
+    options = _ref.options;
+  // When XML parser is finished, it returns a `state`
+  // where it has accumulated the cells it encountered during parsing.
+  // `getSheetData()` function reads the parser `state` and transforms it to `SheetData`.
+  var getSheetData = function getSheetData(state) {
+    var cells = parseSheetData(state.sheetData, sharedStrings, styles, epoch1904, options);
+    var dimensions = state.dimension ? parseSheetDimensionRef(state.dimension) : reconstructSheetDimensionsFromSheetCells(cells);
+    return convertSheetToData2dArray(cells, dimensions);
+  };
+  return parseXmlStream(content, {
+    createInitialState: createInitialStateInSheet,
+    onOpenTag: onOpenTagInSheet,
+    onCloseTag: onCloseTagInSheet,
+    onText: onTextInSheet
+  }).then(function (state) {
+    return getSheetData(state);
+  });
+}
+function createInitialStateInSheet() {
+  return {
+    dimension: undefined,
+    sheetData: undefined
+  };
+}
+function onOpenTagInSheet(tagName, attributes, state) {
+  if (tagName === 'dimension') {
+    state.dimension = attributes.ref;
+  } else if (tagName === 'sheetData') {
+    state.sheetData = createInitialStateInSheetData();
+  } else if (state.sheetData) {
+    onOpenTagInSheetData(tagName, attributes, state.sheetData);
+  }
+}
+function onCloseTagInSheet(tagName, state) {
+  if (state.sheetData) {
+    onCloseTagInSheetData(tagName, state.sheetData);
+  }
+}
+function onTextInSheet(text, state) {
+  if (state.sheetData) {
+    onTextInSheetData(text, state.sheetData);
+  }
+}
+
+/**
+ * Sheet "dimension" defines the spreadsheet area containing all non-empty cells.
+ * Any cells outside the "dimension" are considered empty and should be ignored.
+ * https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1
+ * @param {string} `ref` — The value of `<dimension ref/>` attribute.
+ * @returns {object[]} `undefined` or `[{ row, column }, { row, column }]` — "From row number and column number to row number and column number".
+ */
+function parseSheetDimensionRef(ref) {
+  var dimensions = ref.split(':').map(parseCellAddress).map(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+      row = _ref3[0],
+      column = _ref3[1];
+    return {
+      row: row,
+      column: column
+    };
+  });
+  // Sometimes there can be just a single cell as a spreadsheet's "dimensions".
+  // For example, the default "dimensions" in Apache POI library is "A1",
+  // meaning that only the first cell in the spreadsheet is used.
+  //
+  // A quote from Apache POI library:
+  // "Single cell ranges are formatted like single cell references (e.g. 'A1' instead of 'A1:A1')."
+  //
+  if (dimensions.length === 1) {
+    dimensions = [dimensions[0], dimensions[0]];
+  }
+  return dimensions;
 }
 //# sourceMappingURL=parseSheet.js.map

package/modules/xlsx/parseSheet.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseSheet.js","names":["parseCells","parseSheetDimensions","reconstructSheetDimensionsFromSheetCells","convertSheetToData2dArray","parseSheet","content","xml","sharedStrings","styles","epoch1904","options","sheetDocument","createDocument","cells","dimensions"],"sources":["../../source/xlsx/parseSheet.js"],"sourcesContent":["import parseCells from './parseCells.js'\r\nimport parseSheetDimensions from './parseSheetDimensions.js'\r\nimport reconstructSheetDimensionsFromSheetCells from './reconstructSheetDimensionsFromSheetCells.js'\r\nimport convertSheetToData2dArray from './convertCellsToData2dArray.js'\r\n\r\nexport default function parseSheet(content, xml, sharedStrings, styles, epoch1904, options) {\r\n  const sheetDocument = xml.createDocument(content)\r\n\r\n  const cells = parseCells(sheetDocument, sharedStrings, styles, epoch1904, options)\r\n\r\n  // `dimensions` defines the spreadsheet area enclosing all non-empty cells.\r\n  // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1\r\n  const dimensions = parseSheetDimensions(sheetDocument) || reconstructSheetDimensionsFromSheetCells(cells)\r\n\r\n  return convertSheetToData2dArray(cells, dimensions)\r\n}"],"mappings":"AAAA,OAAOA,UAAU,MAAM,iBAAiB;AACxC,OAAOC,oBAAoB,MAAM,2BAA2B;AAC5D,OAAOC,wCAAwC,MAAM,+CAA+C;AACpG,OAAOC,yBAAyB,MAAM,gCAAgC;AAEtE,eAAe,SAASC,UAAUA,CAACC,OAAO,EAAEC,GAAG,EAAEC,aAAa,EAAEC,MAAM,EAAEC,SAAS,EAAEC,OAAO,EAAE;EAC1F,IAAMC,aAAa,GAAGL,GAAG,CAACM,cAAc,CAACP,OAAO,CAAC;EAEjD,IAAMQ,KAAK,GAAGb,UAAU,CAACW,aAAa,EAAEJ,aAAa,EAAEC,MAAM,EAAEC,SAAS,EAAEC,OAAO,CAAC;;EAElF;EACA;EACA,IAAMI,UAAU,GAAGb,oBAAoB,CAACU,aAAa,CAAC,IAAIT,wCAAwC,CAACW,KAAK,CAAC;EAEzG,OAAOV,yBAAyB,CAACU,KAAK,EAAEC,UAAU,CAAC;AACrD"}
+{"version":3,"file":"parseSheet.js","names":["parseSheetData","createInitialStateInSheetData","onOpenTagInSheetData","onCloseTagInSheetData","onTextInSheetData","parseCellAddress","reconstructSheetDimensionsFromSheetCells","convertSheetToData2dArray","parseSheet","content","parseXmlStream","_ref","sharedStrings","styles","epoch1904","options","getSheetData","state","cells","sheetData","dimensions","dimension","parseSheetDimensionRef","createInitialState","createInitialStateInSheet","onOpenTag","onOpenTagInSheet","onCloseTag","onCloseTagInSheet","onText","onTextInSheet","then","undefined","tagName","attributes","ref","text","split","map","_ref2","_ref3","_slicedToArray","row","column","length"],"sources":["../../source/xlsx/parseSheet.js"],"sourcesContent":["import parseSheetData, {\r\n  createInitialStateInSheetData,\r\n  onOpenTagInSheetData,\r\n  onCloseTagInSheetData,\r\n  onTextInSheetData\r\n} from './parseSheetData.js'\r\n\r\nimport parseCellAddress from './parseCellAddress.js'\r\n\r\nimport reconstructSheetDimensionsFromSheetCells from './reconstructSheetDimensionsFromSheetCells.js'\r\nimport convertSheetToData2dArray from './convertCellsToData2dArray.js'\r\n\r\n/**\r\n * Parses a `sheet.xml` file.\r\n * @param {string} content\r\n * @param {function} parseXmlStream — SAX XML parser.\r\n * @param {object} options\r\n * @returns {Promise<SheetData>}\r\n */\r\nexport default function parseSheet(content, parseXmlStream, { sharedStrings, styles, epoch1904, options }) {\r\n  // When XML parser is finished, it returns a `state`\r\n  // where it has accumulated the cells it encountered during parsing.\r\n  // `getSheetData()` function reads the parser `state` and transforms it to `SheetData`.\r\n  const getSheetData = (state) => {\r\n    const cells = parseSheetData(state.sheetData, sharedStrings, styles, epoch1904, options)\r\n    const dimensions = state.dimension\r\n      ? parseSheetDimensionRef(state.dimension)\r\n      : reconstructSheetDimensionsFromSheetCells(cells)\r\n    return convertSheetToData2dArray(cells, dimensions)\r\n  }\r\n\r\n  return parseXmlStream(content, {\r\n    createInitialState: createInitialStateInSheet,\r\n    onOpenTag: onOpenTagInSheet,\r\n    onCloseTag: onCloseTagInSheet,\r\n    onText: onTextInSheet\r\n  }).then((state) => {\r\n    return getSheetData(state)\r\n  })\r\n}\r\n\r\nfunction createInitialStateInSheet() {\r\n  return {\r\n    dimension: undefined,\r\n    sheetData: undefined\r\n  }\r\n}\r\n\r\nfunction onOpenTagInSheet(tagName, attributes, state) {\r\n  if (tagName === 'dimension') {\r\n    state.dimension = attributes.ref\r\n  } else if (tagName === 'sheetData') {\r\n    state.sheetData = createInitialStateInSheetData()\r\n  } else if (state.sheetData) {\r\n    onOpenTagInSheetData(tagName, attributes, state.sheetData)\r\n  }\r\n}\r\n\r\nfunction onCloseTagInSheet(tagName, state) {\r\n  if (state.sheetData) {\r\n    onCloseTagInSheetData(tagName, state.sheetData)\r\n  }\r\n}\r\n\r\nfunction onTextInSheet(text, state) {\r\n  if (state.sheetData) {\r\n    onTextInSheetData(text, state.sheetData)\r\n  }\r\n}\r\n\r\n/**\r\n * Sheet \"dimension\" defines the spreadsheet area containing all non-empty cells.\r\n * Any cells outside the \"dimension\" are considered empty and should be ignored.\r\n * https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1\r\n * @param {string} `ref` — The value of `<dimension ref/>` attribute.\r\n * @returns {object[]} `undefined` or `[{ row, column }, { row, column }]` — \"From row number and column number to row number and column number\".\r\n */\r\nfunction parseSheetDimensionRef(ref) {\r\n  let dimensions = ref.split(':').map(parseCellAddress).map(\r\n    ([row, column]) => ({ row, column })\r\n  )\r\n  // Sometimes there can be just a single cell as a spreadsheet's \"dimensions\".\r\n  // For example, the default \"dimensions\" in Apache POI library is \"A1\",\r\n  // meaning that only the first cell in the spreadsheet is used.\r\n  //\r\n  // A quote from Apache POI library:\r\n  // \"Single cell ranges are formatted like single cell references (e.g. 'A1' instead of 'A1:A1').\"\r\n  //\r\n  if (dimensions.length === 1) {\r\n    dimensions = [dimensions[0], dimensions[0]]\r\n  }\r\n  return dimensions\r\n}"],"mappings":"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"}

package/modules/xlsx/parseSheetData.js

@@ -0,0 +1,55 @@
+import parseCell, { createInitialStateInCell, onOpenTagInCell, onCloseTagInCell, onTextInCell } from './parseCell.js';
+export default function parseSheetData(state, sharedStrings, styles, epoch1904, options) {
+  return state.cells.map(function (_ref) {
+    var attributes = _ref.attributes,
+      value = _ref.value,
+      inlineString = _ref.inlineString;
+    return parseCell(attributes, value, inlineString, sharedStrings, styles, epoch1904, options);
+  });
+}
+export function createInitialStateInSheetData() {
+  return {
+    c: undefined,
+    cells: []
+  };
+}
+export function onOpenTagInSheetData(tagName, attributes, state) {
+  if (tagName === 'c') {
+    state.c = createInitialStateInCell();
+    state.c.attributes = attributes;
+  } else if (state.c) {
+    onOpenTagInCell(tagName, attributes, state.c);
+  }
+}
+export function onCloseTagInSheetData(tagName, state) {
+  if (tagName === 'c') {
+    state.cells.push({
+      attributes: state.c.attributes,
+      value: state.c.value,
+      inlineString: state.c.inlineString
+    });
+    state.c = undefined;
+  } else if (state.c) {
+    onCloseTagInCell(tagName, state.c);
+  }
+}
+export function onTextInSheetData(text, state) {
+  if (state.c) {
+    onTextInCell(text, state.c);
+  }
+}
+
+// Here, it could also parse "merged cells" and then return them in some special way.
+// But then it's not clear what should be the way to return such merged cells.
+// I.e. should it just return it as a duplicate value in each one of the merged cells?
+// Or should it keep the current behavior of only returning the value of the top-most left-most cell
+// and then just return `null` for the rest of the cells in a "merged cells" group?
+// Perhaps the latter (current) approach is the most sensible one, so there's no need
+// to change anything.
+//
+// const mergedCells = getMergedCellCoordinates(sheetDocument)
+// for (const mergedCell of mergedCells) {
+//   const [from, to] = mergedCell.split(':').map(parseCellAddress)
+//   console.log('Merged Cell.', 'From:', from, 'To:', to)
+// }
+//# sourceMappingURL=parseSheetData.js.map

package/modules/xlsx/parseSheetData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSheetData.js","names":["parseCell","createInitialStateInCell","onOpenTagInCell","onCloseTagInCell","onTextInCell","parseSheetData","state","sharedStrings","styles","epoch1904","options","cells","map","_ref","attributes","value","inlineString","createInitialStateInSheetData","c","undefined","onOpenTagInSheetData","tagName","onCloseTagInSheetData","push","onTextInSheetData","text"],"sources":["../../source/xlsx/parseSheetData.js"],"sourcesContent":["import parseCell, {\r\n  createInitialStateInCell,\r\n  onOpenTagInCell,\r\n  onCloseTagInCell,\r\n  onTextInCell\r\n} from './parseCell.js'\r\n\r\nexport default function parseSheetData(state, sharedStrings, styles, epoch1904, options) {\r\n  return state.cells.map(({ attributes, value, inlineString }) => {\r\n    return parseCell(\r\n      attributes,\r\n      value,\r\n      inlineString,\r\n      sharedStrings,\r\n      styles,\r\n      epoch1904,\r\n      options\r\n    )\r\n  })\r\n}\r\n\r\nexport function createInitialStateInSheetData() {\r\n  return {\r\n    c: undefined,\r\n    cells: []\r\n  }\r\n}\r\n\r\nexport function onOpenTagInSheetData(tagName, attributes, state) {\r\n  if (tagName === 'c') {\r\n    state.c = createInitialStateInCell()\r\n    state.c.attributes = attributes\r\n  } else if (state.c) {\r\n    onOpenTagInCell(tagName, attributes, state.c)\r\n  }\r\n}\r\n\r\nexport function onCloseTagInSheetData(tagName, state) {\r\n  if (tagName === 'c') {\r\n    state.cells.push({\r\n      attributes: state.c.attributes,\r\n      value: state.c.value,\r\n      inlineString: state.c.inlineString\r\n    })\r\n    state.c = undefined\r\n  } else if (state.c) {\r\n    onCloseTagInCell(tagName, state.c)\r\n  }\r\n}\r\n\r\nexport function onTextInSheetData(text, state) {\r\n  if (state.c) {\r\n    onTextInCell(text, state.c)\r\n  }\r\n}\r\n\r\n// Here, it could also parse \"merged cells\" and then return them in some special way.\r\n// But then it's not clear what should be the way to return such merged cells.\r\n// I.e. should it just return it as a duplicate value in each one of the merged cells?\r\n// Or should it keep the current behavior of only returning the value of the top-most left-most cell\r\n// and then just return `null` for the rest of the cells in a \"merged cells\" group?\r\n// Perhaps the latter (current) approach is the most sensible one, so there's no need\r\n// to change anything.\r\n//\r\n// const mergedCells = getMergedCellCoordinates(sheetDocument)\r\n// for (const mergedCell of mergedCells) {\r\n//   const [from, to] = mergedCell.split(':').map(parseCellAddress)\r\n//   console.log('Merged Cell.', 'From:', from, 'To:', to)\r\n// }"],"mappings":"AAAA,OAAOA,SAAS,IACdC,wBAAwB,EACxBC,eAAe,EACfC,gBAAgB,EAChBC,YAAY,QACP,gBAAgB;AAEvB,eAAe,SAASC,cAAcA,CAACC,KAAK,EAAEC,aAAa,EAAEC,MAAM,EAAEC,SAAS,EAAEC,OAAO,EAAE;EACvF,OAAOJ,KAAK,CAACK,KAAK,CAACC,GAAG,CAAC,UAAAC,IAAA,EAAyC;IAAA,IAAtCC,UAAU,GAAAD,IAAA,CAAVC,UAAU;MAAEC,KAAK,GAAAF,IAAA,CAALE,KAAK;MAAEC,YAAY,GAAAH,IAAA,CAAZG,YAAY;IACvD,OAAOhB,SAAS,CACdc,UAAU,EACVC,KAAK,EACLC,YAAY,EACZT,aAAa,EACbC,MAAM,EACNC,SAAS,EACTC,OACF,CAAC;EACH,CAAC,CAAC;AACJ;AAEA,OAAO,SAASO,6BAA6BA,CAAA,EAAG;EAC9C,OAAO;IACLC,CAAC,EAAEC,SAAS;IACZR,KAAK,EAAE;EACT,CAAC;AACH;AAEA,OAAO,SAASS,oBAAoBA,CAACC,OAAO,EAAEP,UAAU,EAAER,KAAK,EAAE;EAC/D,IAAIe,OAAO,KAAK,GAAG,EAAE;IACnBf,KAAK,CAACY,CAAC,GAAGjB,wBAAwB,CAAC,CAAC;IACpCK,KAAK,CAACY,CAAC,CAACJ,UAAU,GAAGA,UAAU;EACjC,CAAC,MAAM,IAAIR,KAAK,CAACY,CAAC,EAAE;IAClBhB,eAAe,CAACmB,OAAO,EAAEP,UAAU,EAAER,KAAK,CAACY,CAAC,CAAC;EAC/C;AACF;AAEA,OAAO,SAASI,qBAAqBA,CAACD,OAAO,EAAEf,KAAK,EAAE;EACpD,IAAIe,OAAO,KAAK,GAAG,EAAE;IACnBf,KAAK,CAACK,KAAK,CAACY,IAAI,CAAC;MACfT,UAAU,EAAER,KAAK,CAACY,CAAC,CAACJ,UAAU;MAC9BC,KAAK,EAAET,KAAK,CAACY,CAAC,CAACH,KAAK;MACpBC,YAAY,EAAEV,KAAK,CAACY,CAAC,CAACF;IACxB,CAAC,CAAC;IACFV,KAAK,CAACY,CAAC,GAAGC,SAAS;EACrB,CAAC,MAAM,IAAIb,KAAK,CAACY,CAAC,EAAE;IAClBf,gBAAgB,CAACkB,OAAO,EAAEf,KAAK,CAACY,CAAC,CAAC;EACpC;AACF;AAEA,OAAO,SAASM,iBAAiBA,CAACC,IAAI,EAAEnB,KAAK,EAAE;EAC7C,IAAIA,KAAK,CAACY,CAAC,EAAE;IACXd,YAAY,CAACqB,IAAI,EAAEnB,KAAK,CAACY,CAAC,CAAC;EAC7B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/modules/xlsx/parseSpreadsheetContents.js

@@ -1,66 +1,162 @@
+var _excluded = ["parseNumber"];
+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 _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; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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); }
 import parseSpreadsheetInfo from './parseSpreadsheetInfo.js';
 import parseFilePaths from './parseFilePaths.js';
 import parseStyles from './parseStyles.js';
 import parseSharedStrings from './parseSharedStrings.js';
 import parseSheet from './parseSheet.js';
+import parseNumberDefault from './parseNumber.js';
+import checkpoint, { latestCheckpointTimestamp } from '../utility/checkpoint.js';
+import isPromise from '../utility/isPromise.js';
 
 // For an introduction in reading `.xlsx` files see "The minimum viable XLSX reader":
 // https://www.brendanlong.com/the-minimum-viable-xlsx-reader.html
 
 /**
  * Reads data from an `.xlsx` file.
+ * @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  {object} [options]
- * @return {Sheet[]}
+ * @return {Promise<Sheet[]>}
  */
-export default function parseSpreadsheetContents(contents, xml) {
+function parseSpreadsheetContents(parseXmlStream, contents) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var getFileContent = function getFileContent(filePath) {
-    if (!contents[filePath]) {
-      throw new Error("\"".concat(filePath, "\" file not found inside the *.xlsx file zip archive"));
-    }
-    return contents[filePath];
-  };
+  // Because of how `.xlsx` file contents are defined in the specification,
+  // it will have to be read in 3 passes:
+  // * First pass — read the actual file paths
+  // * Second pass — read "shared strings" and "styles"
+  // * Thirs pass — read the sheets data
 
-  // Read the paths to certain files inside the `.xlsx` file, which is itself just a `.zip` archive.
-  // These paths aren't standardized between different spreadsheet editors.
-  // https://github.com/tidyverse/readxl/issues/104
-  var filePaths = parseFilePaths(getFileContent('xl/_rels/workbook.xml.rels'), xml);
-
-  // The usual file path for "shared strings" is "xl/sharedStrings.xml".
-  var sharedStrings = filePaths.sharedStrings ? parseSharedStrings(getFileContent(filePaths.sharedStrings), xml) : [];
-
-  // The usual file path for "styles" is "xl/styles.xml".
-  var styles = filePaths.styles ? parseStyles(getFileContent(filePaths.styles), xml) : {};
-  var _parseSpreadsheetInfo = parseSpreadsheetInfo(getFileContent('xl/workbook.xml'), xml),
-    sheets = _parseSpreadsheetInfo.sheets,
-    epoch1904 = _parseSpreadsheetInfo.epoch1904;
-  var sheetIdsToRead = options.sheets && options.sheets.map(function (sheet) {
-    return getSheetId(sheet, sheets);
-  });
+  checkpoint('parse spreadsheet info and file paths');
 
-  // Parse sheets data.
+  // Get spreadsheet info and the paths to files.
+  return readFiles(getXmlFilesAtFixedPaths(), contents, parseXmlStream).then(function (_ref) {
+    var spreadsheetInfo = _ref.spreadsheetInfo,
+      filePaths = _ref.filePaths;
+    checkpoint('parse "shared strings" and "styles"');
 
-  var sheetsData = [];
-  for (var _i = 0, _Object$keys = Object.keys(filePaths.sheets); _i < _Object$keys.length; _i++) {
-    var sheetId = _Object$keys[_i];
-    if (sheetIdsToRead && !sheetIdsToRead.includes(sheetId)) {
-      continue;
-    }
-    sheetsData.push({
-      sheet: getSheetNameById(sheetId, sheets),
-      data: parseSheet(getFileContent(filePaths.sheets[sheetId]), xml, sharedStrings, styles, epoch1904, options)
+    // Parse "shared strings" and "styles".
+    return readFiles(getXmlFilesAtNonFixedPaths(filePaths), contents, parseXmlStream).then(function (_ref2) {
+      var sharedStrings = _ref2.sharedStrings,
+        styles = _ref2.styles;
+      var sheetRelationIdsToRead = options.sheets ? options.sheets.map(function (sheet) {
+        return getSheetRelationId(sheet, spreadsheetInfo.sheets);
+      }) : spreadsheetInfo.sheets.map(function (_) {
+        return _.relationId;
+      });
+      checkpoint("parse sheet".concat(sheetRelationIdsToRead.length === 1 ? '' : 's', " data"));
+
+      // Parse sheets data.
+      return readFiles(getSheetDataXmlFiles(filePaths, sheetRelationIdsToRead, {
+        sharedStrings: sharedStrings,
+        styles: styles,
+        epoch1904: spreadsheetInfo.epoch1904,
+        options: options
+      }), contents, parseXmlStream).then(function (sheetsData) {
+        checkpoint('end');
+        // Return sheets data.
+        return sheetRelationIdsToRead.map(function (sheetRelationId) {
+          return {
+            sheet: getSheetNameByRelationId(sheetRelationId, spreadsheetInfo.sheets),
+            data: sheetsData[sheetRelationId]
+          };
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Reads data from an `.xlsx` file in a worker.
+ * @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} [options]
+ * @return {Promise<Sheet[]>}
+ */
+export default function parseSpreadsheetContentsInWorker(createWorkerFunction, parseXmlStream, contents, options) {
+  // Assign the default `parseNumber()` function in the `options`.
+  // The reason is that the worker code requires it to be non-`undefined`.
+  // Otherwise, it would throw "parseNumber is not defined".
+  if (!(options && options.parseNumber)) {
+    options = _objectSpread(_objectSpread({}, options), {}, {
+      parseNumber: parseNumberDefault
     });
   }
 
-  // Return spreadsheet data.
-  return sheetsData;
+  // Using a worker requires specifying all the top-level variables or functions that it uses.
+  // Currently, that list looks a little bit too long so for now workers aren't used for parsing sheet data.
+  // See the comment in `createWorkerFunction()` call for more details.
+  // createWorkerFunction = undefined
+
+  // If the environment doesn't support "workers", parse spreadsheet contents "synchronously".
+  // This will "block" the main thread while parsing.
+  if (!createWorkerFunction) {
+    return parseSpreadsheetContents(parseXmlStream, contents, options);
+  }
+
+  // Any functions have to be removed from the `options` in order for them to be "serializable"
+  // before sending them to the worker thread.
+  var _options = options,
+    parseNumber = _options.parseNumber,
+    optionsJson = _objectWithoutProperties(_options, _excluded);
+
+  // Create a worker.
+  var workerFn = createWorkerFunction(function (data) {
+    // Reconstruct the `options`.
+    var options = _objectSpread(_objectSpread({}, data.optionsJson), {}, {
+      parseNumber: parseNumber
+    });
+    // Parse sheet data from the `.xml` files.
+    return parseSpreadsheetContents(parseXmlStream, data.contents, options);
+  });
+  workerFn.addDependencies(
+  // Any "outside" dependencies that're referenced in the function (below).
+  function () {
+    return [parseXmlStream, parseNumber, parseSpreadsheetContents, getSheetRelationId, getSheetNameByRelationId, getXmlFilesAtFixedPaths, getXmlFilesAtNonFixedPaths, getSheetDataXmlFiles, readFiles, checkpoint, latestCheckpointTimestamp, isPromise
+    // parseSheet,
+    //
+    // This is not the full list by any means. There's more. Quite a lot more of them.
+    // It started looking a bit too much so I stopped adding the dependencies here.
+    // Now I understand why `fflate`'s source code is all written in a single
+    // multi-thousand-line `index.ts` file. The thing is, once one starts splitting
+    // the code into modules, they'd have to manually export any top-level variables
+    // or functions from those modules and import them here in order to specify them
+    // in the list of dependencies. And even if doing so for every top-level variable
+    // or function in every imported module doesn't seem like an impossible task,
+    // imagine someone refactoring the code later and extracting new top-level
+    // variables or functions. Without 100% code coverage requirement, it won't be caught
+    // at build time and can only be caught in production, which isn't ideal to say the least.
+    // So it seems like users of this package will have to just deal with the "blocking"
+    // nature of the sheet data parser, because I won't follow into `fflate`'s steps
+    // and rewrite this package as a single `index.js` file.
+    // Users of this package will have to manually put their code in a worker
+    // in case they'd prefer it to run in a separate thread to prevent "blocking"
+    // the main thread when parsing sheet data.
+    ];
+  });
+
+  // Post a message with some data to the worker
+  // so that it starts processing the data
+  // and later posts a message back to the main thread
+  // with the result of the calculation.
+  return workerFn.callOnce({
+    optionsJson: optionsJson,
+    contents: contents
+  }); // (optional) add `transferList` argument.
 }
-function getSheetId(sheet, sheets) {
+
+function getSheetRelationId(sheet, sheets) {
   if (typeof sheet === 'string') {
     for (var _iterator = _createForOfIteratorHelperLoose(sheets), _step; !(_step = _iterator()).done;) {
       var _sheet = _step.value;
@@ -68,8 +164,8 @@ function getSheetId(sheet, sheets) {
         return _sheet.relationId;
       }
     }
-    throw new Error("Sheet \"".concat(sheet, "\" not found. Available sheets: ").concat(sheets.map(function (_ref) {
-      var name = _ref.name;
+    throw new Error("Sheet \"".concat(sheet, "\" not found. Available sheets: ").concat(sheets.map(function (_ref3) {
+      var name = _ref3.name;
       return "\"".concat(name, "\"");
     }).join(', ')));
   } else {
@@ -79,13 +175,116 @@ function getSheetId(sheet, sheets) {
     throw new Error("Sheet number out of bounds: ".concat(sheet, ". Available sheets count: ").concat(sheets.length));
   }
 }
-function getSheetNameById(sheetId, sheets) {
+function getSheetNameByRelationId(sheetRelationId, sheets) {
   for (var _iterator2 = _createForOfIteratorHelperLoose(sheets), _step2; !(_step2 = _iterator2()).done;) {
     var sheet = _step2.value;
-    if (sheet.relationId === sheetId) {
+    if (sheet.relationId === sheetRelationId) {
       return sheet.name;
     }
   }
-  throw new Error("Sheet ID not found: ".concat(sheetId));
+  throw new Error("Sheet relation ID not found: ".concat(sheetRelationId));
+}
+function getXmlFilesAtFixedPaths() {
+  return {
+    // Read the paths to certain files inside the `.xlsx` file, which is itself just a `.zip` archive.
+    // These paths aren't standardized between different spreadsheet editors.
+    // https://github.com/tidyverse/readxl/issues/104
+    'xl/_rels/workbook.xml.rels': {
+      name: 'filePaths',
+      parse: parseFilePaths
+    },
+    // General info on the spreadsheet.
+    'xl/workbook.xml': {
+      name: 'spreadsheetInfo',
+      parse: parseSpreadsheetInfo
+    }
+  };
+}
+function getXmlFilesAtNonFixedPaths(filePaths) {
+  var _ref4;
+  return _ref4 = {}, _defineProperty(_ref4, filePaths.sharedStrings || 'xl/sharedStrings.xml', {
+    name: 'sharedStrings',
+    // `parseSharedStrings()` returns a `Promise`.
+    parse: parseSharedStrings,
+    // It seems that "sharedStrings.xml" is not required to exist.
+    // For example, that could be the case when a spreadsheet doesn't contain any strings.
+    // https://github.com/catamphetamine/read-excel-file/issues/85
+    fallback: []
+  }), _defineProperty(_ref4, filePaths.styles || 'xl/styles.xml', {
+    name: 'styles',
+    parse: parseStyles,
+    fallback: {}
+  }), _ref4;
+}
+
+// Returns the list of sheet data `.xml` files.
+function getSheetDataXmlFiles(filePaths, sheetRelationIdsToRead, sheetDataParserParameters) {
+  return Object.keys(filePaths.sheets).filter(function (sheetRelationId) {
+    return sheetRelationIdsToRead.includes(sheetRelationId);
+  }).reduce(function (filesInfo, sheetRelationId) {
+    return _objectSpread(_objectSpread({}, filesInfo), {}, _defineProperty({}, filePaths.sheets[sheetRelationId], {
+      name: sheetRelationId,
+      // `parseSheet()` returns a `Promise`.
+      parse: function parse(content, parseXmlStream) {
+        return parseSheet(content, parseXmlStream, sheetDataParserParameters);
+      }
+    }));
+  }, {});
+}
+
+// In case of converting `.zip` file reader from a "read-and-return" one to a "streaming" one,
+// this function could be modified to process the files as they come rather than all-at-once.
+
+// Reads files from inside an `.xlsx` archive by file paths.
+//
+// In case of converting `.zip` file reader from a "read-and-return" one to a "streaming" one,
+// this function could be modified to process the files as they come rather than all-at-once.
+//
+// But there's a catch: inside an `.xlsx` file, some file paths are not fixed
+// and are instead defined in "xl/_rels/workbook.xml.rels" file,
+// which presents a "chicken and an egg" dilemma: how could one possibly
+// read an `.xlsx` file in one go when the order of the files inside it isn't fixed
+// and could be random. Most likely, in the majority of cases, "xl/_rels/workbook.xml.rels"
+// file is gonna be one of the first in a given `.xlsx` archive, but still it's not guaranteed.
+// A solution would be reading an `.xlsx` file in two passes: one pass would be just to read
+// the "xl/_rels/workbook.xml.rels" and ignore decompressing anything else,
+// and then the second pass would be to read all other files whose paths are now known.
+//
+// Returns:
+// * If none of the `parse()` functions returned a `Promise`, it returns a map of files' contents.
+// * If any of the `parse()` functions returned a `Promise`, it returns a `Promise` that resolves to a map of files' contents.
+//
+function readFiles(filesInfo, contents, parseXmlStream) {
+  // Get files' contents.
+  var results = {};
+  var _loop = function _loop() {
+    var filePath = _Object$keys[_i];
+    var fileInfo = filesInfo[filePath];
+    results[fileInfo.name] = contents[filePath] === undefined ? fileInfo.fallback === undefined ? function () {
+      throw new Error("\"".concat(filePath, "\" file not found inside the `.xlsx` file"));
+    }() : fileInfo.fallback : fileInfo.parse(contents[filePath], parseXmlStream);
+  };
+  for (var _i = 0, _Object$keys = Object.keys(filesInfo); _i < _Object$keys.length; _i++) {
+    _loop();
+  }
+  // Resolve any `Promise`s.
+  var promises = [];
+  var _loop2 = function _loop2() {
+    var name = _Object$keys2[_i2];
+    if (isPromise(results[name])) {
+      promises.push(results[name].then(function (result) {
+        results[name] = result;
+      }));
+    }
+  };
+  for (var _i2 = 0, _Object$keys2 = Object.keys(results); _i2 < _Object$keys2.length; _i2++) {
+    _loop2();
+  }
+  if (promises.length > 0) {
+    return Promise.all(promises).then(function () {
+      return results;
+    });
+  }
+  return results;
 }
 //# sourceMappingURL=parseSpreadsheetContents.js.map