read-excel-file 9.3.3 → 9.3.5

package/modules/xlsx/parseCell.js

@@ -4,119 +4,259 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 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 parseCellValue from './parseCellValue.js';
-import parseCellAddress from './parseCellAddress.js';
+import parseExcelTimestamp from './parseExcelTimestamp.js';
+import isDateFormatStyle from './isDateFormatStyle.js';
 
-// Example of a `<c/>`ell element:
-//
-// <c>
-//    <f>string</f> — formula.
-//    <v>string</v> — formula pre-computed value.
-//    <is>
-//       <t>string</t> — an `inlineStr` string (rather than a "common string" from a dictionary).
-//       <r>
-//          <rPr>
-//            ...
-//          </rPr>
-//          <t>string</t>
-//       </r>
-//       <rPh sb="1" eb="1">
-//          <t>string</t>
-//       </rPh>
-//       <phoneticPr fontId="1"/>
-//    </is>
-//    <extLst>
-//       <ext>
-//          <!--any element-->
-//       </ext>
-//    </extLst>
-// </c>
-//
-export default function parseCell(attributes, value, inlineString, sharedStrings, styles, epoch1904, options) {
-  var _parseCellAddress = parseCellAddress(attributes.r),
-    _parseCellAddress2 = _slicedToArray(_parseCellAddress, 2),
-    row = _parseCellAddress2[0],
-    column = _parseCellAddress2[1];
-  var type = attributes.t;
-  var styleId = attributes.s ? Number(attributes.s) : undefined;
-  return {
-    row: row,
-    column: column,
-    value: parseCellValue(value, type, {
-      inlineString: inlineString,
-      styleId: styleId,
-      styles: styles,
-      sharedStrings: sharedStrings,
-      epoch1904: epoch1904,
-      options: options
-    })
-  };
-}
-export function createInitialStateInCell() {
-  return {
-    v: false,
-    is: false,
-    t: false,
-    r: false,
-    rPh: false,
-    value: undefined,
-    inlineString: undefined,
-    attributes: undefined
-  };
-}
-export function onOpenTagInCell(tagName, attributes, state) {
-  if (tagName === 'v') {
-    state.v = true;
-  } else if (tagName === 'is') {
-    // The possible children of <is> are:
-    // * <t> (Text): The standard child to hold plain, simple text.
-    // * <r> (Rich Text Run): Used for applying different formatting styles (like bold or italic) to specific segments of text within a single cell.
-    // * <rPh> (Phonetic Run): Used primarily for East Asian languages to provide phonetic reading/pronunciation data (e.g., furigana in Japanese). It associates a phonetic pronunciation run right alongside the base string text tag <t>.
-    // * <phoneticPr> (Phonetic Properties): Defines formatting and settings for the phonetic text.
-    state.is = true;
-    state.inlineString = '';
-  } else if (tagName === 't') {
-    state.t = true;
-  } else if (tagName === 'r') {
-    // The possible children of <r/> are:
-    // * <rPr> (Run Properties): The formatting properties for the text (font, size, color, bold, italic, etc.).
-    // * <t> (Text): The actual text payload.
-    // * <rPh> (Phonetic Run): Phonetic pronunciation guidance (used for East Asian languages like Japanese). It associates a phonetic pronunciation run right alongside the base string text tag <t>.
-    state.r = true;
-  } else if (tagName === 'rPh') {
-    // The possible children of <rPh/> are:
-    // * <t> (Text):  Contains the actual phonetic text or reading (usually in Katakana for Japanese) that corresponds to the associated character string.
-    state.rPh = true;
-  }
-}
-export function onCloseTagInCell(tagName, state) {
-  if (tagName === 'v') {
-    state.v = false;
-  } else if (tagName === 'is') {
-    state.is = false;
-  } else if (tagName === 't') {
-    state.t = false;
-  } else if (tagName === 'r') {
-    state.r = false;
-  } else if (tagName === 'rPh') {
-    state.rPh = false;
-  }
-}
-export function onTextInCell(text, state) {
-  if (state.v) {
-    state.value = text;
-  } else if (state.is) {
-    if (state.rPh) {
-      // Ignore anything inside `<rPh/>` tags
-    } else if (state.t) {
-      if (state.r) {
-        // An `<r/>` element could contain multiple `<t/>` elements,
-        // the text content from all of which should be concatenated.
-        state.inlineString += text;
-      } else {
-        state.inlineString = text;
+// An empty cell has `null` value.
+var EMPTY_CELL_VALUE = null;
+
+// This variable represents a cell with a `null` value.
+// It is exported only to be specified as a dependency when using `worker-f`.
+export var EMPTY_CELL = [null, EMPTY_CELL_VALUE];
+
+/**
+ * Parses a cell from the info extracted from XML.
+ * @param {string} [t] — `<c t/>` attribute value (cell type). One of: b (Boolean), e (Error), n (Number), d (Date), s (String).
+ * @param {string} [s] — `<c s/>` attribute value (formatting style ID). When present, should be a stringified zero-based index of the formatting style for a numberic cell.
+ * @param {string} [v] — `<v/>` element text content (value). Will be `undefined` if the `<v/>` element absent. Will be an empty string `""` if the `<v/>` element is present but is empty.
+ * @param {string} [inlineString] — Inline string value.
+ * @param {any[]} parameters
+ * @returns {[string|null,string|number|boolean|null] | string} Either `[type, value]` or `error`, where `value` is the cell value, `type` depends on the type of `value` and could be one of: 's' (string), 'b' (boolean), 'n' (number string), 'd' (date timestamp), 'e' (formula cell error), `null` (null); `error` is an error message: `VALUE_MISSING`, `VALUE_INVALID`, `FORMAT_INVALID`, `TYPE_INVALID`.
+ */
+export default function parseCell(t, s, v, inlineString, _ref) {
+  var _ref2 = _slicedToArray(_ref, 6),
+    sharedStrings = _ref2[0],
+    styles = _ref2[1],
+    epoch1904 = _ref2[2],
+    defaultDateFormat = _ref2[3],
+    dateTemplateParser = _ref2[4],
+    parseNumberCustom = _ref2[5];
+  // Available Excel cell types:
+  // https://github.com/SheetJS/sheetjs/blob/19620da30be2a7d7b9801938a0b9b1fd3c4c4b00/docbits/52_datatype.md
+  //
+  // Some other document (seems to be old):
+  // http://webapp.docx4java.org/OnlineDemo/ecma376/SpreadsheetML/ST_CellType.html
+  //
+  // The default cell type is "n" (numeric), according to XLSX specification.
+  //
+  switch (t || 'n') {
+    // `t="str"` means that the cell value is calculated using a formula.
+    // The formula is defined as the text of a child `<f/>` element.
+    //
+    // It could optionally include a `<v/>` element whose text is the cached result
+    // of the calculation from the last time the file was saved in a spreadsheet editor application.
+    //
+    // An optional `<v/>` element holds a pre-computed result of the formula defined by `<f/>`.
+    //
+    // Example:
+    //
+    // <c r="B3" t="str">
+    // 	<f>CONCATENATE(C1,D1)</f>
+    // 	<v>C1ValueD1Value</v>
+    // </c>
+    //
+    // Here's a guide on formulas in XLSX files:
+    // https://github.com/MiniMax-AI/skills/blob/main/skills/minimax-xlsx/references/validate.md
+    //
+    case 'str':
+      // The `<v/>` element could be absent because it's not required to be pre-computed by the spec.
+      // In such case, `v` argument value would be `undefined`.
+      // Because this package can't include the whole formula calculation engine,
+      // it has to interpret this situation as an error.
+      if (v === undefined) {
+        return 'VALUE_MISSING';
+      }
+      // The `<v/>` element could be present but its text content could be empty
+      // because the formula returns an empty string.
+      // For example, a valid case of `v` argument value being an empty string `""` is when
+      // a formula in cell `A1` is `=CONCATENATE(B1,C1)` and both `B1` and `C1` cells are empty.
+      if (!v) {
+        return EMPTY_CELL;
+      }
+      return ['s', v];
+
+    // `t="inlineStr"` means that `<is/>` holds the string value.
+    //
+    // Inside a `<c t="inlineStr"/>`, the specification requires there to exist an `<is/>` element,
+    // and within that `<is/>` element it requires to exist a `<t/>` element.
+    //
+    // Example:
+    //
+    // <c r="A1" s="1" t="inlineStr">
+    //   <is>
+    //     <t>
+    //       Test 123
+    //     </t>
+    //   </is>
+    // </c>
+    //
+    case 'inlineStr':
+      if (inlineString === undefined) {
+        return 'VALUE_MISSING';
+      }
+      return ['s', inlineString];
+
+    // `type="s"` means that the string value is stored in the Shared Strings Table.
+    // This way it attempts to compress the `.xlsx` file by reusing all string values
+    // in case they repeat throughout the spreadsheet.
+    //
+    // This optimization can't be used when writing an `.xlsx` file in a "streaming"
+    // fashion, i.e. when the entire spreadsheet data is not known in adavance
+    // at the start of writing the file.
+    // But it can be used in all other situations. And hence, it is used.
+    // So this is the most common cell type, actually.
+    //
+    // Example:
+    //
+    // <c r="A3" t="s">
+    //   <v>3</v>
+    // </c>
+    //
+    case 's':
+      // If a cell has no value then there's no `<c/>` element for it.
+      // If a `<c/>` element exists then it's not empty.
+      // The `<v/>` element's text is a zero-based index in the "shared strings" dictionary.
+      if (!v) {
+        return 'VALUE_MISSING';
+      }
+      var sharedStringIndex = Number(v);
+      // The shared string index value could be:
+      // * not a number
+      // * a number but a fractional one
+      // * an integer that is out of bounds of the shared strings array
+      if (isNaN(sharedStringIndex) || sharedStrings[sharedStringIndex] === undefined) {
+        return 'VALUE_INVALID';
+      }
+      return ['s', sharedStrings[sharedStringIndex]];
+
+    // Boolean (TRUE/FALSE) values are stored as either "1" or "0" in cells of type "b".
+    //
+    // Example:
+    //
+    // <c r="A1" t="b">
+    //   <v>1</v>
+    // </c>
+    //
+    case 'b':
+      if (!v) {
+        return 'VALUE_MISSING';
+      }
+      if (v === '1') {
+        return ['b', true];
+      }
+      if (v === '0') {
+        return ['b', false];
+      }
+      return 'VALUE_INVALID';
+
+    // If cell type is "e", the `<v/>` element's text is an error code string (required).
+    //
+    // Example:
+    //
+    // <c r="A1" t="e">
+    //   <f>1/0</f>
+    //   <v>#DIV/0!</v>
+    // </c>
+    //
+    case 'e':
+      // Examples of error codes:
+      //
+      // '#NULL!'
+      // '#DIV/0!'
+      // '#VALUE!'
+      // '#REF!'
+      // '#NAME!'
+      // '#NUM!'
+      // '#N/A'
+      // '#SPILL!'
+      //
+      // The description of each error could be read in the formulas guide:
+      // https://github.com/MiniMax-AI/skills/blob/main/skills/minimax-xlsx/references/validate.md
+      //
+      if (!v) {
+        return 'VALUE_MISSING';
+      }
+      return ['e', v];
+
+    // XLSX supports date cells of type "d", though it seems like it (almost?) never
+    // uses type "d" for storing dates, preferring type "n" and numeric timestamp instead.
+    // The value of a "d" cell is supposedly a string in "ISO 8601" format.
+    // I haven't seen an `.xlsx` file having such cells.
+    //
+    // Example:
+    //
+    // <c r="A1" s="1" t="d">
+    //   <v>
+    //     2021-06-10T00:47:45.700Z
+    //   </v>
+    // </c>
+    //
+    case 'd':
+      if (!v) {
+        return EMPTY_CELL;
+      }
+      var parsedDate = new Date(v);
+      if (isNaN(parsedDate.valueOf())) {
+        return 'VALUE_INVALID';
+      }
+      return ['d', parsedDate.getTime()];
+
+    // type "n" is used for numeric cells.
+    //
+    // An optional `s` attribute defines how this number should be formatted — 
+    // it should be a zero-based index of the style (XF record) in `styles.xml`.
+    //
+    // Example:
+    //
+    // <c r="A1" s="1" t="n">
+    //   <v>123.45</v>
+    // </c>
+    //
+    case 'n':
+      // Numeric cell value is allowed to be missing in the XLSX specification
+      // because "n" is the default type of a cell, so it ends up representing empty cells too.
+      if (!v) {
+        return EMPTY_CELL;
+      }
+      // XLSX does support `type: "d"` cells for storing dates, but it's not commonly used.
+      // Instead, it prefers using `type: "n"` cells for storing dates as timestamps
+      // with a corresponding `s` formatting style.
+      if (s) {
+        var styleId = Number(s);
+        // The style ID value could be:
+        // * not a number
+        // * a number but a fractional one
+        // * an integer that is out of bounds of the styles array
+        if (isNaN(styleId) || styles[styleId] === undefined) {
+          return 'FORMAT_INVALID';
+        }
+        // Whether it's a date cell or just a numeric cell could only be determined
+        // by looking at the formatting style.
+        if (isDateFormatStyle(styles[styleId], defaultDateFormat, dateTemplateParser)) {
+          var timestamp = Number(v);
+          if (isNaN(timestamp)) {
+            return 'VALUE_INVALID';
+          }
+          // First, parse the "serial date" number from string.
+          // Then convert the "serial date" number to a date timestamp.
+          return ['d', parseExcelTimestamp(timestamp, epoch1904)];
+        }
+      }
+      // Return the cell value as a number,
+      // unless custom `parseNumber()` function was passed,
+      // in which case return the number as an unparsed string.
+      // Some people prefer passing a custom `parseNumber()` function
+      // to parse "big integers" without losing any precision.
+      if (parseNumberCustom) {
+        return ['n', v];
+      }
+      var number = Number(v);
+      if (isNaN(number)) {
+        return 'VALUE_INVALID';
       }
-    }
+      return ['n', number];
+    default:
+      return 'TYPE_INVALID';
   }
 }
 //# sourceMappingURL=parseCell.js.map

package/modules/xlsx/parseCell.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseCell.js","names":["parseCellValue","parseCellAddress","parseCell","attributes","value","inlineString","sharedStrings","styles","epoch1904","options","_parseCellAddress","r","_parseCellAddress2","_slicedToArray","row","column","type","t","styleId","s","Number","undefined","createInitialStateInCell","v","is","rPh","onOpenTagInCell","tagName","state","onCloseTagInCell","onTextInCell","text"],"sources":["../../source/xlsx/parseCell.js"],"sourcesContent":["import parseCellValue from './parseCellValue.js'\r\nimport parseCellAddress from './parseCellAddress.js'\r\n\r\n// Example of a `<c/>`ell element:\r\n//\r\n// <c>\r\n//    <f>string</f> — formula.\r\n//    <v>string</v> — formula pre-computed value.\r\n//    <is>\r\n//       <t>string</t> — an `inlineStr` string (rather than a \"common string\" from a dictionary).\r\n//       <r>\r\n//          <rPr>\r\n//            ...\r\n//          </rPr>\r\n//          <t>string</t>\r\n//       </r>\r\n//       <rPh sb=\"1\" eb=\"1\">\r\n//          <t>string</t>\r\n//       </rPh>\r\n//       <phoneticPr fontId=\"1\"/>\r\n//    </is>\r\n//    <extLst>\r\n//       <ext>\r\n//          <!--any element-->\r\n//       </ext>\r\n//    </extLst>\r\n// </c>\r\n//\r\nexport default function 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  const [row, column] = parseCellAddress(attributes.r)\r\n  const type = attributes.t\r\n  const styleId = attributes.s ? Number(attributes.s) : undefined\r\n\r\n  return {\r\n    row,\r\n    column,\r\n    value: parseCellValue(value, type, {\r\n      inlineString,\r\n      styleId,\r\n      styles,\r\n      sharedStrings,\r\n      epoch1904,\r\n      options\r\n    })\r\n  }\r\n}\r\n\r\nexport function createInitialStateInCell() {\r\n  return {\r\n    v: false,\r\n    is: false,\r\n    t: false,\r\n    r: false,\r\n    rPh: false,\r\n    value: undefined,\r\n    inlineString: undefined,\r\n    attributes: undefined\r\n  }\r\n}\r\n\r\nexport function onOpenTagInCell(tagName, attributes, state) {\r\n  if (tagName === 'v') {\r\n    state.v = true\r\n  } else if (tagName === 'is') {\r\n    // The possible children of <is> are:\r\n    // * <t> (Text): The standard child to hold plain, simple text.\r\n    // * <r> (Rich Text Run): Used for applying different formatting styles (like bold or italic) to specific segments of text within a single cell.\r\n    // * <rPh> (Phonetic Run): Used primarily for East Asian languages to provide phonetic reading/pronunciation data (e.g., furigana in Japanese). It associates a phonetic pronunciation run right alongside the base string text tag <t>.\r\n    // * <phoneticPr> (Phonetic Properties): Defines formatting and settings for the phonetic text.\r\n    state.is = true\r\n    state.inlineString = ''\r\n  } else if (tagName === 't') {\r\n    state.t = true\r\n  } else if (tagName === 'r') {\r\n    // The possible children of <r/> are:\r\n    // * <rPr> (Run Properties): The formatting properties for the text (font, size, color, bold, italic, etc.).\r\n    // * <t> (Text): The actual text payload.\r\n    // * <rPh> (Phonetic Run): Phonetic pronunciation guidance (used for East Asian languages like Japanese). It associates a phonetic pronunciation run right alongside the base string text tag <t>.\r\n    state.r = true\r\n  } else if (tagName === 'rPh') {\r\n    // The possible children of <rPh/> are:\r\n    // * <t> (Text):  Contains the actual phonetic text or reading (usually in Katakana for Japanese) that corresponds to the associated character string.\r\n    state.rPh = true\r\n  }\r\n}\r\n\r\nexport function onCloseTagInCell(tagName, state) {\r\n  if (tagName === 'v') {\r\n    state.v = false\r\n  } else if (tagName === 'is') {\r\n    state.is = false\r\n  } else if (tagName === 't') {\r\n    state.t = false\r\n  } else if (tagName === 'r') {\r\n    state.r = false\r\n  } else if (tagName === 'rPh') {\r\n    state.rPh = false\r\n  }\r\n}\r\n\r\nexport function onTextInCell(text, state) {\r\n  if (state.v) {\r\n    state.value = text\r\n  } else if (state.is) {\r\n    if (state.rPh) {\r\n      // Ignore anything inside `<rPh/>` tags\r\n    } else if (state.t) {\r\n      if (state.r) {\r\n        // An `<r/>` element could contain multiple `<t/>` elements,\r\n        // the text content from all of which should be concatenated.\r\n        state.inlineString += text\r\n      } else {\r\n        state.inlineString = text\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;AAAA,OAAOA,cAAc,MAAM,qBAAqB;AAChD,OAAOC,gBAAgB,MAAM,uBAAuB;;AAEpD;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,eAAe,SAASC,SAASA,CAC/BC,UAAU,EACVC,KAAK,EACLC,YAAY,EACZC,aAAa,EACbC,MAAM,EACNC,SAAS,EACTC,OAAO,EACP;EACA,IAAAC,iBAAA,GAAsBT,gBAAgB,CAACE,UAAU,CAACQ,CAAC,CAAC;IAAAC,kBAAA,GAAAC,cAAA,CAAAH,iBAAA;IAA7CI,GAAG,GAAAF,kBAAA;IAAEG,MAAM,GAAAH,kBAAA;EAClB,IAAMI,IAAI,GAAGb,UAAU,CAACc,CAAC;EACzB,IAAMC,OAAO,GAAGf,UAAU,CAACgB,CAAC,GAAGC,MAAM,CAACjB,UAAU,CAACgB,CAAC,CAAC,GAAGE,SAAS;EAE/D,OAAO;IACLP,GAAG,EAAHA,GAAG;IACHC,MAAM,EAANA,MAAM;IACNX,KAAK,EAAEJ,cAAc,CAACI,KAAK,EAAEY,IAAI,EAAE;MACjCX,YAAY,EAAZA,YAAY;MACZa,OAAO,EAAPA,OAAO;MACPX,MAAM,EAANA,MAAM;MACND,aAAa,EAAbA,aAAa;MACbE,SAAS,EAATA,SAAS;MACTC,OAAO,EAAPA;IACF,CAAC;EACH,CAAC;AACH;AAEA,OAAO,SAASa,wBAAwBA,CAAA,EAAG;EACzC,OAAO;IACLC,CAAC,EAAE,KAAK;IACRC,EAAE,EAAE,KAAK;IACTP,CAAC,EAAE,KAAK;IACRN,CAAC,EAAE,KAAK;IACRc,GAAG,EAAE,KAAK;IACVrB,KAAK,EAAEiB,SAAS;IAChBhB,YAAY,EAAEgB,SAAS;IACvBlB,UAAU,EAAEkB;EACd,CAAC;AACH;AAEA,OAAO,SAASK,eAAeA,CAACC,OAAO,EAAExB,UAAU,EAAEyB,KAAK,EAAE;EAC1D,IAAID,OAAO,KAAK,GAAG,EAAE;IACnBC,KAAK,CAACL,CAAC,GAAG,IAAI;EAChB,CAAC,MAAM,IAAII,OAAO,KAAK,IAAI,EAAE;IAC3B;IACA;IACA;IACA;IACA;IACAC,KAAK,CAACJ,EAAE,GAAG,IAAI;IACfI,KAAK,CAACvB,YAAY,GAAG,EAAE;EACzB,CAAC,MAAM,IAAIsB,OAAO,KAAK,GAAG,EAAE;IAC1BC,KAAK,CAACX,CAAC,GAAG,IAAI;EAChB,CAAC,MAAM,IAAIU,OAAO,KAAK,GAAG,EAAE;IAC1B;IACA;IACA;IACA;IACAC,KAAK,CAACjB,CAAC,GAAG,IAAI;EAChB,CAAC,MAAM,IAAIgB,OAAO,KAAK,KAAK,EAAE;IAC5B;IACA;IACAC,KAAK,CAACH,GAAG,GAAG,IAAI;EAClB;AACF;AAEA,OAAO,SAASI,gBAAgBA,CAACF,OAAO,EAAEC,KAAK,EAAE;EAC/C,IAAID,OAAO,KAAK,GAAG,EAAE;IACnBC,KAAK,CAACL,CAAC,GAAG,KAAK;EACjB,CAAC,MAAM,IAAII,OAAO,KAAK,IAAI,EAAE;IAC3BC,KAAK,CAACJ,EAAE,GAAG,KAAK;EAClB,CAAC,MAAM,IAAIG,OAAO,KAAK,GAAG,EAAE;IAC1BC,KAAK,CAACX,CAAC,GAAG,KAAK;EACjB,CAAC,MAAM,IAAIU,OAAO,KAAK,GAAG,EAAE;IAC1BC,KAAK,CAACjB,CAAC,GAAG,KAAK;EACjB,CAAC,MAAM,IAAIgB,OAAO,KAAK,KAAK,EAAE;IAC5BC,KAAK,CAACH,GAAG,GAAG,KAAK;EACnB;AACF;AAEA,OAAO,SAASK,YAAYA,CAACC,IAAI,EAAEH,KAAK,EAAE;EACxC,IAAIA,KAAK,CAACL,CAAC,EAAE;IACXK,KAAK,CAACxB,KAAK,GAAG2B,IAAI;EACpB,CAAC,MAAM,IAAIH,KAAK,CAACJ,EAAE,EAAE;IACnB,IAAII,KAAK,CAACH,GAAG,EAAE;MACb;IAAA,CACD,MAAM,IAAIG,KAAK,CAACX,CAAC,EAAE;MAClB,IAAIW,KAAK,CAACjB,CAAC,EAAE;QACX;QACA;QACAiB,KAAK,CAACvB,YAAY,IAAI0B,IAAI;MAC5B,CAAC,MAAM;QACLH,KAAK,CAACvB,YAAY,GAAG0B,IAAI;MAC3B;IACF;EACF;AACF"}
+{"version":3,"file":"parseCell.js","names":["parseExcelTimestamp","isDateFormatStyle","EMPTY_CELL_VALUE","EMPTY_CELL","parseCell","t","s","v","inlineString","_ref","_ref2","_slicedToArray","sharedStrings","styles","epoch1904","defaultDateFormat","dateTemplateParser","parseNumberCustom","undefined","sharedStringIndex","Number","isNaN","parsedDate","Date","valueOf","getTime","styleId","timestamp","number"],"sources":["../../source/xlsx/parseCell.js"],"sourcesContent":["import parseExcelTimestamp from './parseExcelTimestamp.js'\r\nimport isDateFormatStyle from './isDateFormatStyle.js'\r\n\r\n// An empty cell has `null` value.\r\nconst EMPTY_CELL_VALUE = null\r\n\r\n// This variable represents a cell with a `null` value.\r\n// It is exported only to be specified as a dependency when using `worker-f`.\r\nexport const EMPTY_CELL = [null, EMPTY_CELL_VALUE]\r\n\r\n/**\r\n * Parses a cell from the info extracted from XML.\r\n * @param {string} [t] — `<c t/>` attribute value (cell type). One of: b (Boolean), e (Error), n (Number), d (Date), s (String).\r\n * @param {string} [s] — `<c s/>` attribute value (formatting style ID). When present, should be a stringified zero-based index of the formatting style for a numberic cell.\r\n * @param {string} [v] — `<v/>` element text content (value). Will be `undefined` if the `<v/>` element absent. Will be an empty string `\"\"` if the `<v/>` element is present but is empty.\r\n * @param {string} [inlineString] — Inline string value.\r\n * @param {any[]} parameters\r\n * @returns {[string|null,string|number|boolean|null] | string} Either `[type, value]` or `error`, where `value` is the cell value, `type` depends on the type of `value` and could be one of: 's' (string), 'b' (boolean), 'n' (number string), 'd' (date timestamp), 'e' (formula cell error), `null` (null); `error` is an error message: `VALUE_MISSING`, `VALUE_INVALID`, `FORMAT_INVALID`, `TYPE_INVALID`.\r\n */\r\nexport default function parseCell(\r\n  t,\r\n  s,\r\n  v,\r\n  inlineString,\r\n  [\r\n    sharedStrings,\r\n    styles,\r\n    epoch1904,\r\n    defaultDateFormat,\r\n    dateTemplateParser,\r\n    parseNumberCustom\r\n  ]\r\n) {\r\n  // Available Excel cell types:\r\n  // https://github.com/SheetJS/sheetjs/blob/19620da30be2a7d7b9801938a0b9b1fd3c4c4b00/docbits/52_datatype.md\r\n  //\r\n  // Some other document (seems to be old):\r\n  // http://webapp.docx4java.org/OnlineDemo/ecma376/SpreadsheetML/ST_CellType.html\r\n  //\r\n  // The default cell type is \"n\" (numeric), according to XLSX specification.\r\n  //\r\n  switch (t || 'n') {\r\n    // `t=\"str\"` means that the cell value is calculated using a formula.\r\n    // The formula is defined as the text of a child `<f/>` element.\r\n    //\r\n    // It could optionally include a `<v/>` element whose text is the cached result\r\n    // of the calculation from the last time the file was saved in a spreadsheet editor application.\r\n    //\r\n    // An optional `<v/>` element holds a pre-computed result of the formula defined by `<f/>`.\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"B3\" t=\"str\">\r\n    // \t<f>CONCATENATE(C1,D1)</f>\r\n    // \t<v>C1ValueD1Value</v>\r\n    // </c>\r\n    //\r\n    // Here's a guide on formulas in XLSX files:\r\n    // https://github.com/MiniMax-AI/skills/blob/main/skills/minimax-xlsx/references/validate.md\r\n    //\r\n    case 'str':\r\n      // The `<v/>` element could be absent because it's not required to be pre-computed by the spec.\r\n      // In such case, `v` argument value would be `undefined`.\r\n      // Because this package can't include the whole formula calculation engine,\r\n      // it has to interpret this situation as an error.\r\n      if (v === undefined) {\r\n        return 'VALUE_MISSING'\r\n      }\r\n      // The `<v/>` element could be present but its text content could be empty\r\n      // because the formula returns an empty string.\r\n      // For example, a valid case of `v` argument value being an empty string `\"\"` is when\r\n      // a formula in cell `A1` is `=CONCATENATE(B1,C1)` and both `B1` and `C1` cells are empty.\r\n      if (!v) {\r\n        return EMPTY_CELL\r\n      }\r\n      return ['s', v]\r\n\r\n    // `t=\"inlineStr\"` means that `<is/>` holds the string value.\r\n    //\r\n    // Inside a `<c t=\"inlineStr\"/>`, the specification requires there to exist an `<is/>` element,\r\n    // and within that `<is/>` element it requires to exist a `<t/>` element.\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A1\" s=\"1\" t=\"inlineStr\">\r\n    //   <is>\r\n    //     <t>\r\n    //       Test 123\r\n    //     </t>\r\n    //   </is>\r\n    // </c>\r\n    //\r\n    case 'inlineStr':\r\n      if (inlineString === undefined) {\r\n        return 'VALUE_MISSING'\r\n      }\r\n      return ['s', inlineString]\r\n\r\n    // `type=\"s\"` means that the string value is stored in the Shared Strings Table.\r\n    // This way it attempts to compress the `.xlsx` file by reusing all string values\r\n    // in case they repeat throughout the spreadsheet.\r\n    //\r\n    // This optimization can't be used when writing an `.xlsx` file in a \"streaming\"\r\n    // fashion, i.e. when the entire spreadsheet data is not known in adavance\r\n    // at the start of writing the file.\r\n    // But it can be used in all other situations. And hence, it is used.\r\n    // So this is the most common cell type, actually.\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A3\" t=\"s\">\r\n    //   <v>3</v>\r\n    // </c>\r\n    //\r\n    case 's':\r\n      // If a cell has no value then there's no `<c/>` element for it.\r\n      // If a `<c/>` element exists then it's not empty.\r\n      // The `<v/>` element's text is a zero-based index in the \"shared strings\" dictionary.\r\n      if (!v) {\r\n        return 'VALUE_MISSING'\r\n      }\r\n      const sharedStringIndex = Number(v)\r\n      // The shared string index value could be:\r\n      // * not a number\r\n      // * a number but a fractional one\r\n      // * an integer that is out of bounds of the shared strings array\r\n      if (isNaN(sharedStringIndex) || sharedStrings[sharedStringIndex] === undefined) {\r\n        return 'VALUE_INVALID'\r\n      }\r\n      return ['s', sharedStrings[sharedStringIndex]]\r\n\r\n    // Boolean (TRUE/FALSE) values are stored as either \"1\" or \"0\" in cells of type \"b\".\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A1\" t=\"b\">\r\n    //   <v>1</v>\r\n    // </c>\r\n    //\r\n    case 'b':\r\n      if (!v) {\r\n        return 'VALUE_MISSING'\r\n      }\r\n      if (v === '1') {\r\n        return ['b', true]\r\n      }\r\n      if (v === '0') {\r\n        return ['b', false]\r\n      }\r\n      return 'VALUE_INVALID'\r\n\r\n    // If cell type is \"e\", the `<v/>` element's text is an error code string (required).\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A1\" t=\"e\">\r\n    //   <f>1/0</f>\r\n    //   <v>#DIV/0!</v>\r\n    // </c>\r\n    //\r\n    case 'e':\r\n      // Examples of error codes:\r\n      //\r\n      // '#NULL!'\r\n      // '#DIV/0!'\r\n      // '#VALUE!'\r\n      // '#REF!'\r\n      // '#NAME!'\r\n      // '#NUM!'\r\n      // '#N/A'\r\n      // '#SPILL!'\r\n      //\r\n      // The description of each error could be read in the formulas guide:\r\n      // https://github.com/MiniMax-AI/skills/blob/main/skills/minimax-xlsx/references/validate.md\r\n      //\r\n      if (!v) {\r\n        return 'VALUE_MISSING'\r\n      }\r\n      return ['e', v]\r\n\r\n    // XLSX supports date cells of type \"d\", though it seems like it (almost?) never\r\n    // uses type \"d\" for storing dates, preferring type \"n\" and numeric timestamp instead.\r\n    // The value of a \"d\" cell is supposedly a string in \"ISO 8601\" format.\r\n    // I haven't seen an `.xlsx` file having such cells.\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A1\" s=\"1\" t=\"d\">\r\n    //   <v>\r\n    //     2021-06-10T00:47:45.700Z\r\n    //   </v>\r\n    // </c>\r\n    //\r\n    case 'd':\r\n      if (!v) {\r\n        return EMPTY_CELL\r\n      }\r\n      const parsedDate = new Date(v)\r\n      if (isNaN(parsedDate.valueOf())) {\r\n        return 'VALUE_INVALID'\r\n      }\r\n      return ['d', parsedDate.getTime()]\r\n\r\n    // type \"n\" is used for numeric cells.\r\n    //\r\n    // An optional `s` attribute defines how this number should be formatted — \r\n    // it should be a zero-based index of the style (XF record) in `styles.xml`.\r\n    //\r\n    // Example:\r\n    //\r\n    // <c r=\"A1\" s=\"1\" t=\"n\">\r\n    //   <v>123.45</v>\r\n    // </c>\r\n    //\r\n    case 'n':\r\n      // Numeric cell value is allowed to be missing in the XLSX specification\r\n      // because \"n\" is the default type of a cell, so it ends up representing empty cells too.\r\n      if (!v) {\r\n        return EMPTY_CELL\r\n      }\r\n      // XLSX does support `type: \"d\"` cells for storing dates, but it's not commonly used.\r\n      // Instead, it prefers using `type: \"n\"` cells for storing dates as timestamps\r\n      // with a corresponding `s` formatting style.\r\n      if (s) {\r\n        const styleId = Number(s)\r\n        // The style ID value could be:\r\n        // * not a number\r\n        // * a number but a fractional one\r\n        // * an integer that is out of bounds of the styles array\r\n        if (isNaN(styleId) || styles[styleId] === undefined) {\r\n          return 'FORMAT_INVALID'\r\n        }\r\n        // Whether it's a date cell or just a numeric cell could only be determined\r\n        // by looking at the formatting style.\r\n        if (isDateFormatStyle(styles[styleId], defaultDateFormat, dateTemplateParser)) {\r\n          const timestamp = Number(v)\r\n          if (isNaN(timestamp)) {\r\n            return 'VALUE_INVALID'\r\n          }\r\n          // First, parse the \"serial date\" number from string.\r\n          // Then convert the \"serial date\" number to a date timestamp.\r\n          return ['d', parseExcelTimestamp(timestamp, epoch1904)]\r\n        }\r\n      }\r\n      // Return the cell value as a number,\r\n      // unless custom `parseNumber()` function was passed,\r\n      // in which case return the number as an unparsed string.\r\n      // Some people prefer passing a custom `parseNumber()` function\r\n      // to parse \"big integers\" without losing any precision.\r\n      if (parseNumberCustom) {\r\n        return ['n', v]\r\n      }\r\n      const number = Number(v)\r\n      if (isNaN(number)) {\r\n        return 'VALUE_INVALID'\r\n      }\r\n      return ['n', number]\r\n\r\n    default:\r\n      return 'TYPE_INVALID'\r\n  }\r\n}"],"mappings":"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"}

package/modules/xlsx/parseCellAddress.js

@@ -13,24 +13,15 @@ export default function parseCellAddress(coordinatesString) {
   // Coordinate examples: "AA2091", "R988", "B1".
   var _coordinatesString$sp = coordinatesString.split(/(\d+)/),
     _coordinatesString$sp2 = _slicedToArray(_coordinatesString$sp, 2),
-    column = _coordinatesString$sp2[0],
-    row = _coordinatesString$sp2[1];
-  return [
-  // Row number (starting at `1`).
-  Number(row),
-  // Column number (starting at `1`).
-  // It's not clear if the `column` part could ever be non-trimmed,
-  // but this `.trim()` call was already here when I copied this code from somewhere.
-  getColumnNumberFromColumnLetters(column.trim())];
-}
-
-// Maps "A1"-like coordinates to `{ row, column }` numeric coordinates.
-var LETTERS = ['', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
+    columnLetters = _coordinatesString$sp2[0],
+    rowNumberString = _coordinatesString$sp2[1];
 
-// Converts a letter coordinate to a digit coordinate.
-// Examples: "A" -> 1, "B" -> 2, "Z" -> 26, "AA" -> 27, etc.
-function getColumnNumberFromColumnLetters(columnLetters) {
-  // `for ... of ...` would require Babel polyfill for iterating a string.
+  // Converts a letter coordinate to a digit coordinate.
+  // Examples: "A" -> 1, "B" -> 2, "Z" -> 26, "AA" -> 27, etc.
+  //
+  // This function is inlined only to avoid passing it in `worker-f` dependencies.
+  // Otherwise, it would throw: "getColumnNumberFromColumnLetters is not defined".
+  //
   var n = 0;
   var i = 0;
   while (i < columnLetters.length) {
@@ -38,6 +29,18 @@ function getColumnNumberFromColumnLetters(columnLetters) {
     n += LETTERS.indexOf(columnLetters[i]);
     i++;
   }
-  return n;
+  var columnNumberFromColumnLetters = n;
+  return [
+  // Row number (starting at `1`).
+  Number(rowNumberString),
+  // Column number (starting at `1`).
+  columnNumberFromColumnLetters];
 }
+
+// Maps "A1"-like coordinates to `{ row, column }` numeric coordinates.
+//
+// This is `export`ed only to be passed in `worker-f` dependencies.
+// Otherwise, it would throw: "LETTERS is not defined".
+//
+export var LETTERS = ['', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
 //# sourceMappingURL=parseCellAddress.js.map

package/modules/xlsx/parseCellAddress.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseCellAddress.js","names":["parseCellAddress","coordinatesString","_coordinatesString$sp","split","_coordinatesString$sp2","_slicedToArray","column","row","Number","getColumnNumberFromColumnLetters","trim","LETTERS","columnLetters","n","i","length","indexOf"],"sources":["../../source/xlsx/parseCellAddress.js"],"sourcesContent":["/**\r\n * Parses XLSX cell address into a row number and a column number.\r\n * @param {string} coordinatesString\r\n * @returns {number[]} Returns `[rowNumber, columnNumber]`\r\n */\r\nexport default function parseCellAddress(coordinatesString) {\r\n  // Coordinate examples: \"AA2091\", \"R988\", \"B1\".\r\n  const [column, row] = coordinatesString.split(/(\\d+)/)\r\n  return [\r\n    // Row number (starting at `1`).\r\n    Number(row),\r\n    // Column number (starting at `1`).\r\n\t\t// It's not clear if the `column` part could ever be non-trimmed,\r\n\t\t// but this `.trim()` call was already here when I copied this code from somewhere.\r\n    getColumnNumberFromColumnLetters(column.trim())\r\n  ]\r\n}\r\n\r\n// Maps \"A1\"-like coordinates to `{ row, column }` numeric coordinates.\r\nconst LETTERS = ['', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\r\n\r\n// Converts a letter coordinate to a digit coordinate.\r\n// Examples: \"A\" -> 1, \"B\" -> 2, \"Z\" -> 26, \"AA\" -> 27, etc.\r\nfunction getColumnNumberFromColumnLetters(columnLetters) {\r\n  // `for ... of ...` would require Babel polyfill for iterating a string.\r\n  let n = 0\r\n  let i = 0\r\n  while (i < columnLetters.length) {\r\n    n *= 26\r\n    n += LETTERS.indexOf(columnLetters[i])\r\n    i++\r\n  }\r\n  return n\r\n}\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,gBAAgBA,CAACC,iBAAiB,EAAE;EAC1D;EACA,IAAAC,qBAAA,GAAsBD,iBAAiB,CAACE,KAAK,CAAC,OAAO,CAAC;IAAAC,sBAAA,GAAAC,cAAA,CAAAH,qBAAA;IAA/CI,MAAM,GAAAF,sBAAA;IAAEG,GAAG,GAAAH,sBAAA;EAClB,OAAO;EACL;EACAI,MAAM,CAACD,GAAG,CAAC;EACX;EACF;EACA;EACEE,gCAAgC,CAACH,MAAM,CAACI,IAAI,CAAC,CAAC,CAAC,CAChD;AACH;;AAEA;AACA,IAAMC,OAAO,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;;AAEtJ;AACA;AACA,SAASF,gCAAgCA,CAACG,aAAa,EAAE;EACvD;EACA,IAAIC,CAAC,GAAG,CAAC;EACT,IAAIC,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAGF,aAAa,CAACG,MAAM,EAAE;IAC/BF,CAAC,IAAI,EAAE;IACPA,CAAC,IAAIF,OAAO,CAACK,OAAO,CAACJ,aAAa,CAACE,CAAC,CAAC,CAAC;IACtCA,CAAC,EAAE;EACL;EACA,OAAOD,CAAC;AACV"}
+{"version":3,"file":"parseCellAddress.js","names":["parseCellAddress","coordinatesString","_coordinatesString$sp","split","_coordinatesString$sp2","_slicedToArray","columnLetters","rowNumberString","n","i","length","LETTERS","indexOf","columnNumberFromColumnLetters","Number"],"sources":["../../source/xlsx/parseCellAddress.js"],"sourcesContent":["/**\r\n * Parses XLSX cell address into a row number and a column number.\r\n * @param {string} coordinatesString\r\n * @returns {number[]} Returns `[rowNumber, columnNumber]`\r\n */\r\nexport default function parseCellAddress(coordinatesString) {\r\n  // Coordinate examples: \"AA2091\", \"R988\", \"B1\".\r\n  const [columnLetters, rowNumberString] = coordinatesString.split(/(\\d+)/)\r\n\r\n  // Converts a letter coordinate to a digit coordinate.\r\n  // Examples: \"A\" -> 1, \"B\" -> 2, \"Z\" -> 26, \"AA\" -> 27, etc.\r\n  //\r\n  // This function is inlined only to avoid passing it in `worker-f` dependencies.\r\n  // Otherwise, it would throw: \"getColumnNumberFromColumnLetters is not defined\".\r\n  //\r\n  let n = 0\r\n  let i = 0\r\n  while (i < columnLetters.length) {\r\n    n *= 26\r\n    n += LETTERS.indexOf(columnLetters[i])\r\n    i++\r\n  }\r\n  const columnNumberFromColumnLetters = n\r\n\r\n  return [\r\n    // Row number (starting at `1`).\r\n    Number(rowNumberString),\r\n    // Column number (starting at `1`).\r\n    columnNumberFromColumnLetters\r\n  ]\r\n}\r\n\r\n// Maps \"A1\"-like coordinates to `{ row, column }` numeric coordinates.\r\n//\r\n// This is `export`ed only to be passed in `worker-f` dependencies.\r\n// Otherwise, it would throw: \"LETTERS is not defined\".\r\n//\r\nexport const LETTERS = ['', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASA,gBAAgBA,CAACC,iBAAiB,EAAE;EAC1D;EACA,IAAAC,qBAAA,GAAyCD,iBAAiB,CAACE,KAAK,CAAC,OAAO,CAAC;IAAAC,sBAAA,GAAAC,cAAA,CAAAH,qBAAA;IAAlEI,aAAa,GAAAF,sBAAA;IAAEG,eAAe,GAAAH,sBAAA;;EAErC;EACA;EACA;EACA;EACA;EACA;EACA,IAAII,CAAC,GAAG,CAAC;EACT,IAAIC,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAGH,aAAa,CAACI,MAAM,EAAE;IAC/BF,CAAC,IAAI,EAAE;IACPA,CAAC,IAAIG,OAAO,CAACC,OAAO,CAACN,aAAa,CAACG,CAAC,CAAC,CAAC;IACtCA,CAAC,EAAE;EACL;EACA,IAAMI,6BAA6B,GAAGL,CAAC;EAEvC,OAAO;EACL;EACAM,MAAM,CAACP,eAAe,CAAC;EACvB;EACAM,6BAA6B,CAC9B;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMF,OAAO,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC"}