is a live demo.
+
+
+ Previewing data in a React data grid (click to show)
+
+[`react-data-grid`](https://npm.im/react-data-grid) is a data grid tailored for
+react. It expects two properties: `rows` of data objects and `columns` which
+describe the columns. For the purposes of massaging the data to fit the react
+data grid API it is easiest to start from an array of arrays.
+
+This demo starts by fetching a remote file and using `XLSX.read` to extract:
+
+```js
+import { useEffect, useState } from "react";
+import DataGrid from "react-data-grid";
+import { read, utils } from "xlsx";
+
+const url = "https://oss.sheetjs.com/test_files/RkNumber.xls";
+
+export default function App() {
+ const [columns, setColumns] = useState([]);
+ const [rows, setRows] = useState([]);
+ useEffect(() => {(async () => {
+ const wb = read(await (await fetch(url)).arrayBuffer(), { WTF: 1 });
+
+ /* use sheet_to_json with header: 1 to generate an array of arrays */
+ const data = utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]], { header: 1 });
+
+ /* see react-data-grid docs to understand the shape of the expected data */
+ setColumns(data[0].map((r) => ({ key: r, name: r })));
+ setRows(data.slice(1).map((r) => r.reduce((acc, x, i) => {
+ acc[data[0][i]] = x;
+ return acc;
+ }, {})));
+ })(); });
+
+ return ;
+}
+```
+
+
+
+
+ Previewing data in a VueJS data grid (click to show)
+
+[`vue3-table-lite`](https://github.com/linmasahiro/vue3-table-lite) is a simple
+VueJS 3 data table. It is featured [in the VueJS demo](/demos/vue/modify/).
+
+
+
+
+ Populating a database (SQL or no-SQL) (click to show)
+
+The [`database` demo](/demos/database/) includes examples of working with
+databases and query results.
+
+
+
+
+ Numerical Computations with TensorFlow.js (click to show)
+
+[`@tensorflow/tfjs`](@tensorflow/tfjs) and other libraries expect data in simple
+arrays, well-suited for worksheets where each column is a data vector. That is
+the transpose of how most people use spreadsheets, where each row is a vector.
+
+A single `Array#map` can pull individual named rows from `sheet_to_json` export:
+
+```js
+const XLSX = require("xlsx");
+const tf = require('@tensorflow/tfjs');
+
+const key = "age"; // this is the field we want to pull
+const ages = XLSX.utils.sheet_to_json(worksheet).map(r => r[key]);
+const tf_data = tf.tensor1d(ages);
+```
+
+All fields can be processed at once using a transpose of the 2D tensor generated
+with the `sheet_to_json` export with `header: 1`. The first row, if it contains
+header labels, should be removed with a slice:
+
+```js
+const XLSX = require("xlsx");
+const tf = require('@tensorflow/tfjs');
+
+/* array of arrays of the data starting on the second row */
+const aoa = XLSX.utils.sheet_to_json(worksheet, {header: 1}).slice(1);
+/* dataset in the "correct orientation" */
+const tf_dataset = tf.tensor2d(aoa).transpose();
+/* pull out each dataset with a slice */
+const tf_field0 = tf_dataset.slice([0,0], [1,tensor.shape[1]]).flatten();
+const tf_field1 = tf_dataset.slice([1,0], [1,tensor.shape[1]]).flatten();
+```
+
+The [`array` demo](demos/array/) shows a complete example.
+
+
+
+
+### Generating HTML Tables
+
+**API**
+
+_Generate HTML Table from Worksheet_
+
+```js
+var html = XLSX.utils.sheet_to_html(worksheet);
+```
+
+The `sheet_to_html` utility function generates HTML code based on the worksheet
+data. Each cell in the worksheet is mapped to a `` element. Merged cells
+in the worksheet are serialized by setting `colspan` and `rowspan` attributes.
+
+**Examples**
+
+The `sheet_to_html` utility function generates HTML code that can be added to
+any DOM element by setting the `innerHTML`:
+
+```js
+var container = document.getElementById("tavolo");
+container.innerHTML = XLSX.utils.sheet_to_html(worksheet);
+```
+
+Combining with `fetch`, constructing a site from a workbook is straightforward:
+
+
+ Vanilla JS + HTML fetch workbook and generate table previews (click to show)
+
+```html
+
+
+
+
+
+
+```
+
+
+
+
+ React fetch workbook and generate HTML table previews (click to show)
+
+It is generally recommended to use a React-friendly workflow, but it is possible
+to generate HTML and use it in React with `dangerouslySetInnerHTML`:
+
+```jsx
+function Tabeller(props) {
+ /* the workbook object is the state */
+ const [workbook, setWorkbook] = React.useState(XLSX.utils.book_new());
+
+ /* fetch and update the workbook with an effect */
+ React.useEffect(() => { (async() => {
+ /* fetch and parse workbook -- see the fetch example for details */
+ const wb = XLSX.read(await (await fetch("sheetjs.xlsx")).arrayBuffer());
+ setWorkbook(wb);
+ })(); });
+
+ return workbook.SheetNames.map(name => (<>
+ name
+
+ ));
+}
+```
+
+The [`react` demo](demos/react) includes more React examples.
+
+
+
+
+ VueJS fetch workbook and generate HTML table previews (click to show)
+
+It is generally recommended to use a VueJS-friendly workflow, but it is possible
+to generate HTML and use it in VueJS with the `v-html` directive:
+
+```jsx
+import { read, utils } from 'xlsx';
+import { reactive } from 'vue';
+
+const S5SComponent = {
+ mounted() { (async() => {
+ /* fetch and parse workbook -- see the fetch example for details */
+ const workbook = read(await (await fetch("sheetjs.xlsx")).arrayBuffer());
+ /* loop through the worksheet names in order */
+ workbook.SheetNames.forEach(name => {
+ /* generate HTML from the corresponding worksheets */
+ const html = utils.sheet_to_html(workbook.Sheets[name]);
+ /* add to state */
+ this.wb.wb.push({ name, html });
+ });
+ })(); },
+ /* this state mantra is required for array updates to work */
+ setup() { return { wb: reactive({ wb: [] }) }; },
+ template: `
+ `
+};
+```
+
+The [`vuejs` demo](demos/vue) includes more React examples.
+
+
+
+### Generating Single-Worksheet Snapshots
+
+The `sheet_to_*` functions accept a worksheet object.
+
+**API**
+
+_Generate a CSV from a single worksheet_
+
+```js
+var csv = XLSX.utils.sheet_to_csv(worksheet, opts);
+```
+
+This snapshot is designed to replicate the "CSV UTF8 (`.csv`)" output type.
+["Delimiter-Separated Output"](#delimiter-separated-output) describes the
+function and the optional `opts` argument in more detail.
+
+_Generate "Text" from a single worksheet_
+
+```js
+var txt = XLSX.utils.sheet_to_txt(worksheet, opts);
+```
+
+This snapshot is designed to replicate the "UTF16 Text (`.txt`)" output type.
+["Delimiter-Separated Output"](#delimiter-separated-output) describes the
+function and the optional `opts` argument in more detail.
+
+_Generate a list of formulae from a single worksheet_
+
+```js
+var fmla = XLSX.utils.sheet_to_formulae(worksheet);
+```
+
+This snapshot generates an array of entries representing the embedded formulae.
+Array formulae are rendered in the form `range=formula` while plain cells are
+rendered in the form `cell=formula or value`. String literals are prefixed with
+an apostrophe `'`, consistent with Excel's formula bar display.
+
+["Formulae Output"](#formulae-output) describes the function in more detail.
+
+## Interface
+
+`XLSX` is the exposed variable in the browser and the exported node variable
+
+`XLSX.version` is the version of the library (added by the build script).
+
+`XLSX.SSF` is an embedded version of the [format library](https://git.io/ssf).
+
+### Parsing functions
+
+`XLSX.read(data, read_opts)` attempts to parse `data`.
+
+`XLSX.readFile(filename, read_opts)` attempts to read `filename` and parse.
+
+Parse options are described in the [Parsing Options](#parsing-options) section.
+
+### Writing functions
+
+`XLSX.write(wb, write_opts)` attempts to write the workbook `wb`
+
+`XLSX.writeFile(wb, filename, write_opts)` attempts to write `wb` to `filename`.
+In browser-based environments, it will attempt to force a client-side download.
+
+`XLSX.writeFileAsync(wb, filename, o, cb)` attempts to write `wb` to `filename`.
+If `o` is omitted, the writer will use the third argument as the callback.
+
+`XLSX.stream` contains a set of streaming write functions.
+
+Write options are described in the [Writing Options](#writing-options) section.
+
+### Utilities
+
+Utilities are available in the `XLSX.utils` object and are described in the
+[Utility Functions](#utility-functions) section:
+
+**Constructing:**
+
+- `book_new` creates an empty workbook
+- `book_append_sheet` adds a worksheet to a workbook
+
+**Importing:**
+
+- `aoa_to_sheet` converts an array of arrays of JS data to a worksheet.
+- `json_to_sheet` converts an array of JS objects to a worksheet.
+- `table_to_sheet` converts a DOM TABLE element to a worksheet.
+- `sheet_add_aoa` adds an array of arrays of JS data to an existing worksheet.
+- `sheet_add_json` adds an array of JS objects to an existing worksheet.
+
+
+**Exporting:**
+
+- `sheet_to_json` converts a worksheet object to an array of JSON objects.
+- `sheet_to_csv` generates delimiter-separated-values output.
+- `sheet_to_txt` generates UTF16 formatted text.
+- `sheet_to_html` generates HTML output.
+- `sheet_to_formulae` generates a list of the formulae (with value fallbacks).
+
+
+**Cell and cell address manipulation:**
+
+- `format_cell` generates the text value for a cell (using number formats).
+- `encode_row / decode_row` converts between 0-indexed rows and 1-indexed rows.
+- `encode_col / decode_col` converts between 0-indexed columns and column names.
+- `encode_cell / decode_cell` converts cell addresses.
+- `encode_range / decode_range` converts cell ranges.
+
+## Common Spreadsheet Format
+
+SheetJS conforms to the Common Spreadsheet Format (CSF):
+
+### General Structures
+
+Cell address objects are stored as `{c:C, r:R}` where `C` and `R` are 0-indexed
+column and row numbers, respectively. For example, the cell address `B5` is
+represented by the object `{c:1, r:4}`.
+
+Cell range objects are stored as `{s:S, e:E}` where `S` is the first cell and
+`E` is the last cell in the range. The ranges are inclusive. For example, the
+range `A3:B7` is represented by the object `{s:{c:0, r:2}, e:{c:1, r:6}}`.
+Utility functions perform a row-major order walk traversal of a sheet range:
+
+```js
+for(var R = range.s.r; R <= range.e.r; ++R) {
+ for(var C = range.s.c; C <= range.e.c; ++C) {
+ var cell_address = {c:C, r:R};
+ /* if an A1-style address is needed, encode the address */
+ var cell_ref = XLSX.utils.encode_cell(cell_address);
+ }
+}
+```
+
+### Cell Object
+
+Cell objects are plain JS objects with keys and values following the convention:
+
+| Key | Description |
+| --- | ---------------------------------------------------------------------- |
+| `v` | raw value (see Data Types section for more info) |
+| `w` | formatted text (if applicable) |
+| `t` | type: `b` Boolean, `e` Error, `n` Number, `d` Date, `s` Text, `z` Stub |
+| `f` | cell formula encoded as an A1-style string (if applicable) |
+| `F` | range of enclosing array if formula is array formula (if applicable) |
+| `D` | if true, array formula is dynamic (if applicable) |
+| `r` | rich text encoding (if applicable) |
+| `h` | HTML rendering of the rich text (if applicable) |
+| `c` | comments associated with the cell |
+| `z` | number format string associated with the cell (if requested) |
+| `l` | cell hyperlink object (`.Target` holds link, `.Tooltip` is tooltip) |
+| `s` | the style/theme of the cell (if applicable) |
+
+Built-in export utilities (such as the CSV exporter) will use the `w` text if it
+is available. To change a value, be sure to delete `cell.w` (or set it to
+`undefined`) before attempting to export. The utilities will regenerate the `w`
+text from the number format (`cell.z`) and the raw value if possible.
+
+The actual array formula is stored in the `f` field of the first cell in the
+array range. Other cells in the range will omit the `f` field.
+
+#### Data Types
+
+The raw value is stored in the `v` value property, interpreted based on the `t`
+type property. This separation allows for representation of numbers as well as
+numeric text. There are 6 valid cell types:
+
+| Type | Description |
+| :--: | :-------------------------------------------------------------------- |
+| `b` | Boolean: value interpreted as JS `boolean` |
+| `e` | Error: value is a numeric code and `w` property stores common name ** |
+| `n` | Number: value is a JS `number` ** |
+| `d` | Date: value is a JS `Date` object or string to be parsed as Date ** |
+| `s` | Text: value interpreted as JS `string` and written as text ** |
+| `z` | Stub: blank stub cell that is ignored by data processing utilities ** |
+
+
+ Error values and interpretation (click to show)
+
+| Value | Error Meaning |
+| -----: | :-------------- |
+| `0x00` | `#NULL!` |
+| `0x07` | `#DIV/0!` |
+| `0x0F` | `#VALUE!` |
+| `0x17` | `#REF!` |
+| `0x1D` | `#NAME?` |
+| `0x24` | `#NUM!` |
+| `0x2A` | `#N/A` |
+| `0x2B` | `#GETTING_DATA` |
+
+
+
+Type `n` is the Number type. This includes all forms of data that Excel stores
+as numbers, such as dates/times and Boolean fields. Excel exclusively uses data
+that can be fit in an IEEE754 floating point number, just like JS Number, so the
+`v` field holds the raw number. The `w` field holds formatted text. Dates are
+stored as numbers by default and converted with `XLSX.SSF.parse_date_code`.
+
+Type `d` is the Date type, generated only when the option `cellDates` is passed.
+Since JSON does not have a natural Date type, parsers are generally expected to
+store ISO 8601 Date strings like you would get from `date.toISOString()`. On
+the other hand, writers and exporters should be able to handle date strings and
+JS Date objects. Note that Excel disregards timezone modifiers and treats all
+dates in the local timezone. The library does not correct for this error.
+
+Type `s` is the String type. Values are explicitly stored as text. Excel will
+interpret these cells as "number stored as text". Generated Excel files
+automatically suppress that class of error, but other formats may elicit errors.
+
+Type `z` represents blank stub cells. They are generated in cases where cells
+have no assigned value but hold comments or other metadata. They are ignored by
+the core library data processing utility functions. By default these cells are
+not generated; the parser `sheetStubs` option must be set to `true`.
+
+
+#### Dates
+
+
+ Excel Date Code details (click to show)
+
+By default, Excel stores dates as numbers with a format code that specifies date
+processing. For example, the date `19-Feb-17` is stored as the number `42785`
+with a number format of `d-mmm-yy`. The `SSF` module understands number formats
+and performs the appropriate conversion.
+
+XLSX also supports a special date type `d` where the data is an ISO 8601 date
+string. The formatter converts the date back to a number.
+
+The default behavior for all parsers is to generate number cells. Setting
+`cellDates` to true will force the generators to store dates.
+
+
+
+
+ Time Zones and Dates (click to show)
+
+Excel has no native concept of universal time. All times are specified in the
+local time zone. Excel limitations prevent specifying true absolute dates.
+
+Following Excel, this library treats all dates as relative to local time zone.
+
+
+
+
+ Epochs: 1900 and 1904 (click to show)
+
+Excel supports two epochs (January 1 1900 and January 1 1904).
+The workbook's epoch can be determined by examining the workbook's
+`wb.Workbook.WBProps.date1904` property:
+
+```js
+!!(((wb.Workbook||{}).WBProps||{}).date1904)
+```
+
+
+
+### Sheet Objects
+
+Each key that does not start with `!` maps to a cell (using `A-1` notation)
+
+`sheet[address]` returns the cell object for the specified address.
+
+**Special sheet keys (accessible as `sheet[key]`, each starting with `!`):**
+
+- `sheet['!ref']`: A-1 based range representing the sheet range. Functions that
+ work with sheets should use this parameter to determine the range. Cells that
+ are assigned outside of the range are not processed. In particular, when
+ writing a sheet by hand, cells outside of the range are not included
+
+ Functions that handle sheets should test for the presence of `!ref` field.
+ If the `!ref` is omitted or is not a valid range, functions are free to treat
+ the sheet as empty or attempt to guess the range. The standard utilities that
+ ship with this library treat sheets as empty (for example, the CSV output is
+ empty string).
+
+ When reading a worksheet with the `sheetRows` property set, the ref parameter
+ will use the restricted range. The original range is set at `ws['!fullref']`
+
+- `sheet['!margins']`: Object representing the page margins. The default values
+ follow Excel's "normal" preset. Excel also has a "wide" and a "narrow" preset
+ but they are stored as raw measurements. The main properties are listed below:
+
+
+ Page margin details (click to show)
+
+| key | description | "normal" | "wide" | "narrow" |
+|----------|------------------------|:---------|:-------|:-------- |
+| `left` | left margin (inches) | `0.7` | `1.0` | `0.25` |
+| `right` | right margin (inches) | `0.7` | `1.0` | `0.25` |
+| `top` | top margin (inches) | `0.75` | `1.0` | `0.75` |
+| `bottom` | bottom margin (inches) | `0.75` | `1.0` | `0.75` |
+| `header` | header margin (inches) | `0.3` | `0.5` | `0.3` |
+| `footer` | footer margin (inches) | `0.3` | `0.5` | `0.3` |
+
+```js
+/* Set worksheet sheet to "normal" */
+ws["!margins"]={left:0.7, right:0.7, top:0.75,bottom:0.75,header:0.3,footer:0.3}
+/* Set worksheet sheet to "wide" */
+ws["!margins"]={left:1.0, right:1.0, top:1.0, bottom:1.0, header:0.5,footer:0.5}
+/* Set worksheet sheet to "narrow" */
+ws["!margins"]={left:0.25,right:0.25,top:0.75,bottom:0.75,header:0.3,footer:0.3}
+```
+
+
+#### Worksheet Object
+
+In addition to the base sheet keys, worksheets also add:
+
+- `ws['!cols']`: array of column properties objects. Column widths are actually
+ stored in files in a normalized manner, measured in terms of the "Maximum
+ Digit Width" (the largest width of the rendered digits 0-9, in pixels). When
+ parsed, the column objects store the pixel width in the `wpx` field, character
+ width in the `wch` field, and the maximum digit width in the `MDW` field.
+
+- `ws['!rows']`: array of row properties objects as explained later in the docs.
+ Each row object encodes properties including row height and visibility.
+
+- `ws['!merges']`: array of range objects corresponding to the merged cells in
+ the worksheet. Plain text formats do not support merge cells. CSV export
+ will write all cells in the merge range if they exist, so be sure that only
+ the first cell (upper-left) in the range is set.
+
+- `ws['!outline']`: configure how outlines should behave. Options default to
+ the default settings in Excel 2019:
+
+| key | Excel feature | default |
+|:----------|:----------------------------------------------|:--------|
+| `above` | Uncheck "Summary rows below detail" | `false` |
+| `left` | Uncheck "Summary rows to the right of detail" | `false` |
+
+- `ws['!protect']`: object of write sheet protection properties. The `password`
+ key specifies the password for formats that support password-protected sheets
+ (XLSX/XLSB/XLS). The writer uses the XOR obfuscation method. The following
+ keys control the sheet protection -- set to `false` to enable a feature when
+ sheet is locked or set to `true` to disable a feature:
+
+
+ Worksheet Protection Details (click to show)
+
+| key | feature (true=disabled / false=enabled) | default |
+|:----------------------|:----------------------------------------|:-----------|
+| `selectLockedCells` | Select locked cells | enabled |
+| `selectUnlockedCells` | Select unlocked cells | enabled |
+| `formatCells` | Format cells | disabled |
+| `formatColumns` | Format columns | disabled |
+| `formatRows` | Format rows | disabled |
+| `insertColumns` | Insert columns | disabled |
+| `insertRows` | Insert rows | disabled |
+| `insertHyperlinks` | Insert hyperlinks | disabled |
+| `deleteColumns` | Delete columns | disabled |
+| `deleteRows` | Delete rows | disabled |
+| `sort` | Sort | disabled |
+| `autoFilter` | Filter | disabled |
+| `pivotTables` | Use PivotTable reports | disabled |
+| `objects` | Edit objects | enabled |
+| `scenarios` | Edit scenarios | enabled |
+
+
+- `ws['!autofilter']`: AutoFilter object following the schema:
+
+```typescript
+type AutoFilter = {
+ ref:string; // A-1 based range representing the AutoFilter table range
+}
+```
+
+#### Chartsheet Object
+
+Chartsheets are represented as standard sheets. They are distinguished with the
+`!type` property set to `"chart"`.
+
+The underlying data and `!ref` refer to the cached data in the chartsheet. The
+first row of the chartsheet is the underlying header.
+
+#### Macrosheet Object
+
+Macrosheets are represented as standard sheets. They are distinguished with the
+`!type` property set to `"macro"`.
+
+#### Dialogsheet Object
+
+Dialogsheets are represented as standard sheets. They are distinguished with the
+`!type` property set to `"dialog"`.
+
+### Workbook Object
+
+`workbook.SheetNames` is an ordered list of the sheets in the workbook
+
+`wb.Sheets[sheetname]` returns an object representing the worksheet.
+
+`wb.Props` is an object storing the standard properties. `wb.Custprops` stores
+custom properties. Since the XLS standard properties deviate from the XLSX
+standard, XLS parsing stores core properties in both places.
+
+`wb.Workbook` stores [workbook-level attributes](#workbook-level-attributes).
+
+#### Workbook File Properties
+
+The various file formats use different internal names for file properties. The
+workbook `Props` object normalizes the names:
+
+
+ File Properties (click to show)
+
+| JS Name | Excel Description |
+|:--------------|:-------------------------------|
+| `Title` | Summary tab "Title" |
+| `Subject` | Summary tab "Subject" |
+| `Author` | Summary tab "Author" |
+| `Manager` | Summary tab "Manager" |
+| `Company` | Summary tab "Company" |
+| `Category` | Summary tab "Category" |
+| `Keywords` | Summary tab "Keywords" |
+| `Comments` | Summary tab "Comments" |
+| `LastAuthor` | Statistics tab "Last saved by" |
+| `CreatedDate` | Statistics tab "Created" |
+
+
+
+For example, to set the workbook title property:
+
+```js
+if(!wb.Props) wb.Props = {};
+wb.Props.Title = "Insert Title Here";
+```
+
+Custom properties are added in the workbook `Custprops` object:
+
+```js
+if(!wb.Custprops) wb.Custprops = {};
+wb.Custprops["Custom Property"] = "Custom Value";
+```
+
+Writers will process the `Props` key of the options object:
+
+```js
+/* force the Author to be "SheetJS" */
+XLSX.write(wb, {Props:{Author:"SheetJS"}});
+```
+
+### Workbook-Level Attributes
+
+`wb.Workbook` stores workbook-level attributes.
+
+#### Defined Names
+
+`wb.Workbook.Names` is an array of defined name objects which have the keys:
+
+
+ Defined Name Properties (click to show)
+
+| Key | Description |
+|:----------|:-----------------------------------------------------------------|
+| `Sheet` | Name scope. Sheet Index (0 = first sheet) or `null` (Workbook) |
+| `Name` | Case-sensitive name. Standard rules apply ** |
+| `Ref` | A1-style Reference (`"Sheet1!$A$1:$D$20"`) |
+| `Comment` | Comment (only applicable for XLS/XLSX/XLSB) |
+
+
+
+Excel allows two sheet-scoped defined names to share the same name. However, a
+sheet-scoped name cannot collide with a workbook-scope name. Workbook writers
+may not enforce this constraint.
+
+#### Workbook Views
+
+`wb.Workbook.Views` is an array of workbook view objects which have the keys:
+
+| Key | Description |
+|:----------------|:----------------------------------------------------|
+| `RTL` | If true, display right-to-left |
+
+#### Miscellaneous Workbook Properties
+
+`wb.Workbook.WBProps` holds other workbook properties:
+
+| Key | Description |
+|:----------------|:----------------------------------------------------|
+| `CodeName` | [VBA Project Workbook Code Name](#vba-and-macros) |
+| `date1904` | epoch: 0/false for 1900 system, 1/true for 1904 |
+| `filterPrivacy` | Warn or strip personally identifying info on save |
+
+### Document Features
+
+Even for basic features like date storage, the official Excel formats store the
+same content in different ways. The parsers are expected to convert from the
+underlying file format representation to the Common Spreadsheet Format. Writers
+are expected to convert from CSF back to the underlying file format.
+
+#### Formulae
+
+The A1-style formula string is stored in the `f` field. Even though different
+file formats store the formulae in different ways, the formats are translated.
+Even though some formats store formulae with a leading equal sign, CSF formulae
+do not start with `=`.
+
+
+ Formulae File Format Support (click to show)
+
+| Storage Representation | Formats | Read | Write |
+|:-----------------------|:-------------------------|:-----:|:-----:|
+| A1-style strings | XLSX | ✔ | ✔ |
+| RC-style strings | XLML and plain text | ✔ | ✔ |
+| BIFF Parsed formulae | XLSB and all XLS formats | ✔ | |
+| OpenFormula formulae | ODS/FODS/UOS | ✔ | ✔ |
+| Lotus Parsed formulae | All Lotus WK_ formats | ✔ | |
+
+Since Excel prohibits named cells from colliding with names of A1 or RC style
+cell references, a (not-so-simple) regex conversion is possible. BIFF Parsed
+formulae and Lotus Parsed formulae have to be explicitly unwound. OpenFormula
+formulae can be converted with regular expressions.
+
+Shared formulae are decompressed and each cell has the formula corresponding to
+its cell. Writers generally do not attempt to generate shared formulae.
+
+
+**Single-Cell Formulae**
+
+For simple formulae, the `f` key of the desired cell can be set to the actual
+formula text. This worksheet represents `A1=1`, `A2=2`, and `A3=A1+A2`:
+
+```js
+var worksheet = {
+ "!ref": "A1:A3",
+ A1: { t:'n', v:1 },
+ A2: { t:'n', v:2 },
+ A3: { t:'n', v:3, f:'A1+A2' }
+};
+```
+
+Utilities like `aoa_to_sheet` will accept cell objects in lieu of values:
+
+```js
+var worksheet = XLSX.utils.aoa_to_sheet([
+ [ 1 ], // A1
+ [ 2 ], // A2
+ [ {t: "n", v: 3, f: "A1+A2"} ] // A3
+]);
+```
+
+Cells with formula entries but no value will be serialized in a way that Excel
+and other spreadsheet tools will recognize. This library will not automatically
+compute formula results! For example, the following worksheet will include the
+`BESSELJ` function but the result will not be available in JavaScript:
+
+```js
+var worksheet = XLSX.utils.aoa_to_sheet([
+ [ 3.14159, 2 ], // Row "1"
+ [ { t:'n', f:'BESSELJ(A1,B1)' } ] // Row "2" will be calculated on file open
+}
+```
+
+If the actual results are needed in JS, [SheetJS Pro](https://sheetjs.com/pro)
+offers a formula calculator component for evaluating expressions, updating
+values and dependent cells, and refreshing entire workbooks.
+
+
+**Array Formulae**
+
+_Assign an array formula_
+
+```js
+XLSX.utils.sheet_set_array_formula(worksheet, range, formula);
+```
+
+Array formulae are stored in the top-left cell of the array block. All cells
+of an array formula have a `F` field corresponding to the range. A single-cell
+formula can be distinguished from a plain formula by the presence of `F` field.
+
+For example, setting the cell `C1` to the array formula `{=SUM(A1:A3*B1:B3)}`:
+
+```js
+// API function
+XLSX.utils.sheet_set_array_formula(worksheet, "C1", "SUM(A1:A3*B1:B3)");
+
+// ... OR raw operations
+worksheet['C1'] = { t:'n', f: "SUM(A1:A3*B1:B3)", F:"C1:C1" };
+```
+
+For a multi-cell array formula, every cell has the same array range but only the
+first cell specifies the formula. Consider `D1:D3=A1:A3*B1:B3`:
+
+```js
+// API function
+XLSX.utils.sheet_set_array_formula(worksheet, "D1:D3", "A1:A3*B1:B3");
+
+// ... OR raw operations
+worksheet['D1'] = { t:'n', F:"D1:D3", f:"A1:A3*B1:B3" };
+worksheet['D2'] = { t:'n', F:"D1:D3" };
+worksheet['D3'] = { t:'n', F:"D1:D3" };
+```
+
+Utilities and writers are expected to check for the presence of a `F` field and
+ignore any possible formula element `f` in cells other than the starting cell.
+They are not expected to perform validation of the formulae!
+
+
+**Dynamic Array Formulae**
+
+_Assign a dynamic array formula_
+
+```js
+XLSX.utils.sheet_set_array_formula(worksheet, range, formula, true);
+```
+
+Released in 2020, Dynamic Array Formulae are supported in the XLSX/XLSM and XLSB
+file formats. They are represented like normal array formulae but have special
+cell metadata indicating that the formula should be allowed to adjust the range.
+
+An array formula can be marked as dynamic by setting the cell's `D` property to
+true. The `F` range is expected but can be the set to the current cell:
+
+```js
+// API function
+XLSX.utils.sheet_set_array_formula(worksheet, "C1", "_xlfn.UNIQUE(A1:A3)", 1);
+
+// ... OR raw operations
+worksheet['C1'] = { t: "s", f: "_xlfn.UNIQUE(A1:A3)", F:"C1", D: 1 }; // dynamic
+```
+
+**Localization with Function Names**
+
+SheetJS operates at the file level. Excel stores formula expressions using the
+English (United States) function names. For non-English users, Excel uses a
+localized set of function names.
+
+For example, when the computer language and region is set to French (France),
+Excel interprets `=SOMME(A1:C3)` as if `SOMME` is the `SUM` function. However,
+in the actual file, Excel stores `SUM(A1:C3)`.
+
+**Prefixed "Future Functions"**
+
+Functions introduced in newer versions of Excel are prefixed with `_xlfn.` when
+stored in files. When writing formula expressions using these functions, the
+prefix is required for maximal compatibility:
+
+```js
+// Broadest compatibility
+XLSX.utils.sheet_set_array_formula(worksheet, "C1", "_xlfn.UNIQUE(A1:A3)", 1);
+
+// Can cause errors in spreadsheet software
+XLSX.utils.sheet_set_array_formula(worksheet, "C1", "UNIQUE(A1:A3)", 1);
+```
+
+When reading a file, the `xlfn` option preserves the prefixes.
+
+
+ Functions requiring `_xlfn.` prefix (click to show)
+
+This list is growing with each Excel release.
+
+```
+ACOT
+ACOTH
+AGGREGATE
+ARABIC
+BASE
+BETA.DIST
+BETA.INV
+BINOM.DIST
+BINOM.DIST.RANGE
+BINOM.INV
+BITAND
+BITLSHIFT
+BITOR
+BITRSHIFT
+BITXOR
+BYCOL
+BYROW
+CEILING.MATH
+CEILING.PRECISE
+CHISQ.DIST
+CHISQ.DIST.RT
+CHISQ.INV
+CHISQ.INV.RT
+CHISQ.TEST
+COMBINA
+CONFIDENCE.NORM
+CONFIDENCE.T
+COT
+COTH
+COVARIANCE.P
+COVARIANCE.S
+CSC
+CSCH
+DAYS
+DECIMAL
+ERF.PRECISE
+ERFC.PRECISE
+EXPON.DIST
+F.DIST
+F.DIST.RT
+F.INV
+F.INV.RT
+F.TEST
+FIELDVALUE
+FILTERXML
+FLOOR.MATH
+FLOOR.PRECISE
+FORMULATEXT
+GAMMA
+GAMMA.DIST
+GAMMA.INV
+GAMMALN.PRECISE
+GAUSS
+HYPGEOM.DIST
+IFNA
+IMCOSH
+IMCOT
+IMCSC
+IMCSCH
+IMSEC
+IMSECH
+IMSINH
+IMTAN
+ISFORMULA
+ISOMITTED
+ISOWEEKNUM
+LAMBDA
+LET
+LOGNORM.DIST
+LOGNORM.INV
+MAKEARRAY
+MAP
+MODE.MULT
+MODE.SNGL
+MUNIT
+NEGBINOM.DIST
+NORM.DIST
+NORM.INV
+NORM.S.DIST
+NORM.S.INV
+NUMBERVALUE
+PDURATION
+PERCENTILE.EXC
+PERCENTILE.INC
+PERCENTRANK.EXC
+PERCENTRANK.INC
+PERMUTATIONA
+PHI
+POISSON.DIST
+QUARTILE.EXC
+QUARTILE.INC
+QUERYSTRING
+RANDARRAY
+RANK.AVG
+RANK.EQ
+REDUCE
+RRI
+SCAN
+SEC
+SECH
+SEQUENCE
+SHEET
+SHEETS
+SKEW.P
+SORTBY
+STDEV.P
+STDEV.S
+T.DIST
+T.DIST.2T
+T.DIST.RT
+T.INV
+T.INV.2T
+T.TEST
+UNICHAR
+UNICODE
+UNIQUE
+VAR.P
+VAR.S
+WEBSERVICE
+WEIBULL.DIST
+XLOOKUP
+XOR
+Z.TEST
+```
+
+
+
+#### Row and Column Properties
+
+
+ Format Support (click to show)
+
+**Row Properties**: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM, ODS
+
+**Column Properties**: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM
+
+
+
+
+Row and Column properties are not extracted by default when reading from a file
+and are not persisted by default when writing to a file. The option
+`cellStyles: true` must be passed to the relevant read or write function.
+
+_Column Properties_
+
+The `!cols` array in each worksheet, if present, is a collection of `ColInfo`
+objects which have the following properties:
+
+```typescript
+type ColInfo = {
+ /* visibility */
+ hidden?: boolean; // if true, the column is hidden
+
+ /* column width is specified in one of the following ways: */
+ wpx?: number; // width in screen pixels
+ width?: number; // width in Excel's "Max Digit Width", width*256 is integral
+ wch?: number; // width in characters
+
+ /* other fields for preserving features from files */
+ level?: number; // 0-indexed outline / group level
+ MDW?: number; // Excel's "Max Digit Width" unit, always integral
+};
+```
+
+_Row Properties_
+
+The `!rows` array in each worksheet, if present, is a collection of `RowInfo`
+objects which have the following properties:
+
+```typescript
+type RowInfo = {
+ /* visibility */
+ hidden?: boolean; // if true, the row is hidden
+
+ /* row height is specified in one of the following ways: */
+ hpx?: number; // height in screen pixels
+ hpt?: number; // height in points
+
+ level?: number; // 0-indexed outline / group level
+};
+```
+
+_Outline / Group Levels Convention_
+
+The Excel UI displays the base outline level as `1` and the max level as `8`.
+Following JS conventions, SheetJS uses 0-indexed outline levels wherein the base
+outline level is `0` and the max level is `7`.
+
+
+ Why are there three width types? (click to show)
+
+There are three different width types corresponding to the three different ways
+spreadsheets store column widths:
+
+SYLK and other plain text formats use raw character count. Contemporaneous tools
+like Visicalc and Multiplan were character based. Since the characters had the
+same width, it sufficed to store a count. This tradition was continued into the
+BIFF formats.
+
+SpreadsheetML (2003) tried to align with HTML by standardizing on screen pixel
+count throughout the file. Column widths, row heights, and other measures use
+pixels. When the pixel and character counts do not align, Excel rounds values.
+
+XLSX internally stores column widths in a nebulous "Max Digit Width" form. The
+Max Digit Width is the width of the largest digit when rendered (generally the
+"0" character is the widest). The internal width must be an integer multiple of
+the the width divided by 256. ECMA-376 describes a formula for converting
+between pixels and the internal width. This represents a hybrid approach.
+
+Read functions attempt to populate all three properties. Write functions will
+try to cycle specified values to the desired type. In order to avoid potential
+conflicts, manipulation should delete the other properties first. For example,
+when changing the pixel width, delete the `wch` and `width` properties.
+
+
+
+ Implementation details (click to show)
+
+_Row Heights_
+
+Excel internally stores row heights in points. The default resolution is 72 DPI
+or 96 PPI, so the pixel and point size should agree. For different resolutions
+they may not agree, so the library separates the concepts.
+
+Even though all of the information is made available, writers are expected to
+follow the priority order:
+
+1) use `hpx` pixel height if available
+2) use `hpt` point height if available
+
+_Column Widths_
+
+Given the constraints, it is possible to determine the MDW without actually
+inspecting the font! The parsers guess the pixel width by converting from width
+to pixels and back, repeating for all possible MDW and selecting the MDW that
+minimizes the error. XLML actually stores the pixel width, so the guess works
+in the opposite direction.
+
+Even though all of the information is made available, writers are expected to
+follow the priority order:
+
+1) use `width` field if available
+2) use `wpx` pixel width if available
+3) use `wch` character count if available
+
+
+
+#### Number Formats
+
+The `cell.w` formatted text for each cell is produced from `cell.v` and `cell.z`
+format. If the format is not specified, the Excel `General` format is used.
+The format can either be specified as a string or as an index into the format
+table. Parsers are expected to populate `workbook.SSF` with the number format
+table. Writers are expected to serialize the table.
+
+Custom tools should ensure that the local table has each used format string
+somewhere in the table. Excel convention mandates that the custom formats start
+at index 164. The following example creates a custom format from scratch:
+
+
+ New worksheet with custom format (click to show)
+
+```js
+var wb = {
+ SheetNames: ["Sheet1"],
+ Sheets: {
+ Sheet1: {
+ "!ref":"A1:C1",
+ A1: { t:"n", v:10000 }, // <-- General format
+ B1: { t:"n", v:10000, z: "0%" }, // <-- Builtin format
+ C1: { t:"n", v:10000, z: "\"T\"\ #0.00" } // <-- Custom format
+ }
+ }
+}
+```
+
+
+The rules are slightly different from how Excel displays custom number formats.
+In particular, literal characters must be wrapped in double quotes or preceded
+by a backslash. For more info, see the Excel documentation article
+`Create or delete a custom number format` or ECMA-376 18.8.31 (Number Formats)
+
+
+
+ Default Number Formats (click to show)
+
+The default formats are listed in ECMA-376 18.8.30:
+
+| ID | Format |
+|---:|:---------------------------|
+| 0 | `General` |
+| 1 | `0` |
+| 2 | `0.00` |
+| 3 | `#,##0` |
+| 4 | `#,##0.00` |
+| 9 | `0%` |
+| 10 | `0.00%` |
+| 11 | `0.00E+00` |
+| 12 | `# ?/?` |
+| 13 | `# ??/??` |
+| 14 | `m/d/yy` (see below) |
+| 15 | `d-mmm-yy` |
+| 16 | `d-mmm` |
+| 17 | `mmm-yy` |
+| 18 | `h:mm AM/PM` |
+| 19 | `h:mm:ss AM/PM` |
+| 20 | `h:mm` |
+| 21 | `h:mm:ss` |
+| 22 | `m/d/yy h:mm` |
+| 37 | `#,##0 ;(#,##0)` |
+| 38 | `#,##0 ;[Red](#,##0)` |
+| 39 | `#,##0.00;(#,##0.00)` |
+| 40 | `#,##0.00;[Red](#,##0.00)` |
+| 45 | `mm:ss` |
+| 46 | `[h]:mm:ss` |
+| 47 | `mmss.0` |
+| 48 | `##0.0E+0` |
+| 49 | `@` |
+
+
+
+Format 14 (`m/d/yy`) is localized by Excel: even though the file specifies that
+number format, it will be drawn differently based on system settings. It makes
+sense when the producer and consumer of files are in the same locale, but that
+is not always the case over the Internet. To get around this ambiguity, parse
+functions accept the `dateNF` option to override the interpretation of that
+specific format string.
+
+#### Hyperlinks
+
+
+ Format Support (click to show)
+
+**Cell Hyperlinks**: XLSX/M, XLSB, BIFF8 XLS, XLML, ODS
+
+**Tooltips**: XLSX/M, XLSB, BIFF8 XLS, XLML
+
+
+
+Hyperlinks are stored in the `l` key of cell objects. The `Target` field of the
+hyperlink object is the target of the link, including the URI fragment. Tooltips
+are stored in the `Tooltip` field and are displayed when you move your mouse
+over the text.
+
+For example, the following snippet creates a link from cell `A3` to
+ with the tip `"Find us @ SheetJS.com!"`:
+
+```js
+ws['A1'].l = { Target:"https://sheetjs.com", Tooltip:"Find us @ SheetJS.com!" };
+```
+
+Note that Excel does not automatically style hyperlinks -- they will generally
+be displayed as normal text.
+
+_Remote Links_
+
+HTTP / HTTPS links can be used directly:
+
+```js
+ws['A2'].l = { Target:"https://docs.sheetjs.com/#hyperlinks" };
+ws['A3'].l = { Target:"http://localhost:7262/yes_localhost_works" };
+```
+
+Excel also supports `mailto` email links with subject line:
+
+```js
+ws['A4'].l = { Target:"mailto:ignored@dev.null" };
+ws['A5'].l = { Target:"mailto:ignored@dev.null?subject=Test Subject" };
+```
+
+_Local Links_
+
+Links to absolute paths should use the `file://` URI scheme:
+
+```js
+ws['B1'].l = { Target:"file:///SheetJS/t.xlsx" }; /* Link to /SheetJS/t.xlsx */
+ws['B2'].l = { Target:"file:///c:/SheetJS.xlsx" }; /* Link to c:\SheetJS.xlsx */
+```
+
+Links to relative paths can be specified without a scheme:
+
+```js
+ws['B3'].l = { Target:"SheetJS.xlsb" }; /* Link to SheetJS.xlsb */
+ws['B4'].l = { Target:"../SheetJS.xlsm" }; /* Link to ../SheetJS.xlsm */
+```
+
+Relative Paths have undefined behavior in the SpreadsheetML 2003 format. Excel
+2019 will treat a `..\` parent mark as two levels up.
+
+_Internal Links_
+
+Links where the target is a cell or range or defined name in the same workbook
+("Internal Links") are marked with a leading hash character:
+
+```js
+ws['C1'].l = { Target:"#E2" }; /* Link to cell E2 */
+ws['C2'].l = { Target:"#Sheet2!E2" }; /* Link to cell E2 in sheet Sheet2 */
+ws['C3'].l = { Target:"#SomeDefinedName" }; /* Link to Defined Name */
+```
+
+#### Cell Comments
+
+Cell comments are objects stored in the `c` array of cell objects. The actual
+contents of the comment are split into blocks based on the comment author. The
+`a` field of each comment object is the author of the comment and the `t` field
+is the plain text representation.
+
+For example, the following snippet appends a cell comment into cell `A1`:
+
+```js
+if(!ws.A1.c) ws.A1.c = [];
+ws.A1.c.push({a:"SheetJS", t:"I'm a little comment, short and stout!"});
+```
+
+Note: XLSB enforces a 54 character limit on the Author name. Names longer than
+54 characters may cause issues with other formats.
+
+To mark a comment as normally hidden, set the `hidden` property:
+
+```js
+if(!ws.A1.c) ws.A1.c = [];
+ws.A1.c.push({a:"SheetJS", t:"This comment is visible"});
+
+if(!ws.A2.c) ws.A2.c = [];
+ws.A2.c.hidden = true;
+ws.A2.c.push({a:"SheetJS", t:"This comment will be hidden"});
+```
+
+
+_Threaded Comments_
+
+Introduced in Excel 365, threaded comments are plain text comment snippets with
+author metadata and parent references. They are supported in XLSX and XLSB.
+
+To mark a comment as threaded, each comment part must have a true `T` property:
+
+```js
+if(!ws.A1.c) ws.A1.c = [];
+ws.A1.c.push({a:"SheetJS", t:"This is not threaded"});
+
+if(!ws.A2.c) ws.A2.c = [];
+ws.A2.c.hidden = true;
+ws.A2.c.push({a:"SheetJS", t:"This is threaded", T: true});
+ws.A2.c.push({a:"JSSheet", t:"This is also threaded", T: true});
+```
+
+There is no Active Directory or Office 365 metadata associated with authors in a thread.
+
+#### Sheet Visibility
+
+Excel enables hiding sheets in the lower tab bar. The sheet data is stored in
+the file but the UI does not readily make it available. Standard hidden sheets
+are revealed in the "Unhide" menu. Excel also has "very hidden" sheets which
+cannot be revealed in the menu. It is only accessible in the VB Editor!
+
+The visibility setting is stored in the `Hidden` property of sheet props array.
+
+
+ More details (click to show)
+
+| Value | Definition |
+|:-----:|:------------|
+| 0 | Visible |
+| 1 | Hidden |
+| 2 | Very Hidden |
+
+With :
+
+```js
+> wb.Workbook.Sheets.map(function(x) { return [x.name, x.Hidden] })
+[ [ 'Visible', 0 ], [ 'Hidden', 1 ], [ 'VeryHidden', 2 ] ]
+```
+
+Non-Excel formats do not support the Very Hidden state. The best way to test
+if a sheet is visible is to check if the `Hidden` property is logical truth:
+
+```js
+> wb.Workbook.Sheets.map(function(x) { return [x.name, !x.Hidden] })
+[ [ 'Visible', true ], [ 'Hidden', false ], [ 'VeryHidden', false ] ]
+```
+
+
+#### VBA and Macros
+
+VBA Macros are stored in a special data blob that is exposed in the `vbaraw`
+property of the workbook object when the `bookVBA` option is `true`. They are
+supported in `XLSM`, `XLSB`, and `BIFF8 XLS` formats. The supported format
+writers automatically insert the data blobs if it is present in the workbook and
+associate with the worksheet names.
+
+
+ Custom Code Names (click to show)
+
+The workbook code name is stored in `wb.Workbook.WBProps.CodeName`. By default,
+Excel will write `ThisWorkbook` or a translated phrase like `DieseArbeitsmappe`.
+Worksheet and Chartsheet code names are in the worksheet properties object at
+`wb.Workbook.Sheets[i].CodeName`. Macrosheets and Dialogsheets are ignored.
+
+The readers and writers preserve the code names, but they have to be manually
+set when adding a VBA blob to a different workbook.
+
+
+
+
+ Macrosheets (click to show)
+
+Older versions of Excel also supported a non-VBA "macrosheet" sheet type that
+stored automation commands. These are exposed in objects with the `!type`
+property set to `"macro"`.
+
+
+
+
+ Detecting macros in workbooks (click to show)
+
+The `vbaraw` field will only be set if macros are present, so testing is simple:
+
+```js
+function wb_has_macro(wb/*:workbook*/)/*:boolean*/ {
+ if(!!wb.vbaraw) return true;
+ const sheets = wb.SheetNames.map((n) => wb.Sheets[n]);
+ return sheets.some((ws) => !!ws && ws['!type']=='macro');
+}
+```
+
+
+
+## Parsing Options
+
+The exported `read` and `readFile` functions accept an options argument:
+
+| Option Name | Default | Description |
+| :---------- | ------: | :--------------------------------------------------- |
+|`type` | | Input data encoding (see Input Type below) |
+|`raw` | false | If true, plain text parsing will not parse values ** |
+|`codepage` | | If specified, use code page when appropriate ** |
+|`cellFormula`| true | Save formulae to the .f field |
+|`cellHTML` | true | Parse rich text and save HTML to the `.h` field |
+|`cellNF` | false | Save number format string to the `.z` field |
+|`cellStyles` | false | Save style/theme info to the `.s` field |
+|`cellText` | true | Generated formatted text to the `.w` field |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`dateNF` | | If specified, use the string for date code 14 ** |
+|`sheetStubs` | false | Create cell objects of type `z` for stub cells |
+|`sheetRows` | 0 | If >0, read the first `sheetRows` rows ** |
+|`bookDeps` | false | If true, parse calculation chains |
+|`bookFiles` | false | If true, add raw files to book object ** |
+|`bookProps` | false | If true, only parse enough to get book metadata ** |
+|`bookSheets` | false | If true, only parse enough to get the sheet names |
+|`bookVBA` | false | If true, copy VBA blob to `vbaraw` field ** |
+|`password` | "" | If defined and file is encrypted, use password ** |
+|`WTF` | false | If true, throw errors on unexpected file features ** |
+|`sheets` | | If specified, only parse specified sheets ** |
+|`PRN` | false | If true, allow parsing of PRN files ** |
+|`xlfn` | false | If true, preserve `_xlfn.` prefixes in formulae ** |
+|`FS` | | DSV Field Separator override |
+
+- Even if `cellNF` is false, formatted text will be generated and saved to `.w`
+- In some cases, sheets may be parsed even if `bookSheets` is false.
+- Excel aggressively tries to interpret values from CSV and other plain text.
+ This leads to surprising behavior! The `raw` option suppresses value parsing.
+- `bookSheets` and `bookProps` combine to give both sets of information
+- `Deps` will be an empty object if `bookDeps` is false
+- `bookFiles` behavior depends on file type:
+ * `keys` array (paths in the ZIP) for ZIP-based formats
+ * `files` hash (mapping paths to objects representing the files) for ZIP
+ * `cfb` object for formats using CFB containers
+- `sheetRows-1` rows will be generated when looking at the JSON object output
+ (since the header row is counted as a row when parsing the data)
+- By default all worksheets are parsed. `sheets` restricts based on input type:
+ * number: zero-based index of worksheet to parse (`0` is first worksheet)
+ * string: name of worksheet to parse (case insensitive)
+ * array of numbers and strings to select multiple worksheets.
+- `bookVBA` merely exposes the raw VBA CFB object. It does not parse the data.
+ XLSM and XLSB store the VBA CFB object in `xl/vbaProject.bin`. BIFF8 XLS mixes
+ the VBA entries alongside the core Workbook entry, so the library generates a
+ new XLSB-compatible blob from the XLS CFB container.
+- `codepage` is applied to BIFF2 - BIFF5 files without `CodePage` records and to
+ CSV files without BOM in `type:"binary"`. BIFF8 XLS always defaults to 1200.
+- `PRN` affects parsing of text files without a common delimiter character.
+- Currently only XOR encryption is supported. Unsupported error will be thrown
+ for files employing other encryption methods.
+- Newer Excel functions are serialized with the `_xlfn.` prefix, hidden from the
+ user. SheetJS will strip `_xlfn.` normally. The `xlfn` option preserves them.
+- WTF is mainly for development. By default, the parser will suppress read
+ errors on single worksheets, allowing you to read from the worksheets that do
+ parse properly. Setting `WTF:true` forces those errors to be thrown.
+
+### Input Type
+
+Strings can be interpreted in multiple ways. The `type` parameter for `read`
+tells the library how to parse the data argument:
+
+| `type` | expected input |
+|------------|-----------------------------------------------------------------|
+| `"base64"` | string: Base64 encoding of the file |
+| `"binary"` | string: binary string (byte `n` is `data.charCodeAt(n)`) |
+| `"string"` | string: JS string (characters interpreted as UTF8) |
+| `"buffer"` | nodejs Buffer |
+| `"array"` | array: array of 8-bit unsigned int (byte `n` is `data[n]`) |
+| `"file"` | string: path of file that will be read (nodejs only) |
+
+### Guessing File Type
+
+
+ Implementation Details (click to show)
+
+Excel and other spreadsheet tools read the first few bytes and apply other
+heuristics to determine a file type. This enables file type punning: renaming
+files with the `.xls` extension will tell your computer to use Excel to open the
+file but Excel will know how to handle it. This library applies similar logic:
+
+| Byte 0 | Raw File Type | Spreadsheet Types |
+|:-------|:--------------|:----------------------------------------------------|
+| `0xD0` | CFB Container | BIFF 5/8 or protected XLSX/XLSB or WQ3/QPW or XLR |
+| `0x09` | BIFF Stream | BIFF 2/3/4/5 |
+| `0x3C` | XML/HTML | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+| `0x50` | ZIP Archive | XLSB or XLSX/M or ODS or UOS2 or NUMBERS or text |
+| `0x49` | Plain Text | SYLK or plain text |
+| `0x54` | Plain Text | DIF or plain text |
+| `0xEF` | UTF8 Encoded | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+| `0xFF` | UTF16 Encoded | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+| `0x00` | Record Stream | Lotus WK\* or Quattro Pro or plain text |
+| `0x7B` | Plain text | RTF or plain text |
+| `0x0A` | Plain text | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+| `0x0D` | Plain text | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+| `0x20` | Plain text | SpreadsheetML / Flat ODS / UOS1 / HTML / plain text |
+
+DBF files are detected based on the first byte as well as the third and fourth
+bytes (corresponding to month and day of the file date)
+
+Works for Windows files are detected based on the BOF record with type `0xFF`
+
+Plain text format guessing follows the priority order:
+
+| Format | Test |
+|:-------|:--------------------------------------------------------------------|
+| XML | `
+
+
+ Why are random text files valid? (click to show)
+
+Excel is extremely aggressive in reading files. Adding an XLS extension to any
+display text file (where the only characters are ANSI display chars) tricks
+Excel into thinking that the file is potentially a CSV or TSV file, even if it
+is only one column! This library attempts to replicate that behavior.
+
+The best approach is to validate the desired worksheet and ensure it has the
+expected number of rows or columns. Extracting the range is extremely simple:
+
+```js
+var range = XLSX.utils.decode_range(worksheet['!ref']);
+var ncols = range.e.c - range.s.c + 1, nrows = range.e.r - range.s.r + 1;
+```
+
+
+
+## Writing Options
+
+The exported `write` and `writeFile` functions accept an options argument:
+
+| Option Name | Default | Description |
+| :---------- | -------: | :-------------------------------------------------- |
+|`type` | | Output data encoding (see Output Type below) |
+|`cellDates` | `false` | Store dates as type `d` (default is `n`) |
+|`bookSST` | `false` | Generate Shared String Table ** |
+|`bookType` | `"xlsx"` | Type of Workbook (see below for supported formats) |
+|`sheet` | `""` | Name of Worksheet for single-sheet formats ** |
+|`compression`| `false` | Use ZIP compression for ZIP-based formats ** |
+|`Props` | | Override workbook properties when writing ** |
+|`themeXLSX` | | Override theme XML when writing XLSX/XLSB/XLSM ** |
+|`ignoreEC` | `true` | Suppress "number as text" errors ** |
+|`numbers` | | Payload for NUMBERS export ** |
+
+- `bookSST` is slower and more memory intensive, but has better compatibility
+ with older versions of iOS Numbers
+- The raw data is the only thing guaranteed to be saved. Features not described
+ in this README may not be serialized.
+- `cellDates` only applies to XLSX output and is not guaranteed to work with
+ third-party readers. Excel itself does not usually write cells with type `d`
+ so non-Excel tools may ignore the data or error in the presence of dates.
+- `Props` is an object mirroring the workbook `Props` field. See the table from
+ the [Workbook File Properties](#workbook-file-properties) section.
+- if specified, the string from `themeXLSX` will be saved as the primary theme
+ for XLSX/XLSB/XLSM files (to `xl/theme/theme1.xml` in the ZIP)
+- Due to a bug in the program, some features like "Text to Columns" will crash
+ Excel on worksheets where error conditions are ignored. The writer will mark
+ files to ignore the error by default. Set `ignoreEC` to `false` to suppress.
+- Due to the size of the data, the NUMBERS data is not included by default. The
+ included `xlsx.zahl.js` and `xlsx.zahl.mjs` scripts include the data.
+
+### Supported Output Formats
+
+For broad compatibility with third-party tools, this library supports many
+output formats. The specific file type is controlled with `bookType` option:
+
+| `bookType` | file ext | container | sheets | Description |
+| :--------- | -------: | :-------: | :----- |:------------------------------- |
+| `xlsx` | `.xlsx` | ZIP | multi | Excel 2007+ XML Format |
+| `xlsm` | `.xlsm` | ZIP | multi | Excel 2007+ Macro XML Format |
+| `xlsb` | `.xlsb` | ZIP | multi | Excel 2007+ Binary Format |
+| `biff8` | `.xls` | CFB | multi | Excel 97-2004 Workbook Format |
+| `biff5` | `.xls` | CFB | multi | Excel 5.0/95 Workbook Format |
+| `biff4` | `.xls` | none | single | Excel 4.0 Worksheet Format |
+| `biff3` | `.xls` | none | single | Excel 3.0 Worksheet Format |
+| `biff2` | `.xls` | none | single | Excel 2.0 Worksheet Format |
+| `xlml` | `.xls` | none | multi | Excel 2003-2004 (SpreadsheetML) |
+| `numbers` |`.numbers`| ZIP | single | Numbers 3.0+ Spreadsheet |
+| `ods` | `.ods` | ZIP | multi | OpenDocument Spreadsheet |
+| `fods` | `.fods` | none | multi | Flat OpenDocument Spreadsheet |
+| `wk3` | `.wk3` | none | multi | Lotus Workbook (WK3) |
+| `csv` | `.csv` | none | single | Comma Separated Values |
+| `txt` | `.txt` | none | single | UTF-16 Unicode Text (TXT) |
+| `sylk` | `.sylk` | none | single | Symbolic Link (SYLK) |
+| `html` | `.html` | none | single | HTML Document |
+| `dif` | `.dif` | none | single | Data Interchange Format (DIF) |
+| `dbf` | `.dbf` | none | single | dBASE II + VFP Extensions (DBF) |
+| `wk1` | `.wk1` | none | single | Lotus Worksheet (WK1) |
+| `rtf` | `.rtf` | none | single | Rich Text Format (RTF) |
+| `prn` | `.prn` | none | single | Lotus Formatted Text |
+| `eth` | `.eth` | none | single | Ethercalc Record Format (ETH) |
+
+- `compression` only applies to formats with ZIP containers.
+- Formats that only support a single sheet require a `sheet` option specifying
+ the worksheet. If the string is empty, the first worksheet is used.
+- `writeFile` will automatically guess the output file format based on the file
+ extension if `bookType` is not specified. It will choose the first format in
+ the aforementioned table that matches the extension.
+
+### Output Type
+
+The `type` argument for `write` mirrors the `type` argument for `read`:
+
+| `type` | output |
+|------------|-----------------------------------------------------------------|
+| `"base64"` | string: Base64 encoding of the file |
+| `"binary"` | string: binary string (byte `n` is `data.charCodeAt(n)`) |
+| `"string"` | string: JS string (characters interpreted as UTF8) |
+| `"buffer"` | nodejs Buffer |
+| `"array"` | ArrayBuffer, fallback array of 8-bit unsigned int |
+| `"file"` | string: path of file that will be created (nodejs only) |
+
+- For compatibility with Excel, `csv` output will always include the UTF-8 byte
+ order mark.
+
+## Utility Functions
+
+The `sheet_to_*` functions accept a worksheet and an optional options object.
+
+The `*_to_sheet` functions accept a data object and an optional options object.
+
+The examples are based on the following worksheet:
+
+```
+XXX| A | B | C | D | E | F | G |
+---+---+---+---+---+---+---+---+
+ 1 | S | h | e | e | t | J | S |
+ 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+ 3 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+```
+
+### Array of Arrays Input
+
+`XLSX.utils.aoa_to_sheet` takes an array of arrays of JS values and returns a
+worksheet resembling the input data. Numbers, Booleans and Strings are stored
+as the corresponding styles. Dates are stored as date or numbers. Array holes
+and explicit `undefined` values are skipped. `null` values may be stubbed. All
+other values are stored as strings. The function takes an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :-----: | :--------------------------------------------------- |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`sheetStubs` | false | Create cell objects of type `z` for `null` values |
+|`nullError` | false | If true, emit `#NULL!` error cells for `null` values |
+
+
+ Examples (click to show)
+
+To generate the example sheet:
+
+```js
+var ws = XLSX.utils.aoa_to_sheet([
+ "SheetJS".split(""),
+ [1,2,3,4,5,6,7],
+ [2,3,4,5,6,7,8]
+]);
+```
+
+
+`XLSX.utils.sheet_add_aoa` takes an array of arrays of JS values and updates an
+existing worksheet object. It follows the same process as `aoa_to_sheet` and
+accepts an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :-----: | :--------------------------------------------------- |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`sheetStubs` | false | Create cell objects of type `z` for `null` values |
+|`nullError` | false | If true, emit `#NULL!` error cells for `null` values |
+|`origin` | | Use specified cell as starting point (see below) |
+
+`origin` is expected to be one of:
+
+| `origin` | Description |
+| :--------------- | :-------------------------------------------------------- |
+| (cell object) | Use specified cell (cell object) |
+| (string) | Use specified cell (A1-style cell) |
+| (number >= 0) | Start from the first column at specified row (0-indexed) |
+| -1 | Append to bottom of worksheet starting on first column |
+| (default) | Start from cell A1 |
+
+
+
+ Examples (click to show)
+
+Consider the worksheet:
+
+```
+XXX| A | B | C | D | E | F | G |
+---+---+---+---+---+---+---+---+
+ 1 | S | h | e | e | t | J | S |
+ 2 | 1 | 2 | | | 5 | 6 | 7 |
+ 3 | 2 | 3 | | | 6 | 7 | 8 |
+ 4 | 3 | 4 | | | 7 | 8 | 9 |
+ 5 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |
+```
+
+This worksheet can be built up in the order `A1:G1, A2:B4, E2:G4, A5:G5`:
+
+```js
+/* Initial row */
+var ws = XLSX.utils.aoa_to_sheet([ "SheetJS".split("") ]);
+
+/* Write data starting at A2 */
+XLSX.utils.sheet_add_aoa(ws, [[1,2], [2,3], [3,4]], {origin: "A2"});
+
+/* Write data starting at E2 */
+XLSX.utils.sheet_add_aoa(ws, [[5,6,7], [6,7,8], [7,8,9]], {origin:{r:1, c:4}});
+
+/* Append row */
+XLSX.utils.sheet_add_aoa(ws, [[4,5,6,7,8,9,0]], {origin: -1});
+```
+
+
+
+### Array of Objects Input
+
+`XLSX.utils.json_to_sheet` takes an array of objects and returns a worksheet
+with automatically-generated "headers" based on the keys of the objects. The
+default column order is determined by the first appearance of the field using
+`Object.keys`. The function accepts an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :-----: | :--------------------------------------------------- |
+|`header` | | Use specified field order (default `Object.keys`) ** |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`skipHeader` | false | If true, do not include header row in output |
+|`nullError` | false | If true, emit `#NULL!` error cells for `null` values |
+
+- All fields from each row will be written. If `header` is an array and it does
+ not contain a particular field, the key will be appended to the array.
+- Cell types are deduced from the type of each value. For example, a `Date`
+ object will generate a Date cell, while a string will generate a Text cell.
+- Null values will be skipped by default. If `nullError` is true, an error cell
+ corresponding to `#NULL!` will be written to the worksheet.
+
+
+ Examples (click to show)
+
+The original sheet cannot be reproduced using plain objects since JS object keys
+must be unique. After replacing the second `e` and `S` with `e_1` and `S_1`:
+
+```js
+var ws = XLSX.utils.json_to_sheet([
+ { S:1, h:2, e:3, e_1:4, t:5, J:6, S_1:7 },
+ { S:2, h:3, e:4, e_1:5, t:6, J:7, S_1:8 }
+], {header:["S","h","e","e_1","t","J","S_1"]});
+```
+
+Alternatively, the header row can be skipped:
+
+```js
+var ws = XLSX.utils.json_to_sheet([
+ { A:"S", B:"h", C:"e", D:"e", E:"t", F:"J", G:"S" },
+ { A: 1, B: 2, C: 3, D: 4, E: 5, F: 6, G: 7 },
+ { A: 2, B: 3, C: 4, D: 5, E: 6, F: 7, G: 8 }
+], {header:["A","B","C","D","E","F","G"], skipHeader:true});
+```
+
+
+
+`XLSX.utils.sheet_add_json` takes an array of objects and updates an existing
+worksheet object. It follows the same process as `json_to_sheet` and accepts
+an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :-----: | :--------------------------------------------------- |
+|`header` | | Use specified column order (default `Object.keys`) |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`skipHeader` | false | If true, do not include header row in output |
+|`nullError` | false | If true, emit `#NULL!` error cells for `null` values |
+|`origin` | | Use specified cell as starting point (see below) |
+
+`origin` is expected to be one of:
+
+| `origin` | Description |
+| :--------------- | :-------------------------------------------------------- |
+| (cell object) | Use specified cell (cell object) |
+| (string) | Use specified cell (A1-style cell) |
+| (number >= 0) | Start from the first column at specified row (0-indexed) |
+| -1 | Append to bottom of worksheet starting on first column |
+| (default) | Start from cell A1 |
+
+
+
+ Examples (click to show)
+
+Consider the worksheet:
+
+```
+XXX| A | B | C | D | E | F | G |
+---+---+---+---+---+---+---+---+
+ 1 | S | h | e | e | t | J | S |
+ 2 | 1 | 2 | | | 5 | 6 | 7 |
+ 3 | 2 | 3 | | | 6 | 7 | 8 |
+ 4 | 3 | 4 | | | 7 | 8 | 9 |
+ 5 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |
+```
+
+This worksheet can be built up in the order `A1:G1, A2:B4, E2:G4, A5:G5`:
+
+```js
+/* Initial row */
+var ws = XLSX.utils.json_to_sheet([
+ { A: "S", B: "h", C: "e", D: "e", E: "t", F: "J", G: "S" }
+], {header: ["A", "B", "C", "D", "E", "F", "G"], skipHeader: true});
+
+/* Write data starting at A2 */
+XLSX.utils.sheet_add_json(ws, [
+ { A: 1, B: 2 }, { A: 2, B: 3 }, { A: 3, B: 4 }
+], {skipHeader: true, origin: "A2"});
+
+/* Write data starting at E2 */
+XLSX.utils.sheet_add_json(ws, [
+ { A: 5, B: 6, C: 7 }, { A: 6, B: 7, C: 8 }, { A: 7, B: 8, C: 9 }
+], {skipHeader: true, origin: { r: 1, c: 4 }, header: [ "A", "B", "C" ]});
+
+/* Append row */
+XLSX.utils.sheet_add_json(ws, [
+ { A: 4, B: 5, C: 6, D: 7, E: 8, F: 9, G: 0 }
+], {header: ["A", "B", "C", "D", "E", "F", "G"], skipHeader: true, origin: -1});
+```
+
+
+
+### HTML Table Input
+
+`XLSX.utils.table_to_sheet` takes a table DOM element and returns a worksheet
+resembling the input table. Numbers are parsed. All other data will be stored
+as strings.
+
+`XLSX.utils.table_to_book` produces a minimal workbook based on the worksheet.
+
+Both functions accept options arguments:
+
+| Option Name | Default | Description |
+| :---------- | :------: | :-------------------------------------------------- |
+|`raw` | | If true, every cell will hold raw strings |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`sheetRows` | 0 | If >0, read the first `sheetRows` rows of the table |
+|`display` | false | If true, hidden rows and cells will not be parsed |
+
+
+
+ Examples (click to show)
+
+To generate the example sheet, start with the HTML table:
+
+```html
+
+| S | h | e | e | t | J | S |
+| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+
+```
+
+To process the table:
+
+```js
+var tbl = document.getElementById('sheetjs');
+var wb = XLSX.utils.table_to_book(tbl);
+```
+
+
+Note: `XLSX.read` can handle HTML represented as strings.
+
+
+`XLSX.utils.sheet_add_dom` takes a table DOM element and updates an existing
+worksheet object. It follows the same process as `table_to_sheet` and accepts
+an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :------: | :-------------------------------------------------- |
+|`raw` | | If true, every cell will hold raw strings |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`cellDates` | false | Store dates as type `d` (default is `n`) |
+|`sheetRows` | 0 | If >0, read the first `sheetRows` rows of the table |
+|`display` | false | If true, hidden rows and cells will not be parsed |
+
+`origin` is expected to be one of:
+
+| `origin` | Description |
+| :--------------- | :-------------------------------------------------------- |
+| (cell object) | Use specified cell (cell object) |
+| (string) | Use specified cell (A1-style cell) |
+| (number >= 0) | Start from the first column at specified row (0-indexed) |
+| -1 | Append to bottom of worksheet starting on first column |
+| (default) | Start from cell A1 |
+
+
+
+ Examples (click to show)
+
+A small helper function can create gap rows between tables:
+
+```js
+function create_gap_rows(ws, nrows) {
+ var ref = XLSX.utils.decode_range(ws["!ref"]); // get original range
+ ref.e.r += nrows; // add to ending row
+ ws["!ref"] = XLSX.utils.encode_range(ref); // reassign row
+}
+
+/* first table */
+var ws = XLSX.utils.table_to_sheet(document.getElementById('table1'));
+create_gap_rows(ws, 1); // one row gap after first table
+
+/* second table */
+XLSX.utils.sheet_add_dom(ws, document.getElementById('table2'), {origin: -1});
+create_gap_rows(ws, 3); // three rows gap after second table
+
+/* third table */
+XLSX.utils.sheet_add_dom(ws, document.getElementById('table3'), {origin: -1});
+```
+
+
+
+### Formulae Output
+
+`XLSX.utils.sheet_to_formulae` generates an array of commands that represent
+how a person would enter data into an application. Each entry is of the form
+`A1-cell-address=formula-or-value`. String literals are prefixed with a `'` in
+accordance with Excel.
+
+
+ Examples (click to show)
+
+For the example sheet:
+
+```js
+> var o = XLSX.utils.sheet_to_formulae(ws);
+> [o[0], o[5], o[10], o[15], o[20]];
+[ 'A1=\'S', 'F1=\'J', 'D2=4', 'B3=3', 'G3=8' ]
+```
+
+
+### Delimiter-Separated Output
+
+As an alternative to the `writeFile` CSV type, `XLSX.utils.sheet_to_csv` also
+produces CSV output. The function takes an options argument:
+
+| Option Name | Default | Description |
+| :----------- | :------: | :------------------------------------------------- |
+|`FS` | `","` | "Field Separator" delimiter between fields |
+|`RS` | `"\n"` | "Record Separator" delimiter between rows |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`strip` | false | Remove trailing field separators in each record ** |
+|`blankrows` | true | Include blank lines in the CSV output |
+|`skipHidden` | false | Skips hidden rows/columns in the CSV output |
+|`forceQuotes` | false | Force quotes around fields |
+
+- `strip` will remove trailing commas from each line under default `FS/RS`
+- `blankrows` must be set to `false` to skip blank lines.
+- Fields containing the record or field separator will automatically be wrapped
+ in double quotes; `forceQuotes` forces all cells to be wrapped in quotes.
+- `XLSX.write` with `csv` type will always prepend the UTF-8 byte-order mark for
+ Excel compatibility. `sheet_to_csv` returns a JS string and omits the mark.
+ Using `XLSX.write` with type `string` will also skip the mark.
+
+
+
+ Examples (click to show)
+
+For the example sheet:
+
+```js
+> console.log(XLSX.utils.sheet_to_csv(ws));
+S,h,e,e,t,J,S
+1,2,3,4,5,6,7
+2,3,4,5,6,7,8
+> console.log(XLSX.utils.sheet_to_csv(ws, {FS:"\t"}));
+S h e e t J S
+1 2 3 4 5 6 7
+2 3 4 5 6 7 8
+> console.log(XLSX.utils.sheet_to_csv(ws,{FS:":",RS:"|"}));
+S:h:e:e:t:J:S|1:2:3:4:5:6:7|2:3:4:5:6:7:8|
+```
+
+
+#### UTF-16 Unicode Text
+
+The `txt` output type uses the tab character as the field separator. If the
+`codepage` library is available (included in full distribution but not core),
+the output will be encoded in `CP1200` and the BOM will be prepended.
+
+`XLSX.utils.sheet_to_txt` takes the same arguments as `sheet_to_csv`.
+
+### HTML Output
+
+As an alternative to the `writeFile` HTML type, `XLSX.utils.sheet_to_html` also
+produces HTML output. The function takes an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :------: | :-------------------------------------------------- |
+|`id` | | Specify the `id` attribute for the `TABLE` element |
+|`editable` | false | If true, set `contenteditable="true"` for every TD |
+|`header` | | Override header (default `html body`) |
+|`footer` | | Override footer (default `/body /html`) |
+
+
+ Examples (click to show)
+
+For the example sheet:
+
+```js
+> console.log(XLSX.utils.sheet_to_html(ws));
+// ...
+```
+
+
+### JSON
+
+`XLSX.utils.sheet_to_json` generates different types of JS objects. The function
+takes an options argument:
+
+| Option Name | Default | Description |
+| :---------- | :------: | :-------------------------------------------------- |
+|`raw` | `true` | Use raw values (true) or formatted strings (false) |
+|`range` | from WS | Override Range (see table below) |
+|`header` | | Control output format (see table below) |
+|`dateNF` | FMT 14 | Use specified date format in string output |
+|`defval` | | Use specified value in place of null or undefined |
+|`blankrows` | ** | Include blank lines in the output ** |
+
+- `raw` only affects cells which have a format code (`.z`) field or a formatted
+ text (`.w`) field.
+- If `header` is specified, the first row is considered a data row; if `header`
+ is not specified, the first row is the header row and not considered data.
+- When `header` is not specified, the conversion will automatically disambiguate
+ header entries by affixing `_` and a count starting at `1`. For example, if
+ three columns have header `foo` the output fields are `foo`, `foo_1`, `foo_2`
+- `null` values are returned when `raw` is true but are skipped when false.
+- If `defval` is not specified, null and undefined values are skipped normally.
+ If specified, all null and undefined points will be filled with `defval`
+- When `header` is `1`, the default is to generate blank rows. `blankrows` must
+ be set to `false` to skip blank rows.
+- When `header` is not `1`, the default is to skip blank rows. `blankrows` must
+ be true to generate blank rows
+
+`range` is expected to be one of:
+
+| `range` | Description |
+| :--------------- | :-------------------------------------------------------- |
+| (number) | Use worksheet range but set starting row to the value |
+| (string) | Use specified range (A1-style bounded range string) |
+| (default) | Use worksheet range (`ws['!ref']`) |
+
+`header` is expected to be one of:
+
+| `header` | Description |
+| :--------------- | :-------------------------------------------------------- |
+| `1` | Generate an array of arrays ("2D Array") |
+| `"A"` | Row object keys are literal column labels |
+| array of strings | Use specified strings as keys in row objects |
+| (default) | Read and disambiguate first row as keys |
+
+- If header is not `1`, the row object will contain the non-enumerable property
+ `__rowNum__` that represents the row of the sheet corresponding to the entry.
+- If header is an array, the keys will not be disambiguated. This can lead to
+ unexpected results if the array values are not unique!
+
+
+
+ Examples (click to show)
+
+For the example sheet:
+
+```js
+> XLSX.utils.sheet_to_json(ws);
+[ { S: 1, h: 2, e: 3, e_1: 4, t: 5, J: 6, S_1: 7 },
+ { S: 2, h: 3, e: 4, e_1: 5, t: 6, J: 7, S_1: 8 } ]
+
+> XLSX.utils.sheet_to_json(ws, {header:"A"});
+[ { A: 'S', B: 'h', C: 'e', D: 'e', E: 't', F: 'J', G: 'S' },
+ { A: '1', B: '2', C: '3', D: '4', E: '5', F: '6', G: '7' },
+ { A: '2', B: '3', C: '4', D: '5', E: '6', F: '7', G: '8' } ]
+
+> XLSX.utils.sheet_to_json(ws, {header:["A","E","I","O","U","6","9"]});
+[ { '6': 'J', '9': 'S', A: 'S', E: 'h', I: 'e', O: 'e', U: 't' },
+ { '6': '6', '9': '7', A: '1', E: '2', I: '3', O: '4', U: '5' },
+ { '6': '7', '9': '8', A: '2', E: '3', I: '4', O: '5', U: '6' } ]
+
+> XLSX.utils.sheet_to_json(ws, {header:1});
+[ [ 'S', 'h', 'e', 'e', 't', 'J', 'S' ],
+ [ '1', '2', '3', '4', '5', '6', '7' ],
+ [ '2', '3', '4', '5', '6', '7', '8' ] ]
+```
+
+Example showing the effect of `raw`:
+
+```js
+> ws['A2'].w = "3"; // set A2 formatted string value
+
+> XLSX.utils.sheet_to_json(ws, {header:1, raw:false});
+[ [ 'S', 'h', 'e', 'e', 't', 'J', 'S' ],
+ [ '3', '2', '3', '4', '5', '6', '7' ], // <-- A2 uses the formatted string
+ [ '2', '3', '4', '5', '6', '7', '8' ] ]
+
+> XLSX.utils.sheet_to_json(ws, {header:1});
+[ [ 'S', 'h', 'e', 'e', 't', 'J', 'S' ],
+ [ 1, 2, 3, 4, 5, 6, 7 ], // <-- A2 uses the raw value
+ [ 2, 3, 4, 5, 6, 7, 8 ] ]
+```
+
+
+## File Formats
+
+Despite the library name `xlsx`, it supports numerous spreadsheet file formats:
+
+| Format | Read | Write |
+|:-------------------------------------------------------------|:-----:|:-----:|
+| **Excel Worksheet/Workbook Formats** |:-----:|:-----:|
+| Excel 2007+ XML Formats (XLSX/XLSM) | ✔ | ✔ |
+| Excel 2007+ Binary Format (XLSB BIFF12) | ✔ | ✔ |
+| Excel 2003-2004 XML Format (XML "SpreadsheetML") | ✔ | ✔ |
+| Excel 97-2004 (XLS BIFF8) | ✔ | ✔ |
+| Excel 5.0/95 (XLS BIFF5) | ✔ | ✔ |
+| Excel 4.0 (XLS/XLW BIFF4) | ✔ | ✔ |
+| Excel 3.0 (XLS BIFF3) | ✔ | ✔ |
+| Excel 2.0/2.1 (XLS BIFF2) | ✔ | ✔ |
+| **Excel Supported Text Formats** |:-----:|:-----:|
+| Delimiter-Separated Values (CSV/TXT) | ✔ | ✔ |
+| Data Interchange Format (DIF) | ✔ | ✔ |
+| Symbolic Link (SYLK/SLK) | ✔ | ✔ |
+| Lotus Formatted Text (PRN) | ✔ | ✔ |
+| UTF-16 Unicode Text (TXT) | ✔ | ✔ |
+| **Other Workbook/Worksheet Formats** |:-----:|:-----:|
+| Numbers 3.0+ / iWork 2013+ Spreadsheet (NUMBERS) | ✔ | ✔ |
+| OpenDocument Spreadsheet (ODS) | ✔ | ✔ |
+| Flat XML ODF Spreadsheet (FODS) | ✔ | ✔ |
+| Uniform Office Format Spreadsheet (标文通 UOS1/UOS2) | ✔ | |
+| dBASE II/III/IV / Visual FoxPro (DBF) | ✔ | ✔ |
+| Lotus 1-2-3 (WK1/WK3) | ✔ | ✔ |
+| Lotus 1-2-3 (WKS/WK2/WK4/123) | ✔ | |
+| Quattro Pro Spreadsheet (WQ1/WQ2/WB1/WB2/WB3/QPW) | ✔ | |
+| Works 1.x-3.x DOS / 2.x-5.x Windows Spreadsheet (WKS) | ✔ | |
+| Works 6.x-9.x Spreadsheet (XLR) | ✔ | |
+| **Other Common Spreadsheet Output Formats** |:-----:|:-----:|
+| HTML Tables | ✔ | ✔ |
+| Rich Text Format tables (RTF) | | ✔ |
+| Ethercalc Record Format (ETH) | ✔ | ✔ |
+
+Features not supported by a given file format will not be written. Formats with
+range limits will be silently truncated:
+
+| Format | Last Cell | Max Cols | Max Rows |
+|:------------------------------------------|:-----------|---------:|---------:|
+| Excel 2007+ XML Formats (XLSX/XLSM) | XFD1048576 | 16384 | 1048576 |
+| Excel 2007+ Binary Format (XLSB BIFF12) | XFD1048576 | 16384 | 1048576 |
+| Excel 97-2004 (XLS BIFF8) | IV65536 | 256 | 65536 |
+| Excel 5.0/95 (XLS BIFF5) | IV16384 | 256 | 16384 |
+| Excel 4.0 (XLS BIFF4) | IV16384 | 256 | 16384 |
+| Excel 3.0 (XLS BIFF3) | IV16384 | 256 | 16384 |
+| Excel 2.0/2.1 (XLS BIFF2) | IV16384 | 256 | 16384 |
+| Lotus 1-2-3 R2 - R5 (WK1/WK3/WK4) | IV8192 | 256 | 8192 |
+| Lotus 1-2-3 R1 (WKS) | IV2048 | 256 | 2048 |
+
+Excel 2003 SpreadsheetML range limits are governed by the version of Excel and
+are not enforced by the writer.
+
+
+ File Format Details (click to show)
+
+**Core Spreadsheet Formats**
+
+- **Excel 2007+ XML (XLSX/XLSM)**
+
+XLSX and XLSM files are ZIP containers containing a series of XML files in
+accordance with the Open Packaging Conventions (OPC). The XLSM format, almost
+identical to XLSX, is used for files containing macros.
+
+The format is standardized in ECMA-376 and later in ISO/IEC 29500. Excel does
+not follow the specification, and there are additional documents discussing how
+Excel deviates from the specification.
+
+- **Excel 2.0-95 (BIFF2/BIFF3/BIFF4/BIFF5)**
+
+BIFF 2/3 XLS are single-sheet streams of binary records. Excel 4 introduced
+the concept of a workbook (`XLW` files) but also had single-sheet `XLS` format.
+The structure is largely similar to the Lotus 1-2-3 file formats. BIFF5/8/12
+extended the format in various ways but largely stuck to the same record format.
+
+There is no official specification for any of these formats. Excel 95 can write
+files in these formats, so record lengths and fields were determined by writing
+in all of the supported formats and comparing files. Excel 2016 can generate
+BIFF5 files, enabling a full suite of file tests starting from XLSX or BIFF2.
+
+- **Excel 97-2004 Binary (BIFF8)**
+
+BIFF8 exclusively uses the Compound File Binary container format, splitting some
+content into streams within the file. At its core, it still uses an extended
+version of the binary record format from older versions of BIFF.
+
+The `MS-XLS` specification covers the basics of the file format, and other
+specifications expand on serialization of features like properties.
+
+- **Excel 2003-2004 (SpreadsheetML)**
+
+Predating XLSX, SpreadsheetML files are simple XML files. There is no official
+and comprehensive specification, although MS has released documentation on the
+format. Since Excel 2016 can generate SpreadsheetML files, mapping features is
+pretty straightforward.
+
+- **Excel 2007+ Binary (XLSB, BIFF12)**
+
+Introduced in parallel with XLSX, the XLSB format combines the BIFF architecture
+with the content separation and ZIP container of XLSX. For the most part nodes
+in an XLSX sub-file can be mapped to XLSB records in a corresponding sub-file.
+
+The `MS-XLSB` specification covers the basics of the file format, and other
+specifications expand on serialization of features like properties.
+
+- **Delimiter-Separated Values (CSV/TXT)**
+
+Excel CSV deviates from RFC4180 in a number of important ways. The generated
+CSV files should generally work in Excel although they may not work in RFC4180
+compatible readers. The parser should generally understand Excel CSV. The
+writer proactively generates cells for formulae if values are unavailable.
+
+Excel TXT uses tab as the delimiter and code page 1200.
+
+Like in Excel, files starting with `0x49 0x44 ("ID")` are treated as Symbolic
+Link files. Unlike Excel, if the file does not have a valid SYLK header, it
+will be proactively reinterpreted as CSV. There are some files with semicolon
+delimiter that align with a valid SYLK file. For the broadest compatibility,
+all cells with the value of `ID` are automatically wrapped in double-quotes.
+
+**Miscellaneous Workbook Formats**
+
+Support for other formats is generally far behind XLS/XLSB/XLSX support, due in
+part to a lack of publicly available documentation. Test files were produced in
+the respective apps and compared to their XLS exports to determine structure.
+The main focus is data extraction.
+
+- **Lotus 1-2-3 (WKS/WK1/WK2/WK3/WK4/123)**
+
+The Lotus formats consist of binary records similar to the BIFF structure. Lotus
+did release a specification decades ago covering the original WK1 format. Other
+features were deduced by producing files and comparing to Excel support.
+
+Generated WK1 worksheets are compatible with Lotus 1-2-3 R2 and Excel 5.0.
+
+Generated WK3 workbooks are compatible with Lotus 1-2-3 R9 and Excel 5.0.
+
+- **Quattro Pro (WQ1/WQ2/WB1/WB2/WB3/QPW)**
+
+The Quattro Pro formats use binary records in the same way as BIFF and Lotus.
+Some of the newer formats (namely WB3 and QPW) use a CFB enclosure just like
+BIFF8 XLS.
+
+- **Works for DOS / Windows Spreadsheet (WKS/XLR)**
+
+All versions of Works were limited to a single worksheet.
+
+Works for DOS 1.x - 3.x and Works for Windows 2.x extends the Lotus WKS format
+with additional record types.
+
+Works for Windows 3.x - 5.x uses the same format and WKS extension. The BOF
+record has type `FF`
+
+Works for Windows 6.x - 9.x use the XLR format. XLR is nearly identical to
+BIFF8 XLS: it uses the CFB container with a Workbook stream. Works 9 saves the
+exact Workbook stream for the XLR and the 97-2003 XLS export. Works 6 XLS
+includes two empty worksheets but the main worksheet has an identical encoding.
+XLR also includes a `WksSSWorkBook` stream similar to Lotus FM3/FMT files.
+
+- **Numbers 3.0+ / iWork 2013+ Spreadsheet (NUMBERS)**
+
+iWork 2013 (Numbers 3.0 / Pages 5.0 / Keynote 6.0) switched from a proprietary
+XML-based format to the current file format based on the iWork Archive (IWA).
+This format has been used up through the current release (Numbers 11.2).
+
+The parser focuses on extracting raw data from tables. Numbers technically
+supports multiple tables in a logical worksheet, including custom titles. This
+parser will generate one worksheet per Numbers table.
+
+The writer currently exports a small range from the first worksheet.
+
+- **OpenDocument Spreadsheet (ODS/FODS)**
+
+ODS is an XML-in-ZIP format akin to XLSX while FODS is an XML format akin to
+SpreadsheetML. Both are detailed in the OASIS standard, but tools like LO/OO
+add undocumented extensions. The parsers and writers do not implement the full
+standard, instead focusing on parts necessary to extract and store raw data.
+
+- **Uniform Office Spreadsheet (UOS1/2)**
+
+UOS is a very similar format, and it comes in 2 varieties corresponding to ODS
+and FODS respectively. For the most part, the difference between the formats
+is in the names of tags and attributes.
+
+**Miscellaneous Worksheet Formats**
+
+Many older formats supported only one worksheet:
+
+- **dBASE and Visual FoxPro (DBF)**
+
+DBF is really a typed table format: each column can only hold one data type and
+each record omits type information. The parser generates a header row and
+inserts records starting at the second row of the worksheet. The writer makes
+files compatible with Visual FoxPro extensions.
+
+Multi-file extensions like external memos and tables are currently unsupported,
+limited by the general ability to read arbitrary files in the web browser. The
+reader understands DBF Level 7 extensions like DATETIME.
+
+- **Symbolic Link (SYLK)**
+
+There is no real documentation. All knowledge was gathered by saving files in
+various versions of Excel to deduce the meaning of fields. Notes:
+
+- Plain formulae are stored in the RC form.
+- Column widths are rounded to integral characters.
+
+- **Lotus Formatted Text (PRN)**
+
+There is no real documentation, and in fact Excel treats PRN as an output-only
+file format. Nevertheless we can guess the column widths and reverse-engineer
+the original layout. Excel's 240 character width limitation is not enforced.
+
+- **Data Interchange Format (DIF)**
+
+There is no unified definition. Visicalc DIF differs from Lotus DIF, and both
+differ from Excel DIF. Where ambiguous, the parser/writer follows the expected
+behavior from Excel. In particular, Excel extends DIF in incompatible ways:
+
+- Since Excel automatically converts numbers-as-strings to numbers, numeric
+ string constants are converted to formulae: `"0.3" -> "=""0.3""`
+- DIF technically expects numeric cells to hold the raw numeric data, but Excel
+ permits formatted numbers (including dates)
+- DIF technically has no support for formulae, but Excel will automatically
+ convert plain formulae. Array formulae are not preserved.
+
+- **HTML**
+
+Excel HTML worksheets include special metadata encoded in styles. For example,
+`mso-number-format` is a localized string containing the number format. Despite
+the metadata the output is valid HTML, although it does accept bare `&` symbols.
+
+The writer adds type metadata to the TD elements via the `t` tag. The parser
+looks for those tags and overrides the default interpretation. For example, text
+like `12345 | ` will be parsed as numbers but `12345 | ` will
+be parsed as text.
+
+- **Rich Text Format (RTF)**
+
+Excel RTF worksheets are stored in clipboard when copying cells or ranges from a
+worksheet. The supported codes are a subset of the Word RTF support.
+
+- **Ethercalc Record Format (ETH)**
+
+[Ethercalc](https://ethercalc.net/) is an open source web spreadsheet powered by
+a record format reminiscent of SYLK wrapped in a MIME multi-part message.
+
+
+
+
+## Testing
+
+### Node
+
+
+ (click to show)
+
+`make test` will run the node-based tests. By default it runs tests on files in
+every supported format. To test a specific file type, set `FMTS` to the format
+you want to test. Feature-specific tests are available with `make test_misc`
+
+```bash
+$ make test_misc # run core tests
+$ make test # run full tests
+$ make test_xls # only use the XLS test files
+$ make test_xlsx # only use the XLSX test files
+$ make test_xlsb # only use the XLSB test files
+$ make test_xml # only use the XML test files
+$ make test_ods # only use the ODS test files
+```
+
+To enable all errors, set the environment variable `WTF=1`:
+
+```bash
+$ make test # run full tests
+$ WTF=1 make test # enable all error messages
+```
+
+`flow` and `eslint` checks are available:
+
+```bash
+$ make lint # eslint checks
+$ make flow # make lint + Flow checking
+$ make tslint # check TS definitions
+```
+
+
+
+### Browser
+
+
+ (click to show)
+
+The core in-browser tests are available at `tests/index.html` within this repo.
+Start a local server and navigate to that directory to run the tests.
+`make ctestserv` will start a server on port 8000.
+
+`make ctest` will generate the browser fixtures. To add more files, edit the
+`tests/fixtures.lst` file and add the paths.
+
+To run the full in-browser tests, clone the repo for
+[`oss.sheetjs.com`](https://github.com/SheetJS/SheetJS.github.io) and replace
+the `xlsx.js` file (then open a browser window and go to `stress.html`):
+
+```bash
+$ cp xlsx.js ../SheetJS.github.io
+$ cd ../SheetJS.github.io
+$ simplehttpserver # or "python -mSimpleHTTPServer" or "serve"
+$ open -a Chromium.app http://localhost:8000/stress.html
+```
+
+
+### Tested Environments
+
+
+ (click to show)
+
+ - NodeJS `0.8`, `0.10`, `0.12`, `4.x`, `5.x`, `6.x`, `7.x`, `8.x`
+ - IE 6/7/8/9/10/11 (IE 6-9 require shims)
+ - Chrome 24+ (including Android 4.0+)
+ - Safari 6+ (iOS and Desktop)
+ - Edge 13+, FF 18+, and Opera 12+
+
+Tests utilize the mocha testing framework.
+
+ - for XLS\* modules using Sauce Labs
+
+The test suite also includes tests for various time zones. To change
+the timezone locally, set the TZ environment variable:
+
+```bash
+$ env TZ="Asia/Kolkata" WTF=1 make test_misc
+```
+
+
+
+### Test Files
+
+Test files are housed in [another repo](https://github.com/SheetJS/test_files).
+
+Running `make init` will refresh the `test_files` submodule and get the files.
+Note that this requires `svn`, `git`, `hg` and other commands that may not be
+available. If `make init` fails, please download the latest version of the test
+files snapshot from [the repo](https://github.com/SheetJS/test_files/releases)
+
+
+ Latest Snapshot (click to show)
+
+Latest test files snapshot:
+
+
+(download and unzip to the `test_files` subdirectory)
+
+
+
+## Contributing
+
+Due to the precarious nature of the Open Specifications Promise, it is very
+important to ensure code is cleanroom. [Contribution Notes](CONTRIBUTING.md)
+
+
+ File organization (click to show)
+
+At a high level, the final script is a concatenation of the individual files in
+the `bits` folder. Running `make` should reproduce the final output on all
+platforms. The README is similarly split into bits in the `docbits` folder.
+
+Folders:
+
+| folder | contents |
+|:-------------|:--------------------------------------------------------------|
+| `bits` | raw source files that make up the final script |
+| `docbits` | raw markdown files that make up `README.md` |
+| `bin` | server-side bin scripts (`xlsx.njs`) |
+| `dist` | dist files for web browsers and nonstandard JS environments |
+| `demos` | demo projects for platforms like ExtendScript and Webpack |
+| `tests` | browser tests (run `make ctest` to rebuild) |
+| `types` | typescript definitions and tests |
+| `misc` | miscellaneous supporting scripts |
+| `test_files` | test files (pulled from the test files repository) |
+
+
+
+After cloning the repo, running `make help` will display a list of commands.
+
+### OSX/Linux
+
+
+ (click to show)
+
+The `xlsx.js` file is constructed from the files in the `bits` subdirectory. The
+build script (run `make`) will concatenate the individual bits to produce the
+script. Before submitting a contribution, ensure that running make will produce
+the `xlsx.js` file exactly. The simplest way to test is to add the script:
+
+```bash
+$ git add xlsx.js
+$ make clean
+$ make
+$ git diff xlsx.js
+```
+
+To produce the dist files, run `make dist`. The dist files are updated in each
+version release and *should not be committed between versions*.
+
+
+### Windows
+
+
+ (click to show)
+
+The included `make.cmd` script will build `xlsx.js` from the `bits` directory.
+Building is as simple as:
+
+```cmd
+> make
+```
+
+To prepare development environment:
+
+```cmd
+> make init
+```
+
+The full list of commands available in Windows are displayed in `make help`:
+
+```
+make init -- install deps and global modules
+make lint -- run eslint linter
+make test -- run mocha test suite
+make misc -- run smaller test suite
+make book -- rebuild README and summary
+make help -- display this message
+```
+
+As explained in [Test Files](#test-files), on Windows the release ZIP file must
+be downloaded and extracted. If Bash on Windows is available, it is possible
+to run the OSX/Linux workflow. The following steps prepares the environment:
+
+```bash
+# Install support programs for the build and test commands
+sudo apt-get install make git subversion mercurial
+
+# Install nodejs and NPM within the WSL
+wget -qO- https://deb.nodesource.com/setup_8.x | sudo bash
+sudo apt-get install nodejs
+
+# Install dev dependencies
+sudo npm install -g mocha voc blanket xlsjs
+```
+
+
+
+### Tests
+
+
+ (click to show)
+
+The `test_misc` target (`make test_misc` on Linux/OSX / `make misc` on Windows)
+runs the targeted feature tests. It should take 5-10 seconds to perform feature
+tests without testing against the entire test battery. New features should be
+accompanied with tests for the relevant file formats and features.
+
+For tests involving the read side, an appropriate feature test would involve
+reading an existing file and checking the resulting workbook object. If a
+parameter is involved, files should be read with different values to verify that
+the feature is working as expected.
+
+For tests involving a new write feature which can already be parsed, appropriate
+feature tests would involve writing a workbook with the feature and then opening
+and verifying that the feature is preserved.
+
+For tests involving a new write feature without an existing read ability, please
+add a feature test to the kitchen sink `tests/write.js`.
+
+
+## License
+
+Please consult the attached LICENSE file for details. All rights not explicitly
+granted by the Apache 2.0 License are reserved by the Original Author.
+
+
+## References
+
+
+ OSP-covered Specifications (click to show)
+
+ - `MS-CFB`: Compound File Binary File Format
+ - `MS-CTXLS`: Excel Custom Toolbar Binary File Format
+ - `MS-EXSPXML3`: Excel Calculation Version 2 Web Service XML Schema
+ - `MS-ODATA`: Open Data Protocol (OData)
+ - `MS-ODRAW`: Office Drawing Binary File Format
+ - `MS-ODRAWXML`: Office Drawing Extensions to Office Open XML Structure
+ - `MS-OE376`: Office Implementation Information for ECMA-376 Standards Support
+ - `MS-OFFCRYPTO`: Office Document Cryptography Structure
+ - `MS-OI29500`: Office Implementation Information for ISO/IEC 29500 Standards Support
+ - `MS-OLEDS`: Object Linking and Embedding (OLE) Data Structures
+ - `MS-OLEPS`: Object Linking and Embedding (OLE) Property Set Data Structures
+ - `MS-OODF3`: Office Implementation Information for ODF 1.2 Standards Support
+ - `MS-OSHARED`: Office Common Data Types and Objects Structures
+ - `MS-OVBA`: Office VBA File Format Structure
+ - `MS-XLDM`: Spreadsheet Data Model File Format
+ - `MS-XLS`: Excel Binary File Format (.xls) Structure Specification
+ - `MS-XLSB`: Excel (.xlsb) Binary File Format
+ - `MS-XLSX`: Excel (.xlsx) Extensions to the Office Open XML SpreadsheetML File Format
+ - `XLS`: Microsoft Office Excel 97-2007 Binary File Format Specification
+ - `RTF`: Rich Text Format
+
+
+
+- ISO/IEC 29500:2012(E) "Information technology — Document description and processing languages — Office Open XML File Formats"
+- Open Document Format for Office Applications Version 1.2 (29 September 2011)
+- Worksheet File Format (From Lotus) December 1984
diff --git a/miniapp/miniprogram_npm/xlsx/bin/xlsx.njs b/miniapp/miniprogram_npm/xlsx/bin/xlsx.njs
new file mode 100755
index 0000000..e467337
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/bin/xlsx.njs
@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/* xlsx.js (C) 2013-present SheetJS -- http://sheetjs.com */
+/* eslint-env node */
+/* vim: set ts=2 ft=javascript: */
+var n = "xlsx";
+var X = require('../');
+try { X = require('../xlsx.flow'); } catch(e) {}
+try { require('exit-on-epipe'); } catch(e) {}
+var fs = require('fs'), program;
+try { program = require('commander'); } catch(e) {
+ [
+ "The `xlsx` command line tool is deprecated in favor of `xlsx-cli`.",
+ "",
+ "For new versions of node, we recommend using `npx`:",
+ " $ npx xlsx-cli --help",
+ "",
+ "For older versions of node, explicitly install `xlsx-cli` globally:",
+ " $ npm i -g xlsx-cli",
+ " $ xlsx-cli --help"
+ ].forEach(function(m) { console.error(m); });
+ process.exit(1);
+}
+program
+ .version(X.version)
+ .usage('[options] [sheetname]')
+ .option('-f, --file ', 'use specified workbook')
+ .option('-s, --sheet ', 'print specified sheet (default first sheet)')
+ .option('-N, --sheet-index ', 'use specified sheet index (0-based)')
+ .option('-p, --password ', 'if file is encrypted, try with specified pw')
+ .option('-l, --list-sheets', 'list sheet names and exit')
+ .option('-o, --output ', 'output to specified file')
+
+ .option('-B, --xlsb', 'emit XLSB to or .xlsb')
+ .option('-M, --xlsm', 'emit XLSM to or .xlsm')
+ .option('-X, --xlsx', 'emit XLSX to or .xlsx')
+ .option('-I, --xlam', 'emit XLAM to or .xlam')
+ .option('-Y, --ods', 'emit ODS to or .ods')
+ .option('-8, --xls', 'emit XLS to or .xls (BIFF8)')
+ .option('-5, --biff5','emit XLS to or .xls (BIFF5)')
+ .option('-4, --biff4','emit XLS to or .xls (BIFF4)')
+ .option('-3, --biff3','emit XLS to or .xls (BIFF3)')
+ .option('-2, --biff2','emit XLS to or .xls (BIFF2)')
+ .option('-i, --xla', 'emit XLA to or .xla')
+ .option('-6, --xlml', 'emit SSML to or .xls (2003 XML)')
+ .option('-T, --fods', 'emit FODS to or .fods (Flat ODS)')
+ .option('--wk3', 'emit WK3 to or .txt (Lotus WK3)')
+ .option('--numbers', 'emit NUMBERS to or .numbers')
+
+ .option('-S, --formulae', 'emit list of values and formulae')
+ .option('-j, --json', 'emit formatted JSON (all fields text)')
+ .option('-J, --raw-js', 'emit raw JS object (raw numbers)')
+ .option('-A, --arrays', 'emit rows as JS objects (raw numbers)')
+ .option('-H, --html', 'emit HTML to or .html')
+ .option('-D, --dif', 'emit DIF to or .dif (Lotus DIF)')
+ .option('-U, --dbf', 'emit DBF to or .dbf (MSVFP DBF)')
+ .option('-K, --sylk', 'emit SYLK to or .slk (Excel SYLK)')
+ .option('-P, --prn', 'emit PRN to or .prn (Lotus PRN)')
+ .option('-E, --eth', 'emit ETH to or .eth (Ethercalc)')
+ .option('-t, --txt', 'emit TXT to or .txt (UTF-8 TSV)')
+ .option('-r, --rtf', 'emit RTF to or .txt (Table RTF)')
+ .option('--wk1', 'emit WK1 to or .txt (Lotus WK1)')
+ .option('-z, --dump', 'dump internal representation as JSON')
+ .option('--props', 'dump workbook properties as CSV')
+
+ .option('-F, --field-sep ', 'CSV field separator', ",")
+ .option('-R, --row-sep ', 'CSV row separator', "\n")
+ .option('-n, --sheet-rows ', 'Number of rows to process (0=all rows)')
+ .option('--codepage ', 'default to specified codepage when ambiguous')
+ .option('--req ', 'require module before processing')
+ .option('--sst', 'generate shared string table for XLS* formats')
+ .option('--compress', 'use compression when writing XLSX/M/B and ODS')
+ .option('--read', 'read but do not generate output')
+ .option('--book', 'for single-sheet formats, emit a file per worksheet')
+ .option('--all', 'parse everything; write as much as possible')
+ .option('--dev', 'development mode')
+ .option('--sparse', 'sparse mode')
+ .option('-q, --quiet', 'quiet mode');
+
+program.on('--help', function() {
+ console.log(' Default output format is CSV');
+ console.log(' Support email: dev@sheetjs.com');
+ console.log(' Web Demo: http://oss.sheetjs.com/js-'+n+'/');
+});
+
+/* flag, bookType, default ext */
+var workbook_formats = [
+ ['xlsx', 'xlsx', 'xlsx'],
+ ['xlsm', 'xlsm', 'xlsm'],
+ ['xlam', 'xlam', 'xlam'],
+ ['xlsb', 'xlsb', 'xlsb'],
+ ['xls', 'xls', 'xls'],
+ ['xla', 'xla', 'xla'],
+ ['biff5', 'biff5', 'xls'],
+ ['numbers', 'numbers', 'numbers'],
+ ['ods', 'ods', 'ods'],
+ ['fods', 'fods', 'fods'],
+ ['wk3', 'wk3', 'wk3']
+];
+var wb_formats_2 = [
+ ['xlml', 'xlml', 'xls']
+];
+program.parse(process.argv);
+
+var filename = '', sheetname = '';
+if(program.args[0]) {
+ filename = program.args[0];
+ if(program.args[1]) sheetname = program.args[1];
+}
+if(program.sheet) sheetname = program.sheet;
+if(program.file) filename = program.file;
+
+if(!filename) {
+ console.error(n + ": must specify a filename");
+ process.exit(1);
+}
+if(!fs.existsSync(filename)) {
+ console.error(n + ": " + filename + ": No such file or directory");
+ process.exit(2);
+}
+
+if(program.req) program.req.split(",").forEach(function(r) {
+ require((fs.existsSync(r) || fs.existsSync(r + '.js')) ? require('path').resolve(r) : r);
+});
+
+var opts = {}, wb/*:?Workbook*/;
+if(program.listSheets) opts.bookSheets = true;
+if(program.sheetRows) opts.sheetRows = program.sheetRows;
+if(program.password) opts.password = program.password;
+var seen = false;
+function wb_fmt() {
+ seen = true;
+ opts.cellFormula = true;
+ opts.cellNF = true;
+ opts.xlfn = true;
+ if(program.output) sheetname = program.output;
+}
+function isfmt(m/*:string*/)/*:boolean*/ {
+ if(!program.output) return false;
+ var t = m.charAt(0) === "." ? m : "." + m;
+ return program.output.slice(-t.length) === t;
+}
+workbook_formats.forEach(function(m) { if(program[m[0]] || isfmt(m[0])) { wb_fmt(); } });
+wb_formats_2.forEach(function(m) { if(program[m[0]] || isfmt(m[0])) { wb_fmt(); } });
+if(seen) {
+} else if(program.formulae) opts.cellFormula = true;
+else opts.cellFormula = false;
+
+var wopts = ({WTF:opts.WTF, bookSST:program.sst}/*:any*/);
+if(program.compress) wopts.compression = true;
+
+if(program.all) {
+ opts.cellFormula = true;
+ opts.bookVBA = true;
+ opts.cellNF = true;
+ opts.cellHTML = true;
+ opts.cellStyles = true;
+ opts.sheetStubs = true;
+ opts.cellDates = true;
+ wopts.cellFormula = true;
+ wopts.cellStyles = true;
+ wopts.sheetStubs = true;
+ wopts.bookVBA = true;
+}
+if(program.sparse) opts.dense = false; else opts.dense = true;
+if(program.codepage) opts.codepage = +program.codepage;
+
+if(program.dev) {
+ opts.WTF = true;
+ wb = X.readFile(filename, opts);
+} else try {
+ wb = X.readFile(filename, opts);
+} catch(e) {
+ var msg = (program.quiet) ? "" : n + ": error parsing ";
+ msg += filename + ": " + e;
+ console.error(msg);
+ process.exit(3);
+}
+if(program.read) process.exit(0);
+if(!wb) { console.error(n + ": error parsing " + filename + ": empty workbook"); process.exit(0); }
+/*:: if(!wb) throw new Error("unreachable"); */
+if(program.listSheets) {
+ console.log((wb.SheetNames||[]).join("\n"));
+ process.exit(0);
+}
+if(program.dump) {
+ console.log(JSON.stringify(wb));
+ process.exit(0);
+}
+if(program.props) {
+ if(wb) dump_props(wb);
+ process.exit(0);
+}
+
+/* full workbook formats */
+workbook_formats.forEach(function(m) { if(program[m[0]] || isfmt(m[0])) {
+ wopts.bookType = m[1];
+ if(wopts.bookType == "numbers") try {
+ var XLSX_ZAHL = require("../dist/xlsx.zahl");
+ wopts.numbers = XLSX_ZAHL;
+ } catch(e) {}
+ if(wb) X.writeFile(wb, program.output || sheetname || ((filename || "") + "." + m[2]), wopts);
+ process.exit(0);
+} });
+
+wb_formats_2.forEach(function(m) { if(program[m[0]] || isfmt(m[0])) {
+ wopts.bookType = m[1];
+ if(wb) X.writeFile(wb, program.output || sheetname || ((filename || "") + "." + m[2]), wopts);
+ process.exit(0);
+} });
+
+var target_sheet = sheetname || '';
+if(target_sheet === '') {
+ if(+program.sheetIndex < (wb.SheetNames||[]).length) target_sheet = wb.SheetNames[+program.sheetIndex];
+ else target_sheet = (wb.SheetNames||[""])[0];
+}
+
+var ws;
+try {
+ ws = wb.Sheets[target_sheet];
+ if(!ws) {
+ console.error("Sheet " + target_sheet + " cannot be found");
+ process.exit(3);
+ }
+} catch(e) {
+ console.error(n + ": error parsing "+filename+" "+target_sheet+": " + e);
+ process.exit(4);
+}
+
+if(!program.quiet && !program.book) console.error(target_sheet);
+
+/* single worksheet file formats */
+[
+ ['biff2', '.xls'],
+ ['biff3', '.xls'],
+ ['biff4', '.xls'],
+ ['sylk', '.slk'],
+ ['html', '.html'],
+ ['prn', '.prn'],
+ ['eth', '.eth'],
+ ['rtf', '.rtf'],
+ ['txt', '.txt'],
+ ['dbf', '.dbf'],
+ ['wk1', '.wk1'],
+ ['dif', '.dif']
+].forEach(function(m) { if(program[m[0]] || isfmt(m[1])) {
+ wopts.bookType = m[0];
+ if(program.book) {
+ /*:: if(wb == null) throw new Error("Unreachable"); */
+ wb.SheetNames.forEach(function(n, i) {
+ wopts.sheet = n;
+ X.writeFile(wb, (program.output || sheetname || filename || "") + m[1] + "." + i, wopts);
+ });
+ } else X.writeFile(wb, program.output || sheetname || ((filename || "") + m[1]), wopts);
+ process.exit(0);
+} });
+
+function outit(o, fn) { if(fn) fs.writeFileSync(fn, o); else console.log(o); }
+
+function doit(cb) {
+ /*:: if(!wb) throw new Error("unreachable"); */
+ if(program.book) wb.SheetNames.forEach(function(n, i) {
+ /*:: if(!wb) throw new Error("unreachable"); */
+ outit(cb(wb.Sheets[n]), (program.output || sheetname || filename) + "." + i);
+ });
+ else outit(cb(ws), program.output);
+}
+
+var jso = {};
+switch(true) {
+ case program.formulae:
+ doit(function(ws) { return X.utils.sheet_to_formulae(ws).join("\n"); });
+ break;
+
+ case program.arrays: jso.header = 1;
+ /* falls through */
+ case program.rawJs: jso.raw = true;
+ /* falls through */
+ case program.json:
+ doit(function(ws) { return JSON.stringify(X.utils.sheet_to_json(ws,jso)); });
+ break;
+
+ default:
+ if(!program.book) {
+ var stream = X.stream.to_csv(ws, {FS:program.fieldSep||",", RS:program.rowSep||"\n"});
+ if(program.output) stream.pipe(fs.createWriteStream(program.output));
+ else stream.pipe(process.stdout);
+ } else doit(function(ws) { return X.utils.sheet_to_csv(ws,{FS:program.fieldSep, RS:program.rowSep}); });
+ break;
+}
+
+function dump_props(wb/*:Workbook*/) {
+ var propaoa = [];
+ if(Object.assign && Object.entries) propaoa = Object.entries(Object.assign({}, wb.Props, wb.Custprops));
+ else {
+ var Keys/*:: :Array = []*/, pi;
+ if(wb.Props) {
+ Keys = Object.keys(wb.Props);
+ for(pi = 0; pi < Keys.length; ++pi) {
+ if(Object.prototype.hasOwnProperty.call(Keys, Keys[pi])) propaoa.push([Keys[pi], Keys[/*::+*/Keys[pi]]]);
+ }
+ }
+ if(wb.Custprops) {
+ Keys = Object.keys(wb.Custprops);
+ for(pi = 0; pi < Keys.length; ++pi) {
+ if(Object.prototype.hasOwnProperty.call(Keys, Keys[pi])) propaoa.push([Keys[pi], Keys[/*::+*/Keys[pi]]]);
+ }
+ }
+ }
+ console.log(X.utils.sheet_to_csv(X.utils.aoa_to_sheet(propaoa)));
+}
diff --git a/miniapp/miniprogram_npm/xlsx/bower.json b/miniapp/miniprogram_npm/xlsx/bower.json
new file mode 100644
index 0000000..ec587d2
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/bower.json
@@ -0,0 +1,22 @@
+{
+ "name": "js-xlsx",
+ "homepage": "https://github.com/SheetJS/js-xlsx",
+ "main": ["xlsx.js"],
+ "ignore": [
+ "bin",
+ "bits",
+ "misc",
+ "**/.*"
+ ],
+ "keywords": [
+ "excel",
+ "xls",
+ "xml",
+ "xlsx",
+ "xlsm",
+ "xlsb",
+ "ods",
+ "js-xls",
+ "js-xlsx"
+ ]
+}
diff --git a/miniapp/miniprogram_npm/xlsx/formats.png b/miniapp/miniprogram_npm/xlsx/formats.png
new file mode 100644
index 0000000..dd478aa
Binary files /dev/null and b/miniapp/miniprogram_npm/xlsx/formats.png differ
diff --git a/miniapp/miniprogram_npm/xlsx/legend.png b/miniapp/miniprogram_npm/xlsx/legend.png
new file mode 100644
index 0000000..686a751
Binary files /dev/null and b/miniapp/miniprogram_npm/xlsx/legend.png differ
diff --git a/miniapp/miniprogram_npm/xlsx/package.json b/miniapp/miniprogram_npm/xlsx/package.json
new file mode 100644
index 0000000..c18dfd9
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/package.json
@@ -0,0 +1,101 @@
+{
+ "name": "xlsx",
+ "version": "0.18.5",
+ "author": "sheetjs",
+ "description": "SheetJS Spreadsheet data parser and writer",
+ "keywords": [
+ "excel",
+ "xls",
+ "xlsx",
+ "xlsb",
+ "xlsm",
+ "ods",
+ "csv",
+ "dbf",
+ "dif",
+ "sylk",
+ "office",
+ "spreadsheet"
+ ],
+ "bin": {
+ "xlsx": "./bin/xlsx.njs"
+ },
+ "main": "xlsx.js",
+ "module": "xlsx.mjs",
+ "unpkg": "dist/xlsx.full.min.js",
+ "jsdelivr": "dist/xlsx.full.min.js",
+ "types": "types/index.d.ts",
+ "browser": {
+ "buffer": false,
+ "crypto": false,
+ "stream": false,
+ "process": false,
+ "fs": false
+ },
+ "sideEffects": false,
+ "dependencies": {
+ "adler-32": "~1.3.0",
+ "cfb": "~1.2.1",
+ "codepage": "~1.15.0",
+ "crc-32": "~1.2.1",
+ "ssf": "~0.11.2",
+ "wmf": "~1.0.1",
+ "word": "~0.3.0"
+ },
+ "devDependencies": {
+ "@sheetjs/uglify-js": "~2.7.3",
+ "@types/node": "^8.5.9",
+ "acorn": "7.4.1",
+ "alex": "8.1.1",
+ "blanket": "~1.2.3",
+ "commander": "~2.17.1",
+ "dtslint": "^0.1.2",
+ "eslint": "7.23.0",
+ "eslint-plugin-html": "^6.1.2",
+ "eslint-plugin-json": "^2.1.2",
+ "exit-on-epipe": "~1.0.1",
+ "fflate": "^0.7.1",
+ "jsdom": "~11.1.0",
+ "markdown-spellcheck": "^1.3.1",
+ "mocha": "~2.5.3",
+ "sinon": "^1.17.7",
+ "typescript": "2.2.0"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/SheetJS/sheetjs.git"
+ },
+ "scripts": {
+ "pretest": "npm run lint",
+ "test": "npm run tests-only",
+ "pretest-only": "git submodule init && git submodule update",
+ "tests-only": "make travis",
+ "build": "make",
+ "lint": "make fullint",
+ "dtslint": "dtslint types"
+ },
+ "config": {
+ "blanket": {
+ "pattern": "xlsx.js"
+ }
+ },
+ "alex": {
+ "allow": [
+ "chinese",
+ "special",
+ "simple",
+ "just",
+ "crash",
+ "wtf",
+ "holes"
+ ]
+ },
+ "homepage": "https://sheetjs.com/",
+ "bugs": {
+ "url": "https://github.com/SheetJS/sheetjs/issues"
+ },
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=0.8"
+ }
+}
diff --git a/miniapp/miniprogram_npm/xlsx/types/index.d.ts b/miniapp/miniprogram_npm/xlsx/types/index.d.ts
new file mode 100644
index 0000000..fa06782
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/types/index.d.ts
@@ -0,0 +1,900 @@
+/* index.d.ts (C) 2015-present SheetJS and contributors */
+// TypeScript Version: 2.2
+// import * as CFB from "cfb";
+// import * as SSF from "ssf";
+
+/** Version string */
+export const version: string;
+
+/** SSF Formatter Library */
+// export { SSF };
+export const SSF: any;
+
+/** CFB Library */
+// export { CFB };
+export const CFB: any;
+
+/** ESM ONLY! Set internal `fs` instance */
+export function set_fs(fs: any): void;
+/** ESM ONLY! Set internal codepage tables */
+export function set_cptable(cptable: any): void;
+
+/** NODE ONLY! Attempts to read filename and parse */
+export function readFile(filename: string, opts?: ParsingOptions): WorkBook;
+/** Attempts to parse data */
+export function read(data: any, opts?: ParsingOptions): WorkBook;
+/** Attempts to write or download workbook data to file */
+export function writeFile(data: WorkBook, filename: string, opts?: WritingOptions): any;
+/** Attempts to write or download workbook data to XLSX file */
+export function writeFileXLSX(data: WorkBook, filename: string, opts?: WritingOptions): any;
+/** Attempts to write or download workbook data to file asynchronously */
+type CBFunc = () => void;
+export function writeFileAsync(filename: string, data: WorkBook, opts: WritingOptions | CBFunc, cb?: CBFunc): any;
+/** Attempts to write the workbook data */
+export function write(data: WorkBook, opts: WritingOptions): any;
+/** Attempts to write the workbook data as XLSX */
+export function writeXLSX(data: WorkBook, opts: WritingOptions): any;
+
+/** Utility Functions */
+export const utils: XLSX$Utils;
+/** Stream Utility Functions */
+export const stream: StreamUtils;
+
+/** Number Format (either a string or an index to the format table) */
+export type NumberFormat = string | number;
+
+/** Worksheet specifier (string, number, worksheet) */
+export type WSSpec = string | number | WorkSheet;
+
+/** Range specifier (string or range or cell), single-cell lifted to range */
+export type RangeSpec = string | Range | CellAddress;
+
+/** Basic File Properties */
+export interface Properties {
+ /** Summary tab "Title" */
+ Title?: string;
+ /** Summary tab "Subject" */
+ Subject?: string;
+ /** Summary tab "Author" */
+ Author?: string;
+ /** Summary tab "Manager" */
+ Manager?: string;
+ /** Summary tab "Company" */
+ Company?: string;
+ /** Summary tab "Category" */
+ Category?: string;
+ /** Summary tab "Keywords" */
+ Keywords?: string;
+ /** Summary tab "Comments" */
+ Comments?: string;
+ /** Statistics tab "Last saved by" */
+ LastAuthor?: string;
+ /** Statistics tab "Created" */
+ CreatedDate?: Date;
+}
+
+/** Other supported properties */
+export interface FullProperties extends Properties {
+ ModifiedDate?: Date;
+ Application?: string;
+ AppVersion?: string;
+ DocSecurity?: string;
+ HyperlinksChanged?: boolean;
+ SharedDoc?: boolean;
+ LinksUpToDate?: boolean;
+ ScaleCrop?: boolean;
+ Worksheets?: number;
+ SheetNames?: string[];
+ ContentStatus?: string;
+ LastPrinted?: string;
+ Revision?: string | number;
+ Version?: string;
+ Identifier?: string;
+ Language?: string;
+}
+
+export interface CommonOptions {
+ /**
+ * If true, throw errors when features are not understood
+ * @default false
+ */
+ WTF?: boolean;
+
+ /**
+ * When reading a file with VBA macros, expose CFB blob to `vbaraw` field
+ * When writing BIFF8/XLSB/XLSM, reseat `vbaraw` and export to file
+ * @default false
+ */
+ bookVBA?: boolean;
+
+ /**
+ * When reading a file, store dates as type d (default is n)
+ * When writing XLSX/XLSM file, use native date (default uses date codes)
+ * @default false
+ */
+ cellDates?: boolean;
+
+ /**
+ * Create cell objects for stub cells
+ * @default false
+ */
+ sheetStubs?: boolean;
+
+ /**
+ * When reading a file, save style/theme info to the .s field
+ * When writing a file, export style/theme info
+ * @default false
+ */
+ cellStyles?: boolean;
+
+ /**
+ * If defined and file is encrypted, use password
+ * @default ''
+ */
+ password?: string;
+}
+
+export interface DateNFOption {
+ /** Use specified date format */
+ dateNF?: NumberFormat;
+}
+
+/** Options for read and readFile */
+export interface ParsingOptions extends CommonOptions {
+ /** Input data encoding */
+ type?: 'base64' | 'binary' | 'buffer' | 'file' | 'array' | 'string';
+
+ /** Default codepage */
+ codepage?: number;
+
+ /**
+ * Save formulae to the .f field
+ * @default true
+ */
+ cellFormula?: boolean;
+
+ /**
+ * Parse rich text and save HTML to the .h field
+ * @default true
+ */
+ cellHTML?: boolean;
+
+ /**
+ * Save number format string to the .z field
+ * @default false
+ */
+ cellNF?: boolean;
+
+ /**
+ * Generate formatted text to the .w field
+ * @default true
+ */
+ cellText?: boolean;
+
+ /** Override default date format (code 14) */
+ dateNF?: string;
+
+ /** Field Separator ("Delimiter" override) */
+ FS?: string;
+
+ /**
+ * If >0, read the first sheetRows rows
+ * @default 0
+ */
+ sheetRows?: number;
+
+ /**
+ * If true, parse calculation chains
+ * @default false
+ */
+ bookDeps?: boolean;
+
+ /**
+ * If true, add raw files to book object
+ * @default false
+ */
+ bookFiles?: boolean;
+
+ /**
+ * If true, only parse enough to get book metadata
+ * @default false
+ */
+ bookProps?: boolean;
+
+ /**
+ * If true, only parse enough to get the sheet names
+ * @default false
+ */
+ bookSheets?: boolean;
+
+ /** If specified, only parse the specified sheets or sheet names */
+ sheets?: number | string | Array;
+
+ /** If true, plaintext parsing will not parse values */
+ raw?: boolean;
+
+ /** If true, preserve _xlfn. prefixes in formula function names */
+ xlfn?: boolean;
+
+ dense?: boolean;
+
+ PRN?: boolean;
+}
+
+export interface SheetOption {
+ /**
+ * Name of Worksheet (for single-sheet formats)
+ * @default ''
+ */
+ sheet?: string;
+}
+
+/** Options for write and writeFile */
+export interface WritingOptions extends CommonOptions, SheetOption {
+ /** Output data encoding */
+ type?: 'base64' | 'binary' | 'buffer' | 'file' | 'array' | 'string';
+
+ /**
+ * Generate Shared String Table
+ * @default false
+ */
+ bookSST?: boolean;
+
+ /**
+ * File format of generated workbook
+ * @default 'xlsx'
+ */
+ bookType?: BookType;
+
+ /**
+ * Use ZIP compression for ZIP-based formats
+ * @default false
+ */
+ compression?: boolean;
+
+ /**
+ * Suppress "number stored as text" errors in generated files
+ * @default true
+ */
+ ignoreEC?: boolean;
+
+ /** Override workbook properties on save */
+ Props?: Properties;
+
+ /** Base64 encoding of NUMBERS base for exports */
+ numbers?: string;
+}
+
+/** Workbook Object */
+export interface WorkBook {
+ /**
+ * A dictionary of the worksheets in the workbook.
+ * Use SheetNames to reference these.
+ */
+ Sheets: { [sheet: string]: WorkSheet };
+
+ /** Ordered list of the sheet names in the workbook */
+ SheetNames: string[];
+
+ /** Standard workbook Properties */
+ Props?: FullProperties;
+
+ /** Custom workbook Properties */
+ Custprops?: object;
+
+ Workbook?: WBProps;
+
+ vbaraw?: any;
+}
+
+export interface SheetProps {
+ /** Name of Sheet */
+ name?: string;
+
+ /** Sheet Visibility (0=Visible 1=Hidden 2=VeryHidden) */
+ Hidden?: 0 | 1 | 2;
+
+ /** Name of Document Module in associated VBA Project */
+ CodeName?: string;
+}
+
+/** Defined Name Object */
+export interface DefinedName {
+ /** Name */
+ Name: string;
+
+ /** Reference */
+ Ref: string;
+
+ /** Scope (undefined for workbook scope) */
+ Sheet?: number;
+
+ /** Name comment */
+ Comment?: string;
+}
+
+/** Workbook-Level Attributes */
+export interface WBProps {
+ /** Sheet Properties */
+ Sheets?: SheetProps[];
+
+ /** Defined Names */
+ Names?: DefinedName[];
+
+ /** Workbook Views */
+ Views?: WBView[];
+
+ /** Other Workbook Properties */
+ WBProps?: WorkbookProperties;
+}
+
+/** Workbook View */
+export interface WBView {
+ /** Right-to-left mode */
+ RTL?: boolean;
+}
+
+/** Other Workbook Properties */
+export interface WorkbookProperties {
+ /** Worksheet Epoch (1904 if true, 1900 if false) */
+ date1904?: boolean;
+
+ /** Warn or strip personally identifying info on save */
+ filterPrivacy?: boolean;
+
+ /** Name of Document Module in associated VBA Project */
+ CodeName?: string;
+}
+
+/** DBF Field Header */
+export interface DBFField {
+ /** Original Field Name */
+ name?: string;
+
+ /** Field Type */
+ type?: string;
+
+ /** Field Length */
+ len?: number;
+
+ /** Field Decimal Count */
+ dec?: number;
+}
+
+/** Column Properties Object */
+export interface ColInfo {
+ /* --- visibility --- */
+
+ /** if true, the column is hidden */
+ hidden?: boolean;
+
+ /* --- column width --- */
+
+ /** width in Excel's "Max Digit Width", width*256 is integral */
+ width?: number;
+
+ /** width in screen pixels */
+ wpx?: number;
+
+ /** width in "characters" */
+ wch?: number;
+
+ /** outline / group level */
+ level?: number;
+
+ /** Excel's "Max Digit Width" unit, always integral */
+ MDW?: number;
+
+ /** DBF Field Header */
+ DBF?: DBFField;
+}
+
+/** Row Properties Object */
+export interface RowInfo {
+ /* --- visibility --- */
+
+ /** if true, the column is hidden */
+ hidden?: boolean;
+
+ /* --- row height --- */
+
+ /** height in screen pixels */
+ hpx?: number;
+
+ /** height in points */
+ hpt?: number;
+
+ /** outline / group level */
+ level?: number;
+}
+
+/**
+ * Write sheet protection properties.
+ */
+export interface ProtectInfo {
+ /**
+ * The password for formats that support password-protected sheets
+ * (XLSX/XLSB/XLS). The writer uses the XOR obfuscation method.
+ */
+ password?: string;
+ /**
+ * Select locked cells
+ * @default: true
+ */
+ selectLockedCells?: boolean;
+ /**
+ * Select unlocked cells
+ * @default: true
+ */
+ selectUnlockedCells?: boolean;
+ /**
+ * Format cells
+ * @default: false
+ */
+ formatCells?: boolean;
+ /**
+ * Format columns
+ * @default: false
+ */
+ formatColumns?: boolean;
+ /**
+ * Format rows
+ * @default: false
+ */
+ formatRows?: boolean;
+ /**
+ * Insert columns
+ * @default: false
+ */
+ insertColumns?: boolean;
+ /**
+ * Insert rows
+ * @default: false
+ */
+ insertRows?: boolean;
+ /**
+ * Insert hyperlinks
+ * @default: false
+ */
+ insertHyperlinks?: boolean;
+ /**
+ * Delete columns
+ * @default: false
+ */
+ deleteColumns?: boolean;
+ /**
+ * Delete rows
+ * @default: false
+ */
+ deleteRows?: boolean;
+ /**
+ * Sort
+ * @default: false
+ */
+ sort?: boolean;
+ /**
+ * Filter
+ * @default: false
+ */
+ autoFilter?: boolean;
+ /**
+ * Use PivotTable reports
+ * @default: false
+ */
+ pivotTables?: boolean;
+ /**
+ * Edit objects
+ * @default: true
+ */
+ objects?: boolean;
+ /**
+ * Edit scenarios
+ * @default: true
+ */
+ scenarios?: boolean;
+}
+
+/** Page Margins -- see Excel Page Setup .. Margins diagram for explanation */
+export interface MarginInfo {
+ /** Left side margin (inches) */
+ left?: number;
+ /** Right side margin (inches) */
+ right?: number;
+ /** Top side margin (inches) */
+ top?: number;
+ /** Bottom side margin (inches) */
+ bottom?: number;
+ /** Header top margin (inches) */
+ header?: number;
+ /** Footer bottom height (inches) */
+ footer?: number;
+}
+export type SheetType = 'sheet' | 'chart';
+export type SheetKeys = string | MarginInfo | SheetType;
+/** General object representing a Sheet (worksheet or chartsheet) */
+export interface Sheet {
+ /**
+ * Indexing with a cell address string maps to a cell object
+ * Special keys start with '!'
+ */
+ [cell: string]: CellObject | SheetKeys | any;
+
+ /** Sheet type */
+ '!type'?: SheetType;
+
+ /** Sheet Range */
+ '!ref'?: string;
+
+ /** Page Margins */
+ '!margins'?: MarginInfo;
+}
+
+/** AutoFilter properties */
+export interface AutoFilterInfo {
+ /** Range of the AutoFilter table */
+ ref: string;
+}
+
+export type WSKeys = SheetKeys | ColInfo[] | RowInfo[] | Range[] | ProtectInfo | AutoFilterInfo;
+
+/** Worksheet Object */
+export interface WorkSheet extends Sheet {
+ /**
+ * Indexing with a cell address string maps to a cell object
+ * Special keys start with '!'
+ */
+ [cell: string]: CellObject | WSKeys | any;
+
+ /** Column Info */
+ '!cols'?: ColInfo[];
+
+ /** Row Info */
+ '!rows'?: RowInfo[];
+
+ /** Merge Ranges */
+ '!merges'?: Range[];
+
+ /** Worksheet Protection info */
+ '!protect'?: ProtectInfo;
+
+ /** AutoFilter info */
+ '!autofilter'?: AutoFilterInfo;
+}
+
+/**
+ * Worksheet Object with CellObject type
+ *
+ * The normal Worksheet type uses indexer of type `any` -- this enforces CellObject
+ */
+export interface StrictWS { [addr: string]: CellObject; }
+
+/**
+ * The Excel data type for a cell.
+ * b Boolean, n Number, e error, s String, d Date, z Stub
+ */
+export type ExcelDataType = 'b' | 'n' | 'e' | 's' | 'd' | 'z';
+
+/**
+ * Type of generated workbook
+ * @default 'xlsx'
+ */
+export type BookType = 'xlsx' | 'xlsm' | 'xlsb' | 'xls' | 'xla' | 'biff8' | 'biff5' | 'biff2' | 'xlml' | 'ods' | 'fods' | 'csv' | 'txt' | 'sylk' | 'slk' | 'html' | 'dif' | 'rtf' | 'prn' | 'eth' | 'dbf';
+
+/** Comment element */
+export interface Comment {
+ /** Author of the comment block */
+ a?: string;
+
+ /** Plaintext of the comment */
+ t: string;
+
+ /** If true, mark the comment as a part of a thread */
+ T?: boolean;
+}
+
+/** Cell comments */
+export interface Comments extends Array {
+ /** Hide comment by default */
+ hidden?: boolean;
+}
+
+/** Link object */
+export interface Hyperlink {
+ /** Target of the link (HREF) */
+ Target: string;
+
+ /** Plaintext tooltip to display when mouse is over cell */
+ Tooltip?: string;
+}
+
+/** Worksheet Cell Object */
+export interface CellObject {
+ /** The raw value of the cell. Can be omitted if a formula is specified */
+ v?: string | number | boolean | Date;
+
+ /** Formatted text (if applicable) */
+ w?: string;
+
+ /**
+ * The Excel Data Type of the cell.
+ * b Boolean, n Number, e Error, s String, d Date, z Empty
+ */
+ t: ExcelDataType;
+
+ /** Cell formula (if applicable) */
+ f?: string;
+
+ /** Range of enclosing array if formula is array formula (if applicable) */
+ F?: string;
+
+ /** Rich text encoding (if applicable) */
+ r?: any;
+
+ /** HTML rendering of the rich text (if applicable) */
+ h?: string;
+
+ /** Comments associated with the cell */
+ c?: Comments;
+
+ /** Number format string associated with the cell (if requested) */
+ z?: NumberFormat;
+
+ /** Cell hyperlink object (.Target holds link, .tooltip is tooltip) */
+ l?: Hyperlink;
+
+ /** The style/theme of the cell (if applicable) */
+ s?: any;
+}
+
+/** Simple Cell Address */
+export interface CellAddress {
+ /** Column number */
+ c: number;
+ /** Row number */
+ r: number;
+}
+
+/** Range object (representing ranges like "A1:B2") */
+export interface Range {
+ /** Starting cell */
+ s: CellAddress;
+ /** Ending cell */
+ e: CellAddress;
+}
+
+export interface Sheet2CSVOpts extends DateNFOption {
+ /** Field Separator ("delimiter") */
+ FS?: string;
+
+ /** Record Separator ("row separator") */
+ RS?: string;
+
+ /** Remove trailing field separators in each record */
+ strip?: boolean;
+
+ /** Include blank lines in the CSV output */
+ blankrows?: boolean;
+
+ /** Skip hidden rows and columns in the CSV output */
+ skipHidden?: boolean;
+
+ /** Force quotes around fields */
+ forceQuotes?: boolean;
+
+ /** if true, return raw numbers; if false, return formatted numbers */
+ rawNumbers?: boolean;
+}
+
+export interface OriginOption {
+ /** Top-Left cell for operation (CellAddress or A1 string or row) */
+ origin?: number | string | CellAddress;
+}
+
+export interface Sheet2HTMLOpts {
+ /** TABLE element id attribute */
+ id?: string;
+
+ /** Add contenteditable to every cell */
+ editable?: boolean;
+
+ /** Header HTML */
+ header?: string;
+
+ /** Footer HTML */
+ footer?: string;
+}
+
+export interface Sheet2JSONOpts extends DateNFOption {
+ /** Output format */
+ header?: "A"|number|string[];
+
+ /** Override worksheet range */
+ range?: any;
+
+ /** Include or omit blank lines in the output */
+ blankrows?: boolean;
+
+ /** Default value for null/undefined values */
+ defval?: any;
+
+ /** if true, return raw data; if false, return formatted text */
+ raw?: boolean;
+
+ /** if true, skip hidden rows and columns */
+ skipHidden?: boolean;
+
+ /** if true, return raw numbers; if false, return formatted numbers */
+ rawNumbers?: boolean;
+}
+
+export interface AOA2SheetOpts extends CommonOptions, DateNFOption {
+ /**
+ * Create cell objects for stub cells
+ * @default false
+ */
+ sheetStubs?: boolean;
+}
+
+export interface SheetAOAOpts extends AOA2SheetOpts, OriginOption {}
+
+export interface JSON2SheetOpts extends CommonOptions, DateNFOption {
+ /** Use specified column order */
+ header?: string[];
+
+ /** Skip header row in generated sheet */
+ skipHeader?: boolean;
+}
+
+export interface SheetJSONOpts extends JSON2SheetOpts, OriginOption {}
+
+export interface Table2SheetOpts extends CommonOptions, DateNFOption, OriginOption, SheetOption {
+ /** If true, plaintext parsing will not parse values */
+ raw?: boolean;
+
+ /**
+ * If >0, read the first sheetRows rows
+ * @default 0
+ */
+ sheetRows?: number;
+
+ /** If true, hidden rows and cells will not be parsed */
+ display?: boolean;
+}
+
+/** General utilities */
+export interface XLSX$Utils {
+ /* --- Import Functions --- */
+
+ /** Converts an array of arrays of JS data to a worksheet. */
+ aoa_to_sheet(data: T[][], opts?: AOA2SheetOpts): WorkSheet;
+ aoa_to_sheet(data: any[][], opts?: AOA2SheetOpts): WorkSheet;
+
+ /** Converts an array of JS objects to a worksheet. */
+ json_to_sheet(data: T[], opts?: JSON2SheetOpts): WorkSheet;
+ json_to_sheet(data: any[], opts?: JSON2SheetOpts): WorkSheet;
+
+ /** BROWSER ONLY! Converts a TABLE DOM element to a worksheet. */
+ table_to_sheet(data: any, opts?: Table2SheetOpts): WorkSheet;
+ table_to_book(data: any, opts?: Table2SheetOpts): WorkBook;
+ sheet_add_dom(ws: WorkSheet, data: any, opts?: Table2SheetOpts): WorkSheet;
+
+ /* --- Export Functions --- */
+
+ /** Converts a worksheet object to an array of JSON objects */
+ sheet_to_json(worksheet: WorkSheet, opts?: Sheet2JSONOpts): T[];
+ sheet_to_json(worksheet: WorkSheet, opts?: Sheet2JSONOpts): any[][];
+ sheet_to_json(worksheet: WorkSheet, opts?: Sheet2JSONOpts): any[];
+
+ /** Generates delimiter-separated-values output */
+ sheet_to_csv(worksheet: WorkSheet, options?: Sheet2CSVOpts): string;
+
+ /** Generates UTF16 Formatted Text */
+ sheet_to_txt(worksheet: WorkSheet, options?: Sheet2CSVOpts): string;
+
+ /** Generates HTML */
+ sheet_to_html(worksheet: WorkSheet, options?: Sheet2HTMLOpts): string;
+
+ /** Generates a list of the formulae (with value fallbacks) */
+ sheet_to_formulae(worksheet: WorkSheet): string[];
+
+ /** Generates DIF */
+ sheet_to_dif(worksheet: WorkSheet, options?: Sheet2HTMLOpts): string;
+
+ /** Generates SYLK (Symbolic Link) */
+ sheet_to_slk(worksheet: WorkSheet, options?: Sheet2HTMLOpts): string;
+
+ /** Generates ETH */
+ sheet_to_eth(worksheet: WorkSheet, options?: Sheet2HTMLOpts): string;
+
+ /* --- Cell Address Utilities --- */
+
+ /** Converts 0-indexed cell address to A1 form */
+ encode_cell(cell: CellAddress): string;
+
+ /** Converts 0-indexed row to A1 form */
+ encode_row(row: number): string;
+
+ /** Converts 0-indexed column to A1 form */
+ encode_col(col: number): string;
+
+ /** Converts 0-indexed range to A1 form */
+ encode_range(s: CellAddress, e: CellAddress): string;
+ encode_range(r: Range): string;
+
+ /** Converts A1 cell address to 0-indexed form */
+ decode_cell(address: string): CellAddress;
+
+ /** Converts A1 row to 0-indexed form */
+ decode_row(row: string): number;
+
+ /** Converts A1 column to 0-indexed form */
+ decode_col(col: string): number;
+
+ /** Converts A1 range to 0-indexed form */
+ decode_range(range: string): Range;
+
+ /** Format cell */
+ format_cell(cell: CellObject, v?: any, opts?: any): string;
+
+ /* --- General Utilities --- */
+
+ /** Creates a new workbook */
+ book_new(): WorkBook;
+
+ /** Append a worksheet to a workbook */
+ book_append_sheet(workbook: WorkBook, worksheet: WorkSheet, name?: string, roll?: boolean): void;
+
+ /** Set sheet visibility (visible/hidden/very hidden) */
+ book_set_sheet_visibility(workbook: WorkBook, sheet: number|string, visibility: number): void;
+
+ /** Set number format for a cell */
+ cell_set_number_format(cell: CellObject, fmt: string|number): CellObject;
+
+ /** Set hyperlink for a cell */
+ cell_set_hyperlink(cell: CellObject, target: string, tooltip?: string): CellObject;
+
+ /** Set internal link for a cell */
+ cell_set_internal_link(cell: CellObject, target: string, tooltip?: string): CellObject;
+
+ /** Add comment to a cell */
+ cell_add_comment(cell: CellObject, text: string, author?: string): void;
+
+ /** Assign an Array Formula to a range */
+ sheet_set_array_formula(ws: WorkSheet, range: Range|string, formula: string, dynamic?: boolean): WorkSheet;
+
+ /** Add an array of arrays of JS data to a worksheet */
+ sheet_add_aoa(ws: WorkSheet, data: T[][], opts?: SheetAOAOpts): WorkSheet;
+ sheet_add_aoa(ws: WorkSheet, data: any[][], opts?: SheetAOAOpts): WorkSheet;
+
+ /** Add an array of JS objects to a worksheet */
+ sheet_add_json(ws: WorkSheet, data: any[], opts?: SheetJSONOpts): WorkSheet;
+ sheet_add_json(ws: WorkSheet, data: T[], opts?: SheetJSONOpts): WorkSheet;
+
+
+ consts: XLSX$Consts;
+}
+
+export interface XLSX$Consts {
+ /* --- Sheet Visibility --- */
+
+ /** Visibility: Visible */
+ SHEET_VISIBLE: 0;
+
+ /** Visibility: Hidden */
+ SHEET_HIDDEN: 1;
+
+ /** Visibility: Very Hidden */
+ SHEET_VERYHIDDEN: 2;
+}
+
+/** NODE ONLY! these return Readable Streams */
+export interface StreamUtils {
+ /** CSV output stream, generate one line at a time */
+ to_csv(sheet: WorkSheet, opts?: Sheet2CSVOpts): any;
+ /** HTML output stream, generate one line at a time */
+ to_html(sheet: WorkSheet, opts?: Sheet2HTMLOpts): any;
+ /** JSON object stream, generate one row at a time */
+ to_json(sheet: WorkSheet, opts?: Sheet2JSONOpts): any;
+ /** Set `Readable` (internal) */
+ set_readable(Readable: any): void;
+}
diff --git a/miniapp/miniprogram_npm/xlsx/types/tsconfig.json b/miniapp/miniprogram_npm/xlsx/types/tsconfig.json
new file mode 100644
index 0000000..63534df
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/types/tsconfig.json
@@ -0,0 +1,15 @@
+{
+ "compilerOptions": {
+ "module": "commonjs",
+ "lib": [ "es5" ],
+ "noImplicitAny": true,
+ "noImplicitThis": true,
+ "strictNullChecks": false,
+ "baseUrl": ".",
+ "paths": { "xlsx": ["."] },
+ "types": [],
+ "noEmit": true,
+ "strictFunctionTypes": true,
+ "forceConsistentCasingInFileNames": true
+ }
+}
diff --git a/miniapp/miniprogram_npm/xlsx/xlsx.js b/miniapp/miniprogram_npm/xlsx/xlsx.js
new file mode 100644
index 0000000..e61c7cc
--- /dev/null
+++ b/miniapp/miniprogram_npm/xlsx/xlsx.js
@@ -0,0 +1,24486 @@
+/*! xlsx.js (C) 2013-present SheetJS -- http://sheetjs.com */
+/* vim: set ts=2: */
+/*exported XLSX */
+/*global exports, module, require:false, process:false, Buffer:false, ArrayBuffer:false, DataView:false, Deno:false */
+var XLSX = {};
+function make_xlsx_lib(XLSX){
+XLSX.version = '0.18.5';
+var current_codepage = 1200, current_ansi = 1252;
+/*global cptable:true, window */
+var $cptable;
+if(typeof cptable !== 'undefined') $cptable = cptable;
+else if(typeof module !== "undefined" && typeof require !== 'undefined') {
+ $cptable = require('./dist/cpexcel.js');
+}
+
+var VALID_ANSI = [ 874, 932, 936, 949, 950, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 10000 ];
+/* ECMA-376 Part I 18.4.1 charset to codepage mapping */
+var CS2CP = ({
+0: 1252, /* ANSI */
+1: 65001, /* DEFAULT */
+2: 65001, /* SYMBOL */
+77: 10000, /* MAC */
+128: 932, /* SHIFTJIS */
+129: 949, /* HANGUL */
+130: 1361, /* JOHAB */
+134: 936, /* GB2312 */
+136: 950, /* CHINESEBIG5 */
+161: 1253, /* GREEK */
+162: 1254, /* TURKISH */
+163: 1258, /* VIETNAMESE */
+177: 1255, /* HEBREW */
+178: 1256, /* ARABIC */
+186: 1257, /* BALTIC */
+204: 1251, /* RUSSIAN */
+222: 874, /* THAI */
+238: 1250, /* EASTEUROPE */
+255: 1252, /* OEM */
+69: 6969 /* MISC */
+});
+
+var set_ansi = function(cp) { if(VALID_ANSI.indexOf(cp) == -1) return; current_ansi = CS2CP[0] = cp; };
+function reset_ansi() { set_ansi(1252); }
+
+var set_cp = function(cp) { current_codepage = cp; set_ansi(cp); };
+function reset_cp() { set_cp(1200); reset_ansi(); }
+
+function char_codes(data) { var o = []; for(var i = 0, len = data.length; i < len; ++i) o[i] = data.charCodeAt(i); return o; }
+
+function utf16leread(data) {
+ var o = [];
+ for(var i = 0; i < (data.length>>1); ++i) o[i] = String.fromCharCode(data.charCodeAt(2*i) + (data.charCodeAt(2*i+1)<<8));
+ return o.join("");
+}
+function utf16beread(data) {
+ var o = [];
+ for(var i = 0; i < (data.length>>1); ++i) o[i] = String.fromCharCode(data.charCodeAt(2*i+1) + (data.charCodeAt(2*i)<<8));
+ return o.join("");
+}
+
+var debom = function(data) {
+ var c1 = data.charCodeAt(0), c2 = data.charCodeAt(1);
+ if(c1 == 0xFF && c2 == 0xFE) return utf16leread(data.slice(2));
+ if(c1 == 0xFE && c2 == 0xFF) return utf16beread(data.slice(2));
+ if(c1 == 0xFEFF) return data.slice(1);
+ return data;
+};
+
+var _getchar = function _gc1(x) { return String.fromCharCode(x); };
+var _getansi = function _ga1(x) { return String.fromCharCode(x); };
+if(typeof $cptable !== 'undefined') {
+ set_cp = function(cp) { current_codepage = cp; set_ansi(cp); };
+ debom = function(data) {
+ if(data.charCodeAt(0) === 0xFF && data.charCodeAt(1) === 0xFE) { return $cptable.utils.decode(1200, char_codes(data.slice(2))); }
+ return data;
+ };
+ _getchar = function _gc2(x) {
+ if(current_codepage === 1200) return String.fromCharCode(x);
+ return $cptable.utils.decode(current_codepage, [x&255,x>>8])[0];
+ };
+ _getansi = function _ga2(x) {
+ return $cptable.utils.decode(current_ansi, [x])[0];
+ };
+}
+var DENSE = null;
+var DIF_XL = true;
+var Base64_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+function Base64_encode(input) {
+ var o = "";
+ var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+ for (var i = 0; i < input.length; ) {
+ c1 = input.charCodeAt(i++);
+ e1 = c1 >> 2;
+ c2 = input.charCodeAt(i++);
+ e2 = (c1 & 3) << 4 | c2 >> 4;
+ c3 = input.charCodeAt(i++);
+ e3 = (c2 & 15) << 2 | c3 >> 6;
+ e4 = c3 & 63;
+ if (isNaN(c2)) {
+ e3 = e4 = 64;
+ } else if (isNaN(c3)) {
+ e4 = 64;
+ }
+ o += Base64_map.charAt(e1) + Base64_map.charAt(e2) + Base64_map.charAt(e3) + Base64_map.charAt(e4);
+ }
+ return o;
+}
+function Base64_decode(input) {
+ var o = "";
+ var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+ input = input.replace(/[^\w\+\/\=]/g, "");
+ for (var i = 0; i < input.length; ) {
+ e1 = Base64_map.indexOf(input.charAt(i++));
+ e2 = Base64_map.indexOf(input.charAt(i++));
+ c1 = e1 << 2 | e2 >> 4;
+ o += String.fromCharCode(c1);
+ e3 = Base64_map.indexOf(input.charAt(i++));
+ c2 = (e2 & 15) << 4 | e3 >> 2;
+ if (e3 !== 64) {
+ o += String.fromCharCode(c2);
+ }
+ e4 = Base64_map.indexOf(input.charAt(i++));
+ c3 = (e3 & 3) << 6 | e4;
+ if (e4 !== 64) {
+ o += String.fromCharCode(c3);
+ }
+ }
+ return o;
+}
+var has_buf = (function() { return typeof Buffer !== 'undefined' && typeof process !== 'undefined' && typeof process.versions !== 'undefined' && !!process.versions.node; })();
+
+var Buffer_from = (function() {
+ if(typeof Buffer !== 'undefined') {
+ var nbfs = !Buffer.from;
+ if(!nbfs) try { Buffer.from("foo", "utf8"); } catch(e) { nbfs = true; }
+ return nbfs ? function(buf, enc) { return (enc) ? new Buffer(buf, enc) : new Buffer(buf); } : Buffer.from.bind(Buffer);
+ }
+ return function() {};
+})();
+
+
+function new_raw_buf(len) {
+ /* jshint -W056 */
+ if(has_buf) return Buffer.alloc ? Buffer.alloc(len) : new Buffer(len);
+ return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+ /* jshint +W056 */
+}
+
+function new_unsafe_buf(len) {
+ /* jshint -W056 */
+ if(has_buf) return Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : new Buffer(len);
+ return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+ /* jshint +W056 */
+}
+
+var s2a = function s2a(s) {
+ if(has_buf) return Buffer_from(s, "binary");
+ return s.split("").map(function(x){ return x.charCodeAt(0) & 0xff; });
+};
+
+function s2ab(s) {
+ if(typeof ArrayBuffer === 'undefined') return s2a(s);
+ var buf = new ArrayBuffer(s.length), view = new Uint8Array(buf);
+ for (var i=0; i!=s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
+ return buf;
+}
+
+function a2s(data) {
+ if(Array.isArray(data)) return data.map(function(c) { return String.fromCharCode(c); }).join("");
+ var o = []; for(var i = 0; i < data.length; ++i) o[i] = String.fromCharCode(data[i]); return o.join("");
+}
+
+function a2u(data) {
+ if(typeof Uint8Array === 'undefined') throw new Error("Unsupported");
+ return new Uint8Array(data);
+}
+
+function ab2a(data) {
+ if(typeof ArrayBuffer == 'undefined') throw new Error("Unsupported");
+ if(data instanceof ArrayBuffer) return ab2a(new Uint8Array(data));
+var o = new Array(data.length);
+ for(var i = 0; i < data.length; ++i) o[i] = data[i];
+ return o;
+}
+
+var bconcat = has_buf ? function(bufs) { return Buffer.concat(bufs.map(function(buf) { return Buffer.isBuffer(buf) ? buf : Buffer_from(buf); })); } : function(bufs) {
+ if(typeof Uint8Array !== "undefined") {
+ var i = 0, maxlen = 0;
+ for(i = 0; i < bufs.length; ++i) maxlen += bufs[i].length;
+ var o = new Uint8Array(maxlen);
+ var len = 0;
+ for(i = 0, maxlen = 0; i < bufs.length; maxlen += len, ++i) {
+ len = bufs[i].length;
+ if(bufs[i] instanceof Uint8Array) o.set(bufs[i], maxlen);
+ else if(typeof bufs[i] == "string") { throw "wtf"; }
+ else o.set(new Uint8Array(bufs[i]), maxlen);
+ }
+ return o;
+ }
+ return [].concat.apply([], bufs.map(function(buf) { return Array.isArray(buf) ? buf : [].slice.call(buf); }));
+};
+
+function utf8decode(content) {
+ var out = [], widx = 0, L = content.length + 250;
+ var o = new_raw_buf(content.length + 255);
+ for(var ridx = 0; ridx < content.length; ++ridx) {
+ var c = content.charCodeAt(ridx);
+ if(c < 0x80) o[widx++] = c;
+ else if(c < 0x800) {
+ o[widx++] = (192|((c>>6)&31));
+ o[widx++] = (128|(c&63));
+ } else if(c >= 0xD800 && c < 0xE000) {
+ c = (c&1023)+64;
+ var d = content.charCodeAt(++ridx)&1023;
+ o[widx++] = (240|((c>>8)&7));
+ o[widx++] = (128|((c>>2)&63));
+ o[widx++] = (128|((d>>6)&15)|((c&3)<<4));
+ o[widx++] = (128|(d&63));
+ } else {
+ o[widx++] = (224|((c>>12)&15));
+ o[widx++] = (128|((c>>6)&63));
+ o[widx++] = (128|(c&63));
+ }
+ if(widx > L) {
+ out.push(o.slice(0, widx));
+ widx = 0;
+ o = new_raw_buf(65535);
+ L = 65530;
+ }
+ }
+ out.push(o.slice(0, widx));
+ return bconcat(out);
+}
+
+var chr0 = /\u0000/g, chr1 = /[\u0001-\u0006]/g;
+/* ssf.js (C) 2013-present SheetJS -- http://sheetjs.com */
+/*jshint -W041 */
+function _strrev(x) { var o = "", i = x.length-1; while(i>=0) o += x.charAt(i--); return o; }
+function pad0(v,d){var t=""+v; return t.length>=d?t:fill('0',d-t.length)+t;}
+function pad_(v,d){var t=""+v;return t.length>=d?t:fill(' ',d-t.length)+t;}
+function rpad_(v,d){var t=""+v; return t.length>=d?t:t+fill(' ',d-t.length);}
+function pad0r1(v,d){var t=""+Math.round(v); return t.length>=d?t:fill('0',d-t.length)+t;}
+function pad0r2(v,d){var t=""+v; return t.length>=d?t:fill('0',d-t.length)+t;}
+var p2_32 = Math.pow(2,32);
+function pad0r(v,d){if(v>p2_32||v<-p2_32) return pad0r1(v,d); var i = Math.round(v); return pad0r2(i,d); }
+/* yes, in 2022 this is still faster than string compare */
+function SSF_isgeneral(s, i) { i = i || 0; return s.length >= 7 + i && (s.charCodeAt(i)|32) === 103 && (s.charCodeAt(i+1)|32) === 101 && (s.charCodeAt(i+2)|32) === 110 && (s.charCodeAt(i+3)|32) === 101 && (s.charCodeAt(i+4)|32) === 114 && (s.charCodeAt(i+5)|32) === 97 && (s.charCodeAt(i+6)|32) === 108; }
+var days = [
+ ['Sun', 'Sunday'],
+ ['Mon', 'Monday'],
+ ['Tue', 'Tuesday'],
+ ['Wed', 'Wednesday'],
+ ['Thu', 'Thursday'],
+ ['Fri', 'Friday'],
+ ['Sat', 'Saturday']
+];
+var months = [
+ ['J', 'Jan', 'January'],
+ ['F', 'Feb', 'February'],
+ ['M', 'Mar', 'March'],
+ ['A', 'Apr', 'April'],
+ ['M', 'May', 'May'],
+ ['J', 'Jun', 'June'],
+ ['J', 'Jul', 'July'],
+ ['A', 'Aug', 'August'],
+ ['S', 'Sep', 'September'],
+ ['O', 'Oct', 'October'],
+ ['N', 'Nov', 'November'],
+ ['D', 'Dec', 'December']
+];
+function SSF_init_table(t) {
+ if(!t) t = {};
+ t[0]= 'General';
+ t[1]= '0';
+ t[2]= '0.00';
+ t[3]= '#,##0';
+ t[4]= '#,##0.00';
+ t[9]= '0%';
+ t[10]= '0.00%';
+ t[11]= '0.00E+00';
+ t[12]= '# ?/?';
+ t[13]= '# ??/??';
+ t[14]= 'm/d/yy';
+ t[15]= 'd-mmm-yy';
+ t[16]= 'd-mmm';
+ t[17]= 'mmm-yy';
+ t[18]= 'h:mm AM/PM';
+ t[19]= 'h:mm:ss AM/PM';
+ t[20]= 'h:mm';
+ t[21]= 'h:mm:ss';
+ t[22]= 'm/d/yy h:mm';
+ t[37]= '#,##0 ;(#,##0)';
+ t[38]= '#,##0 ;[Red](#,##0)';
+ t[39]= '#,##0.00;(#,##0.00)';
+ t[40]= '#,##0.00;[Red](#,##0.00)';
+ t[45]= 'mm:ss';
+ t[46]= '[h]:mm:ss';
+ t[47]= 'mmss.0';
+ t[48]= '##0.0E+0';
+ t[49]= '@';
+ t[56]= '"上午/下午 "hh"時"mm"分"ss"秒 "';
+ return t;
+}
+/* repeated to satiate webpack */
+var table_fmt = {
+ 0: 'General',
+ 1: '0',
+ 2: '0.00',
+ 3: '#,##0',
+ 4: '#,##0.00',
+ 9: '0%',
+ 10: '0.00%',
+ 11: '0.00E+00',
+ 12: '# ?/?',
+ 13: '# ??/??',
+ 14: 'm/d/yy',
+ 15: 'd-mmm-yy',
+ 16: 'd-mmm',
+ 17: 'mmm-yy',
+ 18: 'h:mm AM/PM',
+ 19: 'h:mm:ss AM/PM',
+ 20: 'h:mm',
+ 21: 'h:mm:ss',
+ 22: 'm/d/yy h:mm',
+ 37: '#,##0 ;(#,##0)',
+ 38: '#,##0 ;[Red](#,##0)',
+ 39: '#,##0.00;(#,##0.00)',
+ 40: '#,##0.00;[Red](#,##0.00)',
+ 45: 'mm:ss',
+ 46: '[h]:mm:ss',
+ 47: 'mmss.0',
+ 48: '##0.0E+0',
+ 49: '@',
+ 56: '"上午/下午 "hh"時"mm"分"ss"秒 "'
+};
+
+/* Defaults determined by systematically testing in Excel 2019 */
+
+/* These formats appear to default to other formats in the table */
+var SSF_default_map = {
+ 5: 37, 6: 38, 7: 39, 8: 40, // 5 -> 37 ... 8 -> 40
+
+ 23: 0, 24: 0, 25: 0, 26: 0, // 23 -> 0 ... 26 -> 0
+
+ 27: 14, 28: 14, 29: 14, 30: 14, 31: 14, // 27 -> 14 ... 31 -> 14
+
+ 50: 14, 51: 14, 52: 14, 53: 14, 54: 14, // 50 -> 14 ... 58 -> 14
+ 55: 14, 56: 14, 57: 14, 58: 14,
+ 59: 1, 60: 2, 61: 3, 62: 4, // 59 -> 1 ... 62 -> 4
+
+ 67: 9, 68: 10, // 67 -> 9 ... 68 -> 10
+ 69: 12, 70: 13, 71: 14, // 69 -> 12 ... 71 -> 14
+ 72: 14, 73: 15, 74: 16, 75: 17, // 72 -> 14 ... 75 -> 17
+ 76: 20, 77: 21, 78: 22, // 76 -> 20 ... 78 -> 22
+ 79: 45, 80: 46, 81: 47, // 79 -> 45 ... 81 -> 47
+ 82: 0 // 82 -> 0 ... 65536 -> 0 (omitted)
+};
+
+
+/* These formats technically refer to Accounting formats with no equivalent */
+var SSF_default_str = {
+ // 5 -- Currency, 0 decimal, black negative
+ 5: '"$"#,##0_);\\("$"#,##0\\)',
+ 63: '"$"#,##0_);\\("$"#,##0\\)',
+
+ // 6 -- Currency, 0 decimal, red negative
+ 6: '"$"#,##0_);[Red]\\("$"#,##0\\)',
+ 64: '"$"#,##0_);[Red]\\("$"#,##0\\)',
+
+ // 7 -- Currency, 2 decimal, black negative
+ 7: '"$"#,##0.00_);\\("$"#,##0.00\\)',
+ 65: '"$"#,##0.00_);\\("$"#,##0.00\\)',
+
+ // 8 -- Currency, 2 decimal, red negative
+ 8: '"$"#,##0.00_);[Red]\\("$"#,##0.00\\)',
+ 66: '"$"#,##0.00_);[Red]\\("$"#,##0.00\\)',
+
+ // 41 -- Accounting, 0 decimal, No Symbol
+ 41: '_(* #,##0_);_(* \\(#,##0\\);_(* "-"_);_(@_)',
+
+ // 42 -- Accounting, 0 decimal, $ Symbol
+ 42: '_("$"* #,##0_);_("$"* \\(#,##0\\);_("$"* "-"_);_(@_)',
+
+ // 43 -- Accounting, 2 decimal, No Symbol
+ 43: '_(* #,##0.00_);_(* \\(#,##0.00\\);_(* "-"??_);_(@_)',
+
+ // 44 -- Accounting, 2 decimal, $ Symbol
+ 44: '_("$"* #,##0.00_);_("$"* \\(#,##0.00\\);_("$"* "-"??_);_(@_)'
+};
+
+function SSF_frac(x, D, mixed) {
+ var sgn = x < 0 ? -1 : 1;
+ var B = x * sgn;
+ var P_2 = 0, P_1 = 1, P = 0;
+ var Q_2 = 1, Q_1 = 0, Q = 0;
+ var A = Math.floor(B);
+ while(Q_1 < D) {
+ A = Math.floor(B);
+ P = A * P_1 + P_2;
+ Q = A * Q_1 + Q_2;
+ if((B - A) < 0.00000005) break;
+ B = 1 / (B - A);
+ P_2 = P_1; P_1 = P;
+ Q_2 = Q_1; Q_1 = Q;
+ }
+ if(Q > D) { if(Q_1 > D) { Q = Q_2; P = P_2; } else { Q = Q_1; P = P_1; } }
+ if(!mixed) return [0, sgn * P, Q];
+ var q = Math.floor(sgn * P/Q);
+ return [q, sgn*P - q*Q, Q];
+}
+function SSF_parse_date_code(v,opts,b2) {
+ if(v > 2958465 || v < 0) return null;
+ var date = (v|0), time = Math.floor(86400 * (v - date)), dow=0;
+ var dout=[];
+ var out={D:date, T:time, u:86400*(v-date)-time,y:0,m:0,d:0,H:0,M:0,S:0,q:0};
+ if(Math.abs(out.u) < 1e-6) out.u = 0;
+ if(opts && opts.date1904) date += 1462;
+ if(out.u > 0.9999) {
+ out.u = 0;
+ if(++time == 86400) { out.T = time = 0; ++date; ++out.D; }
+ }
+ if(date === 60) {dout = b2 ? [1317,10,29] : [1900,2,29]; dow=3;}
+ else if(date === 0) {dout = b2 ? [1317,8,29] : [1900,1,0]; dow=6;}
+ else {
+ if(date > 60) --date;
+ /* 1 = Jan 1 1900 in Gregorian */
+ var d = new Date(1900, 0, 1);
+ d.setDate(d.getDate() + date - 1);
+ dout = [d.getFullYear(), d.getMonth()+1,d.getDate()];
+ dow = d.getDay();
+ if(date < 60) dow = (dow + 6) % 7;
+ if(b2) dow = SSF_fix_hijri(d, dout);
+ }
+ out.y = dout[0]; out.m = dout[1]; out.d = dout[2];
+ out.S = time % 60; time = Math.floor(time / 60);
+ out.M = time % 60; time = Math.floor(time / 60);
+ out.H = time;
+ out.q = dow;
+ return out;
+}
+var SSFbasedate = new Date(1899, 11, 31, 0, 0, 0);
+var SSFdnthresh = SSFbasedate.getTime();
+var SSFbase1904 = new Date(1900, 2, 1, 0, 0, 0);
+function datenum_local(v, date1904) {
+ var epoch = v.getTime();
+ if(date1904) epoch -= 1461*24*60*60*1000;
+ else if(v >= SSFbase1904) epoch += 24*60*60*1000;
+ return (epoch - (SSFdnthresh + (v.getTimezoneOffset() - SSFbasedate.getTimezoneOffset()) * 60000)) / (24 * 60 * 60 * 1000);
+}
+/* ECMA-376 18.8.30 numFmt*/
+/* Note: `toPrecision` uses standard form when prec > E and E >= -6 */
+/* exponent >= -9 and <= 9 */
+function SSF_strip_decimal(o) {
+ return (o.indexOf(".") == -1) ? o : o.replace(/(?:\.0*|(\.\d*[1-9])0+)$/, "$1");
+}
+
+/* General Exponential always shows 2 digits exp and trims the mantissa */
+function SSF_normalize_exp(o) {
+ if(o.indexOf("E") == -1) return o;
+ return o.replace(/(?:\.0*|(\.\d*[1-9])0+)[Ee]/,"$1E").replace(/(E[+-])(\d)$/,"$10$2");
+}
+
+/* exponent >= -9 and <= 9 */
+function SSF_small_exp(v) {
+ var w = (v<0?12:11);
+ var o = SSF_strip_decimal(v.toFixed(12)); if(o.length <= w) return o;
+ o = v.toPrecision(10); if(o.length <= w) return o;
+ return v.toExponential(5);
+}
+
+/* exponent >= 11 or <= -10 likely exponential */
+function SSF_large_exp(v) {
+ var o = SSF_strip_decimal(v.toFixed(11));
+ return (o.length > (v<0?12:11) || o === "0" || o === "-0") ? v.toPrecision(6) : o;
+}
+
+function SSF_general_num(v) {
+ var V = Math.floor(Math.log(Math.abs(v))*Math.LOG10E), o;
+
+ if(V >= -4 && V <= -1) o = v.toPrecision(10+V);
+ else if(Math.abs(V) <= 9) o = SSF_small_exp(v);
+ else if(V === 10) o = v.toFixed(10).substr(0,12);
+ else o = SSF_large_exp(v);
+
+ return SSF_strip_decimal(SSF_normalize_exp(o.toUpperCase()));
+}
+
+
+/*
+ "General" rules:
+ - text is passed through ("@")
+ - booleans are rendered as TRUE/FALSE
+ - "up to 11 characters" displayed for numbers
+ - Default date format (code 14) used for Dates
+
+ The longest 32-bit integer text is "-2147483648", exactly 11 chars
+ TODO: technically the display depends on the width of the cell
+*/
+function SSF_general(v, opts) {
+ switch(typeof v) {
+ case 'string': return v;
+ case 'boolean': return v ? "TRUE" : "FALSE";
+ case 'number': return (v|0) === v ? v.toString(10) : SSF_general_num(v);
+ case 'undefined': return "";
+ case 'object':
+ if(v == null) return "";
+ if(v instanceof Date) return SSF_format(14, datenum_local(v, opts && opts.date1904), opts);
+ }
+ throw new Error("unsupported value in General format: " + v);
+}
+
+function SSF_fix_hijri(date, o) {
+ /* TODO: properly adjust y/m/d and */
+ o[0] -= 581;
+ var dow = date.getDay();
+ if(date < 60) dow = (dow + 6) % 7;
+ return dow;
+}
+//var THAI_DIGITS = "\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59".split("");
+function SSF_write_date(type, fmt, val, ss0) {
+ var o="", ss=0, tt=0, y = val.y, out, outl = 0;
+ switch(type) {
+ case 98: /* 'b' buddhist year */
+ y = val.y + 543;
+ /* falls through */
+ case 121: /* 'y' year */
+ switch(fmt.length) {
+ case 1: case 2: out = y % 100; outl = 2; break;
+ default: out = y % 10000; outl = 4; break;
+ } break;
+ case 109: /* 'm' month */
+ switch(fmt.length) {
+ case 1: case 2: out = val.m; outl = fmt.length; break;
+ case 3: return months[val.m-1][1];
+ case 5: return months[val.m-1][0];
+ default: return months[val.m-1][2];
+ } break;
+ case 100: /* 'd' day */
+ switch(fmt.length) {
+ case 1: case 2: out = val.d; outl = fmt.length; break;
+ case 3: return days[val.q][0];
+ default: return days[val.q][1];
+ } break;
+ case 104: /* 'h' 12-hour */
+ switch(fmt.length) {
+ case 1: case 2: out = 1+(val.H+11)%12; outl = fmt.length; break;
+ default: throw 'bad hour format: ' + fmt;
+ } break;
+ case 72: /* 'H' 24-hour */
+ switch(fmt.length) {
+ case 1: case 2: out = val.H; outl = fmt.length; break;
+ default: throw 'bad hour format: ' + fmt;
+ } break;
+ case 77: /* 'M' minutes */
+ switch(fmt.length) {
+ case 1: case 2: out = val.M; outl = fmt.length; break;
+ default: throw 'bad minute format: ' + fmt;
+ } break;
+ case 115: /* 's' seconds */
+ if(fmt != 's' && fmt != 'ss' && fmt != '.0' && fmt != '.00' && fmt != '.000') throw 'bad second format: ' + fmt;
+ if(val.u === 0 && (fmt == "s" || fmt == "ss")) return pad0(val.S, fmt.length);
+if(ss0 >= 2) tt = ss0 === 3 ? 1000 : 100;
+ else tt = ss0 === 1 ? 10 : 1;
+ ss = Math.round((tt)*(val.S + val.u));
+ if(ss >= 60*tt) ss = 0;
+ if(fmt === 's') return ss === 0 ? "0" : ""+ss/tt;
+ o = pad0(ss,2 + ss0);
+ if(fmt === 'ss') return o.substr(0,2);
+ return "." + o.substr(2,fmt.length-1);
+ case 90: /* 'Z' absolute time */
+ switch(fmt) {
+ case '[h]': case '[hh]': out = val.D*24+val.H; break;
+ case '[m]': case '[mm]': out = (val.D*24+val.H)*60+val.M; break;
+ case '[s]': case '[ss]': out = ((val.D*24+val.H)*60+val.M)*60+Math.round(val.S+val.u); break;
+ default: throw 'bad abstime format: ' + fmt;
+ } outl = fmt.length === 3 ? 1 : 2; break;
+ case 101: /* 'e' era */
+ out = y; outl = 1; break;
+ }
+ var outstr = outl > 0 ? pad0(out, outl) : "";
+ return outstr;
+}
+
+
+/*jshint -W086 */
+/*jshint +W086 */
+function commaify(s) {
+ var w = 3;
+ if(s.length <= w) return s;
+ var j = (s.length % w), o = s.substr(0,j);
+ for(; j!=s.length; j+=w) o+=(o.length > 0 ? "," : "") + s.substr(j,w);
+ return o;
+}
+var pct1 = /%/g;
+function write_num_pct(type, fmt, val){
+ var sfmt = fmt.replace(pct1,""), mul = fmt.length - sfmt.length;
+ return write_num(type, sfmt, val * Math.pow(10,2*mul)) + fill("%",mul);
+}
+
+function write_num_cm(type, fmt, val){
+ var idx = fmt.length - 1;
+ while(fmt.charCodeAt(idx-1) === 44) --idx;
+ return write_num(type, fmt.substr(0,idx), val / Math.pow(10,3*(fmt.length-idx)));
+}
+
+function write_num_exp(fmt, val){
+ var o;
+ var idx = fmt.indexOf("E") - fmt.indexOf(".") - 1;
+ if(fmt.match(/^#+0.0E\+0$/)) {
+ if(val == 0) return "0.0E+0";
+ else if(val < 0) return "-" + write_num_exp(fmt, -val);
+ var period = fmt.indexOf("."); if(period === -1) period=fmt.indexOf('E');
+ var ee = Math.floor(Math.log(val)*Math.LOG10E)%period;
+ if(ee < 0) ee += period;
+ o = (val/Math.pow(10,ee)).toPrecision(idx+1+(period+ee)%period);
+ if(o.indexOf("e") === -1) {
+ var fakee = Math.floor(Math.log(val)*Math.LOG10E);
+ if(o.indexOf(".") === -1) o = o.charAt(0) + "." + o.substr(1) + "E+" + (fakee - o.length+ee);
+ else o += "E+" + (fakee - ee);
+ while(o.substr(0,2) === "0.") {
+ o = o.charAt(0) + o.substr(2,period) + "." + o.substr(2+period);
+ o = o.replace(/^0+([1-9])/,"$1").replace(/^0+\./,"0.");
+ }
+ o = o.replace(/\+-/,"-");
+ }
+ o = o.replace(/^([+-]?)(\d*)\.(\d*)[Ee]/,function($$,$1,$2,$3) { return $1 + $2 + $3.substr(0,(period+ee)%period) + "." + $3.substr(ee) + "E"; });
+ } else o = val.toExponential(idx);
+ if(fmt.match(/E\+00$/) && o.match(/e[+-]\d$/)) o = o.substr(0,o.length-1) + "0" + o.charAt(o.length-1);
+ if(fmt.match(/E\-/) && o.match(/e\+/)) o = o.replace(/e\+/,"e");
+ return o.replace("e","E");
+}
+var frac1 = /# (\?+)( ?)\/( ?)(\d+)/;
+function write_num_f1(r, aval, sign) {
+ var den = parseInt(r[4],10), rr = Math.round(aval * den), base = Math.floor(rr/den);
+ var myn = (rr - base*den), myd = den;
+ return sign + (base === 0 ? "" : ""+base) + " " + (myn === 0 ? fill(" ", r[1].length + 1 + r[4].length) : pad_(myn,r[1].length) + r[2] + "/" + r[3] + pad0(myd,r[4].length));
+}
+function write_num_f2(r, aval, sign) {
+ return sign + (aval === 0 ? "" : ""+aval) + fill(" ", r[1].length + 2 + r[4].length);
+}
+var dec1 = /^#*0*\.([0#]+)/;
+var closeparen = /\).*[0#]/;
+var phone = /\(###\) ###\\?-####/;
+function hashq(str) {
+ var o = "", cc;
+ for(var i = 0; i != str.length; ++i) switch((cc=str.charCodeAt(i))) {
+ case 35: break;
+ case 63: o+= " "; break;
+ case 48: o+= "0"; break;
+ default: o+= String.fromCharCode(cc);
+ }
+ return o;
+}
+function rnd(val, d) { var dd = Math.pow(10,d); return ""+(Math.round(val * dd)/dd); }
+function dec(val, d) {
+ var _frac = val - Math.floor(val), dd = Math.pow(10,d);
+ if (d < ('' + Math.round(_frac * dd)).length) return 0;
+ return Math.round(_frac * dd);
+}
+function carry(val, d) {
+ if (d < ('' + Math.round((val-Math.floor(val))*Math.pow(10,d))).length) {
+ return 1;
+ }
+ return 0;
+}
+function flr(val) {
+ if(val < 2147483647 && val > -2147483648) return ""+(val >= 0 ? (val|0) : (val-1|0));
+ return ""+Math.floor(val);
+}
+function write_num_flt(type, fmt, val) {
+ if(type.charCodeAt(0) === 40 && !fmt.match(closeparen)) {
+ var ffmt = fmt.replace(/\( */,"").replace(/ \)/,"").replace(/\)/,"");
+ if(val >= 0) return write_num_flt('n', ffmt, val);
+ return '(' + write_num_flt('n', ffmt, -val) + ')';
+ }
+ if(fmt.charCodeAt(fmt.length - 1) === 44) return write_num_cm(type, fmt, val);
+ if(fmt.indexOf('%') !== -1) return write_num_pct(type, fmt, val);
+ if(fmt.indexOf('E') !== -1) return write_num_exp(fmt, val);
+ if(fmt.charCodeAt(0) === 36) return "$"+write_num_flt(type,fmt.substr(fmt.charAt(1)==' '?2:1),val);
+ var o;
+ var r, ri, ff, aval = Math.abs(val), sign = val < 0 ? "-" : "";
+ if(fmt.match(/^00+$/)) return sign + pad0r(aval,fmt.length);
+ if(fmt.match(/^[#?]+$/)) {
+ o = pad0r(val,0); if(o === "0") o = "";
+ return o.length > fmt.length ? o : hashq(fmt.substr(0,fmt.length-o.length)) + o;
+ }
+ if((r = fmt.match(frac1))) return write_num_f1(r, aval, sign);
+ if(fmt.match(/^#+0+$/)) return sign + pad0r(aval,fmt.length - fmt.indexOf("0"));
+ if((r = fmt.match(dec1))) {
+ o = rnd(val, r[1].length).replace(/^([^\.]+)$/,"$1."+hashq(r[1])).replace(/\.$/,"."+hashq(r[1])).replace(/\.(\d*)$/,function($$, $1) { return "." + $1 + fill("0", hashq(r[1]).length-$1.length); });
+ return fmt.indexOf("0.") !== -1 ? o : o.replace(/^0\./,".");
+ }
+ fmt = fmt.replace(/^#+([0.])/, "$1");
+ if((r = fmt.match(/^(0*)\.(#*)$/))) {
+ return sign + rnd(aval, r[2].length).replace(/\.(\d*[1-9])0*$/,".$1").replace(/^(-?\d*)$/,"$1.").replace(/^0\./,r[1].length?"0.":".");
+ }
+ if((r = fmt.match(/^#{1,3},##0(\.?)$/))) return sign + commaify(pad0r(aval,0));
+ if((r = fmt.match(/^#,##0\.([#0]*0)$/))) {
+ return val < 0 ? "-" + write_num_flt(type, fmt, -val) : commaify(""+(Math.floor(val) + carry(val, r[1].length))) + "." + pad0(dec(val, r[1].length),r[1].length);
+ }
+ if((r = fmt.match(/^#,#*,#0/))) return write_num_flt(type,fmt.replace(/^#,#*,/,""),val);
+ if((r = fmt.match(/^([0#]+)(\\?-([0#]+))+$/))) {
+ o = _strrev(write_num_flt(type, fmt.replace(/[\\-]/g,""), val));
+ ri = 0;
+ return _strrev(_strrev(fmt.replace(/\\/g,"")).replace(/[0#]/g,function(x){return ri= 0) return write_num_int('n', ffmt, val);
+ return '(' + write_num_int('n', ffmt, -val) + ')';
+ }
+ if(fmt.charCodeAt(fmt.length - 1) === 44) return write_num_cm2(type, fmt, val);
+ if(fmt.indexOf('%') !== -1) return write_num_pct2(type, fmt, val);
+ if(fmt.indexOf('E') !== -1) return write_num_exp2(fmt, val);
+ if(fmt.charCodeAt(0) === 36) return "$"+write_num_int(type,fmt.substr(fmt.charAt(1)==' '?2:1),val);
+ var o;
+ var r, ri, ff, aval = Math.abs(val), sign = val < 0 ? "-" : "";
+ if(fmt.match(/^00+$/)) return sign + pad0(aval,fmt.length);
+ if(fmt.match(/^[#?]+$/)) {
+ o = (""+val); if(val === 0) o = "";
+ return o.length > fmt.length ? o : hashq(fmt.substr(0,fmt.length-o.length)) + o;
+ }
+ if((r = fmt.match(frac1))) return write_num_f2(r, aval, sign);
+ if(fmt.match(/^#+0+$/)) return sign + pad0(aval,fmt.length - fmt.indexOf("0"));
+ if((r = fmt.match(dec1))) {
+o = (""+val).replace(/^([^\.]+)$/,"$1."+hashq(r[1])).replace(/\.$/,"."+hashq(r[1]));
+ o = o.replace(/\.(\d*)$/,function($$, $1) {
+return "." + $1 + fill("0", hashq(r[1]).length-$1.length); });
+ return fmt.indexOf("0.") !== -1 ? o : o.replace(/^0\./,".");
+ }
+ fmt = fmt.replace(/^#+([0.])/, "$1");
+ if((r = fmt.match(/^(0*)\.(#*)$/))) {
+ return sign + (""+aval).replace(/\.(\d*[1-9])0*$/,".$1").replace(/^(-?\d*)$/,"$1.").replace(/^0\./,r[1].length?"0.":".");
+ }
+ if((r = fmt.match(/^#{1,3},##0(\.?)$/))) return sign + commaify((""+aval));
+ if((r = fmt.match(/^#,##0\.([#0]*0)$/))) {
+ return val < 0 ? "-" + write_num_int(type, fmt, -val) : commaify((""+val)) + "." + fill('0',r[1].length);
+ }
+ if((r = fmt.match(/^#,#*,#0/))) return write_num_int(type,fmt.replace(/^#,#*,/,""),val);
+ if((r = fmt.match(/^([0#]+)(\\?-([0#]+))+$/))) {
+ o = _strrev(write_num_int(type, fmt.replace(/[\\-]/g,""), val));
+ ri = 0;
+ return _strrev(_strrev(fmt.replace(/\\/g,"")).replace(/[0#]/g,function(x){return ri -1 || (c=='\\' && fmt.charAt(i+1) == "-" && "0#".indexOf(fmt.charAt(i+2))>-1))){/* empty */}
+ break;
+ case '?': while(fmt.charAt(++i) === c){/* empty */} break;
+ case '*': ++i; if(fmt.charAt(i) == ' ' || fmt.charAt(i) == '*') ++i; break;
+ case '(': case ')': ++i; break;
+ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+ while(i < fmt.length && "0123456789".indexOf(fmt.charAt(++i)) > -1){/* empty */} break;
+ case ' ': ++i; break;
+ default: ++i; break;
+ }
+ }
+ return false;
+}
+
+function eval_fmt(fmt, v, opts, flen) {
+ var out = [], o = "", i = 0, c = "", lst='t', dt, j, cc;
+ var hr='H';
+ /* Tokenize */
+ while(i < fmt.length) {
+ switch((c = fmt.charAt(i))) {
+ case 'G': /* General */
+ if(!SSF_isgeneral(fmt, i)) throw new Error('unrecognized character ' + c + ' in ' +fmt);
+ out[out.length] = {t:'G', v:'General'}; i+=7; break;
+ case '"': /* Literal text */
+ for(o="";(cc=fmt.charCodeAt(++i)) !== 34 && i < fmt.length;) o += String.fromCharCode(cc);
+ out[out.length] = {t:'t', v:o}; ++i; break;
+ case '\\': var w = fmt.charAt(++i), t = (w === "(" || w === ")") ? w : 't';
+ out[out.length] = {t:t, v:w}; ++i; break;
+ case '_': out[out.length] = {t:'t', v:" "}; i+=2; break;
+ case '@': /* Text Placeholder */
+ out[out.length] = {t:'T', v:v}; ++i; break;
+ case 'B': case 'b':
+ if(fmt.charAt(i+1) === "1" || fmt.charAt(i+1) === "2") {
+ if(dt==null) { dt=SSF_parse_date_code(v, opts, fmt.charAt(i+1) === "2"); if(dt==null) return ""; }
+ out[out.length] = {t:'X', v:fmt.substr(i,2)}; lst = c; i+=2; break;
+ }
+ /* falls through */
+ case 'M': case 'D': case 'Y': case 'H': case 'S': case 'E':
+ c = c.toLowerCase();
+ /* falls through */
+ case 'm': case 'd': case 'y': case 'h': case 's': case 'e': case 'g':
+ if(v < 0) return "";
+ if(dt==null) { dt=SSF_parse_date_code(v, opts); if(dt==null) return ""; }
+ o = c; while(++i < fmt.length && fmt.charAt(i).toLowerCase() === c) o+=c;
+ if(c === 'm' && lst.toLowerCase() === 'h') c = 'M';
+ if(c === 'h') c = hr;
+ out[out.length] = {t:c, v:o}; lst = c; break;
+ case 'A': case 'a': case '上':
+ var q={t:c, v:c};
+ if(dt==null) dt=SSF_parse_date_code(v, opts);
+ if(fmt.substr(i, 3).toUpperCase() === "A/P") { if(dt!=null) q.v = dt.H >= 12 ? "P" : "A"; q.t = 'T'; hr='h';i+=3;}
+ else if(fmt.substr(i,5).toUpperCase() === "AM/PM") { if(dt!=null) q.v = dt.H >= 12 ? "PM" : "AM"; q.t = 'T'; i+=5; hr='h'; }
+ else if(fmt.substr(i,5).toUpperCase() === "上午/下午") { if(dt!=null) q.v = dt.H >= 12 ? "下午" : "上午"; q.t = 'T'; i+=5; hr='h'; }
+ else { q.t = "t"; ++i; }
+ if(dt==null && q.t === 'T') return "";
+ out[out.length] = q; lst = c; break;
+ case '[':
+ o = c;
+ while(fmt.charAt(i++) !== ']' && i < fmt.length) o += fmt.charAt(i);
+ if(o.slice(-1) !== ']') throw 'unterminated "[" block: |' + o + '|';
+ if(o.match(SSF_abstime)) {
+ if(dt==null) { dt=SSF_parse_date_code(v, opts); if(dt==null) return ""; }
+ out[out.length] = {t:'Z', v:o.toLowerCase()};
+ lst = o.charAt(1);
+ } else if(o.indexOf("$") > -1) {
+ o = (o.match(/\$([^-\[\]]*)/)||[])[1]||"$";
+ if(!fmt_is_date(fmt)) out[out.length] = {t:'t',v:o};
+ }
+ break;
+ /* Numbers */
+ case '.':
+ if(dt != null) {
+ o = c; while(++i < fmt.length && (c=fmt.charAt(i)) === "0") o += c;
+ out[out.length] = {t:'s', v:o}; break;
+ }
+ /* falls through */
+ case '0': case '#':
+ o = c; while(++i < fmt.length && "0#?.,E+-%".indexOf(c=fmt.charAt(i)) > -1) o += c;
+ out[out.length] = {t:'n', v:o}; break;
+ case '?':
+ o = c; while(fmt.charAt(++i) === c) o+=c;
+ out[out.length] = {t:c, v:o}; lst = c; break;
+ case '*': ++i; if(fmt.charAt(i) == ' ' || fmt.charAt(i) == '*') ++i; break; // **
+ case '(': case ')': out[out.length] = {t:(flen===1?'t':c), v:c}; ++i; break;
+ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+ o = c; while(i < fmt.length && "0123456789".indexOf(fmt.charAt(++i)) > -1) o+=fmt.charAt(i);
+ out[out.length] = {t:'D', v:o}; break;
+ case ' ': out[out.length] = {t:c, v:c}; ++i; break;
+ case '$': out[out.length] = {t:'t', v:'$'}; ++i; break;
+ default:
+ if(",$-+/():!^&'~{}<>=€acfijklopqrtuvwxzP".indexOf(c) === -1) throw new Error('unrecognized character ' + c + ' in ' + fmt);
+ out[out.length] = {t:'t', v:c}; ++i; break;
+ }
+ }
+
+ /* Scan for date/time parts */
+ var bt = 0, ss0 = 0, ssm;
+ for(i=out.length-1, lst='t'; i >= 0; --i) {
+ switch(out[i].t) {
+ case 'h': case 'H': out[i].t = hr; lst='h'; if(bt < 1) bt = 1; break;
+ case 's':
+ if((ssm=out[i].v.match(/\.0+$/))) ss0=Math.max(ss0,ssm[0].length-1);
+ if(bt < 3) bt = 3;
+ /* falls through */
+ case 'd': case 'y': case 'M': case 'e': lst=out[i].t; break;
+ case 'm': if(lst === 's') { out[i].t = 'M'; if(bt < 2) bt = 2; } break;
+ case 'X': /*if(out[i].v === "B2");*/
+ break;
+ case 'Z':
+ if(bt < 1 && out[i].v.match(/[Hh]/)) bt = 1;
+ if(bt < 2 && out[i].v.match(/[Mm]/)) bt = 2;
+ if(bt < 3 && out[i].v.match(/[Ss]/)) bt = 3;
+ }
+ }
+ /* time rounding depends on presence of minute / second / usec fields */
+ switch(bt) {
+ case 0: break;
+ case 1:
+if(dt.u >= 0.5) { dt.u = 0; ++dt.S; }
+ if(dt.S >= 60) { dt.S = 0; ++dt.M; }
+ if(dt.M >= 60) { dt.M = 0; ++dt.H; }
+ break;
+ case 2:
+if(dt.u >= 0.5) { dt.u = 0; ++dt.S; }
+ if(dt.S >= 60) { dt.S = 0; ++dt.M; }
+ break;
+ }
+
+ /* replace fields */
+ var nstr = "", jj;
+ for(i=0; i < out.length; ++i) {
+ switch(out[i].t) {
+ case 't': case 'T': case ' ': case 'D': break;
+ case 'X': out[i].v = ""; out[i].t = ";"; break;
+ case 'd': case 'm': case 'y': case 'h': case 'H': case 'M': case 's': case 'e': case 'b': case 'Z':
+out[i].v = SSF_write_date(out[i].t.charCodeAt(0), out[i].v, dt, ss0);
+ out[i].t = 't'; break;
+ case 'n': case '?':
+ jj = i+1;
+ while(out[jj] != null && (
+ (c=out[jj].t) === "?" || c === "D" ||
+ ((c === " " || c === "t") && out[jj+1] != null && (out[jj+1].t === '?' || out[jj+1].t === "t" && out[jj+1].v === '/')) ||
+ (out[i].t === '(' && (c === ' ' || c === 'n' || c === ')')) ||
+ (c === 't' && (out[jj].v === '/' || out[jj].v === ' ' && out[jj+1] != null && out[jj+1].t == '?'))
+ )) {
+ out[i].v += out[jj].v;
+ out[jj] = {v:"", t:";"}; ++jj;
+ }
+ nstr += out[i].v;
+ i = jj-1; break;
+ case 'G': out[i].t = 't'; out[i].v = SSF_general(v,opts); break;
+ }
+ }
+ var vv = "", myv, ostr;
+ if(nstr.length > 0) {
+ if(nstr.charCodeAt(0) == 40) /* '(' */ {
+ myv = (v<0&&nstr.charCodeAt(0) === 45 ? -v : v);
+ ostr = write_num('n', nstr, myv);
+ } else {
+ myv = (v<0 && flen > 1 ? -v : v);
+ ostr = write_num('n', nstr, myv);
+ if(myv < 0 && out[0] && out[0].t == 't') {
+ ostr = ostr.substr(1);
+ out[0].v = "-" + out[0].v;
+ }
+ }
+ jj=ostr.length-1;
+ var decpt = out.length;
+ for(i=0; i < out.length; ++i) if(out[i] != null && out[i].t != 't' && out[i].v.indexOf(".") > -1) { decpt = i; break; }
+ var lasti=out.length;
+ if(decpt === out.length && ostr.indexOf("E") === -1) {
+ for(i=out.length-1; i>= 0;--i) {
+ if(out[i] == null || 'n?'.indexOf(out[i].t) === -1) continue;
+ if(jj>=out[i].v.length-1) { jj -= out[i].v.length; out[i].v = ostr.substr(jj+1, out[i].v.length); }
+ else if(jj < 0) out[i].v = "";
+ else { out[i].v = ostr.substr(0, jj+1); jj = -1; }
+ out[i].t = 't';
+ lasti = i;
+ }
+ if(jj>=0 && lasti= 0; --i) {
+ if(out[i] == null || 'n?'.indexOf(out[i].t) === -1) continue;
+ j=out[i].v.indexOf(".")>-1&&i===decpt?out[i].v.indexOf(".")-1:out[i].v.length-1;
+ vv = out[i].v.substr(j+1);
+ for(; j>=0; --j) {
+ if(jj>=0 && (out[i].v.charAt(j) === "0" || out[i].v.charAt(j) === "#")) vv = ostr.charAt(jj--) + vv;
+ }
+ out[i].v = vv;
+ out[i].t = 't';
+ lasti = i;
+ }
+ if(jj>=0 && lasti-1&&i===decpt?out[i].v.indexOf(".")+1:0;
+ vv = out[i].v.substr(0,j);
+ for(; j-1) {
+ myv = (flen >1 && v < 0 && i>0 && out[i-1].v === "-" ? -v:v);
+ out[i].v = write_num(out[i].t, out[i].v, myv);
+ out[i].t = 't';
+ }
+ var retval = "";
+ for(i=0; i !== out.length; ++i) if(out[i] != null) retval += out[i].v;
+ return retval;
+}
+
+var cfregex2 = /\[(=|>[=]?|<[>=]?)(-?\d+(?:\.\d*)?)\]/;
+function chkcond(v, rr) {
+ if(rr == null) return false;
+ var thresh = parseFloat(rr[2]);
+ switch(rr[1]) {
+ case "=": if(v == thresh) return true; break;
+ case ">": if(v > thresh) return true; break;
+ case "<": if(v < thresh) return true; break;
+ case "<>": if(v != thresh) return true; break;
+ case ">=": if(v >= thresh) return true; break;
+ case "<=": if(v <= thresh) return true; break;
+ }
+ return false;
+}
+function choose_fmt(f, v) {
+ var fmt = SSF_split_fmt(f);
+ var l = fmt.length, lat = fmt[l-1].indexOf("@");
+ if(l<4 && lat>-1) --l;
+ if(fmt.length > 4) throw new Error("cannot find right format for |" + fmt.join("|") + "|");
+ if(typeof v !== "number") return [4, fmt.length === 4 || lat>-1?fmt[fmt.length-1]:"@"];
+ switch(fmt.length) {
+ case 1: fmt = lat>-1 ? ["General", "General", "General", fmt[0]] : [fmt[0], fmt[0], fmt[0], "@"]; break;
+ case 2: fmt = lat>-1 ? [fmt[0], fmt[0], fmt[0], fmt[1]] : [fmt[0], fmt[1], fmt[0], "@"]; break;
+ case 3: fmt = lat>-1 ? [fmt[0], fmt[1], fmt[0], fmt[2]] : [fmt[0], fmt[1], fmt[2], "@"]; break;
+ case 4: break;
+ }
+ var ff = v > 0 ? fmt[0] : v < 0 ? fmt[1] : fmt[2];
+ if(fmt[0].indexOf("[") === -1 && fmt[1].indexOf("[") === -1) return [l, ff];
+ if(fmt[0].match(/\[[=<>]/) != null || fmt[1].match(/\[[=<>]/) != null) {
+ var m1 = fmt[0].match(cfregex2);
+ var m2 = fmt[1].match(cfregex2);
+ return chkcond(v, m1) ? [l, fmt[0]] : chkcond(v, m2) ? [l, fmt[1]] : [l, fmt[m1 != null && m2 != null ? 2 : 1]];
+ }
+ return [l, ff];
+}
+function SSF_format(fmt,v,o) {
+ if(o == null) o = {};
+ var sfmt = "";
+ switch(typeof fmt) {
+ case "string":
+ if(fmt == "m/d/yy" && o.dateNF) sfmt = o.dateNF;
+ else sfmt = fmt;
+ break;
+ case "number":
+ if(fmt == 14 && o.dateNF) sfmt = o.dateNF;
+ else sfmt = (o.table != null ? (o.table) : table_fmt)[fmt];
+ if(sfmt == null) sfmt = (o.table && o.table[SSF_default_map[fmt]]) || table_fmt[SSF_default_map[fmt]];
+ if(sfmt == null) sfmt = SSF_default_str[fmt] || "General";
+ break;
+ }
+ if(SSF_isgeneral(sfmt,0)) return SSF_general(v, o);
+ if(v instanceof Date) v = datenum_local(v, o.date1904);
+ var f = choose_fmt(sfmt, v);
+ if(SSF_isgeneral(f[1])) return SSF_general(v, o);
+ if(v === true) v = "TRUE"; else if(v === false) v = "FALSE";
+ else if(v === "" || v == null) return "";
+ return eval_fmt(f[1], v, o, f[0]);
+}
+function SSF_load(fmt, idx) {
+ if(typeof idx != 'number') {
+ idx = +idx || -1;
+for(var i = 0; i < 0x0188; ++i) {
+if(table_fmt[i] == undefined) { if(idx < 0) idx = i; continue; }
+ if(table_fmt[i] == fmt) { idx = i; break; }
+ }
+if(idx < 0) idx = 0x187;
+ }
+table_fmt[idx] = fmt;
+ return idx;
+}
+function SSF_load_table(tbl) {
+ for(var i=0; i!=0x0188; ++i)
+ if(tbl[i] !== undefined) SSF_load(tbl[i], i);
+}
+
+function make_ssf() {
+ table_fmt = SSF_init_table();
+}
+
+var SSF = {
+ format: SSF_format,
+ load: SSF_load,
+ _table: table_fmt,
+ load_table: SSF_load_table,
+ parse_date_code: SSF_parse_date_code,
+ is_date: fmt_is_date,
+ get_table: function get_table() { return SSF._table = table_fmt; }
+};
+
+var SSFImplicit/*{[number]:string}*/ = ({
+ "5": '"$"#,##0_);\\("$"#,##0\\)',
+ "6": '"$"#,##0_);[Red]\\("$"#,##0\\)',
+ "7": '"$"#,##0.00_);\\("$"#,##0.00\\)',
+ "8": '"$"#,##0.00_);[Red]\\("$"#,##0.00\\)',
+ "23": 'General', "24": 'General', "25": 'General', "26": 'General',
+ "27": 'm/d/yy', "28": 'm/d/yy', "29": 'm/d/yy', "30": 'm/d/yy', "31": 'm/d/yy',
+ "32": 'h:mm:ss', "33": 'h:mm:ss', "34": 'h:mm:ss', "35": 'h:mm:ss',
+ "36": 'm/d/yy',
+ "41": '_(* #,##0_);_(* \(#,##0\);_(* "-"_);_(@_)',
+ "42": '_("$"* #,##0_);_("$"* \(#,##0\);_("$"* "-"_);_(@_)',
+ "43": '_(* #,##0.00_);_(* \(#,##0.00\);_(* "-"??_);_(@_)',
+ "44": '_("$"* #,##0.00_);_("$"* \(#,##0.00\);_("$"* "-"??_);_(@_)',
+ "50": 'm/d/yy', "51": 'm/d/yy', "52": 'm/d/yy', "53": 'm/d/yy', "54": 'm/d/yy',
+ "55": 'm/d/yy', "56": 'm/d/yy', "57": 'm/d/yy', "58": 'm/d/yy',
+ "59": '0',
+ "60": '0.00',
+ "61": '#,##0',
+ "62": '#,##0.00',
+ "63": '"$"#,##0_);\\("$"#,##0\\)',
+ "64": '"$"#,##0_);[Red]\\("$"#,##0\\)',
+ "65": '"$"#,##0.00_);\\("$"#,##0.00\\)',
+ "66": '"$"#,##0.00_);[Red]\\("$"#,##0.00\\)',
+ "67": '0%',
+ "68": '0.00%',
+ "69": '# ?/?',
+ "70": '# ??/??',
+ "71": 'm/d/yy',
+ "72": 'm/d/yy',
+ "73": 'd-mmm-yy',
+ "74": 'd-mmm',
+ "75": 'mmm-yy',
+ "76": 'h:mm',
+ "77": 'h:mm:ss',
+ "78": 'm/d/yy h:mm',
+ "79": 'mm:ss',
+ "80": '[h]:mm:ss',
+ "81": 'mmss.0'
+});
+
+/* dateNF parse TODO: move to SSF */
+var dateNFregex = /[dD]+|[mM]+|[yYeE]+|[Hh]+|[Ss]+/g;
+function dateNF_regex(dateNF) {
+ var fmt = typeof dateNF == "number" ? table_fmt[dateNF] : dateNF;
+ fmt = fmt.replace(dateNFregex, "(\\d+)");
+ return new RegExp("^" + fmt + "$");
+}
+function dateNF_fix(str, dateNF, match) {
+ var Y = -1, m = -1, d = -1, H = -1, M = -1, S = -1;
+ (dateNF.match(dateNFregex)||[]).forEach(function(n, i) {
+ var v = parseInt(match[i+1], 10);
+ switch(n.toLowerCase().charAt(0)) {
+ case 'y': Y = v; break; case 'd': d = v; break;
+ case 'h': H = v; break; case 's': S = v; break;
+ case 'm': if(H >= 0) M = v; else m = v; break;
+ }
+ });
+ if(S >= 0 && M == -1 && m >= 0) { M = m; m = -1; }
+ var datestr = (("" + (Y>=0?Y: new Date().getFullYear())).slice(-4) + "-" + ("00" + (m>=1?m:1)).slice(-2) + "-" + ("00" + (d>=1?d:1)).slice(-2));
+ if(datestr.length == 7) datestr = "0" + datestr;
+ if(datestr.length == 8) datestr = "20" + datestr;
+ var timestr = (("00" + (H>=0?H:0)).slice(-2) + ":" + ("00" + (M>=0?M:0)).slice(-2) + ":" + ("00" + (S>=0?S:0)).slice(-2));
+ if(H == -1 && M == -1 && S == -1) return datestr;
+ if(Y == -1 && m == -1 && d == -1) return timestr;
+ return datestr + "T" + timestr;
+}
+
+/* cfb.js (C) 2013-present SheetJS -- http://sheetjs.com */
+/* vim: set ts=2: */
+/*jshint eqnull:true */
+/*exported CFB */
+/*global Uint8Array:false, Uint16Array:false */
+
+/* crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
+/* vim: set ts=2: */
+/*exported CRC32 */
+var CRC32 = (function() {
+var CRC32 = {};
+CRC32.version = '1.2.0';
+/* see perf/crc32table.js */
+/*global Int32Array */
+function signed_crc_table() {
+ var c = 0, table = new Array(256);
+
+ for(var n =0; n != 256; ++n){
+ c = n;
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ c = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
+ table[n] = c;
+ }
+
+ return typeof Int32Array !== 'undefined' ? new Int32Array(table) : table;
+}
+
+var T0 = signed_crc_table();
+function slice_by_16_tables(T) {
+ var c = 0, v = 0, n = 0, table = typeof Int32Array !== 'undefined' ? new Int32Array(4096) : new Array(4096) ;
+
+ for(n = 0; n != 256; ++n) table[n] = T[n];
+ for(n = 0; n != 256; ++n) {
+ v = T[n];
+ for(c = 256 + n; c < 4096; c += 256) v = table[c] = (v >>> 8) ^ T[v & 0xFF];
+ }
+ var out = [];
+ for(n = 1; n != 16; ++n) out[n - 1] = typeof Int32Array !== 'undefined' ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
+ return out;
+}
+var TT = slice_by_16_tables(T0);
+var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
+var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
+var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
+function crc32_bstr(bstr, seed) {
+ var C = seed ^ -1;
+ for(var i = 0, L = bstr.length; i < L;) C = (C>>>8) ^ T0[(C^bstr.charCodeAt(i++))&0xFF];
+ return ~C;
+}
+
+function crc32_buf(B, seed) {
+ var C = seed ^ -1, L = B.length - 15, i = 0;
+ for(; i < L;) C =
+ Tf[B[i++] ^ (C & 255)] ^
+ Te[B[i++] ^ ((C >> 8) & 255)] ^
+ Td[B[i++] ^ ((C >> 16) & 255)] ^
+ Tc[B[i++] ^ (C >>> 24)] ^
+ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^
+ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^
+ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
+ L += 15;
+ while(i < L) C = (C>>>8) ^ T0[(C^B[i++])&0xFF];
+ return ~C;
+}
+
+function crc32_str(str, seed) {
+ var C = seed ^ -1;
+ for(var i = 0, L = str.length, c = 0, d = 0; i < L;) {
+ c = str.charCodeAt(i++);
+ if(c < 0x80) {
+ C = (C>>>8) ^ T0[(C^c)&0xFF];
+ } else if(c < 0x800) {
+ C = (C>>>8) ^ T0[(C ^ (192|((c>>6)&31)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|(c&63)))&0xFF];
+ } else if(c >= 0xD800 && c < 0xE000) {
+ c = (c&1023)+64; d = str.charCodeAt(i++)&1023;
+ C = (C>>>8) ^ T0[(C ^ (240|((c>>8)&7)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|((c>>2)&63)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|((d>>6)&15)|((c&3)<<4)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|(d&63)))&0xFF];
+ } else {
+ C = (C>>>8) ^ T0[(C ^ (224|((c>>12)&15)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|((c>>6)&63)))&0xFF];
+ C = (C>>>8) ^ T0[(C ^ (128|(c&63)))&0xFF];
+ }
+ }
+ return ~C;
+}
+CRC32.table = T0;
+CRC32.bstr = crc32_bstr;
+CRC32.buf = crc32_buf;
+CRC32.str = crc32_str;
+return CRC32;
+})();
+/* [MS-CFB] v20171201 */
+var CFB = (function _CFB(){
+var exports = {};
+exports.version = '1.2.1';
+/* [MS-CFB] 2.6.4 */
+function namecmp(l, r) {
+ var L = l.split("/"), R = r.split("/");
+ for(var i = 0, c = 0, Z = Math.min(L.length, R.length); i < Z; ++i) {
+ if((c = L[i].length - R[i].length)) return c;
+ if(L[i] != R[i]) return L[i] < R[i] ? -1 : 1;
+ }
+ return L.length - R.length;
+}
+function dirname(p) {
+ if(p.charAt(p.length - 1) == "/") return (p.slice(0,-1).indexOf("/") === -1) ? p : dirname(p.slice(0, -1));
+ var c = p.lastIndexOf("/");
+ return (c === -1) ? p : p.slice(0, c+1);
+}
+
+function filename(p) {
+ if(p.charAt(p.length - 1) == "/") return filename(p.slice(0, -1));
+ var c = p.lastIndexOf("/");
+ return (c === -1) ? p : p.slice(c+1);
+}
+/* -------------------------------------------------------------------------- */
+/* DOS Date format:
+ high|YYYYYYYm.mmmddddd.HHHHHMMM.MMMSSSSS|low
+ add 1980 to stored year
+ stored second should be doubled
+*/
+
+/* write JS date to buf as a DOS date */
+function write_dos_date(buf, date) {
+ if(typeof date === "string") date = new Date(date);
+ var hms = date.getHours();
+ hms = hms << 6 | date.getMinutes();
+ hms = hms << 5 | (date.getSeconds()>>>1);
+ buf.write_shift(2, hms);
+ var ymd = (date.getFullYear() - 1980);
+ ymd = ymd << 4 | (date.getMonth()+1);
+ ymd = ymd << 5 | date.getDate();
+ buf.write_shift(2, ymd);
+}
+
+/* read four bytes from buf and interpret as a DOS date */
+function parse_dos_date(buf) {
+ var hms = buf.read_shift(2) & 0xFFFF;
+ var ymd = buf.read_shift(2) & 0xFFFF;
+ var val = new Date();
+ var d = ymd & 0x1F; ymd >>>= 5;
+ var m = ymd & 0x0F; ymd >>>= 4;
+ val.setMilliseconds(0);
+ val.setFullYear(ymd + 1980);
+ val.setMonth(m-1);
+ val.setDate(d);
+ var S = hms & 0x1F; hms >>>= 5;
+ var M = hms & 0x3F; hms >>>= 6;
+ val.setHours(hms);
+ val.setMinutes(M);
+ val.setSeconds(S<<1);
+ return val;
+}
+function parse_extra_field(blob) {
+ prep_blob(blob, 0);
+ var o = {};
+ var flags = 0;
+ while(blob.l <= blob.length - 4) {
+ var type = blob.read_shift(2);
+ var sz = blob.read_shift(2), tgt = blob.l + sz;
+ var p = {};
+ switch(type) {
+ /* UNIX-style Timestamps */
+ case 0x5455: {
+ flags = blob.read_shift(1);
+ if(flags & 1) p.mtime = blob.read_shift(4);
+ /* for some reason, CD flag corresponds to LFH */
+ if(sz > 5) {
+ if(flags & 2) p.atime = blob.read_shift(4);
+ if(flags & 4) p.ctime = blob.read_shift(4);
+ }
+ if(p.mtime) p.mt = new Date(p.mtime*1000);
+ }
+ break;
+ }
+ blob.l = tgt;
+ o[type] = p;
+ }
+ return o;
+}
+var fs;
+function get_fs() { return fs || (fs = require('fs')); }
+function parse(file, options) {
+if(file[0] == 0x50 && file[1] == 0x4b) return parse_zip(file, options);
+if((file[0] | 0x20) == 0x6d && (file[1]|0x20) == 0x69) return parse_mad(file, options);
+if(file.length < 512) throw new Error("CFB file size " + file.length + " < 512");
+var mver = 3;
+var ssz = 512;
+var nmfs = 0; // number of mini FAT sectors
+var difat_sec_cnt = 0;
+var dir_start = 0;
+var minifat_start = 0;
+var difat_start = 0;
+
+var fat_addrs = []; // locations of FAT sectors
+
+/* [MS-CFB] 2.2 Compound File Header */
+var blob = file.slice(0,512);
+prep_blob(blob, 0);
+
+/* major version */
+var mv = check_get_mver(blob);
+mver = mv[0];
+switch(mver) {
+ case 3: ssz = 512; break; case 4: ssz = 4096; break;
+ case 0: if(mv[1] == 0) return parse_zip(file, options);
+ /* falls through */
+ default: throw new Error("Major Version: Expected 3 or 4 saw " + mver);
+}
+
+/* reprocess header */
+if(ssz !== 512) { blob = file.slice(0,ssz); prep_blob(blob, 28 /* blob.l */); }
+/* Save header for final object */
+var header = file.slice(0,ssz);
+
+check_shifts(blob, mver);
+
+// Number of Directory Sectors
+var dir_cnt = blob.read_shift(4, 'i');
+if(mver === 3 && dir_cnt !== 0) throw new Error('# Directory Sectors: Expected 0 saw ' + dir_cnt);
+
+// Number of FAT Sectors
+blob.l += 4;
+
+// First Directory Sector Location
+dir_start = blob.read_shift(4, 'i');
+
+// Transaction Signature
+blob.l += 4;
+
+// Mini Stream Cutoff Size
+blob.chk('00100000', 'Mini Stream Cutoff Size: ');
+
+// First Mini FAT Sector Location
+minifat_start = blob.read_shift(4, 'i');
+
+// Number of Mini FAT Sectors
+nmfs = blob.read_shift(4, 'i');
+
+// First DIFAT sector location
+difat_start = blob.read_shift(4, 'i');
+
+// Number of DIFAT Sectors
+difat_sec_cnt = blob.read_shift(4, 'i');
+
+// Grab FAT Sector Locations
+for(var q = -1, j = 0; j < 109; ++j) { /* 109 = (512 - blob.l)>>>2; */
+ q = blob.read_shift(4, 'i');
+ if(q<0) break;
+ fat_addrs[j] = q;
+}
+
+/** Break the file up into sectors */
+var sectors = sectorify(file, ssz);
+
+sleuth_fat(difat_start, difat_sec_cnt, sectors, ssz, fat_addrs);
+
+/** Chains */
+var sector_list = make_sector_list(sectors, dir_start, fat_addrs, ssz);
+
+sector_list[dir_start].name = "!Directory";
+if(nmfs > 0 && minifat_start !== ENDOFCHAIN) sector_list[minifat_start].name = "!MiniFAT";
+sector_list[fat_addrs[0]].name = "!FAT";
+sector_list.fat_addrs = fat_addrs;
+sector_list.ssz = ssz;
+
+/* [MS-CFB] 2.6.1 Compound File Directory Entry */
+var files = {}, Paths = [], FileIndex = [], FullPaths = [];
+read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, minifat_start);
+
+build_full_paths(FileIndex, FullPaths, Paths);
+Paths.shift();
+
+var o = {
+ FileIndex: FileIndex,
+ FullPaths: FullPaths
+};
+
+// $FlowIgnore
+if(options && options.raw) o.raw = {header: header, sectors: sectors};
+return o;
+} // parse
+
+/* [MS-CFB] 2.2 Compound File Header -- read up to major version */
+function check_get_mver(blob) {
+ if(blob[blob.l] == 0x50 && blob[blob.l + 1] == 0x4b) return [0, 0];
+ // header signature 8
+ blob.chk(HEADER_SIGNATURE, 'Header Signature: ');
+
+ // clsid 16
+ //blob.chk(HEADER_CLSID, 'CLSID: ');
+ blob.l += 16;
+
+ // minor version 2
+ var mver = blob.read_shift(2, 'u');
+
+ return [blob.read_shift(2,'u'), mver];
+}
+function check_shifts(blob, mver) {
+ var shift = 0x09;
+
+ // Byte Order
+ //blob.chk('feff', 'Byte Order: '); // note: some writers put 0xffff
+ blob.l += 2;
+
+ // Sector Shift
+ switch((shift = blob.read_shift(2))) {
+ case 0x09: if(mver != 3) throw new Error('Sector Shift: Expected 9 saw ' + shift); break;
+ case 0x0c: if(mver != 4) throw new Error('Sector Shift: Expected 12 saw ' + shift); break;
+ default: throw new Error('Sector Shift: Expected 9 or 12 saw ' + shift);
+ }
+
+ // Mini Sector Shift
+ blob.chk('0600', 'Mini Sector Shift: ');
+
+ // Reserved
+ blob.chk('000000000000', 'Reserved: ');
+}
+
+/** Break the file up into sectors */
+function sectorify(file, ssz) {
+ var nsectors = Math.ceil(file.length/ssz)-1;
+ var sectors = [];
+ for(var i=1; i < nsectors; ++i) sectors[i-1] = file.slice(i*ssz,(i+1)*ssz);
+ sectors[nsectors-1] = file.slice(nsectors*ssz);
+ return sectors;
+}
+
+/* [MS-CFB] 2.6.4 Red-Black Tree */
+function build_full_paths(FI, FP, Paths) {
+ var i = 0, L = 0, R = 0, C = 0, j = 0, pl = Paths.length;
+ var dad = [], q = [];
+
+ for(; i < pl; ++i) { dad[i]=q[i]=i; FP[i]=Paths[i]; }
+
+ for(; j < q.length; ++j) {
+ i = q[j];
+ L = FI[i].L; R = FI[i].R; C = FI[i].C;
+ if(dad[i] === i) {
+ if(L !== -1 /*NOSTREAM*/ && dad[L] !== L) dad[i] = dad[L];
+ if(R !== -1 && dad[R] !== R) dad[i] = dad[R];
+ }
+ if(C !== -1 /*NOSTREAM*/) dad[C] = i;
+ if(L !== -1 && i != dad[i]) { dad[L] = dad[i]; if(q.lastIndexOf(L) < j) q.push(L); }
+ if(R !== -1 && i != dad[i]) { dad[R] = dad[i]; if(q.lastIndexOf(R) < j) q.push(R); }
+ }
+ for(i=1; i < pl; ++i) if(dad[i] === i) {
+ if(R !== -1 /*NOSTREAM*/ && dad[R] !== R) dad[i] = dad[R];
+ else if(L !== -1 && dad[L] !== L) dad[i] = dad[L];
+ }
+
+ for(i=1; i < pl; ++i) {
+ if(FI[i].type === 0 /* unknown */) continue;
+ j = i;
+ if(j != dad[j]) do {
+ j = dad[j];
+ FP[i] = FP[j] + "/" + FP[i];
+ } while (j !== 0 && -1 !== dad[j] && j != dad[j]);
+ dad[i] = -1;
+ }
+
+ FP[0] += "/";
+ for(i=1; i < pl; ++i) {
+ if(FI[i].type !== 2 /* stream */) FP[i] += "/";
+ }
+}
+
+function get_mfat_entry(entry, payload, mini) {
+ var start = entry.start, size = entry.size;
+ //return (payload.slice(start*MSSZ, start*MSSZ + size));
+ var o = [];
+ var idx = start;
+ while(mini && size > 0 && idx >= 0) {
+ o.push(payload.slice(idx * MSSZ, idx * MSSZ + MSSZ));
+ size -= MSSZ;
+ idx = __readInt32LE(mini, idx * 4);
+ }
+ if(o.length === 0) return (new_buf(0));
+ return (bconcat(o).slice(0, entry.size));
+}
+
+/** Chase down the rest of the DIFAT chain to build a comprehensive list
+ DIFAT chains by storing the next sector number as the last 32 bits */
+function sleuth_fat(idx, cnt, sectors, ssz, fat_addrs) {
+ var q = ENDOFCHAIN;
+ if(idx === ENDOFCHAIN) {
+ if(cnt !== 0) throw new Error("DIFAT chain shorter than expected");
+ } else if(idx !== -1 /*FREESECT*/) {
+ var sector = sectors[idx], m = (ssz>>>2)-1;
+ if(!sector) return;
+ for(var i = 0; i < m; ++i) {
+ if((q = __readInt32LE(sector,i*4)) === ENDOFCHAIN) break;
+ fat_addrs.push(q);
+ }
+ sleuth_fat(__readInt32LE(sector,ssz-4),cnt - 1, sectors, ssz, fat_addrs);
+ }
+}
+
+/** Follow the linked list of sectors for a given starting point */
+function get_sector_list(sectors, start, fat_addrs, ssz, chkd) {
+ var buf = [], buf_chain = [];
+ if(!chkd) chkd = [];
+ var modulus = ssz - 1, j = 0, jj = 0;
+ for(j=start; j>=0;) {
+ chkd[j] = true;
+ buf[buf.length] = j;
+ buf_chain.push(sectors[j]);
+ var addr = fat_addrs[Math.floor(j*4/ssz)];
+ jj = ((j*4) & modulus);
+ if(ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 "+ssz);
+ if(!sectors[addr]) break;
+ j = __readInt32LE(sectors[addr], jj);
+ }
+ return {nodes: buf, data:__toBuffer([buf_chain])};
+}
+
+/** Chase down the sector linked lists */
+function make_sector_list(sectors, dir_start, fat_addrs, ssz) {
+ var sl = sectors.length, sector_list = ([]);
+ var chkd = [], buf = [], buf_chain = [];
+ var modulus = ssz - 1, i=0, j=0, k=0, jj=0;
+ for(i=0; i < sl; ++i) {
+ buf = ([]);
+ k = (i + dir_start); if(k >= sl) k-=sl;
+ if(chkd[k]) continue;
+ buf_chain = [];
+ var seen = [];
+ for(j=k; j>=0;) {
+ seen[j] = true;
+ chkd[j] = true;
+ buf[buf.length] = j;
+ buf_chain.push(sectors[j]);
+ var addr = fat_addrs[Math.floor(j*4/ssz)];
+ jj = ((j*4) & modulus);
+ if(ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 "+ssz);
+ if(!sectors[addr]) break;
+ j = __readInt32LE(sectors[addr], jj);
+ if(seen[j]) break;
+ }
+ sector_list[k] = ({nodes: buf, data:__toBuffer([buf_chain])});
+ }
+ return sector_list;
+}
+
+/* [MS-CFB] 2.6.1 Compound File Directory Entry */
+function read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, mini) {
+ var minifat_store = 0, pl = (Paths.length?2:0);
+ var sector = sector_list[dir_start].data;
+ var i = 0, namelen = 0, name;
+ for(; i < sector.length; i+= 128) {
+ var blob = sector.slice(i, i+128);
+ prep_blob(blob, 64);
+ namelen = blob.read_shift(2);
+ name = __utf16le(blob,0,namelen-pl);
+ Paths.push(name);
+ var o = ({
+ name: name,
+ type: blob.read_shift(1),
+ color: blob.read_shift(1),
+ L: blob.read_shift(4, 'i'),
+ R: blob.read_shift(4, 'i'),
+ C: blob.read_shift(4, 'i'),
+ clsid: blob.read_shift(16),
+ state: blob.read_shift(4, 'i'),
+ start: 0,
+ size: 0
+ });
+ var ctime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
+ if(ctime !== 0) o.ct = read_date(blob, blob.l-8);
+ var mtime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
+ if(mtime !== 0) o.mt = read_date(blob, blob.l-8);
+ o.start = blob.read_shift(4, 'i');
+ o.size = blob.read_shift(4, 'i');
+ if(o.size < 0 && o.start < 0) { o.size = o.type = 0; o.start = ENDOFCHAIN; o.name = ""; }
+ if(o.type === 5) { /* root */
+ minifat_store = o.start;
+ if(nmfs > 0 && minifat_store !== ENDOFCHAIN) sector_list[minifat_store].name = "!StreamData";
+ /*minifat_size = o.size;*/
+ } else if(o.size >= 4096 /* MSCSZ */) {
+ o.storage = 'fat';
+ if(sector_list[o.start] === undefined) sector_list[o.start] = get_sector_list(sectors, o.start, sector_list.fat_addrs, sector_list.ssz);
+ sector_list[o.start].name = o.name;
+ o.content = (sector_list[o.start].data.slice(0,o.size));
+ } else {
+ o.storage = 'minifat';
+ if(o.size < 0) o.size = 0;
+ else if(minifat_store !== ENDOFCHAIN && o.start !== ENDOFCHAIN && sector_list[minifat_store]) {
+ o.content = get_mfat_entry(o, sector_list[minifat_store].data, (sector_list[mini]||{}).data);
+ }
+ }
+ if(o.content) prep_blob(o.content, 0);
+ files[name] = o;
+ FileIndex.push(o);
+ }
+}
+
+function read_date(blob, offset) {
+ return new Date(( ( (__readUInt32LE(blob,offset+4)/1e7)*Math.pow(2,32)+__readUInt32LE(blob,offset)/1e7 ) - 11644473600)*1000);
+}
+
+function read_file(filename, options) {
+ get_fs();
+ return parse(fs.readFileSync(filename), options);
+}
+
+function read(blob, options) {
+ var type = options && options.type;
+ if(!type) {
+ if(has_buf && Buffer.isBuffer(blob)) type = "buffer";
+ }
+ switch(type || "base64") {
+ case "file": return read_file(blob, options);
+ case "base64": return parse(s2a(Base64_decode(blob)), options);
+ case "binary": return parse(s2a(blob), options);
+ }
+ return parse(blob, options);
+}
+
+function init_cfb(cfb, opts) {
+ var o = opts || {}, root = o.root || "Root Entry";
+ if(!cfb.FullPaths) cfb.FullPaths = [];
+ if(!cfb.FileIndex) cfb.FileIndex = [];
+ if(cfb.FullPaths.length !== cfb.FileIndex.length) throw new Error("inconsistent CFB structure");
+ if(cfb.FullPaths.length === 0) {
+ cfb.FullPaths[0] = root + "/";
+ cfb.FileIndex[0] = ({ name: root, type: 5 });
+ }
+ if(o.CLSID) cfb.FileIndex[0].clsid = o.CLSID;
+ seed_cfb(cfb);
+}
+function seed_cfb(cfb) {
+ var nm = "\u0001Sh33tJ5";
+ if(CFB.find(cfb, "/" + nm)) return;
+ var p = new_buf(4); p[0] = 55; p[1] = p[3] = 50; p[2] = 54;
+ cfb.FileIndex.push(({ name: nm, type: 2, content:p, size:4, L:69, R:69, C:69 }));
+ cfb.FullPaths.push(cfb.FullPaths[0] + nm);
+ rebuild_cfb(cfb);
+}
+function rebuild_cfb(cfb, f) {
+ init_cfb(cfb);
+ var gc = false, s = false;
+ for(var i = cfb.FullPaths.length - 1; i >= 0; --i) {
+ var _file = cfb.FileIndex[i];
+ switch(_file.type) {
+ case 0:
+ if(s) gc = true;
+ else { cfb.FileIndex.pop(); cfb.FullPaths.pop(); }
+ break;
+ case 1: case 2: case 5:
+ s = true;
+ if(isNaN(_file.R * _file.L * _file.C)) gc = true;
+ if(_file.R > -1 && _file.L > -1 && _file.R == _file.L) gc = true;
+ break;
+ default: gc = true; break;
+ }
+ }
+ if(!gc && !f) return;
+
+ var now = new Date(1987, 1, 19), j = 0;
+ // Track which names exist
+ var fullPaths = Object.create ? Object.create(null) : {};
+ var data = [];
+ for(i = 0; i < cfb.FullPaths.length; ++i) {
+ fullPaths[cfb.FullPaths[i]] = true;
+ if(cfb.FileIndex[i].type === 0) continue;
+ data.push([cfb.FullPaths[i], cfb.FileIndex[i]]);
+ }
+ for(i = 0; i < data.length; ++i) {
+ var dad = dirname(data[i][0]);
+ s = fullPaths[dad];
+ if(!s) {
+ data.push([dad, ({
+ name: filename(dad).replace("/",""),
+ type: 1,
+ clsid: HEADER_CLSID,
+ ct: now, mt: now,
+ content: null
+ })]);
+ // Add name to set
+ fullPaths[dad] = true;
+ }
+ }
+
+ data.sort(function(x,y) { return namecmp(x[0], y[0]); });
+ cfb.FullPaths = []; cfb.FileIndex = [];
+ for(i = 0; i < data.length; ++i) { cfb.FullPaths[i] = data[i][0]; cfb.FileIndex[i] = data[i][1]; }
+ for(i = 0; i < data.length; ++i) {
+ var elt = cfb.FileIndex[i];
+ var nm = cfb.FullPaths[i];
+
+ elt.name = filename(nm).replace("/","");
+ elt.L = elt.R = elt.C = -(elt.color = 1);
+ elt.size = elt.content ? elt.content.length : 0;
+ elt.start = 0;
+ elt.clsid = (elt.clsid || HEADER_CLSID);
+ if(i === 0) {
+ elt.C = data.length > 1 ? 1 : -1;
+ elt.size = 0;
+ elt.type = 5;
+ } else if(nm.slice(-1) == "/") {
+ for(j=i+1;j < data.length; ++j) if(dirname(cfb.FullPaths[j])==nm) break;
+ elt.C = j >= data.length ? -1 : j;
+ for(j=i+1;j < data.length; ++j) if(dirname(cfb.FullPaths[j])==dirname(nm)) break;
+ elt.R = j >= data.length ? -1 : j;
+ elt.type = 1;
+ } else {
+ if(dirname(cfb.FullPaths[i+1]||"") == dirname(nm)) elt.R = i + 1;
+ elt.type = 2;
+ }
+ }
+
+}
+
+function _write(cfb, options) {
+ var _opts = options || {};
+ /* MAD is order-sensitive, skip rebuild and sort */
+ if(_opts.fileType == 'mad') return write_mad(cfb, _opts);
+ rebuild_cfb(cfb);
+ switch(_opts.fileType) {
+ case 'zip': return write_zip(cfb, _opts);
+ //case 'mad': return write_mad(cfb, _opts);
+ }
+ var L = (function(cfb){
+ var mini_size = 0, fat_size = 0;
+ for(var i = 0; i < cfb.FileIndex.length; ++i) {
+ var file = cfb.FileIndex[i];
+ if(!file.content) continue;
+var flen = file.content.length;
+ if(flen > 0){
+ if(flen < 0x1000) mini_size += (flen + 0x3F) >> 6;
+ else fat_size += (flen + 0x01FF) >> 9;
+ }
+ }
+ var dir_cnt = (cfb.FullPaths.length +3) >> 2;
+ var mini_cnt = (mini_size + 7) >> 3;
+ var mfat_cnt = (mini_size + 0x7F) >> 7;
+ var fat_base = mini_cnt + fat_size + dir_cnt + mfat_cnt;
+ var fat_cnt = (fat_base + 0x7F) >> 7;
+ var difat_cnt = fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt-109)/0x7F);
+ while(((fat_base + fat_cnt + difat_cnt + 0x7F) >> 7) > fat_cnt) difat_cnt = ++fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt-109)/0x7F);
+ var L = [1, difat_cnt, fat_cnt, mfat_cnt, dir_cnt, fat_size, mini_size, 0];
+ cfb.FileIndex[0].size = mini_size << 6;
+ L[7] = (cfb.FileIndex[0].start=L[0]+L[1]+L[2]+L[3]+L[4]+L[5])+((L[6]+7) >> 3);
+ return L;
+ })(cfb);
+ var o = new_buf(L[7] << 9);
+ var i = 0, T = 0;
+ {
+ for(i = 0; i < 8; ++i) o.write_shift(1, HEADER_SIG[i]);
+ for(i = 0; i < 8; ++i) o.write_shift(2, 0);
+ o.write_shift(2, 0x003E);
+ o.write_shift(2, 0x0003);
+ o.write_shift(2, 0xFFFE);
+ o.write_shift(2, 0x0009);
+ o.write_shift(2, 0x0006);
+ for(i = 0; i < 3; ++i) o.write_shift(2, 0);
+ o.write_shift(4, 0);
+ o.write_shift(4, L[2]);
+ o.write_shift(4, L[0] + L[1] + L[2] + L[3] - 1);
+ o.write_shift(4, 0);
+ o.write_shift(4, 1<<12);
+ o.write_shift(4, L[3] ? L[0] + L[1] + L[2] - 1: ENDOFCHAIN);
+ o.write_shift(4, L[3]);
+ o.write_shift(-4, L[1] ? L[0] - 1: ENDOFCHAIN);
+ o.write_shift(4, L[1]);
+ for(i = 0; i < 109; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
+ }
+ if(L[1]) {
+ for(T = 0; T < L[1]; ++T) {
+ for(; i < 236 + T * 127; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
+ o.write_shift(-4, T === L[1] - 1 ? ENDOFCHAIN : T + 1);
+ }
+ }
+ var chainit = function(w) {
+ for(T += w; i> 9);
+ }
+ chainit((L[6] + 7) >> 3);
+ while(o.l & 0x1FF) o.write_shift(-4, consts.ENDOFCHAIN);
+ T = i = 0;
+ for(j = 0; j < cfb.FileIndex.length; ++j) {
+ file = cfb.FileIndex[j];
+ if(!file.content) continue;
+flen = file.content.length;
+ if(!flen || flen >= 0x1000) continue;
+ file.start = T;
+ chainit((flen + 0x3F) >> 6);
+ }
+ while(o.l & 0x1FF) o.write_shift(-4, consts.ENDOFCHAIN);
+ for(i = 0; i < L[4]<<2; ++i) {
+ var nm = cfb.FullPaths[i];
+ if(!nm || nm.length === 0) {
+ for(j = 0; j < 17; ++j) o.write_shift(4, 0);
+ for(j = 0; j < 3; ++j) o.write_shift(4, -1);
+ for(j = 0; j < 12; ++j) o.write_shift(4, 0);
+ continue;
+ }
+ file = cfb.FileIndex[i];
+ if(i === 0) file.start = file.size ? file.start - 1 : ENDOFCHAIN;
+ var _nm = (i === 0 && _opts.root) || file.name;
+ flen = 2*(_nm.length+1);
+ o.write_shift(64, _nm, "utf16le");
+ o.write_shift(2, flen);
+ o.write_shift(1, file.type);
+ o.write_shift(1, file.color);
+ o.write_shift(-4, file.L);
+ o.write_shift(-4, file.R);
+ o.write_shift(-4, file.C);
+ if(!file.clsid) for(j = 0; j < 4; ++j) o.write_shift(4, 0);
+ else o.write_shift(16, file.clsid, "hex");
+ o.write_shift(4, file.state || 0);
+ o.write_shift(4, 0); o.write_shift(4, 0);
+ o.write_shift(4, 0); o.write_shift(4, 0);
+ o.write_shift(4, file.start);
+ o.write_shift(4, file.size); o.write_shift(4, 0);
+ }
+ for(i = 1; i < cfb.FileIndex.length; ++i) {
+ file = cfb.FileIndex[i];
+if(file.size >= 0x1000) {
+ o.l = (file.start+1) << 9;
+ if (has_buf && Buffer.isBuffer(file.content)) {
+ file.content.copy(o, o.l, 0, file.size);
+ // o is a 0-filled Buffer so just set next offset
+ o.l += (file.size + 511) & -512;
+ } else {
+ for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+ for(; j & 0x1FF; ++j) o.write_shift(1, 0);
+ }
+ }
+ }
+ for(i = 1; i < cfb.FileIndex.length; ++i) {
+ file = cfb.FileIndex[i];
+if(file.size > 0 && file.size < 0x1000) {
+ if (has_buf && Buffer.isBuffer(file.content)) {
+ file.content.copy(o, o.l, 0, file.size);
+ // o is a 0-filled Buffer so just set next offset
+ o.l += (file.size + 63) & -64;
+ } else {
+ for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+ for(; j & 0x3F; ++j) o.write_shift(1, 0);
+ }
+ }
+ }
+ if (has_buf) {
+ o.l = o.length;
+ } else {
+ // When using Buffer, already 0-filled
+ while(o.l < o.length) o.write_shift(1, 0);
+ }
+ return o;
+}
+/* [MS-CFB] 2.6.4 (Unicode 3.0.1 case conversion) */
+function find(cfb, path) {
+ var UCFullPaths = cfb.FullPaths.map(function(x) { return x.toUpperCase(); });
+ var UCPaths = UCFullPaths.map(function(x) { var y = x.split("/"); return y[y.length - (x.slice(-1) == "/" ? 2 : 1)]; });
+ var k = false;
+ if(path.charCodeAt(0) === 47 /* "/" */) { k = true; path = UCFullPaths[0].slice(0, -1) + path; }
+ else k = path.indexOf("/") !== -1;
+ var UCPath = path.toUpperCase();
+ var w = k === true ? UCFullPaths.indexOf(UCPath) : UCPaths.indexOf(UCPath);
+ if(w !== -1) return cfb.FileIndex[w];
+
+ var m = !UCPath.match(chr1);
+ UCPath = UCPath.replace(chr0,'');
+ if(m) UCPath = UCPath.replace(chr1,'!');
+ for(w = 0; w < UCFullPaths.length; ++w) {
+ if((m ? UCFullPaths[w].replace(chr1,'!') : UCFullPaths[w]).replace(chr0,'') == UCPath) return cfb.FileIndex[w];
+ if((m ? UCPaths[w].replace(chr1,'!') : UCPaths[w]).replace(chr0,'') == UCPath) return cfb.FileIndex[w];
+ }
+ return null;
+}
+/** CFB Constants */
+var MSSZ = 64; /* Mini Sector Size = 1<<6 */
+//var MSCSZ = 4096; /* Mini Stream Cutoff Size */
+/* 2.1 Compound File Sector Numbers and Types */
+var ENDOFCHAIN = -2;
+/* 2.2 Compound File Header */
+var HEADER_SIGNATURE = 'd0cf11e0a1b11ae1';
+var HEADER_SIG = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+var HEADER_CLSID = '00000000000000000000000000000000';
+var consts = {
+ /* 2.1 Compund File Sector Numbers and Types */
+ MAXREGSECT: -6,
+ DIFSECT: -4,
+ FATSECT: -3,
+ ENDOFCHAIN: ENDOFCHAIN,
+ FREESECT: -1,
+ /* 2.2 Compound File Header */
+ HEADER_SIGNATURE: HEADER_SIGNATURE,
+ HEADER_MINOR_VERSION: '3e00',
+ MAXREGSID: -6,
+ NOSTREAM: -1,
+ HEADER_CLSID: HEADER_CLSID,
+ /* 2.6.1 Compound File Directory Entry */
+ EntryTypes: ['unknown','storage','stream','lockbytes','property','root']
+};
+
+function write_file(cfb, filename, options) {
+ get_fs();
+ var o = _write(cfb, options);
+fs.writeFileSync(filename, o);
+}
+
+function a2s(o) {
+ var out = new Array(o.length);
+ for(var i = 0; i < o.length; ++i) out[i] = String.fromCharCode(o[i]);
+ return out.join("");
+}
+
+function write(cfb, options) {
+ var o = _write(cfb, options);
+ switch(options && options.type || "buffer") {
+ case "file": get_fs(); fs.writeFileSync(options.filename, (o)); return o;
+ case "binary": return typeof o == "string" ? o : a2s(o);
+ case "base64": return Base64_encode(typeof o == "string" ? o : a2s(o));
+ case "buffer": if(has_buf) return Buffer.isBuffer(o) ? o : Buffer_from(o);
+ /* falls through */
+ case "array": return typeof o == "string" ? s2a(o) : o;
+ }
+ return o;
+}
+/* node < 8.1 zlib does not expose bytesRead, so default to pure JS */
+var _zlib;
+function use_zlib(zlib) { try {
+ var InflateRaw = zlib.InflateRaw;
+ var InflRaw = new InflateRaw();
+ InflRaw._processChunk(new Uint8Array([3, 0]), InflRaw._finishFlushFlag);
+ if(InflRaw.bytesRead) _zlib = zlib;
+ else throw new Error("zlib does not expose bytesRead");
+} catch(e) {console.error("cannot use native zlib: " + (e.message || e)); } }
+
+function _inflateRawSync(payload, usz) {
+ if(!_zlib) return _inflate(payload, usz);
+ var InflateRaw = _zlib.InflateRaw;
+ var InflRaw = new InflateRaw();
+ var out = InflRaw._processChunk(payload.slice(payload.l), InflRaw._finishFlushFlag);
+ payload.l += InflRaw.bytesRead;
+ return out;
+}
+
+function _deflateRawSync(payload) {
+ return _zlib ? _zlib.deflateRawSync(payload) : _deflate(payload);
+}
+var CLEN_ORDER = [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
+
+/* LEN_ID = [ 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285 ]; */
+var LEN_LN = [ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13 , 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258 ];
+
+/* DST_ID = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 ]; */
+var DST_LN = [ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 ];
+
+function bit_swap_8(n) { var t = (((((n<<1)|(n<<11)) & 0x22110) | (((n<<5)|(n<<15)) & 0x88440))); return ((t>>16) | (t>>8) |t)&0xFF; }
+
+var use_typed_arrays = typeof Uint8Array !== 'undefined';
+
+var bitswap8 = use_typed_arrays ? new Uint8Array(1<<8) : [];
+for(var q = 0; q < (1<<8); ++q) bitswap8[q] = bit_swap_8(q);
+
+function bit_swap_n(n, b) {
+ var rev = bitswap8[n & 0xFF];
+ if(b <= 8) return rev >>> (8-b);
+ rev = (rev << 8) | bitswap8[(n>>8)&0xFF];
+ if(b <= 16) return rev >>> (16-b);
+ rev = (rev << 8) | bitswap8[(n>>16)&0xFF];
+ return rev >>> (24-b);
+}
+
+/* helpers for unaligned bit reads */
+function read_bits_2(buf, bl) { var w = (bl&7), h = (bl>>>3); return ((buf[h]|(w <= 6 ? 0 : buf[h+1]<<8))>>>w)& 0x03; }
+function read_bits_3(buf, bl) { var w = (bl&7), h = (bl>>>3); return ((buf[h]|(w <= 5 ? 0 : buf[h+1]<<8))>>>w)& 0x07; }
+function read_bits_4(buf, bl) { var w = (bl&7), h = (bl>>>3); return ((buf[h]|(w <= 4 ? 0 : buf[h+1]<<8))>>>w)& 0x0F; }
+function read_bits_5(buf, bl) { var w = (bl&7), h = (bl>>>3); return ((buf[h]|(w <= 3 ? 0 : buf[h+1]<<8))>>>w)& 0x1F; }
+function read_bits_7(buf, bl) { var w = (bl&7), h = (bl>>>3); return ((buf[h]|(w <= 1 ? 0 : buf[h+1]<<8))>>>w)& 0x7F; }
+
+/* works up to n = 3 * 8 + 1 = 25 */
+function read_bits_n(buf, bl, n) {
+ var w = (bl&7), h = (bl>>>3), f = ((1<>> w;
+ if(n < 8 - w) return v & f;
+ v |= buf[h+1]<<(8-w);
+ if(n < 16 - w) return v & f;
+ v |= buf[h+2]<<(16-w);
+ if(n < 24 - w) return v & f;
+ v |= buf[h+3]<<(24-w);
+ return v & f;
+}
+
+/* helpers for unaligned bit writes */
+function write_bits_3(buf, bl, v) { var w = bl & 7, h = bl >>> 3;
+ if(w <= 5) buf[h] |= (v & 7) << w;
+ else {
+ buf[h] |= (v << w) & 0xFF;
+ buf[h+1] = (v&7) >> (8-w);
+ }
+ return bl + 3;
+}
+
+function write_bits_1(buf, bl, v) {
+ var w = bl & 7, h = bl >>> 3;
+ v = (v&1) << w;
+ buf[h] |= v;
+ return bl + 1;
+}
+function write_bits_8(buf, bl, v) {
+ var w = bl & 7, h = bl >>> 3;
+ v <<= w;
+ buf[h] |= v & 0xFF; v >>>= 8;
+ buf[h+1] = v;
+ return bl + 8;
+}
+function write_bits_16(buf, bl, v) {
+ var w = bl & 7, h = bl >>> 3;
+ v <<= w;
+ buf[h] |= v & 0xFF; v >>>= 8;
+ buf[h+1] = v & 0xFF;
+ buf[h+2] = v >>> 8;
+ return bl + 16;
+}
+
+/* until ArrayBuffer#realloc is a thing, fake a realloc */
+function realloc(b, sz) {
+ var L = b.length, M = 2*L > sz ? 2*L : sz + 5, i = 0;
+ if(L >= sz) return b;
+ if(has_buf) {
+ var o = new_unsafe_buf(M);
+ // $FlowIgnore
+ if(b.copy) b.copy(o);
+ else for(; i < b.length; ++i) o[i] = b[i];
+ return o;
+ } else if(use_typed_arrays) {
+ var a = new Uint8Array(M);
+ if(a.set) a.set(b);
+ else for(; i < L; ++i) a[i] = b[i];
+ return a;
+ }
+ b.length = M;
+ return b;
+}
+
+/* zero-filled arrays for older browsers */
+function zero_fill_array(n) {
+ var o = new Array(n);
+ for(var i = 0; i < n; ++i) o[i] = 0;
+ return o;
+}
+
+/* build tree (used for literals and lengths) */
+function build_tree(clens, cmap, MAX) {
+ var maxlen = 1, w = 0, i = 0, j = 0, ccode = 0, L = clens.length;
+
+ var bl_count = use_typed_arrays ? new Uint16Array(32) : zero_fill_array(32);
+ for(i = 0; i < 32; ++i) bl_count[i] = 0;
+
+ for(i = L; i < MAX; ++i) clens[i] = 0;
+ L = clens.length;
+
+ var ctree = use_typed_arrays ? new Uint16Array(L) : zero_fill_array(L); // []
+
+ /* build code tree */
+ for(i = 0; i < L; ++i) {
+ bl_count[(w = clens[i])]++;
+ if(maxlen < w) maxlen = w;
+ ctree[i] = 0;
+ }
+ bl_count[0] = 0;
+ for(i = 1; i <= maxlen; ++i) bl_count[i+16] = (ccode = (ccode + bl_count[i-1])<<1);
+ for(i = 0; i < L; ++i) {
+ ccode = clens[i];
+ if(ccode != 0) ctree[i] = bl_count[ccode+16]++;
+ }
+
+ /* cmap[maxlen + 4 bits] = (off&15) + (lit<<4) reverse mapping */
+ var cleni = 0;
+ for(i = 0; i < L; ++i) {
+ cleni = clens[i];
+ if(cleni != 0) {
+ ccode = bit_swap_n(ctree[i], maxlen)>>(maxlen-cleni);
+ for(j = (1<<(maxlen + 4 - cleni)) - 1; j>=0; --j)
+ cmap[ccode|(j< 0) out[out.l++] = data[boff++];
+ }
+ return out.l;
+ }
+
+ /* Fixed Huffman */
+ function write_huff_fixed(data, out) {
+ var bl = 0;
+ var boff = 0;
+ var addrs = use_typed_arrays ? new Uint16Array(0x8000) : [];
+ while(boff < data.length) {
+ var L = /* data.length - boff; */ Math.min(0xFFFF, data.length - boff);
+
+ /* write a stored block for short data */
+ if(L < 10) {
+ bl = write_bits_3(out, bl, +!!(boff + L == data.length)); // jshint ignore:line
+ if(bl & 7) bl += 8 - (bl & 7);
+ out.l = (bl / 8) | 0;
+ out.write_shift(2, L);
+ out.write_shift(2, (~L) & 0xFFFF);
+ while(L-- > 0) out[out.l++] = data[boff++];
+ bl = out.l * 8;
+ continue;
+ }
+
+ bl = write_bits_3(out, bl, +!!(boff + L == data.length) + 2); // jshint ignore:line
+ var hash = 0;
+ while(L-- > 0) {
+ var d = data[boff];
+ hash = ((hash << 5) ^ d) & 0x7FFF;
+
+ var match = -1, mlen = 0;
+
+ if((match = addrs[hash])) {
+ match |= boff & ~0x7FFF;
+ if(match > boff) match -= 0x8000;
+ if(match < boff) while(data[match + mlen] == data[boff + mlen] && mlen < 250) ++mlen;
+ }
+
+ if(mlen > 2) {
+ /* Copy Token */
+ d = LEN_LN_RE[mlen];
+ if(d <= 22) bl = write_bits_8(out, bl, bitswap8[d+1]>>1) - 1;
+ else {
+ write_bits_8(out, bl, 3);
+ bl += 5;
+ write_bits_8(out, bl, bitswap8[d-23]>>5);
+ bl += 3;
+ }
+ var len_eb = (d < 8) ? 0 : ((d - 4)>>2);
+ if(len_eb > 0) {
+ write_bits_16(out, bl, mlen - LEN_LN[d]);
+ bl += len_eb;
+ }
+
+ d = DST_LN_RE[boff - match];
+ bl = write_bits_8(out, bl, bitswap8[d]>>3);
+ bl -= 3;
+
+ var dst_eb = d < 4 ? 0 : (d-2)>>1;
+ if(dst_eb > 0) {
+ write_bits_16(out, bl, boff - match - DST_LN[d]);
+ bl += dst_eb;
+ }
+ for(var q = 0; q < mlen; ++q) {
+ addrs[hash] = boff & 0x7FFF;
+ hash = ((hash << 5) ^ data[boff]) & 0x7FFF;
+ ++boff;
+ }
+ L-= mlen - 1;
+ } else {
+ /* Literal Token */
+ if(d <= 143) d = d + 48;
+ else bl = write_bits_1(out, bl, 1);
+ bl = write_bits_8(out, bl, bitswap8[d]);
+ addrs[hash] = boff & 0x7FFF;
+ ++boff;
+ }
+ }
+
+ bl = write_bits_8(out, bl, 0) - 1;
+ }
+ out.l = ((bl + 7)/8)|0;
+ return out.l;
+ }
+ return function _deflateRaw(data, out) {
+ if(data.length < 8) return write_stored(data, out);
+ return write_huff_fixed(data, out);
+ };
+})();
+
+function _deflate(data) {
+ var buf = new_buf(50+Math.floor(data.length*1.1));
+ var off = _deflateRaw(data, buf);
+ return buf.slice(0, off);
+}
+/* modified inflate function also moves original read head */
+
+var dyn_lmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
+var dyn_dmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
+var dyn_cmap = use_typed_arrays ? new Uint16Array(128) : zero_fill_array(128);
+var dyn_len_1 = 1, dyn_len_2 = 1;
+
+/* 5.5.3 Expanding Huffman Codes */
+function dyn(data, boff) {
+ /* nomenclature from RFC1951 refers to bit values; these are offset by the implicit constant */
+ var _HLIT = read_bits_5(data, boff) + 257; boff += 5;
+ var _HDIST = read_bits_5(data, boff) + 1; boff += 5;
+ var _HCLEN = read_bits_4(data, boff) + 4; boff += 4;
+ var w = 0;
+
+ /* grab and store code lengths */
+ var clens = use_typed_arrays ? new Uint8Array(19) : zero_fill_array(19);
+ var ctree = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+ var maxlen = 1;
+ var bl_count = use_typed_arrays ? new Uint8Array(8) : zero_fill_array(8);
+ var next_code = use_typed_arrays ? new Uint8Array(8) : zero_fill_array(8);
+ var L = clens.length; /* 19 */
+ for(var i = 0; i < _HCLEN; ++i) {
+ clens[CLEN_ORDER[i]] = w = read_bits_3(data, boff);
+ if(maxlen < w) maxlen = w;
+ bl_count[w]++;
+ boff += 3;
+ }
+
+ /* build code tree */
+ var ccode = 0;
+ bl_count[0] = 0;
+ for(i = 1; i <= maxlen; ++i) next_code[i] = ccode = (ccode + bl_count[i-1])<<1;
+ for(i = 0; i < L; ++i) if((ccode = clens[i]) != 0) ctree[i] = next_code[ccode]++;
+ /* cmap[7 bits from stream] = (off&7) + (lit<<3) */
+ var cleni = 0;
+ for(i = 0; i < L; ++i) {
+ cleni = clens[i];
+ if(cleni != 0) {
+ ccode = bitswap8[ctree[i]]>>(8-cleni);
+ for(var j = (1<<(7-cleni))-1; j>=0; --j) dyn_cmap[ccode|(j<>>= 3)) {
+ case 16:
+ w = 3 + read_bits_2(data, boff); boff += 2;
+ ccode = hcodes[hcodes.length - 1];
+ while(w-- > 0) hcodes.push(ccode);
+ break;
+ case 17:
+ w = 3 + read_bits_3(data, boff); boff += 3;
+ while(w-- > 0) hcodes.push(0);
+ break;
+ case 18:
+ w = 11 + read_bits_7(data, boff); boff += 7;
+ while(w -- > 0) hcodes.push(0);
+ break;
+ default:
+ hcodes.push(ccode);
+ if(maxlen < ccode) maxlen = ccode;
+ break;
+ }
+ }
+
+ /* build literal / length trees */
+ var h1 = hcodes.slice(0, _HLIT), h2 = hcodes.slice(_HLIT);
+ for(i = _HLIT; i < 286; ++i) h1[i] = 0;
+ for(i = _HDIST; i < 30; ++i) h2[i] = 0;
+ dyn_len_1 = build_tree(h1, dyn_lmap, 286);
+ dyn_len_2 = build_tree(h2, dyn_dmap, 30);
+ return boff;
+}
+
+/* return [ data, bytesRead ] */
+function inflate(data, usz) {
+ /* shortcircuit for empty buffer [0x03, 0x00] */
+ if(data[0] == 3 && !(data[1] & 0x3)) { return [new_raw_buf(usz), 2]; }
+
+ /* bit offset */
+ var boff = 0;
+
+ /* header includes final bit and type bits */
+ var header = 0;
+
+ var outbuf = new_unsafe_buf(usz ? usz : (1<<18));
+ var woff = 0;
+ var OL = outbuf.length>>>0;
+ var max_len_1 = 0, max_len_2 = 0;
+
+ while((header&1) == 0) {
+ header = read_bits_3(data, boff); boff += 3;
+ if((header >>> 1) == 0) {
+ /* Stored block */
+ if(boff & 7) boff += 8 - (boff&7);
+ /* 2 bytes sz, 2 bytes bit inverse */
+ var sz = data[boff>>>3] | data[(boff>>>3)+1]<<8;
+ boff += 32;
+ /* push sz bytes */
+ if(sz > 0) {
+ if(!usz && OL < woff + sz) { outbuf = realloc(outbuf, woff + sz); OL = outbuf.length; }
+ while(sz-- > 0) { outbuf[woff++] = data[boff>>>3]; boff += 8; }
+ }
+ continue;
+ } else if((header >> 1) == 1) {
+ /* Fixed Huffman */
+ max_len_1 = 9; max_len_2 = 5;
+ } else {
+ /* Dynamic Huffman */
+ boff = dyn(data, boff);
+ max_len_1 = dyn_len_1; max_len_2 = dyn_len_2;
+ }
+ for(;;) { // while(true) is apparently out of vogue in modern JS circles
+ if(!usz && (OL < woff + 32767)) { outbuf = realloc(outbuf, woff + 32767); OL = outbuf.length; }
+ /* ingest code and move read head */
+ var bits = read_bits_n(data, boff, max_len_1);
+ var code = (header>>>1) == 1 ? fix_lmap[bits] : dyn_lmap[bits];
+ boff += code & 15; code >>>= 4;
+ /* 0-255 are literals, 256 is end of block token, 257+ are copy tokens */
+ if(((code>>>8)&0xFF) === 0) outbuf[woff++] = code;
+ else if(code == 256) break;
+ else {
+ code -= 257;
+ var len_eb = (code < 8) ? 0 : ((code-4)>>2); if(len_eb > 5) len_eb = 0;
+ var tgt = woff + LEN_LN[code];
+ /* length extra bits */
+ if(len_eb > 0) {
+ tgt += read_bits_n(data, boff, len_eb);
+ boff += len_eb;
+ }
+
+ /* dist code */
+ bits = read_bits_n(data, boff, max_len_2);
+ code = (header>>>1) == 1 ? fix_dmap[bits] : dyn_dmap[bits];
+ boff += code & 15; code >>>= 4;
+ var dst_eb = (code < 4 ? 0 : (code-2)>>1);
+ var dst = DST_LN[code];
+ /* dist extra bits */
+ if(dst_eb > 0) {
+ dst += read_bits_n(data, boff, dst_eb);
+ boff += dst_eb;
+ }
+
+ /* in the common case, manual byte copy is faster than TA set / Buffer copy */
+ if(!usz && OL < tgt) { outbuf = realloc(outbuf, tgt + 100); OL = outbuf.length; }
+ while(woff < tgt) { outbuf[woff] = outbuf[woff - dst]; ++woff; }
+ }
+ }
+ }
+ if(usz) return [outbuf, (boff+7)>>>3];
+ return [outbuf.slice(0, woff), (boff+7)>>>3];
+}
+
+function _inflate(payload, usz) {
+ var data = payload.slice(payload.l||0);
+ var out = inflate(data, usz);
+ payload.l += out[1];
+ return out[0];
+}
+
+function warn_or_throw(wrn, msg) {
+ if(wrn) { if(typeof console !== 'undefined') console.error(msg); }
+ else throw new Error(msg);
+}
+
+function parse_zip(file, options) {
+ var blob = file;
+ prep_blob(blob, 0);
+
+ var FileIndex = [], FullPaths = [];
+ var o = {
+ FileIndex: FileIndex,
+ FullPaths: FullPaths
+ };
+ init_cfb(o, { root: options.root });
+
+ /* find end of central directory, start just after signature */
+ var i = blob.length - 4;
+ while((blob[i] != 0x50 || blob[i+1] != 0x4b || blob[i+2] != 0x05 || blob[i+3] != 0x06) && i >= 0) --i;
+ blob.l = i + 4;
+
+ /* parse end of central directory */
+ blob.l += 4;
+ var fcnt = blob.read_shift(2);
+ blob.l += 6;
+ var start_cd = blob.read_shift(4);
+
+ /* parse central directory */
+ blob.l = start_cd;
+
+ for(i = 0; i < fcnt; ++i) {
+ /* trust local file header instead of CD entry */
+ blob.l += 20;
+ var csz = blob.read_shift(4);
+ var usz = blob.read_shift(4);
+ var namelen = blob.read_shift(2);
+ var efsz = blob.read_shift(2);
+ var fcsz = blob.read_shift(2);
+ blob.l += 8;
+ var offset = blob.read_shift(4);
+ var EF = parse_extra_field(blob.slice(blob.l+namelen, blob.l+namelen+efsz));
+ blob.l += namelen + efsz + fcsz;
+
+ var L = blob.l;
+ blob.l = offset + 4;
+ parse_local_file(blob, csz, usz, o, EF);
+ blob.l = L;
+ }
+ return o;
+}
+
+
+/* head starts just after local file header signature */
+function parse_local_file(blob, csz, usz, o, EF) {
+ /* [local file header] */
+ blob.l += 2;
+ var flags = blob.read_shift(2);
+ var meth = blob.read_shift(2);
+ var date = parse_dos_date(blob);
+
+ if(flags & 0x2041) throw new Error("Unsupported ZIP encryption");
+ var crc32 = blob.read_shift(4);
+ var _csz = blob.read_shift(4);
+ var _usz = blob.read_shift(4);
+
+ var namelen = blob.read_shift(2);
+ var efsz = blob.read_shift(2);
+
+ // TODO: flags & (1<<11) // UTF8
+ var name = ""; for(var i = 0; i < namelen; ++i) name += String.fromCharCode(blob[blob.l++]);
+ if(efsz) {
+ var ef = parse_extra_field(blob.slice(blob.l, blob.l + efsz));
+ if((ef[0x5455]||{}).mt) date = ef[0x5455].mt;
+ if(((EF||{})[0x5455]||{}).mt) date = EF[0x5455].mt;
+ }
+ blob.l += efsz;
+
+ /* [encryption header] */
+
+ /* [file data] */
+ var data = blob.slice(blob.l, blob.l + _csz);
+ switch(meth) {
+ case 8: data = _inflateRawSync(blob, _usz); break;
+ case 0: break; // TODO: scan for magic number
+ default: throw new Error("Unsupported ZIP Compression method " + meth);
+ }
+
+ /* [data descriptor] */
+ var wrn = false;
+ if(flags & 8) {
+ crc32 = blob.read_shift(4);
+ if(crc32 == 0x08074b50) { crc32 = blob.read_shift(4); wrn = true; }
+ _csz = blob.read_shift(4);
+ _usz = blob.read_shift(4);
+ }
+
+ if(_csz != csz) warn_or_throw(wrn, "Bad compressed size: " + csz + " != " + _csz);
+ if(_usz != usz) warn_or_throw(wrn, "Bad uncompressed size: " + usz + " != " + _usz);
+ //var _crc32 = CRC32.buf(data, 0);
+ //if((crc32>>0) != (_crc32>>0)) warn_or_throw(wrn, "Bad CRC32 checksum: " + crc32 + " != " + _crc32);
+ cfb_add(o, name, data, {unsafe: true, mt: date});
+}
+function write_zip(cfb, options) {
+ var _opts = options || {};
+ var out = [], cdirs = [];
+ var o = new_buf(1);
+ var method = (_opts.compression ? 8 : 0), flags = 0;
+ var desc = false;
+ if(desc) flags |= 8;
+ var i = 0, j = 0;
+
+ var start_cd = 0, fcnt = 0;
+ var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+ var crcs = [];
+ var sz_cd = 0;
+
+ for(i = 1; i < cfb.FullPaths.length; ++i) {
+ fp = cfb.FullPaths[i].slice(root.length); fi = cfb.FileIndex[i];
+ if(!fi.size || !fi.content || fp == "\u0001Sh33tJ5") continue;
+ var start = start_cd;
+
+ /* TODO: CP437 filename */
+ var namebuf = new_buf(fp.length);
+ for(j = 0; j < fp.length; ++j) namebuf.write_shift(1, fp.charCodeAt(j) & 0x7F);
+ namebuf = namebuf.slice(0, namebuf.l);
+ crcs[fcnt] = CRC32.buf(fi.content, 0);
+
+ var outbuf = fi.content;
+ if(method == 8) outbuf = _deflateRawSync(outbuf);
+
+ /* local file header */
+ o = new_buf(30);
+ o.write_shift(4, 0x04034b50);
+ o.write_shift(2, 20);
+ o.write_shift(2, flags);
+ o.write_shift(2, method);
+ /* TODO: last mod file time/date */
+ if(fi.mt) write_dos_date(o, fi.mt);
+ else o.write_shift(4, 0);
+ o.write_shift(-4, (flags & 8) ? 0 : crcs[fcnt]);
+ o.write_shift(4, (flags & 8) ? 0 : outbuf.length);
+ o.write_shift(4, (flags & 8) ? 0 : fi.content.length);
+ o.write_shift(2, namebuf.length);
+ o.write_shift(2, 0);
+
+ start_cd += o.length;
+ out.push(o);
+ start_cd += namebuf.length;
+ out.push(namebuf);
+
+ /* TODO: extra fields? */
+
+ /* TODO: encryption header ? */
+
+ start_cd += outbuf.length;
+ out.push(outbuf);
+
+ /* data descriptor */
+ if(flags & 8) {
+ o = new_buf(12);
+ o.write_shift(-4, crcs[fcnt]);
+ o.write_shift(4, outbuf.length);
+ o.write_shift(4, fi.content.length);
+ start_cd += o.l;
+ out.push(o);
+ }
+
+ /* central directory */
+ o = new_buf(46);
+ o.write_shift(4, 0x02014b50);
+ o.write_shift(2, 0);
+ o.write_shift(2, 20);
+ o.write_shift(2, flags);
+ o.write_shift(2, method);
+ o.write_shift(4, 0); /* TODO: last mod file time/date */
+ o.write_shift(-4, crcs[fcnt]);
+
+ o.write_shift(4, outbuf.length);
+ o.write_shift(4, fi.content.length);
+ o.write_shift(2, namebuf.length);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(4, 0);
+ o.write_shift(4, start);
+
+ sz_cd += o.l;
+ cdirs.push(o);
+ sz_cd += namebuf.length;
+ cdirs.push(namebuf);
+ ++fcnt;
+ }
+
+ /* end of central directory */
+ o = new_buf(22);
+ o.write_shift(4, 0x06054b50);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(2, fcnt);
+ o.write_shift(2, fcnt);
+ o.write_shift(4, sz_cd);
+ o.write_shift(4, start_cd);
+ o.write_shift(2, 0);
+
+ return bconcat(([bconcat((out)), bconcat(cdirs), o]));
+}
+var ContentTypeMap = ({
+ "htm": "text/html",
+ "xml": "text/xml",
+
+ "gif": "image/gif",
+ "jpg": "image/jpeg",
+ "png": "image/png",
+
+ "mso": "application/x-mso",
+ "thmx": "application/vnd.ms-officetheme",
+ "sh33tj5": "application/octet-stream"
+});
+
+function get_content_type(fi, fp) {
+ if(fi.ctype) return fi.ctype;
+
+ var ext = fi.name || "", m = ext.match(/\.([^\.]+)$/);
+ if(m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+
+ if(fp) {
+ m = (ext = fp).match(/[\.\\]([^\.\\])+$/);
+ if(m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+ }
+
+ return "application/octet-stream";
+}
+
+/* 76 character chunks TODO: intertwine encoding */
+function write_base64_76(bstr) {
+ var data = Base64_encode(bstr);
+ var o = [];
+ for(var i = 0; i < data.length; i+= 76) o.push(data.slice(i, i+76));
+ return o.join("\r\n") + "\r\n";
+}
+
+/*
+Rules for QP:
+ - escape =## applies for all non-display characters and literal "="
+ - space or tab at end of line must be encoded
+ - \r\n newlines can be preserved, but bare \r and \n must be escaped
+ - lines must not exceed 76 characters, use soft breaks =\r\n
+
+TODO: Some files from word appear to write line extensions with bare equals:
+
+```
+ 0) {
+ root = root.slice(0, root.length - 1);
+ root = root.slice(0, root.lastIndexOf("/") + 1);
+ if(row.slice(0,root.length) == root) break;
+ }
+ }
+
+ var mboundary = (data[1] || "").match(/boundary="(.*?)"/);
+ if(!mboundary) throw new Error("MAD cannot find boundary");
+ var boundary = "--" + (mboundary[1] || "");
+
+ var FileIndex = [], FullPaths = [];
+ var o = {
+ FileIndex: FileIndex,
+ FullPaths: FullPaths
+ };
+ init_cfb(o);
+ var start_di, fcnt = 0;
+ for(di = 0; di < data.length; ++di) {
+ var line = data[di];
+ if(line !== boundary && line !== boundary + "--") continue;
+ if(fcnt++) parse_mime(o, data.slice(start_di, di), root);
+ start_di = di;
+ }
+ return o;
+}
+
+function write_mad(cfb, options) {
+ var opts = options || {};
+ var boundary = opts.boundary || "SheetJS";
+ boundary = '------=' + boundary;
+
+ var out = [
+ 'MIME-Version: 1.0',
+ 'Content-Type: multipart/related; boundary="' + boundary.slice(2) + '"',
+ '',
+ '',
+ ''
+ ];
+
+ var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+ for(var i = 1; i < cfb.FullPaths.length; ++i) {
+ fp = cfb.FullPaths[i].slice(root.length);
+ fi = cfb.FileIndex[i];
+ if(!fi.size || !fi.content || fp == "\u0001Sh33tJ5") continue;
+
+ /* Normalize filename */
+ fp = fp.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF]/g, function(c) {
+ return "_x" + c.charCodeAt(0).toString(16) + "_";
+ }).replace(/[\u0080-\uFFFF]/g, function(u) {
+ return "_u" + u.charCodeAt(0).toString(16) + "_";
+ });
+
+ /* Extract content as binary string */
+ var ca = fi.content;
+ // $FlowIgnore
+ var cstr = has_buf && Buffer.isBuffer(ca) ? ca.toString("binary") : a2s(ca);
+
+ /* 4/5 of first 1024 chars ascii -> quoted printable, else base64 */
+ var dispcnt = 0, L = Math.min(1024, cstr.length), cc = 0;
+ for(var csl = 0; csl <= L; ++csl) if((cc=cstr.charCodeAt(csl)) >= 0x20 && cc < 0x80) ++dispcnt;
+ var qp = dispcnt >= L * 4 / 5;
+
+ out.push(boundary);
+ out.push('Content-Location: ' + (opts.root || 'file:///C:/SheetJS/') + fp);
+ out.push('Content-Transfer-Encoding: ' + (qp ? 'quoted-printable' : 'base64'));
+ out.push('Content-Type: ' + get_content_type(fi, fp));
+ out.push('');
+
+ out.push(qp ? write_quoted_printable(cstr) : write_base64_76(cstr));
+ }
+ out.push(boundary + '--\r\n');
+ return out.join("\r\n");
+}
+function cfb_new(opts) {
+ var o = ({});
+ init_cfb(o, opts);
+ return o;
+}
+
+function cfb_add(cfb, name, content, opts) {
+ var unsafe = opts && opts.unsafe;
+ if(!unsafe) init_cfb(cfb);
+ var file = !unsafe && CFB.find(cfb, name);
+ if(!file) {
+ var fpath = cfb.FullPaths[0];
+ if(name.slice(0, fpath.length) == fpath) fpath = name;
+ else {
+ if(fpath.slice(-1) != "/") fpath += "/";
+ fpath = (fpath + name).replace("//","/");
+ }
+ file = ({name: filename(name), type: 2});
+ cfb.FileIndex.push(file);
+ cfb.FullPaths.push(fpath);
+ if(!unsafe) CFB.utils.cfb_gc(cfb);
+ }
+file.content = (content);
+ file.size = content ? content.length : 0;
+ if(opts) {
+ if(opts.CLSID) file.clsid = opts.CLSID;
+ if(opts.mt) file.mt = opts.mt;
+ if(opts.ct) file.ct = opts.ct;
+ }
+ return file;
+}
+
+function cfb_del(cfb, name) {
+ init_cfb(cfb);
+ var file = CFB.find(cfb, name);
+ if(file) for(var j = 0; j < cfb.FileIndex.length; ++j) if(cfb.FileIndex[j] == file) {
+ cfb.FileIndex.splice(j, 1);
+ cfb.FullPaths.splice(j, 1);
+ return true;
+ }
+ return false;
+}
+
+function cfb_mov(cfb, old_name, new_name) {
+ init_cfb(cfb);
+ var file = CFB.find(cfb, old_name);
+ if(file) for(var j = 0; j < cfb.FileIndex.length; ++j) if(cfb.FileIndex[j] == file) {
+ cfb.FileIndex[j].name = filename(new_name);
+ cfb.FullPaths[j] = new_name;
+ return true;
+ }
+ return false;
+}
+
+function cfb_gc(cfb) { rebuild_cfb(cfb, true); }
+
+exports.find = find;
+exports.read = read;
+exports.parse = parse;
+exports.write = write;
+exports.writeFile = write_file;
+exports.utils = {
+ cfb_new: cfb_new,
+ cfb_add: cfb_add,
+ cfb_del: cfb_del,
+ cfb_mov: cfb_mov,
+ cfb_gc: cfb_gc,
+ ReadShift: ReadShift,
+ CheckField: CheckField,
+ prep_blob: prep_blob,
+ bconcat: bconcat,
+ use_zlib: use_zlib,
+ _deflateRaw: _deflate,
+ _inflateRaw: _inflate,
+ consts: consts
+};
+
+return exports;
+})();
+
+var _fs;
+if(typeof require !== 'undefined') try { _fs = require('fs'); } catch(e) {}
+
+/* normalize data for blob ctor */
+function blobify(data) {
+ if(typeof data === "string") return s2ab(data);
+ if(Array.isArray(data)) return a2u(data);
+ return data;
+}
+/* write or download file */
+function write_dl(fname, payload, enc) {
+ /*global IE_SaveFile, Blob, navigator, saveAs, document, File, chrome */
+ if(typeof _fs !== 'undefined' && _fs.writeFileSync) return enc ? _fs.writeFileSync(fname, payload, enc) : _fs.writeFileSync(fname, payload);
+ if(typeof Deno !== 'undefined') {
+ /* in this spot, it's safe to assume typed arrays and TextEncoder/TextDecoder exist */
+ if(enc && typeof payload == "string") switch(enc) {
+ case "utf8": payload = new TextEncoder(enc).encode(payload); break;
+ case "binary": payload = s2ab(payload); break;
+ /* TODO: binary equivalent */
+ default: throw new Error("Unsupported encoding " + enc);
+ }
+ return Deno.writeFileSync(fname, payload);
+ }
+ var data = (enc == "utf8") ? utf8write(payload) : payload;
+if(typeof IE_SaveFile !== 'undefined') return IE_SaveFile(data, fname);
+ if(typeof Blob !== 'undefined') {
+ var blob = new Blob([blobify(data)], {type:"application/octet-stream"});
+if(typeof navigator !== 'undefined' && navigator.msSaveBlob) return navigator.msSaveBlob(blob, fname);
+if(typeof saveAs !== 'undefined') return saveAs(blob, fname);
+ if(typeof URL !== 'undefined' && typeof document !== 'undefined' && document.createElement && URL.createObjectURL) {
+ var url = URL.createObjectURL(blob);
+if(typeof chrome === 'object' && typeof (chrome.downloads||{}).download == "function") {
+ if(URL.revokeObjectURL && typeof setTimeout !== 'undefined') setTimeout(function() { URL.revokeObjectURL(url); }, 60000);
+ return chrome.downloads.download({ url: url, filename: fname, saveAs: true});
+ }
+ var a = document.createElement("a");
+ if(a.download != null) {
+a.download = fname; a.href = url; document.body.appendChild(a); a.click();
+document.body.removeChild(a);
+ if(URL.revokeObjectURL && typeof setTimeout !== 'undefined') setTimeout(function() { URL.revokeObjectURL(url); }, 60000);
+ return url;
+ }
+ }
+ }
+ // $FlowIgnore
+ if(typeof $ !== 'undefined' && typeof File !== 'undefined' && typeof Folder !== 'undefined') try { // extendscript
+ // $FlowIgnore
+ var out = File(fname); out.open("w"); out.encoding = "binary";
+ if(Array.isArray(payload)) payload = a2s(payload);
+ out.write(payload); out.close(); return payload;
+ } catch(e) { if(!e.message || !e.message.match(/onstruct/)) throw e; }
+ throw new Error("cannot save file " + fname);
+}
+
+/* read binary data from file */
+function read_binary(path) {
+ if(typeof _fs !== 'undefined') return _fs.readFileSync(path);
+ if(typeof Deno !== 'undefined') return Deno.readFileSync(path);
+ // $FlowIgnore
+ if(typeof $ !== 'undefined' && typeof File !== 'undefined' && typeof Folder !== 'undefined') try { // extendscript
+ // $FlowIgnore
+ var infile = File(path); infile.open("r"); infile.encoding = "binary";
+ var data = infile.read(); infile.close();
+ return data;
+ } catch(e) { if(!e.message || !e.message.match(/onstruct/)) throw e; }
+ throw new Error("Cannot access file " + path);
+}
+function keys(o) {
+ var ks = Object.keys(o), o2 = [];
+ for(var i = 0; i < ks.length; ++i) if(Object.prototype.hasOwnProperty.call(o, ks[i])) o2.push(ks[i]);
+ return o2;
+}
+
+function evert_key(obj, key) {
+ var o = ([]), K = keys(obj);
+ for(var i = 0; i !== K.length; ++i) if(o[obj[K[i]][key]] == null) o[obj[K[i]][key]] = K[i];
+ return o;
+}
+
+function evert(obj) {
+ var o = ([]), K = keys(obj);
+ for(var i = 0; i !== K.length; ++i) o[obj[K[i]]] = K[i];
+ return o;
+}
+
+function evert_num(obj) {
+ var o = ([]), K = keys(obj);
+ for(var i = 0; i !== K.length; ++i) o[obj[K[i]]] = parseInt(K[i],10);
+ return o;
+}
+
+function evert_arr(obj) {
+ var o = ([]), K = keys(obj);
+ for(var i = 0; i !== K.length; ++i) {
+ if(o[obj[K[i]]] == null) o[obj[K[i]]] = [];
+ o[obj[K[i]]].push(K[i]);
+ }
+ return o;
+}
+
+var basedate = new Date(1899, 11, 30, 0, 0, 0); // 2209161600000
+function datenum(v, date1904) {
+ var epoch = v.getTime();
+ if(date1904) epoch -= 1462*24*60*60*1000;
+ var dnthresh = basedate.getTime() + (v.getTimezoneOffset() - basedate.getTimezoneOffset()) * 60000;
+ return (epoch - dnthresh) / (24 * 60 * 60 * 1000);
+}
+var refdate = new Date();
+var dnthresh = basedate.getTime() + (refdate.getTimezoneOffset() - basedate.getTimezoneOffset()) * 60000;
+var refoffset = refdate.getTimezoneOffset();
+function numdate(v) {
+ var out = new Date();
+ out.setTime(v * 24 * 60 * 60 * 1000 + dnthresh);
+ if (out.getTimezoneOffset() !== refoffset) {
+ out.setTime(out.getTime() + (out.getTimezoneOffset() - refoffset) * 60000);
+ }
+ return out;
+}
+
+/* ISO 8601 Duration */
+function parse_isodur(s) {
+ var sec = 0, mt = 0, time = false;
+ var m = s.match(/P([0-9\.]+Y)?([0-9\.]+M)?([0-9\.]+D)?T([0-9\.]+H)?([0-9\.]+M)?([0-9\.]+S)?/);
+ if(!m) throw new Error("|" + s + "| is not an ISO8601 Duration");
+ for(var i = 1; i != m.length; ++i) {
+ if(!m[i]) continue;
+ mt = 1;
+ if(i > 3) time = true;
+ switch(m[i].slice(m[i].length-1)) {
+ case 'Y':
+ throw new Error("Unsupported ISO Duration Field: " + m[i].slice(m[i].length-1));
+ case 'D': mt *= 24;
+ /* falls through */
+ case 'H': mt *= 60;
+ /* falls through */
+ case 'M':
+ if(!time) throw new Error("Unsupported ISO Duration Field: M");
+ else mt *= 60;
+ /* falls through */
+ case 'S': break;
+ }
+ sec += mt * parseInt(m[i], 10);
+ }
+ return sec;
+}
+
+var good_pd_date_1 = new Date('2017-02-19T19:06:09.000Z');
+var good_pd_date = isNaN(good_pd_date_1.getFullYear()) ? new Date('2/19/17') : good_pd_date_1;
+var good_pd = good_pd_date.getFullYear() == 2017;
+/* parses a date as a local date */
+function parseDate(str, fixdate) {
+ var d = new Date(str);
+ if(good_pd) {
+if(fixdate > 0) d.setTime(d.getTime() + d.getTimezoneOffset() * 60 * 1000);
+ else if(fixdate < 0) d.setTime(d.getTime() - d.getTimezoneOffset() * 60 * 1000);
+ return d;
+ }
+ if(str instanceof Date) return str;
+ if(good_pd_date.getFullYear() == 1917 && !isNaN(d.getFullYear())) {
+ var s = d.getFullYear();
+ if(str.indexOf("" + s) > -1) return d;
+ d.setFullYear(d.getFullYear() + 100); return d;
+ }
+ var n = str.match(/\d+/g)||["2017","2","19","0","0","0"];
+ var out = new Date(+n[0], +n[1] - 1, +n[2], (+n[3]||0), (+n[4]||0), (+n[5]||0));
+ if(str.indexOf("Z") > -1) out = new Date(out.getTime() - out.getTimezoneOffset() * 60 * 1000);
+ return out;
+}
+
+function cc2str(arr, debomit) {
+ if(has_buf && Buffer.isBuffer(arr)) {
+ if(debomit) {
+ if(arr[0] == 0xFF && arr[1] == 0xFE) return utf8write(arr.slice(2).toString("utf16le"));
+ if(arr[1] == 0xFE && arr[2] == 0xFF) return utf8write(utf16beread(arr.slice(2).toString("binary")));
+ }
+ return arr.toString("binary");
+ }
+
+ if(typeof TextDecoder !== "undefined") try {
+ if(debomit) {
+ if(arr[0] == 0xFF && arr[1] == 0xFE) return utf8write(new TextDecoder("utf-16le").decode(arr.slice(2)));
+ if(arr[0] == 0xFE && arr[1] == 0xFF) return utf8write(new TextDecoder("utf-16be").decode(arr.slice(2)));
+ }
+ var rev = {
+ "\u20ac": "\x80", "\u201a": "\x82", "\u0192": "\x83", "\u201e": "\x84",
+ "\u2026": "\x85", "\u2020": "\x86", "\u2021": "\x87", "\u02c6": "\x88",
+ "\u2030": "\x89", "\u0160": "\x8a", "\u2039": "\x8b", "\u0152": "\x8c",
+ "\u017d": "\x8e", "\u2018": "\x91", "\u2019": "\x92", "\u201c": "\x93",
+ "\u201d": "\x94", "\u2022": "\x95", "\u2013": "\x96", "\u2014": "\x97",
+ "\u02dc": "\x98", "\u2122": "\x99", "\u0161": "\x9a", "\u203a": "\x9b",
+ "\u0153": "\x9c", "\u017e": "\x9e", "\u0178": "\x9f"
+ };
+ if(Array.isArray(arr)) arr = new Uint8Array(arr);
+ return new TextDecoder("latin1").decode(arr).replace(/[€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ]/g, function(c) { return rev[c] || c; });
+ } catch(e) {}
+
+ var o = [];
+ for(var i = 0; i != arr.length; ++i) o.push(String.fromCharCode(arr[i]));
+ return o.join("");
+}
+
+function dup(o) {
+ if(typeof JSON != 'undefined' && !Array.isArray(o)) return JSON.parse(JSON.stringify(o));
+ if(typeof o != 'object' || o == null) return o;
+ if(o instanceof Date) return new Date(o.getTime());
+ var out = {};
+ for(var k in o) if(Object.prototype.hasOwnProperty.call(o, k)) out[k] = dup(o[k]);
+ return out;
+}
+
+function fill(c,l) { var o = ""; while(o.length < l) o+=c; return o; }
+
+/* TODO: stress test */
+function fuzzynum(s) {
+ var v = Number(s);
+ if(!isNaN(v)) return isFinite(v) ? v : NaN;
+ if(!/\d/.test(s)) return v;
+ var wt = 1;
+ var ss = s.replace(/([\d]),([\d])/g,"$1$2").replace(/[$]/g,"").replace(/[%]/g, function() { wt *= 100; return "";});
+ if(!isNaN(v = Number(ss))) return v / wt;
+ ss = ss.replace(/[(](.*)[)]/,function($$, $1) { wt = -wt; return $1;});
+ if(!isNaN(v = Number(ss))) return v / wt;
+ return v;
+}
+var lower_months = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'];
+function fuzzydate(s) {
+ var o = new Date(s), n = new Date(NaN);
+ var y = o.getYear(), m = o.getMonth(), d = o.getDate();
+ if(isNaN(d)) return n;
+ var lower = s.toLowerCase();
+ if(lower.match(/jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/)) {
+ lower = lower.replace(/[^a-z]/g,"").replace(/([^a-z]|^)[ap]m?([^a-z]|$)/,"");
+ if(lower.length > 3 && lower_months.indexOf(lower) == -1) return n;
+ } else if(lower.match(/[a-z]/)) return n;
+ if(y < 0 || y > 8099) return n;
+ if((m > 0 || d > 1) && y != 101) return o;
+ if(s.match(/[^-0-9:,\/\\]/)) return n;
+ return o;
+}
+
+var split_regex = (function() {
+ var safe_split_regex = "abacaba".split(/(:?b)/i).length == 5;
+ return function split_regex(str, re, def) {
+ if(safe_split_regex || typeof re == "string") return str.split(re);
+ var p = str.split(re), o = [p[0]];
+ for(var i = 1; i < p.length; ++i) { o.push(def); o.push(p[i]); }
+ return o;
+ };
+})();
+function getdatastr(data) {
+ if(!data) return null;
+ if(data.content && data.type) return cc2str(data.content, true);
+ if(data.data) return debom(data.data);
+ if(data.asNodeBuffer && has_buf) return debom(data.asNodeBuffer().toString('binary'));
+ if(data.asBinary) return debom(data.asBinary());
+ if(data._data && data._data.getContent) return debom(cc2str(Array.prototype.slice.call(data._data.getContent(),0)));
+ return null;
+}
+
+function getdatabin(data) {
+ if(!data) return null;
+ if(data.data) return char_codes(data.data);
+ if(data.asNodeBuffer && has_buf) return data.asNodeBuffer();
+ if(data._data && data._data.getContent) {
+ var o = data._data.getContent();
+ if(typeof o == "string") return char_codes(o);
+ return Array.prototype.slice.call(o);
+ }
+ if(data.content && data.type) return data.content;
+ return null;
+}
+
+function getdata(data) { return (data && data.name.slice(-4) === ".bin") ? getdatabin(data) : getdatastr(data); }
+
+/* Part 2 Section 10.1.2 "Mapping Content Types" Names are case-insensitive */
+/* OASIS does not comment on filename case sensitivity */
+function safegetzipfile(zip, file) {
+ var k = zip.FullPaths || keys(zip.files);
+ var f = file.toLowerCase().replace(/[\/]/g, '\\'), g = f.replace(/\\/g,'\/');
+ for(var i=0; i\/]+)\s*=\s*((?:")([^"]*)(?:")|(?:')([^']*)(?:')|([^'">\s]+))/g;
+var tagregex1=/<[\/\?]?[a-zA-Z0-9:_-]+(?:\s+[^"\s?>\/]+\s*=\s*(?:"[^"]*"|'[^']*'|[^'">\s=]+))*\s*[\/\?]?>/mg, tagregex2 = /<[^>]*>/g;
+var tagregex = XML_HEADER.match(tagregex1) ? tagregex1 : tagregex2;
+var nsregex=/<\w*:/, nsregex2 = /<(\/?)\w+:/;
+function parsexmltag(tag, skip_root, skip_LC) {
+ var z = ({});
+ var eq = 0, c = 0;
+ for(; eq !== tag.length; ++eq) if((c = tag.charCodeAt(eq)) === 32 || c === 10 || c === 13) break;
+ if(!skip_root) z[0] = tag.slice(0, eq);
+ if(eq === tag.length) return z;
+ var m = tag.match(attregexg), j=0, v="", i=0, q="", cc="", quot = 1;
+ if(m) for(i = 0; i != m.length; ++i) {
+ cc = m[i];
+ for(c=0; c != cc.length; ++c) if(cc.charCodeAt(c) === 61) break;
+ q = cc.slice(0,c).trim();
+ while(cc.charCodeAt(c+1) == 32) ++c;
+ quot = ((eq=cc.charCodeAt(c+1)) == 34 || eq == 39) ? 1 : 0;
+ v = cc.slice(c+1+quot, cc.length-quot);
+ for(j=0;j!=q.length;++j) if(q.charCodeAt(j) === 58) break;
+ if(j===q.length) {
+ if(q.indexOf("_") > 0) q = q.slice(0, q.indexOf("_")); // from ods
+ z[q] = v;
+ if(!skip_LC) z[q.toLowerCase()] = v;
+ }
+ else {
+ var k = (j===5 && q.slice(0,5)==="xmlns"?"xmlns":"")+q.slice(j+1);
+ if(z[k] && q.slice(j-3,j) == "ext") continue; // from ods
+ z[k] = v;
+ if(!skip_LC) z[k.toLowerCase()] = v;
+ }
+ }
+ return z;
+}
+function strip_ns(x) { return x.replace(nsregex2, "<$1"); }
+
+var encodings = {
+ '"': '"',
+ ''': "'",
+ '>': '>',
+ '<': '<',
+ '&': '&'
+};
+var rencoding = evert(encodings);
+//var rencstr = "&<>'\"".split("");
+
+// TODO: CP remap (need to read file version to determine OS)
+var unescapexml = (function() {
+ /* 22.4.2.4 bstr (Basic String) */
+ var encregex = /&(?:quot|apos|gt|lt|amp|#x?([\da-fA-F]+));/ig, coderegex = /_x([\da-fA-F]{4})_/ig;
+ return function unescapexml(text) {
+ var s = text + '', i = s.indexOf("-1?16:10))||$$; }).replace(coderegex,function(m,c) {return String.fromCharCode(parseInt(c,16));});
+ var j = s.indexOf("]]>");
+ return unescapexml(s.slice(0, i)) + s.slice(i+9,j) + unescapexml(s.slice(j+3));
+ };
+})();
+
+var decregex=/[&<>'"]/g, charegex = /[\u0000-\u0008\u000b-\u001f]/g;
+function escapexml(text){
+ var s = text + '';
+ return s.replace(decregex, function(y) { return rencoding[y]; }).replace(charegex,function(s) { return "_x" + ("000"+s.charCodeAt(0).toString(16)).slice(-4) + "_";});
+}
+function escapexmltag(text){ return escapexml(text).replace(/ /g,"_x0020_"); }
+
+var htmlcharegex = /[\u0000-\u001f]/g;
+function escapehtml(text){
+ var s = text + '';
+ return s.replace(decregex, function(y) { return rencoding[y]; }).replace(/\n/g, "
").replace(htmlcharegex,function(s) { return "&#x" + ("000"+s.charCodeAt(0).toString(16)).slice(-4) + ";"; });
+}
+
+function escapexlml(text){
+ var s = text + '';
+ return s.replace(decregex, function(y) { return rencoding[y]; }).replace(htmlcharegex,function(s) { return "&#x" + (s.charCodeAt(0).toString(16)).toUpperCase() + ";"; });
+}
+
+/* TODO: handle codepages */
+var xlml_fixstr = (function() {
+ var entregex = /&#(\d+);/g;
+ function entrepl($$,$1) { return String.fromCharCode(parseInt($1,10)); }
+ return function xlml_fixstr(str) { return str.replace(entregex,entrepl); };
+})();
+function xlml_unfixstr(str) { return str.replace(/(\r\n|[\r\n])/g,"\
"); }
+
+function parsexmlbool(value) {
+ switch(value) {
+ case 1: case true: case '1': case 'true': case 'TRUE': return true;
+ /* case '0': case 'false': case 'FALSE':*/
+ default: return false;
+ }
+}
+
+function utf8reada(orig) {
+ var out = "", i = 0, c = 0, d = 0, e = 0, f = 0, w = 0;
+ while (i < orig.length) {
+ c = orig.charCodeAt(i++);
+ if (c < 128) { out += String.fromCharCode(c); continue; }
+ d = orig.charCodeAt(i++);
+ if (c>191 && c<224) { f = ((c & 31) << 6); f |= (d & 63); out += String.fromCharCode(f); continue; }
+ e = orig.charCodeAt(i++);
+ if (c < 240) { out += String.fromCharCode(((c & 15) << 12) | ((d & 63) << 6) | (e & 63)); continue; }
+ f = orig.charCodeAt(i++);
+ w = (((c & 7) << 18) | ((d & 63) << 12) | ((e & 63) << 6) | (f & 63))-65536;
+ out += String.fromCharCode(0xD800 + ((w>>>10)&1023));
+ out += String.fromCharCode(0xDC00 + (w&1023));
+ }
+ return out;
+}
+
+function utf8readb(data) {
+ var out = new_raw_buf(2*data.length), w, i, j = 1, k = 0, ww=0, c;
+ for(i = 0; i < data.length; i+=j) {
+ j = 1;
+ if((c=data.charCodeAt(i)) < 128) w = c;
+ else if(c < 224) { w = (c&31)*64+(data.charCodeAt(i+1)&63); j=2; }
+ else if(c < 240) { w=(c&15)*4096+(data.charCodeAt(i+1)&63)*64+(data.charCodeAt(i+2)&63); j=3; }
+ else { j = 4;
+ w = (c & 7)*262144+(data.charCodeAt(i+1)&63)*4096+(data.charCodeAt(i+2)&63)*64+(data.charCodeAt(i+3)&63);
+ w -= 65536; ww = 0xD800 + ((w>>>10)&1023); w = 0xDC00 + (w&1023);
+ }
+ if(ww !== 0) { out[k++] = ww&255; out[k++] = ww>>>8; ww = 0; }
+ out[k++] = w%256; out[k++] = w>>>8;
+ }
+ return out.slice(0,k).toString('ucs2');
+}
+
+function utf8readc(data) { return Buffer_from(data, 'binary').toString('utf8'); }
+
+var utf8corpus = "foo bar baz\u00e2\u0098\u0083\u00f0\u009f\u008d\u00a3";
+var utf8read = has_buf && (utf8readc(utf8corpus) == utf8reada(utf8corpus) && utf8readc || utf8readb(utf8corpus) == utf8reada(utf8corpus) && utf8readb) || utf8reada;
+
+var utf8write = has_buf ? function(data) { return Buffer_from(data, 'utf8').toString("binary"); } : function(orig) {
+ var out = [], i = 0, c = 0, d = 0;
+ while(i < orig.length) {
+ c = orig.charCodeAt(i++);
+ switch(true) {
+ case c < 128: out.push(String.fromCharCode(c)); break;
+ case c < 2048:
+ out.push(String.fromCharCode(192 + (c >> 6)));
+ out.push(String.fromCharCode(128 + (c & 63)));
+ break;
+ case c >= 55296 && c < 57344:
+ c -= 55296; d = orig.charCodeAt(i++) - 56320 + (c<<10);
+ out.push(String.fromCharCode(240 + ((d >>18) & 7)));
+ out.push(String.fromCharCode(144 + ((d >>12) & 63)));
+ out.push(String.fromCharCode(128 + ((d >> 6) & 63)));
+ out.push(String.fromCharCode(128 + (d & 63)));
+ break;
+ default:
+ out.push(String.fromCharCode(224 + (c >> 12)));
+ out.push(String.fromCharCode(128 + ((c >> 6) & 63)));
+ out.push(String.fromCharCode(128 + (c & 63)));
+ }
+ }
+ return out.join("");
+};
+
+// matches ... extracts content
+var matchtag = (function() {
+ var mtcache = ({});
+ return function matchtag(f,g) {
+ var t = f+"|"+(g||"");
+ if(mtcache[t]) return mtcache[t];
+ return (mtcache[t] = new RegExp('<(?:\\w+:)?'+f+'(?: xml:space="preserve")?(?:[^>]*)>([\\s\\S]*?)',((g||""))));
+ };
+})();
+
+var htmldecode = (function() {
+ var entities = [
+ ['nbsp', ' '], ['middot', '·'],
+ ['quot', '"'], ['apos', "'"], ['gt', '>'], ['lt', '<'], ['amp', '&']
+ ].map(function(x) { return [new RegExp('&' + x[0] + ';', "ig"), x[1]]; });
+ return function htmldecode(str) {
+ var o = str
+ // Remove new lines and spaces from start of content
+ .replace(/^[\t\n\r ]+/, "")
+ // Remove new lines and spaces from end of content
+ .replace(/[\t\n\r ]+$/,"")
+ // Added line which removes any white space characters after and before html tags
+ .replace(/>\s+/g,">").replace(/\s+ tags with new lines
+ .replace(/<\s*[bB][rR]\s*\/?>/g,"\n")
+ // Strip HTML elements
+ .replace(/<[^>]*>/g,"");
+ for(var i = 0; i < entities.length; ++i) o = o.replace(entities[i][0], entities[i][1]);
+ return o;
+ };
+})();
+
+var vtregex = (function(){ var vt_cache = {};
+ return function vt_regex(bt) {
+ if(vt_cache[bt] !== undefined) return vt_cache[bt];
+ return (vt_cache[bt] = new RegExp("<(?:vt:)?" + bt + ">([\\s\\S]*?)", 'g') );
+};})();
+var vtvregex = /<\/?(?:vt:)?variant>/g, vtmregex = /<(?:vt:)([^>]*)>([\s\S]*)' + g + ''; }
+
+function wxt_helper(h) { return keys(h).map(function(k) { return " " + k + '="' + h[k] + '"';}).join(""); }
+function writextag(f,g,h) { return '<' + f + ((h != null) ? wxt_helper(h) : "") + ((g != null) ? (g.match(wtregex)?' xml:space="preserve"' : "") + '>' + g + '';}
+
+function write_w3cdtf(d, t) { try { return d.toISOString().replace(/\.\d*/,""); } catch(e) { if(t) throw e; } return ""; }
+
+function write_vt(s, xlsx) {
+ switch(typeof s) {
+ case 'string':
+ var o = writextag('vt:lpwstr', escapexml(s));
+ if(xlsx) o = o.replace(/"/g, "_x0022_");
+ return o;
+ case 'number': return writextag((s|0)==s?'vt:i4':'vt:r8', escapexml(String(s)));
+ case 'boolean': return writextag('vt:bool',s?'true':'false');
+ }
+ if(s instanceof Date) return writextag('vt:filetime', write_w3cdtf(s));
+ throw new Error("Unable to serialize " + s);
+}
+
+function xlml_normalize(d) {
+ if(has_buf && Buffer.isBuffer(d)) return d.toString('utf8');
+ if(typeof d === 'string') return d;
+ /* duktape */
+ if(typeof Uint8Array !== 'undefined' && d instanceof Uint8Array) return utf8read(a2s(ab2a(d)));
+ throw new Error("Bad input format: expected Buffer or string");
+}
+/* UOS uses CJK in tags */
+var xlmlregex = /<(\/?)([^\s?>:\/]+)(?:[\s?:\/][^>]*)?>/mg;
+//var xlmlregex = /<(\/?)([a-z0-9]*:|)(\w+)[^>]*>/mg;
+
+var XMLNS = ({
+ CORE_PROPS: 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties',
+ CUST_PROPS: "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties",
+ EXT_PROPS: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+ CT: 'http://schemas.openxmlformats.org/package/2006/content-types',
+ RELS: 'http://schemas.openxmlformats.org/package/2006/relationships',
+ TCMNT: 'http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments',
+ 'dc': 'http://purl.org/dc/elements/1.1/',
+ 'dcterms': 'http://purl.org/dc/terms/',
+ 'dcmitype': 'http://purl.org/dc/dcmitype/',
+ 'mx': 'http://schemas.microsoft.com/office/mac/excel/2008/main',
+ 'r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+ 'sjs': 'http://schemas.openxmlformats.org/package/2006/sheetjs/core-properties',
+ 'vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes',
+ 'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+ 'xsd': 'http://www.w3.org/2001/XMLSchema'
+});
+
+var XMLNS_main = [
+ 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+ 'http://purl.oclc.org/ooxml/spreadsheetml/main',
+ 'http://schemas.microsoft.com/office/excel/2006/main',
+ 'http://schemas.microsoft.com/office/excel/2006/2'
+];
+
+var XLMLNS = ({
+ 'o': 'urn:schemas-microsoft-com:office:office',
+ 'x': 'urn:schemas-microsoft-com:office:excel',
+ 'ss': 'urn:schemas-microsoft-com:office:spreadsheet',
+ 'dt': 'uuid:C2F41010-65B3-11d1-A29F-00AA00C14882',
+ 'mv': 'http://macVmlSchemaUri',
+ 'v': 'urn:schemas-microsoft-com:vml',
+ 'html': 'http://www.w3.org/TR/REC-html40'
+});
+function read_double_le(b, idx) {
+ var s = 1 - 2 * (b[idx + 7] >>> 7);
+ var e = ((b[idx + 7] & 0x7f) << 4) + ((b[idx + 6] >>> 4) & 0x0f);
+ var m = (b[idx+6]&0x0f);
+ for(var i = 5; i >= 0; --i) m = m * 256 + b[idx + i];
+ if(e == 0x7ff) return m == 0 ? (s * Infinity) : NaN;
+ if(e == 0) e = -1022;
+ else { e -= 1023; m += Math.pow(2,52); }
+ return s * Math.pow(2, e - 52) * m;
+}
+
+function write_double_le(b, v, idx) {
+ var bs = ((((v < 0) || (1/v == -Infinity)) ? 1 : 0) << 7), e = 0, m = 0;
+ var av = bs ? (-v) : v;
+ if(!isFinite(av)) { e = 0x7ff; m = isNaN(v) ? 0x6969 : 0; }
+ else if(av == 0) e = m = 0;
+ else {
+ e = Math.floor(Math.log(av) / Math.LN2);
+ m = av * Math.pow(2, 52 - e);
+ if((e <= -1023) && (!isFinite(m) || (m < Math.pow(2,52)))) { e = -1022; }
+ else { m -= Math.pow(2,52); e+=1023; }
+ }
+ for(var i = 0; i <= 5; ++i, m/=256) b[idx + i] = m & 0xff;
+ b[idx + 6] = ((e & 0x0f) << 4) | (m & 0xf);
+ b[idx + 7] = (e >> 4) | bs;
+}
+
+var ___toBuffer = function(bufs) { var x=[],w=10240; for(var i=0;i 0 && Buffer.isBuffer(bufs[0][0])) ? Buffer.concat(bufs[0].map(function(x) { return Buffer.isBuffer(x) ? x : Buffer_from(x); })) : ___toBuffer(bufs);} : ___toBuffer;
+
+var ___utf16le = function(b,s,e) { var ss=[]; for(var i=s; i 0 ? __utf8(b, i+4,i+4+len-1) : "";};
+var __lpstr = ___lpstr;
+
+var ___cpstr = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? __utf8(b, i+4,i+4+len-1) : "";};
+var __cpstr = ___cpstr;
+
+var ___lpwstr = function(b,i) { var len = 2*__readUInt32LE(b,i); return len > 0 ? __utf8(b, i+4,i+4+len-1) : "";};
+var __lpwstr = ___lpwstr;
+
+var ___lpp4 = function lpp4_(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? __utf16le(b, i+4,i+4+len) : "";};
+var __lpp4 = ___lpp4;
+
+var ___8lpp4 = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? __utf8(b, i+4,i+4+len) : "";};
+var __8lpp4 = ___8lpp4;
+
+var ___double = function(b, idx) { return read_double_le(b, idx);};
+var __double = ___double;
+
+var is_buf = function is_buf_a(a) { return Array.isArray(a) || (typeof Uint8Array !== "undefined" && a instanceof Uint8Array); };
+
+if(has_buf) {
+ __lpstr = function lpstr_b(b, i) { if(!Buffer.isBuffer(b)) return ___lpstr(b, i); var len = b.readUInt32LE(i); return len > 0 ? b.toString('utf8',i+4,i+4+len-1) : "";};
+ __cpstr = function cpstr_b(b, i) { if(!Buffer.isBuffer(b)) return ___cpstr(b, i); var len = b.readUInt32LE(i); return len > 0 ? b.toString('utf8',i+4,i+4+len-1) : "";};
+ __lpwstr = function lpwstr_b(b, i) { if(!Buffer.isBuffer(b)) return ___lpwstr(b, i); var len = 2*b.readUInt32LE(i); return b.toString('utf16le',i+4,i+4+len-1);};
+ __lpp4 = function lpp4_b(b, i) { if(!Buffer.isBuffer(b)) return ___lpp4(b, i); var len = b.readUInt32LE(i); return b.toString('utf16le',i+4,i+4+len);};
+ __8lpp4 = function lpp4_8b(b, i) { if(!Buffer.isBuffer(b)) return ___8lpp4(b, i); var len = b.readUInt32LE(i); return b.toString('utf8',i+4,i+4+len);};
+ __double = function double_(b, i) { if(Buffer.isBuffer(b)) return b.readDoubleLE(i); return ___double(b,i); };
+ is_buf = function is_buf_b(a) { return Buffer.isBuffer(a) || Array.isArray(a) || (typeof Uint8Array !== "undefined" && a instanceof Uint8Array); };
+}
+
+/* from js-xls */
+function cpdoit() {
+ __utf16le = function(b,s,e) { return $cptable.utils.decode(1200, b.slice(s,e)).replace(chr0, ''); };
+ __utf8 = function(b,s,e) { return $cptable.utils.decode(65001, b.slice(s,e)); };
+ __lpstr = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? $cptable.utils.decode(current_ansi, b.slice(i+4, i+4+len-1)) : "";};
+ __cpstr = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? $cptable.utils.decode(current_codepage, b.slice(i+4, i+4+len-1)) : "";};
+ __lpwstr = function(b,i) { var len = 2*__readUInt32LE(b,i); return len > 0 ? $cptable.utils.decode(1200, b.slice(i+4,i+4+len-1)) : "";};
+ __lpp4 = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? $cptable.utils.decode(1200, b.slice(i+4,i+4+len)) : "";};
+ __8lpp4 = function(b,i) { var len = __readUInt32LE(b,i); return len > 0 ? $cptable.utils.decode(65001, b.slice(i+4,i+4+len)) : "";};
+}
+if(typeof $cptable !== 'undefined') cpdoit();
+
+var __readUInt8 = function(b, idx) { return b[idx]; };
+var __readUInt16LE = function(b, idx) { return (b[idx+1]*(1<<8))+b[idx]; };
+var __readInt16LE = function(b, idx) { var u = (b[idx+1]*(1<<8))+b[idx]; return (u < 0x8000) ? u : ((0xffff - u + 1) * -1); };
+var __readUInt32LE = function(b, idx) { return b[idx+3]*(1<<24)+(b[idx+2]<<16)+(b[idx+1]<<8)+b[idx]; };
+var __readInt32LE = function(b, idx) { return (b[idx+3]<<24)|(b[idx+2]<<16)|(b[idx+1]<<8)|b[idx]; };
+var __readInt32BE = function(b, idx) { return (b[idx]<<24)|(b[idx+1]<<16)|(b[idx+2]<<8)|b[idx+3]; };
+
+function ReadShift(size, t) {
+ var o="", oI, oR, oo=[], w, vv, i, loc;
+ switch(t) {
+ case 'dbcs':
+ loc = this.l;
+ if(has_buf && Buffer.isBuffer(this)) o = this.slice(this.l, this.l+2*size).toString("utf16le");
+ else for(i = 0; i < size; ++i) { o+=String.fromCharCode(__readUInt16LE(this, loc)); loc+=2; }
+ size *= 2;
+ break;
+
+ case 'utf8': o = __utf8(this, this.l, this.l + size); break;
+ case 'utf16le': size *= 2; o = __utf16le(this, this.l, this.l + size); break;
+
+ case 'wstr':
+ if(typeof $cptable !== 'undefined') o = $cptable.utils.decode(current_codepage, this.slice(this.l, this.l+2*size));
+ else return ReadShift.call(this, size, 'dbcs');
+ size = 2 * size; break;
+
+ /* [MS-OLEDS] 2.1.4 LengthPrefixedAnsiString */
+ case 'lpstr-ansi': o = __lpstr(this, this.l); size = 4 + __readUInt32LE(this, this.l); break;
+ case 'lpstr-cp': o = __cpstr(this, this.l); size = 4 + __readUInt32LE(this, this.l); break;
+ /* [MS-OLEDS] 2.1.5 LengthPrefixedUnicodeString */
+ case 'lpwstr': o = __lpwstr(this, this.l); size = 4 + 2 * __readUInt32LE(this, this.l); break;
+ /* [MS-OFFCRYPTO] 2.1.2 Length-Prefixed Padded Unicode String (UNICODE-LP-P4) */
+ case 'lpp4': size = 4 + __readUInt32LE(this, this.l); o = __lpp4(this, this.l); if(size & 0x02) size += 2; break;
+ /* [MS-OFFCRYPTO] 2.1.3 Length-Prefixed UTF-8 String (UTF-8-LP-P4) */
+ case '8lpp4': size = 4 + __readUInt32LE(this, this.l); o = __8lpp4(this, this.l); if(size & 0x03) size += 4 - (size & 0x03); break;
+
+ case 'cstr': size = 0; o = "";
+ while((w=__readUInt8(this, this.l + size++))!==0) oo.push(_getchar(w));
+ o = oo.join(""); break;
+ case '_wstr': size = 0; o = "";
+ while((w=__readUInt16LE(this,this.l +size))!==0){oo.push(_getchar(w));size+=2;}
+ size+=2; o = oo.join(""); break;
+
+ /* sbcs and dbcs support continue records in the SST way TODO codepages */
+ case 'dbcs-cont': o = ""; loc = this.l;
+ for(i = 0; i < size; ++i) {
+ if(this.lens && this.lens.indexOf(loc) !== -1) {
+ w = __readUInt8(this, loc);
+ this.l = loc + 1;
+ vv = ReadShift.call(this, size-i, w ? 'dbcs-cont' : 'sbcs-cont');
+ return oo.join("") + vv;
+ }
+ oo.push(_getchar(__readUInt16LE(this, loc)));
+ loc+=2;
+ } o = oo.join(""); size *= 2; break;
+
+ case 'cpstr':
+ if(typeof $cptable !== 'undefined') {
+ o = $cptable.utils.decode(current_codepage, this.slice(this.l, this.l + size));
+ break;
+ }
+ /* falls through */
+ case 'sbcs-cont': o = ""; loc = this.l;
+ for(i = 0; i != size; ++i) {
+ if(this.lens && this.lens.indexOf(loc) !== -1) {
+ w = __readUInt8(this, loc);
+ this.l = loc + 1;
+ vv = ReadShift.call(this, size-i, w ? 'dbcs-cont' : 'sbcs-cont');
+ return oo.join("") + vv;
+ }
+ oo.push(_getchar(__readUInt8(this, loc)));
+ loc+=1;
+ } o = oo.join(""); break;
+
+ default:
+ switch(size) {
+ case 1: oI = __readUInt8(this, this.l); this.l++; return oI;
+ case 2: oI = (t === 'i' ? __readInt16LE : __readUInt16LE)(this, this.l); this.l += 2; return oI;
+ case 4: case -4:
+ if(t === 'i' || ((this[this.l+3] & 0x80)===0)) { oI = ((size > 0) ? __readInt32LE : __readInt32BE)(this, this.l); this.l += 4; return oI; }
+ else { oR = __readUInt32LE(this, this.l); this.l += 4; } return oR;
+ case 8: case -8:
+ if(t === 'f') {
+ if(size == 8) oR = __double(this, this.l);
+ else oR = __double([this[this.l+7],this[this.l+6],this[this.l+5],this[this.l+4],this[this.l+3],this[this.l+2],this[this.l+1],this[this.l+0]], 0);
+ this.l += 8; return oR;
+ } else size = 8;
+ /* falls through */
+ case 16: o = __hexlify(this, this.l, size); break;
+ }}
+ this.l+=size; return o;
+}
+
+var __writeUInt32LE = function(b, val, idx) { b[idx] = (val & 0xFF); b[idx+1] = ((val >>> 8) & 0xFF); b[idx+2] = ((val >>> 16) & 0xFF); b[idx+3] = ((val >>> 24) & 0xFF); };
+var __writeInt32LE = function(b, val, idx) { b[idx] = (val & 0xFF); b[idx+1] = ((val >> 8) & 0xFF); b[idx+2] = ((val >> 16) & 0xFF); b[idx+3] = ((val >> 24) & 0xFF); };
+var __writeUInt16LE = function(b, val, idx) { b[idx] = (val & 0xFF); b[idx+1] = ((val >>> 8) & 0xFF); };
+
+function WriteShift(t, val, f) {
+ var size = 0, i = 0;
+ if(f === 'dbcs') {
+for(i = 0; i != val.length; ++i) __writeUInt16LE(this, val.charCodeAt(i), this.l + 2 * i);
+ size = 2 * val.length;
+ } else if(f === 'sbcs') {
+ if(typeof $cptable !== 'undefined' && current_ansi == 874) {
+ /* TODO: use tables directly, don't encode */
+for(i = 0; i != val.length; ++i) {
+ var cppayload = $cptable.utils.encode(current_ansi, val.charAt(i));
+ this[this.l + i] = cppayload[0];
+ }
+ } else {
+val = val.replace(/[^\x00-\x7F]/g, "_");
+for(i = 0; i != val.length; ++i) this[this.l + i] = (val.charCodeAt(i) & 0xFF);
+ }
+ size = val.length;
+ } else if(f === 'hex') {
+ for(; i < t; ++i) {
+this[this.l++] = (parseInt(val.slice(2*i, 2*i+2), 16)||0);
+ } return this;
+ } else if(f === 'utf16le') {
+var end = Math.min(this.l + t, this.length);
+ for(i = 0; i < Math.min(val.length, t); ++i) {
+ var cc = val.charCodeAt(i);
+ this[this.l++] = (cc & 0xff);
+ this[this.l++] = (cc >> 8);
+ }
+ while(this.l < end) this[this.l++] = 0;
+ return this;
+ } else switch(t) {
+ case 1: size = 1; this[this.l] = val&0xFF; break;
+ case 2: size = 2; this[this.l] = val&0xFF; val >>>= 8; this[this.l+1] = val&0xFF; break;
+ case 3: size = 3; this[this.l] = val&0xFF; val >>>= 8; this[this.l+1] = val&0xFF; val >>>= 8; this[this.l+2] = val&0xFF; break;
+ case 4: size = 4; __writeUInt32LE(this, val, this.l); break;
+ case 8: size = 8; if(f === 'f') { write_double_le(this, val, this.l); break; }
+ /* falls through */
+ case 16: break;
+ case -4: size = 4; __writeInt32LE(this, val, this.l); break;
+ }
+ this.l += size; return this;
+}
+
+function CheckField(hexstr, fld) {
+ var m = __hexlify(this,this.l,hexstr.length>>1);
+ if(m !== hexstr) throw new Error(fld + 'Expected ' + hexstr + ' saw ' + m);
+ this.l += hexstr.length>>1;
+}
+
+function prep_blob(blob, pos) {
+ blob.l = pos;
+ blob.read_shift = ReadShift;
+ blob.chk = CheckField;
+ blob.write_shift = WriteShift;
+}
+
+function parsenoop(blob, length) { blob.l += length; }
+
+function new_buf(sz) {
+ var o = new_raw_buf(sz);
+ prep_blob(o, 0);
+ return o;
+}
+
+/* [MS-XLSB] 2.1.4 Record */
+function recordhopper(data, cb, opts) {
+ if(!data) return;
+ var tmpbyte, cntbyte, length;
+ prep_blob(data, data.l || 0);
+ var L = data.length, RT = 0, tgt = 0;
+ while(data.l < L) {
+ RT = data.read_shift(1);
+ if(RT & 0x80) RT = (RT & 0x7F) + ((data.read_shift(1) & 0x7F)<<7);
+ var R = XLSBRecordEnum[RT] || XLSBRecordEnum[0xFFFF];
+ tmpbyte = data.read_shift(1);
+ length = tmpbyte & 0x7F;
+ for(cntbyte = 1; cntbyte <4 && (tmpbyte & 0x80); ++cntbyte) length += ((tmpbyte = data.read_shift(1)) & 0x7F)<<(7*cntbyte);
+ tgt = data.l + length;
+ var d = R.f && R.f(data, length, opts);
+ data.l = tgt;
+ if(cb(d, R, RT)) return;
+ }
+}
+
+/* control buffer usage for fixed-length buffers */
+function buf_array() {
+ var bufs = [], blksz = has_buf ? 256 : 2048;
+ var newblk = function ba_newblk(sz) {
+ var o = (new_buf(sz));
+ prep_blob(o, 0);
+ return o;
+ };
+
+ var curbuf = newblk(blksz);
+
+ var endbuf = function ba_endbuf() {
+ if(!curbuf) return;
+ if(curbuf.length > curbuf.l) { curbuf = curbuf.slice(0, curbuf.l); curbuf.l = curbuf.length; }
+ if(curbuf.length > 0) bufs.push(curbuf);
+ curbuf = null;
+ };
+
+ var next = function ba_next(sz) {
+ if(curbuf && (sz < (curbuf.length - curbuf.l))) return curbuf;
+ endbuf();
+ return (curbuf = newblk(Math.max(sz+1, blksz)));
+ };
+
+ var end = function ba_end() {
+ endbuf();
+ return bconcat(bufs);
+ };
+
+ var push = function ba_push(buf) { endbuf(); curbuf = buf; if(curbuf.l == null) curbuf.l = curbuf.length; next(blksz); };
+
+ return ({ next:next, push:push, end:end, _bufs:bufs });
+}
+
+function write_record(ba, type, payload, length) {
+ var t = +type, l;
+ if(isNaN(t)) return; // TODO: throw something here?
+ if(!length) length = XLSBRecordEnum[t].p || (payload||[]).length || 0;
+ l = 1 + (t >= 0x80 ? 1 : 0) + 1/* + length*/;
+ if(length >= 0x80) ++l; if(length >= 0x4000) ++l; if(length >= 0x200000) ++l;
+ var o = ba.next(l);
+ if(t <= 0x7F) o.write_shift(1, t);
+ else {
+ o.write_shift(1, (t & 0x7F) + 0x80);
+ o.write_shift(1, (t >> 7));
+ }
+ for(var i = 0; i != 4; ++i) {
+ if(length >= 0x80) { o.write_shift(1, (length & 0x7F)+0x80); length >>= 7; }
+ else { o.write_shift(1, length); break; }
+ }
+ if(length > 0 && is_buf(payload)) ba.push(payload);
+}
+/* XLS ranges enforced */
+function shift_cell_xls(cell, tgt, opts) {
+ var out = dup(cell);
+ if(tgt.s) {
+ if(out.cRel) out.c += tgt.s.c;
+ if(out.rRel) out.r += tgt.s.r;
+ } else {
+ if(out.cRel) out.c += tgt.c;
+ if(out.rRel) out.r += tgt.r;
+ }
+ if(!opts || opts.biff < 12) {
+ while(out.c >= 0x100) out.c -= 0x100;
+ while(out.r >= 0x10000) out.r -= 0x10000;
+ }
+ return out;
+}
+
+function shift_range_xls(cell, range, opts) {
+ var out = dup(cell);
+ out.s = shift_cell_xls(out.s, range.s, opts);
+ out.e = shift_cell_xls(out.e, range.s, opts);
+ return out;
+}
+
+function encode_cell_xls(c, biff) {
+ if(c.cRel && c.c < 0) { c = dup(c); while(c.c < 0) c.c += (biff > 8) ? 0x4000 : 0x100; }
+ if(c.rRel && c.r < 0) { c = dup(c); while(c.r < 0) c.r += (biff > 8) ? 0x100000 : ((biff > 5) ? 0x10000 : 0x4000); }
+ var s = encode_cell(c);
+ if(!c.cRel && c.cRel != null) s = fix_col(s);
+ if(!c.rRel && c.rRel != null) s = fix_row(s);
+ return s;
+}
+
+function encode_range_xls(r, opts) {
+ if(r.s.r == 0 && !r.s.rRel) {
+ if(r.e.r == (opts.biff >= 12 ? 0xFFFFF : (opts.biff >= 8 ? 0x10000 : 0x4000)) && !r.e.rRel) {
+ return (r.s.cRel ? "" : "$") + encode_col(r.s.c) + ":" + (r.e.cRel ? "" : "$") + encode_col(r.e.c);
+ }
+ }
+ if(r.s.c == 0 && !r.s.cRel) {
+ if(r.e.c == (opts.biff >= 12 ? 0x3FFF : 0xFF) && !r.e.cRel) {
+ return (r.s.rRel ? "" : "$") + encode_row(r.s.r) + ":" + (r.e.rRel ? "" : "$") + encode_row(r.e.r);
+ }
+ }
+ return encode_cell_xls(r.s, opts.biff) + ":" + encode_cell_xls(r.e, opts.biff);
+}
+function decode_row(rowstr) { return parseInt(unfix_row(rowstr),10) - 1; }
+function encode_row(row) { return "" + (row + 1); }
+function fix_row(cstr) { return cstr.replace(/([A-Z]|^)(\d+)$/,"$1$$$2"); }
+function unfix_row(cstr) { return cstr.replace(/\$(\d+)$/,"$1"); }
+
+function decode_col(colstr) { var c = unfix_col(colstr), d = 0, i = 0; for(; i !== c.length; ++i) d = 26*d + c.charCodeAt(i) - 64; return d - 1; }
+function encode_col(col) { if(col < 0) throw new Error("invalid column " + col); var s=""; for(++col; col; col=Math.floor((col-1)/26)) s = String.fromCharCode(((col-1)%26) + 65) + s; return s; }
+function fix_col(cstr) { return cstr.replace(/^([A-Z])/,"$$$1"); }
+function unfix_col(cstr) { return cstr.replace(/^\$([A-Z])/,"$1"); }
+
+function split_cell(cstr) { return cstr.replace(/(\$?[A-Z]*)(\$?\d*)/,"$1,$2").split(","); }
+//function decode_cell(cstr) { var splt = split_cell(cstr); return { c:decode_col(splt[0]), r:decode_row(splt[1]) }; }
+function decode_cell(cstr) {
+ var R = 0, C = 0;
+ for(var i = 0; i < cstr.length; ++i) {
+ var cc = cstr.charCodeAt(i);
+ if(cc >= 48 && cc <= 57) R = 10 * R + (cc - 48);
+ else if(cc >= 65 && cc <= 90) C = 26 * C + (cc - 64);
+ }
+ return { c: C - 1, r:R - 1 };
+}
+//function encode_cell(cell) { return encode_col(cell.c) + encode_row(cell.r); }
+function encode_cell(cell) {
+ var col = cell.c + 1;
+ var s="";
+ for(; col; col=((col-1)/26)|0) s = String.fromCharCode(((col-1)%26) + 65) + s;
+ return s + (cell.r + 1);
+}
+function decode_range(range) {
+ var idx = range.indexOf(":");
+ if(idx == -1) return { s: decode_cell(range), e: decode_cell(range) };
+ return { s: decode_cell(range.slice(0, idx)), e: decode_cell(range.slice(idx + 1)) };
+}
+function encode_range(cs,ce) {
+ if(typeof ce === 'undefined' || typeof ce === 'number') {
+return encode_range(cs.s, cs.e);
+ }
+if(typeof cs !== 'string') cs = encode_cell((cs));
+ if(typeof ce !== 'string') ce = encode_cell((ce));
+return cs == ce ? cs : cs + ":" + ce;
+}
+
+function safe_decode_range(range) {
+ var o = {s:{c:0,r:0},e:{c:0,r:0}};
+ var idx = 0, i = 0, cc = 0;
+ var len = range.length;
+ for(idx = 0; i < len; ++i) {
+ if((cc=range.charCodeAt(i)-64) < 1 || cc > 26) break;
+ idx = 26*idx + cc;
+ }
+ o.s.c = --idx;
+
+ for(idx = 0; i < len; ++i) {
+ if((cc=range.charCodeAt(i)-48) < 0 || cc > 9) break;
+ idx = 10*idx + cc;
+ }
+ o.s.r = --idx;
+
+ if(i === len || cc != 10) { o.e.c=o.s.c; o.e.r=o.s.r; return o; }
+ ++i;
+
+ for(idx = 0; i != len; ++i) {
+ if((cc=range.charCodeAt(i)-64) < 1 || cc > 26) break;
+ idx = 26*idx + cc;
+ }
+ o.e.c = --idx;
+
+ for(idx = 0; i != len; ++i) {
+ if((cc=range.charCodeAt(i)-48) < 0 || cc > 9) break;
+ idx = 10*idx + cc;
+ }
+ o.e.r = --idx;
+ return o;
+}
+
+function safe_format_cell(cell, v) {
+ var q = (cell.t == 'd' && v instanceof Date);
+ if(cell.z != null) try { return (cell.w = SSF_format(cell.z, q ? datenum(v) : v)); } catch(e) { }
+ try { return (cell.w = SSF_format((cell.XF||{}).numFmtId||(q ? 14 : 0), q ? datenum(v) : v)); } catch(e) { return ''+v; }
+}
+
+function format_cell(cell, v, o) {
+ if(cell == null || cell.t == null || cell.t == 'z') return "";
+ if(cell.w !== undefined) return cell.w;
+ if(cell.t == 'd' && !cell.z && o && o.dateNF) cell.z = o.dateNF;
+ if(cell.t == "e") return BErr[cell.v] || cell.v;
+ if(v == undefined) return safe_format_cell(cell, cell.v);
+ return safe_format_cell(cell, v);
+}
+
+function sheet_to_workbook(sheet, opts) {
+ var n = opts && opts.sheet ? opts.sheet : "Sheet1";
+ var sheets = {}; sheets[n] = sheet;
+ return { SheetNames: [n], Sheets: sheets };
+}
+
+function sheet_add_aoa(_ws, data, opts) {
+ var o = opts || {};
+ var dense = _ws ? Array.isArray(_ws) : o.dense;
+ if(DENSE != null && dense == null) dense = DENSE;
+ var ws = _ws || (dense ? ([]) : ({}));
+ var _R = 0, _C = 0;
+ if(ws && o.origin != null) {
+ if(typeof o.origin == 'number') _R = o.origin;
+ else {
+ var _origin = typeof o.origin == "string" ? decode_cell(o.origin) : o.origin;
+ _R = _origin.r; _C = _origin.c;
+ }
+ if(!ws["!ref"]) ws["!ref"] = "A1:A1";
+ }
+ var range = ({s: {c:10000000, r:10000000}, e: {c:0, r:0}});
+ if(ws['!ref']) {
+ var _range = safe_decode_range(ws['!ref']);
+ range.s.c = _range.s.c;
+ range.s.r = _range.s.r;
+ range.e.c = Math.max(range.e.c, _range.e.c);
+ range.e.r = Math.max(range.e.r, _range.e.r);
+ if(_R == -1) range.e.r = _R = _range.e.r + 1;
+ }
+ for(var R = 0; R != data.length; ++R) {
+ if(!data[R]) continue;
+ if(!Array.isArray(data[R])) throw new Error("aoa_to_sheet expects an array of arrays");
+ for(var C = 0; C != data[R].length; ++C) {
+ if(typeof data[R][C] === 'undefined') continue;
+ var cell = ({v: data[R][C] });
+ var __R = _R + R, __C = _C + C;
+ if(range.s.r > __R) range.s.r = __R;
+ if(range.s.c > __C) range.s.c = __C;
+ if(range.e.r < __R) range.e.r = __R;
+ if(range.e.c < __C) range.e.c = __C;
+ if(data[R][C] && typeof data[R][C] === 'object' && !Array.isArray(data[R][C]) && !(data[R][C] instanceof Date)) cell = data[R][C];
+ else {
+ if(Array.isArray(cell.v)) { cell.f = data[R][C][1]; cell.v = cell.v[0]; }
+ if(cell.v === null) {
+ if(cell.f) cell.t = 'n';
+ else if(o.nullError) { cell.t = 'e'; cell.v = 0; }
+ else if(!o.sheetStubs) continue;
+ else cell.t = 'z';
+ }
+ else if(typeof cell.v === 'number') cell.t = 'n';
+ else if(typeof cell.v === 'boolean') cell.t = 'b';
+ else if(cell.v instanceof Date) {
+ cell.z = o.dateNF || table_fmt[14];
+ if(o.cellDates) { cell.t = 'd'; cell.w = SSF_format(cell.z, datenum(cell.v)); }
+ else { cell.t = 'n'; cell.v = datenum(cell.v); cell.w = SSF_format(cell.z, cell.v); }
+ }
+ else cell.t = 's';
+ }
+ if(dense) {
+ if(!ws[__R]) ws[__R] = [];
+ if(ws[__R][__C] && ws[__R][__C].z) cell.z = ws[__R][__C].z;
+ ws[__R][__C] = cell;
+ } else {
+ var cell_ref = encode_cell(({c:__C,r:__R}));
+ if(ws[cell_ref] && ws[cell_ref].z) cell.z = ws[cell_ref].z;
+ ws[cell_ref] = cell;
+ }
+ }
+ }
+ if(range.s.c < 10000000) ws['!ref'] = encode_range(range);
+ return ws;
+}
+function aoa_to_sheet(data, opts) { return sheet_add_aoa(null, data, opts); }
+
+function parse_Int32LE(data) {
+ return data.read_shift(4, 'i');
+}
+function write_UInt32LE(x, o) {
+ if (!o) o = new_buf(4);
+ o.write_shift(4, x);
+ return o;
+}
+
+/* [MS-XLSB] 2.5.168 */
+function parse_XLWideString(data) {
+ var cchCharacters = data.read_shift(4);
+ return cchCharacters === 0 ? "" : data.read_shift(cchCharacters, 'dbcs');
+}
+function write_XLWideString(data, o) {
+ var _null = false; if (o == null) { _null = true; o = new_buf(4 + 2 * data.length); }
+ o.write_shift(4, data.length);
+ if (data.length > 0) o.write_shift(0, data, 'dbcs');
+ return _null ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.5.91 */
+//function parse_LPWideString(data) {
+// var cchCharacters = data.read_shift(2);
+// return cchCharacters === 0 ? "" : data.read_shift(cchCharacters, "utf16le");
+//}
+
+/* [MS-XLSB] 2.5.143 */
+function parse_StrRun(data) {
+ return { ich: data.read_shift(2), ifnt: data.read_shift(2) };
+}
+function write_StrRun(run, o) {
+ if (!o) o = new_buf(4);
+ o.write_shift(2, run.ich || 0);
+ o.write_shift(2, run.ifnt || 0);
+ return o;
+}
+
+/* [MS-XLSB] 2.5.121 */
+function parse_RichStr(data, length) {
+ var start = data.l;
+ var flags = data.read_shift(1);
+ var str = parse_XLWideString(data);
+ var rgsStrRun = [];
+ var z = ({ t: str, h: str });
+ if ((flags & 1) !== 0) { /* fRichStr */
+ /* TODO: formatted string */
+ var dwSizeStrRun = data.read_shift(4);
+ for (var i = 0; i != dwSizeStrRun; ++i) rgsStrRun.push(parse_StrRun(data));
+ z.r = rgsStrRun;
+ }
+ else z.r = [{ ich: 0, ifnt: 0 }];
+ //if((flags & 2) !== 0) { /* fExtStr */
+ // /* TODO: phonetic string */
+ //}
+ data.l = start + length;
+ return z;
+}
+function write_RichStr(str, o) {
+ /* TODO: formatted string */
+ var _null = false; if (o == null) { _null = true; o = new_buf(15 + 4 * str.t.length); }
+ o.write_shift(1, 0);
+ write_XLWideString(str.t, o);
+ return _null ? o.slice(0, o.l) : o;
+}
+/* [MS-XLSB] 2.4.328 BrtCommentText (RichStr w/1 run) */
+var parse_BrtCommentText = parse_RichStr;
+function write_BrtCommentText(str, o) {
+ /* TODO: formatted string */
+ var _null = false; if (o == null) { _null = true; o = new_buf(23 + 4 * str.t.length); }
+ o.write_shift(1, 1);
+ write_XLWideString(str.t, o);
+ o.write_shift(4, 1);
+ write_StrRun({ ich: 0, ifnt: 0 }, o);
+ return _null ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.5.9 */
+function parse_XLSBCell(data) {
+ var col = data.read_shift(4);
+ var iStyleRef = data.read_shift(2);
+ iStyleRef += data.read_shift(1) << 16;
+ data.l++; //var fPhShow = data.read_shift(1);
+ return { c: col, iStyleRef: iStyleRef };
+}
+function write_XLSBCell(cell, o) {
+ if (o == null) o = new_buf(8);
+ o.write_shift(-4, cell.c);
+ o.write_shift(3, cell.iStyleRef || cell.s);
+ o.write_shift(1, 0); /* fPhShow */
+ return o;
+}
+
+/* Short XLSB Cell does not include column */
+function parse_XLSBShortCell(data) {
+ var iStyleRef = data.read_shift(2);
+ iStyleRef += data.read_shift(1) <<16;
+ data.l++; //var fPhShow = data.read_shift(1);
+ return { c:-1, iStyleRef: iStyleRef };
+}
+function write_XLSBShortCell(cell, o) {
+ if(o == null) o = new_buf(4);
+ o.write_shift(3, cell.iStyleRef || cell.s);
+ o.write_shift(1, 0); /* fPhShow */
+ return o;
+}
+
+/* [MS-XLSB] 2.5.21 */
+var parse_XLSBCodeName = parse_XLWideString;
+var write_XLSBCodeName = write_XLWideString;
+
+/* [MS-XLSB] 2.5.166 */
+function parse_XLNullableWideString(data) {
+ var cchCharacters = data.read_shift(4);
+ return cchCharacters === 0 || cchCharacters === 0xFFFFFFFF ? "" : data.read_shift(cchCharacters, 'dbcs');
+}
+function write_XLNullableWideString(data, o) {
+ var _null = false; if (o == null) { _null = true; o = new_buf(127); }
+ o.write_shift(4, data.length > 0 ? data.length : 0xFFFFFFFF);
+ if (data.length > 0) o.write_shift(0, data, 'dbcs');
+ return _null ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.5.165 */
+var parse_XLNameWideString = parse_XLWideString;
+//var write_XLNameWideString = write_XLWideString;
+
+/* [MS-XLSB] 2.5.114 */
+var parse_RelID = parse_XLNullableWideString;
+var write_RelID = write_XLNullableWideString;
+
+
+/* [MS-XLS] 2.5.217 ; [MS-XLSB] 2.5.122 */
+function parse_RkNumber(data) {
+ var b = data.slice(data.l, data.l + 4);
+ var fX100 = (b[0] & 1), fInt = (b[0] & 2);
+ data.l += 4;
+ var RK = fInt === 0 ? __double([0, 0, 0, 0, (b[0] & 0xFC), b[1], b[2], b[3]], 0) : __readInt32LE(b, 0) >> 2;
+ return fX100 ? (RK / 100) : RK;
+}
+function write_RkNumber(data, o) {
+ if (o == null) o = new_buf(4);
+ var fX100 = 0, fInt = 0, d100 = data * 100;
+ if ((data == (data | 0)) && (data >= -(1 << 29)) && (data < (1 << 29))) { fInt = 1; }
+ else if ((d100 == (d100 | 0)) && (d100 >= -(1 << 29)) && (d100 < (1 << 29))) { fInt = 1; fX100 = 1; }
+ if (fInt) o.write_shift(-4, ((fX100 ? d100 : data) << 2) + (fX100 + 2));
+ else throw new Error("unsupported RkNumber " + data); // TODO
+}
+
+
+/* [MS-XLSB] 2.5.117 RfX */
+function parse_RfX(data ) {
+ var cell = ({ s: {}, e: {} });
+ cell.s.r = data.read_shift(4);
+ cell.e.r = data.read_shift(4);
+ cell.s.c = data.read_shift(4);
+ cell.e.c = data.read_shift(4);
+ return cell;
+}
+function write_RfX(r, o) {
+ if (!o) o = new_buf(16);
+ o.write_shift(4, r.s.r);
+ o.write_shift(4, r.e.r);
+ o.write_shift(4, r.s.c);
+ o.write_shift(4, r.e.c);
+ return o;
+}
+
+/* [MS-XLSB] 2.5.153 UncheckedRfX */
+var parse_UncheckedRfX = parse_RfX;
+var write_UncheckedRfX = write_RfX;
+
+/* [MS-XLSB] 2.5.155 UncheckedSqRfX */
+//function parse_UncheckedSqRfX(data) {
+// var cnt = data.read_shift(4);
+// var out = [];
+// for(var i = 0; i < cnt; ++i) {
+// var rng = parse_UncheckedRfX(data);
+// out.push(encode_range(rng));
+// }
+// return out.join(",");
+//}
+//function write_UncheckedSqRfX(sqrfx) {
+// var parts = sqrfx.split(/\s*,\s*/);
+// var o = new_buf(4); o.write_shift(4, parts.length);
+// var out = [o];
+// parts.forEach(function(rng) {
+// out.push(write_UncheckedRfX(safe_decode_range(rng)));
+// });
+// return bconcat(out);
+//}
+
+/* [MS-XLS] 2.5.342 ; [MS-XLSB] 2.5.171 */
+/* TODO: error checking, NaN and Infinity values are not valid Xnum */
+function parse_Xnum(data) {
+ if(data.length - data.l < 8) throw "XLS Xnum Buffer underflow";
+ return data.read_shift(8, 'f');
+}
+function write_Xnum(data, o) { return (o || new_buf(8)).write_shift(8, data, 'f'); }
+
+/* [MS-XLSB] 2.4.324 BrtColor */
+function parse_BrtColor(data) {
+ var out = {};
+ var d = data.read_shift(1);
+
+ //var fValidRGB = d & 1;
+ var xColorType = d >>> 1;
+
+ var index = data.read_shift(1);
+ var nTS = data.read_shift(2, 'i');
+ var bR = data.read_shift(1);
+ var bG = data.read_shift(1);
+ var bB = data.read_shift(1);
+ data.l++; //var bAlpha = data.read_shift(1);
+
+ switch (xColorType) {
+ case 0: out.auto = 1; break;
+ case 1:
+ out.index = index;
+ var icv = XLSIcv[index];
+ /* automatic pseudo index 81 */
+ if (icv) out.rgb = rgb2Hex(icv);
+ break;
+ case 2:
+ /* if(!fValidRGB) throw new Error("invalid"); */
+ out.rgb = rgb2Hex([bR, bG, bB]);
+ break;
+ case 3: out.theme = index; break;
+ }
+ if (nTS != 0) out.tint = nTS > 0 ? nTS / 32767 : nTS / 32768;
+
+ return out;
+}
+function write_BrtColor(color, o) {
+ if (!o) o = new_buf(8);
+ if (!color || color.auto) { o.write_shift(4, 0); o.write_shift(4, 0); return o; }
+ if (color.index != null) {
+ o.write_shift(1, 0x02);
+ o.write_shift(1, color.index);
+ } else if (color.theme != null) {
+ o.write_shift(1, 0x06);
+ o.write_shift(1, color.theme);
+ } else {
+ o.write_shift(1, 0x05);
+ o.write_shift(1, 0);
+ }
+ var nTS = color.tint || 0;
+ if (nTS > 0) nTS *= 32767;
+ else if (nTS < 0) nTS *= 32768;
+ o.write_shift(2, nTS);
+ if (!color.rgb || color.theme != null) {
+ o.write_shift(2, 0);
+ o.write_shift(1, 0);
+ o.write_shift(1, 0);
+ } else {
+ var rgb = (color.rgb || 'FFFFFF');
+ if (typeof rgb == 'number') rgb = ("000000" + rgb.toString(16)).slice(-6);
+ o.write_shift(1, parseInt(rgb.slice(0, 2), 16));
+ o.write_shift(1, parseInt(rgb.slice(2, 4), 16));
+ o.write_shift(1, parseInt(rgb.slice(4, 6), 16));
+ o.write_shift(1, 0xFF);
+ }
+ return o;
+}
+
+/* [MS-XLSB] 2.5.52 */
+function parse_FontFlags(data) {
+ var d = data.read_shift(1);
+ data.l++;
+ var out = {
+ fBold: d & 0x01,
+ fItalic: d & 0x02,
+ fUnderline: d & 0x04,
+ fStrikeout: d & 0x08,
+ fOutline: d & 0x10,
+ fShadow: d & 0x20,
+ fCondense: d & 0x40,
+ fExtend: d & 0x80
+ };
+ return out;
+}
+function write_FontFlags(font, o) {
+ if (!o) o = new_buf(2);
+ var grbit =
+ (font.italic ? 0x02 : 0) |
+ (font.strike ? 0x08 : 0) |
+ (font.outline ? 0x10 : 0) |
+ (font.shadow ? 0x20 : 0) |
+ (font.condense ? 0x40 : 0) |
+ (font.extend ? 0x80 : 0);
+ o.write_shift(1, grbit);
+ o.write_shift(1, 0);
+ return o;
+}
+
+/* [MS-OLEDS] 2.3.1 and 2.3.2 */
+function parse_ClipboardFormatOrString(o, w) {
+ // $FlowIgnore
+ var ClipFmt = { 2: "BITMAP", 3: "METAFILEPICT", 8: "DIB", 14: "ENHMETAFILE" };
+ var m = o.read_shift(4);
+ switch (m) {
+ case 0x00000000: return "";
+ case 0xffffffff: case 0xfffffffe: return ClipFmt[o.read_shift(4)] || "";
+ }
+ if (m > 0x190) throw new Error("Unsupported Clipboard: " + m.toString(16));
+ o.l -= 4;
+ return o.read_shift(0, w == 1 ? "lpstr" : "lpwstr");
+}
+function parse_ClipboardFormatOrAnsiString(o) { return parse_ClipboardFormatOrString(o, 1); }
+function parse_ClipboardFormatOrUnicodeString(o) { return parse_ClipboardFormatOrString(o, 2); }
+
+/* [MS-OLEPS] 2.2 PropertyType */
+// Note: some tree shakers cannot handle VT_VECTOR | $CONST, hence extra vars
+//var VT_EMPTY = 0x0000;
+//var VT_NULL = 0x0001;
+var VT_I2 = 0x0002;
+var VT_I4 = 0x0003;
+//var VT_R4 = 0x0004;
+//var VT_R8 = 0x0005;
+//var VT_CY = 0x0006;
+//var VT_DATE = 0x0007;
+//var VT_BSTR = 0x0008;
+//var VT_ERROR = 0x000A;
+var VT_BOOL = 0x000B;
+var VT_VARIANT = 0x000C;
+//var VT_DECIMAL = 0x000E;
+//var VT_I1 = 0x0010;
+//var VT_UI1 = 0x0011;
+//var VT_UI2 = 0x0012;
+var VT_UI4 = 0x0013;
+//var VT_I8 = 0x0014;
+//var VT_UI8 = 0x0015;
+//var VT_INT = 0x0016;
+//var VT_UINT = 0x0017;
+var VT_LPSTR = 0x001E;
+//var VT_LPWSTR = 0x001F;
+var VT_FILETIME = 0x0040;
+var VT_BLOB = 0x0041;
+//var VT_STREAM = 0x0042;
+//var VT_STORAGE = 0x0043;
+//var VT_STREAMED_Object = 0x0044;
+//var VT_STORED_Object = 0x0045;
+//var VT_BLOB_Object = 0x0046;
+var VT_CF = 0x0047;
+//var VT_CLSID = 0x0048;
+//var VT_VERSIONED_STREAM = 0x0049;
+var VT_VECTOR = 0x1000;
+var VT_VECTOR_VARIANT = 0x100C;
+var VT_VECTOR_LPSTR = 0x101E;
+//var VT_ARRAY = 0x2000;
+
+var VT_STRING = 0x0050; // 2.3.3.1.11 VtString
+var VT_USTR = 0x0051; // 2.3.3.1.12 VtUnalignedString
+var VT_CUSTOM = [VT_STRING, VT_USTR];
+
+/* [MS-OSHARED] 2.3.3.2.2.1 Document Summary Information PIDDSI */
+var DocSummaryPIDDSI = {
+0x01: { n: 'CodePage', t: VT_I2 },
+0x02: { n: 'Category', t: VT_STRING },
+0x03: { n: 'PresentationFormat', t: VT_STRING },
+0x04: { n: 'ByteCount', t: VT_I4 },
+0x05: { n: 'LineCount', t: VT_I4 },
+0x06: { n: 'ParagraphCount', t: VT_I4 },
+0x07: { n: 'SlideCount', t: VT_I4 },
+0x08: { n: 'NoteCount', t: VT_I4 },
+0x09: { n: 'HiddenCount', t: VT_I4 },
+0x0a: { n: 'MultimediaClipCount', t: VT_I4 },
+0x0b: { n: 'ScaleCrop', t: VT_BOOL },
+0x0c: { n: 'HeadingPairs', t: VT_VECTOR_VARIANT /* VT_VECTOR | VT_VARIANT */ },
+0x0d: { n: 'TitlesOfParts', t: VT_VECTOR_LPSTR /* VT_VECTOR | VT_LPSTR */ },
+0x0e: { n: 'Manager', t: VT_STRING },
+0x0f: { n: 'Company', t: VT_STRING },
+0x10: { n: 'LinksUpToDate', t: VT_BOOL },
+0x11: { n: 'CharacterCount', t: VT_I4 },
+0x13: { n: 'SharedDoc', t: VT_BOOL },
+0x16: { n: 'HyperlinksChanged', t: VT_BOOL },
+0x17: { n: 'AppVersion', t: VT_I4, p: 'version' },
+0x18: { n: 'DigSig', t: VT_BLOB },
+0x1A: { n: 'ContentType', t: VT_STRING },
+0x1B: { n: 'ContentStatus', t: VT_STRING },
+0x1C: { n: 'Language', t: VT_STRING },
+0x1D: { n: 'Version', t: VT_STRING },
+0xFF: {},
+ /* [MS-OLEPS] 2.18 */
+0x80000000: { n: 'Locale', t: VT_UI4 },
+0x80000003: { n: 'Behavior', t: VT_UI4 },
+0x72627262: {}
+};
+
+/* [MS-OSHARED] 2.3.3.2.1.1 Summary Information Property Set PIDSI */
+var SummaryPIDSI = {
+0x01: { n: 'CodePage', t: VT_I2 },
+0x02: { n: 'Title', t: VT_STRING },
+0x03: { n: 'Subject', t: VT_STRING },
+0x04: { n: 'Author', t: VT_STRING },
+0x05: { n: 'Keywords', t: VT_STRING },
+0x06: { n: 'Comments', t: VT_STRING },
+0x07: { n: 'Template', t: VT_STRING },
+0x08: { n: 'LastAuthor', t: VT_STRING },
+0x09: { n: 'RevNumber', t: VT_STRING },
+0x0A: { n: 'EditTime', t: VT_FILETIME },
+0x0B: { n: 'LastPrinted', t: VT_FILETIME },
+0x0C: { n: 'CreatedDate', t: VT_FILETIME },
+0x0D: { n: 'ModifiedDate', t: VT_FILETIME },
+0x0E: { n: 'PageCount', t: VT_I4 },
+0x0F: { n: 'WordCount', t: VT_I4 },
+0x10: { n: 'CharCount', t: VT_I4 },
+0x11: { n: 'Thumbnail', t: VT_CF },
+0x12: { n: 'Application', t: VT_STRING },
+0x13: { n: 'DocSecurity', t: VT_I4 },
+0xFF: {},
+ /* [MS-OLEPS] 2.18 */
+0x80000000: { n: 'Locale', t: VT_UI4 },
+0x80000003: { n: 'Behavior', t: VT_UI4 },
+0x72627262: {}
+};
+
+/* [MS-XLS] 2.4.63 Country/Region codes */
+var CountryEnum = {
+0x0001: "US", // United States
+0x0002: "CA", // Canada
+0x0003: "", // Latin America (except Brazil)
+0x0007: "RU", // Russia
+0x0014: "EG", // Egypt
+0x001E: "GR", // Greece
+0x001F: "NL", // Netherlands
+0x0020: "BE", // Belgium
+0x0021: "FR", // France
+0x0022: "ES", // Spain
+0x0024: "HU", // Hungary
+0x0027: "IT", // Italy
+0x0029: "CH", // Switzerland
+0x002B: "AT", // Austria
+0x002C: "GB", // United Kingdom
+0x002D: "DK", // Denmark
+0x002E: "SE", // Sweden
+0x002F: "NO", // Norway
+0x0030: "PL", // Poland
+0x0031: "DE", // Germany
+0x0034: "MX", // Mexico
+0x0037: "BR", // Brazil
+0x003d: "AU", // Australia
+0x0040: "NZ", // New Zealand
+0x0042: "TH", // Thailand
+0x0051: "JP", // Japan
+0x0052: "KR", // Korea
+0x0054: "VN", // Viet Nam
+0x0056: "CN", // China
+0x005A: "TR", // Turkey
+0x0069: "JS", // Ramastan
+0x00D5: "DZ", // Algeria
+0x00D8: "MA", // Morocco
+0x00DA: "LY", // Libya
+0x015F: "PT", // Portugal
+0x0162: "IS", // Iceland
+0x0166: "FI", // Finland
+0x01A4: "CZ", // Czech Republic
+0x0376: "TW", // Taiwan
+0x03C1: "LB", // Lebanon
+0x03C2: "JO", // Jordan
+0x03C3: "SY", // Syria
+0x03C4: "IQ", // Iraq
+0x03C5: "KW", // Kuwait
+0x03C6: "SA", // Saudi Arabia
+0x03CB: "AE", // United Arab Emirates
+0x03CC: "IL", // Israel
+0x03CE: "QA", // Qatar
+0x03D5: "IR", // Iran
+0xFFFF: "US" // United States
+};
+
+/* [MS-XLS] 2.5.127 */
+var XLSFillPattern = [
+ null,
+ 'solid',
+ 'mediumGray',
+ 'darkGray',
+ 'lightGray',
+ 'darkHorizontal',
+ 'darkVertical',
+ 'darkDown',
+ 'darkUp',
+ 'darkGrid',
+ 'darkTrellis',
+ 'lightHorizontal',
+ 'lightVertical',
+ 'lightDown',
+ 'lightUp',
+ 'lightGrid',
+ 'lightTrellis',
+ 'gray125',
+ 'gray0625'
+];
+
+function rgbify(arr) { return arr.map(function(x) { return [(x>>16)&255,(x>>8)&255,x&255]; }); }
+
+/* [MS-XLS] 2.5.161 */
+/* [MS-XLSB] 2.5.75 Icv */
+var _XLSIcv = rgbify([
+ /* Color Constants */
+ 0x000000,
+ 0xFFFFFF,
+ 0xFF0000,
+ 0x00FF00,
+ 0x0000FF,
+ 0xFFFF00,
+ 0xFF00FF,
+ 0x00FFFF,
+
+ /* Overridable Defaults */
+ 0x000000,
+ 0xFFFFFF,
+ 0xFF0000,
+ 0x00FF00,
+ 0x0000FF,
+ 0xFFFF00,
+ 0xFF00FF,
+ 0x00FFFF,
+
+ 0x800000,
+ 0x008000,
+ 0x000080,
+ 0x808000,
+ 0x800080,
+ 0x008080,
+ 0xC0C0C0,
+ 0x808080,
+ 0x9999FF,
+ 0x993366,
+ 0xFFFFCC,
+ 0xCCFFFF,
+ 0x660066,
+ 0xFF8080,
+ 0x0066CC,
+ 0xCCCCFF,
+
+ 0x000080,
+ 0xFF00FF,
+ 0xFFFF00,
+ 0x00FFFF,
+ 0x800080,
+ 0x800000,
+ 0x008080,
+ 0x0000FF,
+ 0x00CCFF,
+ 0xCCFFFF,
+ 0xCCFFCC,
+ 0xFFFF99,
+ 0x99CCFF,
+ 0xFF99CC,
+ 0xCC99FF,
+ 0xFFCC99,
+
+ 0x3366FF,
+ 0x33CCCC,
+ 0x99CC00,
+ 0xFFCC00,
+ 0xFF9900,
+ 0xFF6600,
+ 0x666699,
+ 0x969696,
+ 0x003366,
+ 0x339966,
+ 0x003300,
+ 0x333300,
+ 0x993300,
+ 0x993366,
+ 0x333399,
+ 0x333333,
+
+ /* Other entries to appease BIFF8/12 */
+ 0xFFFFFF, /* 0x40 icvForeground ?? */
+ 0x000000, /* 0x41 icvBackground ?? */
+ 0x000000, /* 0x42 icvFrame ?? */
+ 0x000000, /* 0x43 icv3D ?? */
+ 0x000000, /* 0x44 icv3DText ?? */
+ 0x000000, /* 0x45 icv3DHilite ?? */
+ 0x000000, /* 0x46 icv3DShadow ?? */
+ 0x000000, /* 0x47 icvHilite ?? */
+ 0x000000, /* 0x48 icvCtlText ?? */
+ 0x000000, /* 0x49 icvCtlScrl ?? */
+ 0x000000, /* 0x4A icvCtlInv ?? */
+ 0x000000, /* 0x4B icvCtlBody ?? */
+ 0x000000, /* 0x4C icvCtlFrame ?? */
+ 0x000000, /* 0x4D icvCtlFore ?? */
+ 0x000000, /* 0x4E icvCtlBack ?? */
+ 0x000000, /* 0x4F icvCtlNeutral */
+ 0x000000, /* 0x50 icvInfoBk ?? */
+ 0x000000 /* 0x51 icvInfoText ?? */
+]);
+var XLSIcv = dup(_XLSIcv);
+
+/* [MS-XLSB] 2.5.97.2 */
+var BErr = {
+0x00: "#NULL!",
+0x07: "#DIV/0!",
+0x0F: "#VALUE!",
+0x17: "#REF!",
+0x1D: "#NAME?",
+0x24: "#NUM!",
+0x2A: "#N/A",
+0x2B: "#GETTING_DATA",
+0xFF: "#WTF?"
+};
+//var RBErr = evert_num(BErr);
+var RBErr = {
+ "#NULL!": 0x00,
+ "#DIV/0!": 0x07,
+ "#VALUE!": 0x0F,
+ "#REF!": 0x17,
+ "#NAME?": 0x1D,
+ "#NUM!": 0x24,
+ "#N/A": 0x2A,
+ "#GETTING_DATA": 0x2B,
+ "#WTF?": 0xFF
+};
+
+/* Parts enumerated in OPC spec, MS-XLSB and MS-XLSX */
+/* 12.3 Part Summary */
+/* 14.2 Part Summary */
+/* [MS-XLSX] 2.1 Part Enumerations ; [MS-XLSB] 2.1.7 Part Enumeration */
+var ct2type/*{[string]:string}*/ = ({
+ /* Workbook */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": "workbooks",
+ "application/vnd.ms-excel.sheet.macroEnabled.main+xml": "workbooks",
+ "application/vnd.ms-excel.sheet.binary.macroEnabled.main": "workbooks",
+ "application/vnd.ms-excel.addin.macroEnabled.main+xml": "workbooks",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": "workbooks",
+
+ /* Worksheet */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": "sheets",
+ "application/vnd.ms-excel.worksheet": "sheets",
+ "application/vnd.ms-excel.binIndexWs": "TODO", /* Binary Index */
+
+ /* Chartsheet */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": "charts",
+ "application/vnd.ms-excel.chartsheet": "charts",
+
+ /* Macrosheet */
+ "application/vnd.ms-excel.macrosheet+xml": "macros",
+ "application/vnd.ms-excel.macrosheet": "macros",
+ "application/vnd.ms-excel.intlmacrosheet": "TODO",
+ "application/vnd.ms-excel.binIndexMs": "TODO", /* Binary Index */
+
+ /* Dialogsheet */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": "dialogs",
+ "application/vnd.ms-excel.dialogsheet": "dialogs",
+
+ /* Shared Strings */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml": "strs",
+ "application/vnd.ms-excel.sharedStrings": "strs",
+
+ /* Styles */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": "styles",
+ "application/vnd.ms-excel.styles": "styles",
+
+ /* File Properties */
+ "application/vnd.openxmlformats-package.core-properties+xml": "coreprops",
+ "application/vnd.openxmlformats-officedocument.custom-properties+xml": "custprops",
+ "application/vnd.openxmlformats-officedocument.extended-properties+xml": "extprops",
+
+ /* Custom Data Properties */
+ "application/vnd.openxmlformats-officedocument.customXmlProperties+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.customProperty": "TODO",
+
+ /* Comments */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": "comments",
+ "application/vnd.ms-excel.comments": "comments",
+ "application/vnd.ms-excel.threadedcomments+xml": "threadedcomments",
+ "application/vnd.ms-excel.person+xml": "people",
+
+ /* Metadata (Stock/Geography and Dynamic Array) */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml": "metadata",
+ "application/vnd.ms-excel.sheetMetadata": "metadata",
+
+ /* PivotTable */
+ "application/vnd.ms-excel.pivotTable": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml": "TODO",
+
+ /* Chart Objects */
+ "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": "TODO",
+
+ /* Chart Colors */
+ "application/vnd.ms-office.chartcolorstyle+xml": "TODO",
+
+ /* Chart Style */
+ "application/vnd.ms-office.chartstyle+xml": "TODO",
+
+ /* Chart Advanced */
+ "application/vnd.ms-office.chartex+xml": "TODO",
+
+ /* Calculation Chain */
+ "application/vnd.ms-excel.calcChain": "calcchains",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml": "calcchains",
+
+ /* Printer Settings */
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.printerSettings": "TODO",
+
+ /* ActiveX */
+ "application/vnd.ms-office.activeX": "TODO",
+ "application/vnd.ms-office.activeX+xml": "TODO",
+
+ /* Custom Toolbars */
+ "application/vnd.ms-excel.attachedToolbars": "TODO",
+
+ /* External Data Connections */
+ "application/vnd.ms-excel.connections": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": "TODO",
+
+ /* External Links */
+ "application/vnd.ms-excel.externalLink": "links",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml": "links",
+
+ /* PivotCache */
+ "application/vnd.ms-excel.pivotCacheDefinition": "TODO",
+ "application/vnd.ms-excel.pivotCacheRecords": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml": "TODO",
+
+ /* Query Table */
+ "application/vnd.ms-excel.queryTable": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml": "TODO",
+
+ /* Shared Workbook */
+ "application/vnd.ms-excel.userNames": "TODO",
+ "application/vnd.ms-excel.revisionHeaders": "TODO",
+ "application/vnd.ms-excel.revisionLog": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml": "TODO",
+
+ /* Single Cell Table */
+ "application/vnd.ms-excel.tableSingleCells": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml": "TODO",
+
+ /* Slicer */
+ "application/vnd.ms-excel.slicer": "TODO",
+ "application/vnd.ms-excel.slicerCache": "TODO",
+ "application/vnd.ms-excel.slicer+xml": "TODO",
+ "application/vnd.ms-excel.slicerCache+xml": "TODO",
+
+ /* Sort Map */
+ "application/vnd.ms-excel.wsSortMap": "TODO",
+
+ /* Table */
+ "application/vnd.ms-excel.table": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": "TODO",
+
+ /* Themes */
+ "application/vnd.openxmlformats-officedocument.theme+xml": "themes",
+
+ /* Theme Override */
+ "application/vnd.openxmlformats-officedocument.themeOverride+xml": "TODO",
+
+ /* Timeline */
+ "application/vnd.ms-excel.Timeline+xml": "TODO", /* verify */
+ "application/vnd.ms-excel.TimelineCache+xml": "TODO", /* verify */
+
+ /* VBA */
+ "application/vnd.ms-office.vbaProject": "vba",
+ "application/vnd.ms-office.vbaProjectSignature": "TODO",
+
+ /* Volatile Dependencies */
+ "application/vnd.ms-office.volatileDependencies": "TODO",
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml": "TODO",
+
+ /* Control Properties */
+ "application/vnd.ms-excel.controlproperties+xml": "TODO",
+
+ /* Data Model */
+ "application/vnd.openxmlformats-officedocument.model+data": "TODO",
+
+ /* Survey */
+ "application/vnd.ms-excel.Survey+xml": "TODO",
+
+ /* Drawing */
+ "application/vnd.openxmlformats-officedocument.drawing+xml": "drawings",
+ "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml": "TODO",
+ "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml": "TODO",
+
+ /* VML */
+ "application/vnd.openxmlformats-officedocument.vmlDrawing": "TODO",
+
+ "application/vnd.openxmlformats-package.relationships+xml": "rels",
+ "application/vnd.openxmlformats-officedocument.oleObject": "TODO",
+
+ /* Image */
+ "image/png": "TODO",
+
+ "sheet": "js"
+});
+
+var CT_LIST = {
+ workbooks: {
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+ xlsm: "application/vnd.ms-excel.sheet.macroEnabled.main+xml",
+ xlsb: "application/vnd.ms-excel.sheet.binary.macroEnabled.main",
+ xlam: "application/vnd.ms-excel.addin.macroEnabled.main+xml",
+ xltx: "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml"
+ },
+ strs: { /* Shared Strings */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",
+ xlsb: "application/vnd.ms-excel.sharedStrings"
+ },
+ comments: { /* Comments */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
+ xlsb: "application/vnd.ms-excel.comments"
+ },
+ sheets: { /* Worksheet */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+ xlsb: "application/vnd.ms-excel.worksheet"
+ },
+ charts: { /* Chartsheet */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml",
+ xlsb: "application/vnd.ms-excel.chartsheet"
+ },
+ dialogs: { /* Dialogsheet */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml",
+ xlsb: "application/vnd.ms-excel.dialogsheet"
+ },
+ macros: { /* Macrosheet (Excel 4.0 Macros) */
+ xlsx: "application/vnd.ms-excel.macrosheet+xml",
+ xlsb: "application/vnd.ms-excel.macrosheet"
+ },
+ metadata: { /* Metadata (Stock/Geography and Dynamic Array) */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml",
+ xlsb: "application/vnd.ms-excel.sheetMetadata"
+ },
+ styles: { /* Styles */
+ xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
+ xlsb: "application/vnd.ms-excel.styles"
+ }
+};
+
+function new_ct() {
+ return ({
+ workbooks:[], sheets:[], charts:[], dialogs:[], macros:[],
+ rels:[], strs:[], comments:[], threadedcomments:[], links:[],
+ coreprops:[], extprops:[], custprops:[], themes:[], styles:[],
+ calcchains:[], vba: [], drawings: [], metadata: [], people:[],
+ TODO:[], xmlns: "" });
+}
+
+function parse_ct(data) {
+ var ct = new_ct();
+ if(!data || !data.match) return ct;
+ var ctext = {};
+ (data.match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ switch(y[0].replace(nsregex,"<")) {
+ case ' 0 ? ct.calcchains[0] : "";
+ ct.sst = ct.strs.length > 0 ? ct.strs[0] : "";
+ ct.style = ct.styles.length > 0 ? ct.styles[0] : "";
+ ct.defaults = ctext;
+ delete ct.calcchains;
+ return ct;
+}
+
+function write_ct(ct, opts) {
+ var type2ct/*{[string]:Array}*/ = evert_arr(ct2type);
+
+ var o = [], v;
+ o[o.length] = (XML_HEADER);
+ o[o.length] = writextag('Types', null, {
+ 'xmlns': XMLNS.CT,
+ 'xmlns:xsd': XMLNS.xsd,
+ 'xmlns:xsi': XMLNS.xsi
+ });
+
+ o = o.concat([
+ ['xml', 'application/xml'],
+ ['bin', 'application/vnd.ms-excel.sheet.binary.macroEnabled.main'],
+ ['vml', 'application/vnd.openxmlformats-officedocument.vmlDrawing'],
+ ['data', 'application/vnd.openxmlformats-officedocument.model+data'],
+ /* from test files */
+ ['bmp', 'image/bmp'],
+ ['png', 'image/png'],
+ ['gif', 'image/gif'],
+ ['emf', 'image/x-emf'],
+ ['wmf', 'image/x-wmf'],
+ ['jpg', 'image/jpeg'], ['jpeg', 'image/jpeg'],
+ ['tif', 'image/tiff'], ['tiff', 'image/tiff'],
+ ['pdf', 'application/pdf'],
+ ['rels', 'application/vnd.openxmlformats-package.relationships+xml']
+ ].map(function(x) {
+ return writextag('Default', null, {'Extension':x[0], 'ContentType': x[1]});
+ }));
+
+ /* only write first instance */
+ var f1 = function(w) {
+ if(ct[w] && ct[w].length > 0) {
+ v = ct[w][0];
+ o[o.length] = (writextag('Override', null, {
+ 'PartName': (v[0] == '/' ? "":"/") + v,
+ 'ContentType': CT_LIST[w][opts.bookType] || CT_LIST[w]['xlsx']
+ }));
+ }
+ };
+
+ /* book type-specific */
+ var f2 = function(w) {
+ (ct[w]||[]).forEach(function(v) {
+ o[o.length] = (writextag('Override', null, {
+ 'PartName': (v[0] == '/' ? "":"/") + v,
+ 'ContentType': CT_LIST[w][opts.bookType] || CT_LIST[w]['xlsx']
+ }));
+ });
+ };
+
+ /* standard type */
+ var f3 = function(t) {
+ (ct[t]||[]).forEach(function(v) {
+ o[o.length] = (writextag('Override', null, {
+ 'PartName': (v[0] == '/' ? "":"/") + v,
+ 'ContentType': type2ct[t][0]
+ }));
+ });
+ };
+
+ f1('workbooks');
+ f2('sheets');
+ f2('charts');
+ f3('themes');
+ ['strs', 'styles'].forEach(f1);
+ ['coreprops', 'extprops', 'custprops'].forEach(f3);
+ f3('vba');
+ f3('comments');
+ f3('threadedcomments');
+ f3('drawings');
+ f2('metadata');
+ f3('people');
+ if(o.length>2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* 9.3 Relationships */
+var RELS = ({
+ WB: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+ SHEET: "http://sheetjs.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+ HLINK: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+ VML: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing",
+ XPATH: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLinkPath",
+ XMISS: "http://schemas.microsoft.com/office/2006/relationships/xlExternalLinkPath/xlPathMissing",
+ XLINK: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink",
+ CXML: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml",
+ CXMLP: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps",
+ CMNT: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+ CORE_PROPS: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+ EXT_PROPS: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties',
+ CUST_PROPS: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties',
+ SST: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+ STY: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+ THEME: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+ CHART: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+ CHARTEX: "http://schemas.microsoft.com/office/2014/relationships/chartEx",
+ CS: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartsheet",
+ WS: [
+ "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+ "http://purl.oclc.org/ooxml/officeDocument/relationships/worksheet"
+ ],
+ DS: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/dialogsheet",
+ MS: "http://schemas.microsoft.com/office/2006/relationships/xlMacrosheet",
+ IMG: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+ DRAW: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+ XLMETA: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata",
+ TCMNT: "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment",
+ PEOPLE: "http://schemas.microsoft.com/office/2017/10/relationships/person",
+ VBA: "http://schemas.microsoft.com/office/2006/relationships/vbaProject"
+});
+
+
+/* 9.3.3 Representing Relationships */
+function get_rels_path(file) {
+ var n = file.lastIndexOf("/");
+ return file.slice(0,n+1) + '_rels/' + file.slice(n+1) + ".rels";
+}
+
+function parse_rels(data, currentFilePath) {
+ var rels = {"!id":{}};
+ if (!data) return rels;
+ if (currentFilePath.charAt(0) !== '/') {
+ currentFilePath = '/'+currentFilePath;
+ }
+ var hash = {};
+
+ (data.match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ /* 9.3.2.2 OPC_Relationships */
+ if (y[0] === '2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+
+function add_rels(rels, rId, f, type, relobj, targetmode) {
+ if(!relobj) relobj = {};
+ if(!rels['!id']) rels['!id'] = {};
+ if(!rels['!idx']) rels['!idx'] = 1;
+ if(rId < 0) for(rId = rels['!idx']; rels['!id']['rId' + rId]; ++rId){/* empty */}
+ rels['!idx'] = rId + 1;
+ relobj.Id = 'rId' + rId;
+ relobj.Type = type;
+ relobj.Target = f;
+ if(targetmode) relobj.TargetMode = targetmode;
+ else if([RELS.HLINK, RELS.XPATH, RELS.XMISS].indexOf(relobj.Type) > -1) relobj.TargetMode = "External";
+ if(rels['!id'][relobj.Id]) throw new Error("Cannot rewrite rId " + rId);
+ rels['!id'][relobj.Id] = relobj;
+ rels[('/' + relobj.Target).replace("//","/")] = relobj;
+ return rId;
+}
+/* Open Document Format for Office Applications (OpenDocument) Version 1.2 */
+/* Part 3 Section 4 Manifest File */
+var CT_ODS = "application/vnd.oasis.opendocument.spreadsheet";
+function parse_manifest(d, opts) {
+ var str = xlml_normalize(d);
+ var Rn;
+ var FEtag;
+ while((Rn = xlmlregex.exec(str))) switch(Rn[3]) {
+ case 'manifest': break; // 4.2
+ case 'file-entry': // 4.3
+ FEtag = parsexmltag(Rn[0], false);
+ if(FEtag.path == '/' && FEtag.type !== CT_ODS) throw new Error("This OpenDocument is not a spreadsheet");
+ break;
+ case 'encryption-data': // 4.4
+ case 'algorithm': // 4.5
+ case 'start-key-generation': // 4.6
+ case 'key-derivation': // 4.7
+ throw new Error("Unsupported ODS Encryption");
+ default: if(opts && opts.WTF) throw Rn;
+ }
+}
+
+function write_manifest(manifest) {
+ var o = [XML_HEADER];
+ o.push('\n');
+ o.push(' \n');
+ for(var i = 0; i < manifest.length; ++i) o.push(' \n');
+ o.push('');
+ return o.join("");
+}
+
+/* Part 3 Section 6 Metadata Manifest File */
+function write_rdf_type(file, res, tag) {
+ return [
+ ' \n',
+ ' \n',
+ ' \n'
+ ].join("");
+}
+function write_rdf_has(base, file) {
+ return [
+ ' \n',
+ ' \n',
+ ' \n'
+ ].join("");
+}
+function write_rdf(rdf) {
+ var o = [XML_HEADER];
+ o.push('\n');
+ for(var i = 0; i != rdf.length; ++i) {
+ o.push(write_rdf_type(rdf[i][0], rdf[i][1]));
+ o.push(write_rdf_has("",rdf[i][0]));
+ }
+ o.push(write_rdf_type("","Document", "pkg"));
+ o.push('');
+ return o.join("");
+}
+/* TODO: pull properties */
+function write_meta_ods() {
+ return 'Sheet' + 'JS ' + XLSX.version + '';
+}
+
+/* ECMA-376 Part II 11.1 Core Properties Part */
+/* [MS-OSHARED] 2.3.3.2.[1-2].1 (PIDSI/PIDDSI) */
+var CORE_PROPS = [
+ ["cp:category", "Category"],
+ ["cp:contentStatus", "ContentStatus"],
+ ["cp:keywords", "Keywords"],
+ ["cp:lastModifiedBy", "LastAuthor"],
+ ["cp:lastPrinted", "LastPrinted"],
+ ["cp:revision", "RevNumber"],
+ ["cp:version", "Version"],
+ ["dc:creator", "Author"],
+ ["dc:description", "Comments"],
+ ["dc:identifier", "Identifier"],
+ ["dc:language", "Language"],
+ ["dc:subject", "Subject"],
+ ["dc:title", "Title"],
+ ["dcterms:created", "CreatedDate", 'date'],
+ ["dcterms:modified", "ModifiedDate", 'date']
+];
+
+var CORE_PROPS_REGEX = (function() {
+ var r = new Array(CORE_PROPS.length);
+ for(var i = 0; i < CORE_PROPS.length; ++i) {
+ var f = CORE_PROPS[i];
+ var g = "(?:"+ f[0].slice(0,f[0].indexOf(":")) +":)"+ f[0].slice(f[0].indexOf(":")+1);
+ r[i] = new RegExp("<" + g + "[^>]*>([\\s\\S]*?)<\/" + g + ">");
+ }
+ return r;
+})();
+
+function parse_core_props(data) {
+ var p = {};
+ data = utf8read(data);
+
+ for(var i = 0; i < CORE_PROPS.length; ++i) {
+ var f = CORE_PROPS[i], cur = data.match(CORE_PROPS_REGEX[i]);
+ if(cur != null && cur.length > 0) p[f[1]] = unescapexml(cur[1]);
+ if(f[2] === 'date' && p[f[1]]) p[f[1]] = parseDate(p[f[1]]);
+ }
+
+ return p;
+}
+
+function cp_doit(f, g, h, o, p) {
+ if(p[f] != null || g == null || g === "") return;
+ p[f] = g;
+ g = escapexml(g);
+ o[o.length] = (h ? writextag(f,g,h) : writetag(f,g));
+}
+
+function write_core_props(cp, _opts) {
+ var opts = _opts || {};
+ var o = [XML_HEADER, writextag('cp:coreProperties', null, {
+ //'xmlns': XMLNS.CORE_PROPS,
+ 'xmlns:cp': XMLNS.CORE_PROPS,
+ 'xmlns:dc': XMLNS.dc,
+ 'xmlns:dcterms': XMLNS.dcterms,
+ 'xmlns:dcmitype': XMLNS.dcmitype,
+ 'xmlns:xsi': XMLNS.xsi
+ })], p = {};
+ if(!cp && !opts.Props) return o.join("");
+
+ if(cp) {
+ if(cp.CreatedDate != null) cp_doit("dcterms:created", typeof cp.CreatedDate === "string" ? cp.CreatedDate : write_w3cdtf(cp.CreatedDate, opts.WTF), {"xsi:type":"dcterms:W3CDTF"}, o, p);
+ if(cp.ModifiedDate != null) cp_doit("dcterms:modified", typeof cp.ModifiedDate === "string" ? cp.ModifiedDate : write_w3cdtf(cp.ModifiedDate, opts.WTF), {"xsi:type":"dcterms:W3CDTF"}, o, p);
+ }
+
+ for(var i = 0; i != CORE_PROPS.length; ++i) {
+ var f = CORE_PROPS[i];
+ var v = opts.Props && opts.Props[f[1]] != null ? opts.Props[f[1]] : cp ? cp[f[1]] : null;
+ if(v === true) v = "1";
+ else if(v === false) v = "0";
+ else if(typeof v == "number") v = String(v);
+ if(v != null) cp_doit(f[0], v, null, o, p);
+ }
+ if(o.length>2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* 15.2.12.3 Extended File Properties Part */
+/* [MS-OSHARED] 2.3.3.2.[1-2].1 (PIDSI/PIDDSI) */
+var EXT_PROPS = [
+ ["Application", "Application", "string"],
+ ["AppVersion", "AppVersion", "string"],
+ ["Company", "Company", "string"],
+ ["DocSecurity", "DocSecurity", "string"],
+ ["Manager", "Manager", "string"],
+ ["HyperlinksChanged", "HyperlinksChanged", "bool"],
+ ["SharedDoc", "SharedDoc", "bool"],
+ ["LinksUpToDate", "LinksUpToDate", "bool"],
+ ["ScaleCrop", "ScaleCrop", "bool"],
+ ["HeadingPairs", "HeadingPairs", "raw"],
+ ["TitlesOfParts", "TitlesOfParts", "raw"]
+];
+
+var PseudoPropsPairs = [
+ "Worksheets", "SheetNames",
+ "NamedRanges", "DefinedNames",
+ "Chartsheets", "ChartNames"
+];
+function load_props_pairs(HP, TOP, props, opts) {
+ var v = [];
+ if(typeof HP == "string") v = parseVector(HP, opts);
+ else for(var j = 0; j < HP.length; ++j) v = v.concat(HP[j].map(function(hp) { return {v:hp}; }));
+ var parts = (typeof TOP == "string") ? parseVector(TOP, opts).map(function (x) { return x.v; }) : TOP;
+ var idx = 0, len = 0;
+ if(parts.length > 0) for(var i = 0; i !== v.length; i += 2) {
+ len = +(v[i+1].v);
+ switch(v[i].v) {
+ case "Worksheets":
+ case "工作表":
+ case "Листы":
+ case "أوراق العمل":
+ case "ワークシート":
+ case "גליונות עבודה":
+ case "Arbeitsblätter":
+ case "Çalışma Sayfaları":
+ case "Feuilles de calcul":
+ case "Fogli di lavoro":
+ case "Folhas de cálculo":
+ case "Planilhas":
+ case "Regneark":
+ case "Hojas de cálculo":
+ case "Werkbladen":
+ props.Worksheets = len;
+ props.SheetNames = parts.slice(idx, idx + len);
+ break;
+
+ case "Named Ranges":
+ case "Rangos con nombre":
+ case "名前付き一覧":
+ case "Benannte Bereiche":
+ case "Navngivne områder":
+ props.NamedRanges = len;
+ props.DefinedNames = parts.slice(idx, idx + len);
+ break;
+
+ case "Charts":
+ case "Diagramme":
+ props.Chartsheets = len;
+ props.ChartNames = parts.slice(idx, idx + len);
+ break;
+ }
+ idx += len;
+ }
+}
+
+function parse_ext_props(data, p, opts) {
+ var q = {}; if(!p) p = {};
+ data = utf8read(data);
+
+ EXT_PROPS.forEach(function(f) {
+ var xml = (data.match(matchtag(f[0]))||[])[1];
+ switch(f[2]) {
+ case "string": if(xml) p[f[1]] = unescapexml(xml); break;
+ case "bool": p[f[1]] = xml === "true"; break;
+ case "raw":
+ var cur = data.match(new RegExp("<" + f[0] + "[^>]*>([\\s\\S]*?)<\/" + f[0] + ">"));
+ if(cur && cur.length > 0) q[f[1]] = cur[1];
+ break;
+ }
+ });
+
+ if(q.HeadingPairs && q.TitlesOfParts) load_props_pairs(q.HeadingPairs, q.TitlesOfParts, p, opts);
+
+ return p;
+}
+
+function write_ext_props(cp) {
+ var o = [], W = writextag;
+ if(!cp) cp = {};
+ cp.Application = "SheetJS";
+ o[o.length] = (XML_HEADER);
+ o[o.length] = (writextag('Properties', null, {
+ 'xmlns': XMLNS.EXT_PROPS,
+ 'xmlns:vt': XMLNS.vt
+ }));
+
+ EXT_PROPS.forEach(function(f) {
+ if(cp[f[1]] === undefined) return;
+ var v;
+ switch(f[2]) {
+ case 'string': v = escapexml(String(cp[f[1]])); break;
+ case 'bool': v = cp[f[1]] ? 'true' : 'false'; break;
+ }
+ if(v !== undefined) o[o.length] = (W(f[0], v));
+ });
+
+ /* TODO: HeadingPairs, TitlesOfParts */
+ o[o.length] = (W('HeadingPairs', W('vt:vector', W('vt:variant', 'Worksheets')+W('vt:variant', W('vt:i4', String(cp.Worksheets))), {size:2, baseType:"variant"})));
+ o[o.length] = (W('TitlesOfParts', W('vt:vector', cp.SheetNames.map(function(s) { return "" + escapexml(s) + ""; }).join(""), {size: cp.Worksheets, baseType:"lpstr"})));
+ if(o.length>2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* 15.2.12.2 Custom File Properties Part */
+var custregex = /<[^>]+>[^<]*/g;
+function parse_cust_props(data, opts) {
+ var p = {}, name = "";
+ var m = data.match(custregex);
+ if(m) for(var i = 0; i != m.length; ++i) {
+ var x = m[i], y = parsexmltag(x);
+ switch(y[0]) {
+ case '': name = null; break;
+ default: if (x.indexOf('');
+ var type = toks[0].slice(4), text = toks[1];
+ /* 22.4.2.32 (CT_Variant). Omit the binary types from 22.4 (Variant Types) */
+ switch(type) {
+ case 'lpstr': case 'bstr': case 'lpwstr':
+ p[name] = unescapexml(text);
+ break;
+ case 'bool':
+ p[name] = parsexmlbool(text);
+ break;
+ case 'i1': case 'i2': case 'i4': case 'i8': case 'int': case 'uint':
+ p[name] = parseInt(text, 10);
+ break;
+ case 'r4': case 'r8': case 'decimal':
+ p[name] = parseFloat(text);
+ break;
+ case 'filetime': case 'date':
+ p[name] = parseDate(text);
+ break;
+ case 'cy': case 'error':
+ p[name] = unescapexml(text);
+ break;
+ default:
+ if(type.slice(-1) == '/') break;
+ if(opts.WTF && typeof console !== 'undefined') console.warn('Unexpected', x, type, toks);
+ }
+ } else if(x.slice(0,2) === "2){ o[o.length] = ''; o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* Common Name -> XLML Name */
+var XLMLDocPropsMap = {
+ Title: 'Title',
+ Subject: 'Subject',
+ Author: 'Author',
+ Keywords: 'Keywords',
+ Comments: 'Description',
+ LastAuthor: 'LastAuthor',
+ RevNumber: 'Revision',
+ Application: 'AppName',
+ /* TotalTime: 'TotalTime', */
+ LastPrinted: 'LastPrinted',
+ CreatedDate: 'Created',
+ ModifiedDate: 'LastSaved',
+ /* Pages */
+ /* Words */
+ /* Characters */
+ Category: 'Category',
+ /* PresentationFormat */
+ Manager: 'Manager',
+ Company: 'Company',
+ /* Guid */
+ /* HyperlinkBase */
+ /* Bytes */
+ /* Lines */
+ /* Paragraphs */
+ /* CharactersWithSpaces */
+ AppVersion: 'Version',
+
+ ContentStatus: 'ContentStatus', /* NOTE: missing from schema */
+ Identifier: 'Identifier', /* NOTE: missing from schema */
+ Language: 'Language' /* NOTE: missing from schema */
+};
+var evert_XLMLDPM;
+
+function xlml_set_prop(Props, tag, val) {
+ if(!evert_XLMLDPM) evert_XLMLDPM = evert(XLMLDocPropsMap);
+ tag = evert_XLMLDPM[tag] || tag;
+ Props[tag] = val;
+}
+
+function xlml_write_docprops(Props, opts) {
+ var o = [];
+ keys(XLMLDocPropsMap).map(function(m) {
+ for(var i = 0; i < CORE_PROPS.length; ++i) if(CORE_PROPS[i][1] == m) return CORE_PROPS[i];
+ for(i = 0; i < EXT_PROPS.length; ++i) if(EXT_PROPS[i][1] == m) return EXT_PROPS[i];
+ throw m;
+ }).forEach(function(p) {
+ if(Props[p[1]] == null) return;
+ var m = opts && opts.Props && opts.Props[p[1]] != null ? opts.Props[p[1]] : Props[p[1]];
+ switch(p[2]) {
+ case 'date': m = new Date(m).toISOString().replace(/\.\d*Z/,"Z"); break;
+ }
+ if(typeof m == 'number') m = String(m);
+ else if(m === true || m === false) { m = m ? "1" : "0"; }
+ else if(m instanceof Date) m = new Date(m).toISOString().replace(/\.\d*Z/,"");
+ o.push(writetag(XLMLDocPropsMap[p[1]] || p[1], m));
+ });
+ return writextag('DocumentProperties', o.join(""), {xmlns:XLMLNS.o });
+}
+function xlml_write_custprops(Props, Custprops) {
+ var BLACKLIST = ["Worksheets","SheetNames"];
+ var T = 'CustomDocumentProperties';
+ var o = [];
+ if(Props) keys(Props).forEach(function(k) {
+if(!Object.prototype.hasOwnProperty.call(Props, k)) return;
+ for(var i = 0; i < CORE_PROPS.length; ++i) if(k == CORE_PROPS[i][1]) return;
+ for(i = 0; i < EXT_PROPS.length; ++i) if(k == EXT_PROPS[i][1]) return;
+ for(i = 0; i < BLACKLIST.length; ++i) if(k == BLACKLIST[i]) return;
+
+ var m = Props[k];
+ var t = "string";
+ if(typeof m == 'number') { t = "float"; m = String(m); }
+ else if(m === true || m === false) { t = "boolean"; m = m ? "1" : "0"; }
+ else m = String(m);
+ o.push(writextag(escapexmltag(k), m, {"dt:dt":t}));
+ });
+ if(Custprops) keys(Custprops).forEach(function(k) {
+if(!Object.prototype.hasOwnProperty.call(Custprops, k)) return;
+ if(Props && Object.prototype.hasOwnProperty.call(Props, k)) return;
+ var m = Custprops[k];
+ var t = "string";
+ if(typeof m == 'number') { t = "float"; m = String(m); }
+ else if(m === true || m === false) { t = "boolean"; m = m ? "1" : "0"; }
+ else if(m instanceof Date) { t = "dateTime.tz"; m = m.toISOString(); }
+ else m = String(m);
+ o.push(writextag(escapexmltag(k), m, {"dt:dt":t}));
+ });
+ return '<' + T + ' xmlns="' + XLMLNS.o + '">' + o.join("") + '';
+}
+/* [MS-DTYP] 2.3.3 FILETIME */
+/* [MS-OLEDS] 2.1.3 FILETIME (Packet Version) */
+/* [MS-OLEPS] 2.8 FILETIME (Packet Version) */
+function parse_FILETIME(blob) {
+ var dwLowDateTime = blob.read_shift(4), dwHighDateTime = blob.read_shift(4);
+ return new Date(((dwHighDateTime/1e7*Math.pow(2,32) + dwLowDateTime/1e7) - 11644473600)*1000).toISOString().replace(/\.000/,"");
+}
+function write_FILETIME(time) {
+ var date = (typeof time == "string") ? new Date(Date.parse(time)) : time;
+ var t = date.getTime() / 1000 + 11644473600;
+ var l = t % Math.pow(2,32), h = (t - l) / Math.pow(2,32);
+ l *= 1e7; h *= 1e7;
+ var w = (l / Math.pow(2,32)) | 0;
+ if(w > 0) { l = l % Math.pow(2,32); h += w; }
+ var o = new_buf(8); o.write_shift(4, l); o.write_shift(4, h); return o;
+}
+
+/* [MS-OSHARED] 2.3.3.1.4 Lpstr */
+function parse_lpstr(blob, type, pad) {
+ var start = blob.l;
+ var str = blob.read_shift(0, 'lpstr-cp');
+ if(pad) while((blob.l - start) & 3) ++blob.l;
+ return str;
+}
+
+/* [MS-OSHARED] 2.3.3.1.6 Lpwstr */
+function parse_lpwstr(blob, type, pad) {
+ var str = blob.read_shift(0, 'lpwstr');
+ if(pad) blob.l += (4 - ((str.length+1) & 3)) & 3;
+ return str;
+}
+
+
+/* [MS-OSHARED] 2.3.3.1.11 VtString */
+/* [MS-OSHARED] 2.3.3.1.12 VtUnalignedString */
+function parse_VtStringBase(blob, stringType, pad) {
+ if(stringType === 0x1F /*VT_LPWSTR*/) return parse_lpwstr(blob);
+ return parse_lpstr(blob, stringType, pad);
+}
+
+function parse_VtString(blob, t, pad) { return parse_VtStringBase(blob, t, pad === false ? 0: 4); }
+function parse_VtUnalignedString(blob, t) { if(!t) throw new Error("VtUnalignedString must have positive length"); return parse_VtStringBase(blob, t, 0); }
+
+/* [MS-OSHARED] 2.3.3.1.7 VtVecLpwstrValue */
+function parse_VtVecLpwstrValue(blob) {
+ var length = blob.read_shift(4);
+ var ret = [];
+ for(var i = 0; i != length; ++i) {
+ var start = blob.l;
+ ret[i] = blob.read_shift(0, 'lpwstr').replace(chr0,'');
+ if((blob.l - start) & 0x02) blob.l += 2;
+ }
+ return ret;
+}
+
+/* [MS-OSHARED] 2.3.3.1.9 VtVecUnalignedLpstrValue */
+function parse_VtVecUnalignedLpstrValue(blob) {
+ var length = blob.read_shift(4);
+ var ret = [];
+ for(var i = 0; i != length; ++i) ret[i] = blob.read_shift(0, 'lpstr-cp').replace(chr0,'');
+ return ret;
+}
+
+
+/* [MS-OSHARED] 2.3.3.1.13 VtHeadingPair */
+function parse_VtHeadingPair(blob) {
+ var start = blob.l;
+ var headingString = parse_TypedPropertyValue(blob, VT_USTR);
+ if(blob[blob.l] == 0x00 && blob[blob.l+1] == 0x00 && ((blob.l - start) & 0x02)) blob.l += 2;
+ var headerParts = parse_TypedPropertyValue(blob, VT_I4);
+ return [headingString, headerParts];
+}
+
+/* [MS-OSHARED] 2.3.3.1.14 VtVecHeadingPairValue */
+function parse_VtVecHeadingPairValue(blob) {
+ var cElements = blob.read_shift(4);
+ var out = [];
+ for(var i = 0; i < cElements / 2; ++i) out.push(parse_VtHeadingPair(blob));
+ return out;
+}
+
+/* [MS-OLEPS] 2.18.1 Dictionary (uses 2.17, 2.16) */
+function parse_dictionary(blob,CodePage) {
+ var cnt = blob.read_shift(4);
+ var dict = ({});
+ for(var j = 0; j != cnt; ++j) {
+ var pid = blob.read_shift(4);
+ var len = blob.read_shift(4);
+ dict[pid] = blob.read_shift(len, (CodePage === 0x4B0 ?'utf16le':'utf8')).replace(chr0,'').replace(chr1,'!');
+ if(CodePage === 0x4B0 && (len % 2)) blob.l += 2;
+ }
+ if(blob.l & 3) blob.l = (blob.l>>2+1)<<2;
+ return dict;
+}
+
+/* [MS-OLEPS] 2.9 BLOB */
+function parse_BLOB(blob) {
+ var size = blob.read_shift(4);
+ var bytes = blob.slice(blob.l,blob.l+size);
+ blob.l += size;
+ if((size & 3) > 0) blob.l += (4 - (size & 3)) & 3;
+ return bytes;
+}
+
+/* [MS-OLEPS] 2.11 ClipboardData */
+function parse_ClipboardData(blob) {
+ // TODO
+ var o = {};
+ o.Size = blob.read_shift(4);
+ //o.Format = blob.read_shift(4);
+ blob.l += o.Size + 3 - (o.Size - 1) % 4;
+ return o;
+}
+
+/* [MS-OLEPS] 2.15 TypedPropertyValue */
+function parse_TypedPropertyValue(blob, type, _opts) {
+ var t = blob.read_shift(2), ret, opts = _opts||{};
+ blob.l += 2;
+ if(type !== VT_VARIANT)
+ if(t !== type && VT_CUSTOM.indexOf(type)===-1 && !((type & 0xFFFE) == 0x101E && (t & 0xFFFE) == 0x101E)) throw new Error('Expected type ' + type + ' saw ' + t);
+ switch(type === VT_VARIANT ? t : type) {
+ case 0x02 /*VT_I2*/: ret = blob.read_shift(2, 'i'); if(!opts.raw) blob.l += 2; return ret;
+ case 0x03 /*VT_I4*/: ret = blob.read_shift(4, 'i'); return ret;
+ case 0x0B /*VT_BOOL*/: return blob.read_shift(4) !== 0x0;
+ case 0x13 /*VT_UI4*/: ret = blob.read_shift(4); return ret;
+ case 0x1E /*VT_LPSTR*/: return parse_lpstr(blob, t, 4).replace(chr0,'');
+ case 0x1F /*VT_LPWSTR*/: return parse_lpwstr(blob);
+ case 0x40 /*VT_FILETIME*/: return parse_FILETIME(blob);
+ case 0x41 /*VT_BLOB*/: return parse_BLOB(blob);
+ case 0x47 /*VT_CF*/: return parse_ClipboardData(blob);
+ case 0x50 /*VT_STRING*/: return parse_VtString(blob, t, !opts.raw).replace(chr0,'');
+ case 0x51 /*VT_USTR*/: return parse_VtUnalignedString(blob, t/*, 4*/).replace(chr0,'');
+ case 0x100C /*VT_VECTOR|VT_VARIANT*/: return parse_VtVecHeadingPairValue(blob);
+ case 0x101E /*VT_VECTOR|VT_LPSTR*/:
+ case 0x101F /*VT_VECTOR|VT_LPWSTR*/:
+ return t == 0x101F ? parse_VtVecLpwstrValue(blob) : parse_VtVecUnalignedLpstrValue(blob);
+ default: throw new Error("TypedPropertyValue unrecognized type " + type + " " + t);
+ }
+}
+function write_TypedPropertyValue(type, value) {
+ var o = new_buf(4), p = new_buf(4);
+ o.write_shift(4, type == 0x50 ? 0x1F : type);
+ switch(type) {
+ case 0x03 /*VT_I4*/: p.write_shift(-4, value); break;
+ case 0x05 /*VT_I4*/: p = new_buf(8); p.write_shift(8, value, 'f'); break;
+ case 0x0B /*VT_BOOL*/: p.write_shift(4, value ? 0x01 : 0x00); break;
+ case 0x40 /*VT_FILETIME*/: p = write_FILETIME(value); break;
+ case 0x1F /*VT_LPWSTR*/:
+ case 0x50 /*VT_STRING*/:
+p = new_buf(4 + 2 * (value.length + 1) + (value.length % 2 ? 0 : 2));
+ p.write_shift(4, value.length + 1);
+ p.write_shift(0, value, "dbcs");
+ while(p.l != p.length) p.write_shift(1, 0);
+ break;
+ default: throw new Error("TypedPropertyValue unrecognized type " + type + " " + value);
+ }
+ return bconcat([o, p]);
+}
+
+/* [MS-OLEPS] 2.20 PropertySet */
+function parse_PropertySet(blob, PIDSI) {
+ var start_addr = blob.l;
+ var size = blob.read_shift(4);
+ var NumProps = blob.read_shift(4);
+ var Props = [], i = 0;
+ var CodePage = 0;
+ var Dictionary = -1, DictObj = ({});
+ for(i = 0; i != NumProps; ++i) {
+ var PropID = blob.read_shift(4);
+ var Offset = blob.read_shift(4);
+ Props[i] = [PropID, Offset + start_addr];
+ }
+ Props.sort(function(x,y) { return x[1] - y[1]; });
+ var PropH = {};
+ for(i = 0; i != NumProps; ++i) {
+ if(blob.l !== Props[i][1]) {
+ var fail = true;
+ if(i>0 && PIDSI) switch(PIDSI[Props[i-1][0]].t) {
+ case 0x02 /*VT_I2*/: if(blob.l+2 === Props[i][1]) { blob.l+=2; fail = false; } break;
+ case 0x50 /*VT_STRING*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false; } break;
+ case 0x100C /*VT_VECTOR|VT_VARIANT*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false; } break;
+ }
+ if((!PIDSI||i==0) && blob.l <= Props[i][1]) { fail=false; blob.l = Props[i][1]; }
+ if(fail) throw new Error("Read Error: Expected address " + Props[i][1] + ' at ' + blob.l + ' :' + i);
+ }
+ if(PIDSI) {
+ var piddsi = PIDSI[Props[i][0]];
+ PropH[piddsi.n] = parse_TypedPropertyValue(blob, piddsi.t, {raw:true});
+ if(piddsi.p === 'version') PropH[piddsi.n] = String(PropH[piddsi.n] >> 16) + "." + ("0000" + String(PropH[piddsi.n] & 0xFFFF)).slice(-4);
+ if(piddsi.n == "CodePage") switch(PropH[piddsi.n]) {
+ case 0: PropH[piddsi.n] = 1252;
+ /* falls through */
+ case 874:
+ case 932:
+ case 936:
+ case 949:
+ case 950:
+ case 1250:
+ case 1251:
+ case 1253:
+ case 1254:
+ case 1255:
+ case 1256:
+ case 1257:
+ case 1258:
+ case 10000:
+ case 1200:
+ case 1201:
+ case 1252:
+ case 65000: case -536:
+ case 65001: case -535:
+ set_cp(CodePage = (PropH[piddsi.n]>>>0) & 0xFFFF); break;
+ default: throw new Error("Unsupported CodePage: " + PropH[piddsi.n]);
+ }
+ } else {
+ if(Props[i][0] === 0x1) {
+ CodePage = PropH.CodePage = (parse_TypedPropertyValue(blob, VT_I2));
+ set_cp(CodePage);
+ if(Dictionary !== -1) {
+ var oldpos = blob.l;
+ blob.l = Props[Dictionary][1];
+ DictObj = parse_dictionary(blob,CodePage);
+ blob.l = oldpos;
+ }
+ } else if(Props[i][0] === 0) {
+ if(CodePage === 0) { Dictionary = i; blob.l = Props[i+1][1]; continue; }
+ DictObj = parse_dictionary(blob,CodePage);
+ } else {
+ var name = DictObj[Props[i][0]];
+ var val;
+ /* [MS-OSHARED] 2.3.3.2.3.1.2 + PROPVARIANT */
+ switch(blob[blob.l]) {
+ case 0x41 /*VT_BLOB*/: blob.l += 4; val = parse_BLOB(blob); break;
+ case 0x1E /*VT_LPSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]).replace(/\u0000+$/,""); break;
+ case 0x1F /*VT_LPWSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]).replace(/\u0000+$/,""); break;
+ case 0x03 /*VT_I4*/: blob.l += 4; val = blob.read_shift(4, 'i'); break;
+ case 0x13 /*VT_UI4*/: blob.l += 4; val = blob.read_shift(4); break;
+ case 0x05 /*VT_R8*/: blob.l += 4; val = blob.read_shift(8, 'f'); break;
+ case 0x0B /*VT_BOOL*/: blob.l += 4; val = parsebool(blob, 4); break;
+ case 0x40 /*VT_FILETIME*/: blob.l += 4; val = parseDate(parse_FILETIME(blob)); break;
+ default: throw new Error("unparsed value: " + blob[blob.l]);
+ }
+ PropH[name] = val;
+ }
+ }
+ }
+ blob.l = start_addr + size; /* step ahead to skip padding */
+ return PropH;
+}
+var XLSPSSkip = [ "CodePage", "Thumbnail", "_PID_LINKBASE", "_PID_HLINKS", "SystemIdentifier", "FMTID" ]; //.concat(PseudoPropsPairs);
+function guess_property_type(val) {
+ switch(typeof val) {
+ case "boolean": return 0x0B;
+ case "number": return ((val|0)==val) ? 0x03 : 0x05;
+ case "string": return 0x1F;
+ case "object": if(val instanceof Date) return 0x40; break;
+ }
+ return -1;
+}
+function write_PropertySet(entries, RE, PIDSI) {
+ var hdr = new_buf(8), piao = [], prop = [];
+ var sz = 8, i = 0;
+
+ var pr = new_buf(8), pio = new_buf(8);
+ pr.write_shift(4, 0x0002);
+ pr.write_shift(4, 0x04B0);
+ pio.write_shift(4, 0x0001);
+ prop.push(pr); piao.push(pio);
+ sz += 8 + pr.length;
+
+ if(!RE) {
+ pio = new_buf(8);
+ pio.write_shift(4, 0);
+ piao.unshift(pio);
+
+ var bufs = [new_buf(4)];
+ bufs[0].write_shift(4, entries.length);
+ for(i = 0; i < entries.length; ++i) {
+ var value = entries[i][0];
+ pr = new_buf(4 + 4 + 2 * (value.length + 1) + (value.length % 2 ? 0 : 2));
+ pr.write_shift(4, i+2);
+ pr.write_shift(4, value.length + 1);
+ pr.write_shift(0, value, "dbcs");
+ while(pr.l != pr.length) pr.write_shift(1, 0);
+ bufs.push(pr);
+ }
+ pr = bconcat(bufs);
+ prop.unshift(pr);
+ sz += 8 + pr.length;
+ }
+
+ for(i = 0; i < entries.length; ++i) {
+ if(RE && !RE[entries[i][0]]) continue;
+ if(XLSPSSkip.indexOf(entries[i][0]) > -1 || PseudoPropsPairs.indexOf(entries[i][0]) > -1) continue;
+ if(entries[i][1] == null) continue;
+
+ var val = entries[i][1], idx = 0;
+ if(RE) {
+ idx = +RE[entries[i][0]];
+ var pinfo = (PIDSI)[idx];
+ if(pinfo.p == "version" && typeof val == "string") {
+var arr = val.split(".");
+ val = ((+arr[0])<<16) + ((+arr[1])||0);
+ }
+ pr = write_TypedPropertyValue(pinfo.t, val);
+ } else {
+ var T = guess_property_type(val);
+ if(T == -1) { T = 0x1F; val = String(val); }
+ pr = write_TypedPropertyValue(T, val);
+ }
+ prop.push(pr);
+
+ pio = new_buf(8);
+ pio.write_shift(4, !RE ? 2+i : idx);
+ piao.push(pio);
+
+ sz += 8 + pr.length;
+ }
+
+ var w = 8 * (prop.length + 1);
+ for(i = 0; i < prop.length; ++i) { piao[i].write_shift(4, w); w += prop[i].length; }
+ hdr.write_shift(4, sz);
+ hdr.write_shift(4, prop.length);
+ return bconcat([hdr].concat(piao).concat(prop));
+}
+
+/* [MS-OLEPS] 2.21 PropertySetStream */
+function parse_PropertySetStream(file, PIDSI, clsid) {
+ var blob = file.content;
+ if(!blob) return ({});
+ prep_blob(blob, 0);
+
+ var NumSets, FMTID0, FMTID1, Offset0, Offset1 = 0;
+ blob.chk('feff', 'Byte Order: ');
+
+ /*var vers = */blob.read_shift(2); // TODO: check version
+ var SystemIdentifier = blob.read_shift(4);
+ var CLSID = blob.read_shift(16);
+ if(CLSID !== CFB.utils.consts.HEADER_CLSID && CLSID !== clsid) throw new Error("Bad PropertySet CLSID " + CLSID);
+ NumSets = blob.read_shift(4);
+ if(NumSets !== 1 && NumSets !== 2) throw new Error("Unrecognized #Sets: " + NumSets);
+ FMTID0 = blob.read_shift(16); Offset0 = blob.read_shift(4);
+
+ if(NumSets === 1 && Offset0 !== blob.l) throw new Error("Length mismatch: " + Offset0 + " !== " + blob.l);
+ else if(NumSets === 2) { FMTID1 = blob.read_shift(16); Offset1 = blob.read_shift(4); }
+ var PSet0 = parse_PropertySet(blob, PIDSI);
+
+ var rval = ({ SystemIdentifier: SystemIdentifier });
+ for(var y in PSet0) rval[y] = PSet0[y];
+ //rval.blob = blob;
+ rval.FMTID = FMTID0;
+ //rval.PSet0 = PSet0;
+ if(NumSets === 1) return rval;
+ if(Offset1 - blob.l == 2) blob.l += 2;
+ if(blob.l !== Offset1) throw new Error("Length mismatch 2: " + blob.l + " !== " + Offset1);
+ var PSet1;
+ try { PSet1 = parse_PropertySet(blob, null); } catch(e) {/* empty */}
+ for(y in PSet1) rval[y] = PSet1[y];
+ rval.FMTID = [FMTID0, FMTID1]; // TODO: verify FMTID0/1
+ return rval;
+}
+function write_PropertySetStream(entries, clsid, RE, PIDSI, entries2, clsid2) {
+ var hdr = new_buf(entries2 ? 68 : 48);
+ var bufs = [hdr];
+ hdr.write_shift(2, 0xFFFE);
+ hdr.write_shift(2, 0x0000); /* TODO: type 1 props */
+ hdr.write_shift(4, 0x32363237);
+ hdr.write_shift(16, CFB.utils.consts.HEADER_CLSID, "hex");
+ hdr.write_shift(4, (entries2 ? 2 : 1));
+ hdr.write_shift(16, clsid, "hex");
+ hdr.write_shift(4, (entries2 ? 68 : 48));
+ var ps0 = write_PropertySet(entries, RE, PIDSI);
+ bufs.push(ps0);
+
+ if(entries2) {
+ var ps1 = write_PropertySet(entries2, null, null);
+ hdr.write_shift(16, clsid2, "hex");
+ hdr.write_shift(4, 68 + ps0.length);
+ bufs.push(ps1);
+ }
+ return bconcat(bufs);
+}
+
+function parsenoop2(blob, length) { blob.read_shift(length); return null; }
+function writezeroes(n, o) { if(!o) o=new_buf(n); for(var j=0; j= 12 ? 2 : 1);
+ var encoding = 'sbcs-cont';
+ var cp = current_codepage;
+ if(opts && opts.biff >= 8) current_codepage = 1200;
+ if(!opts || opts.biff == 8 ) {
+ var fHighByte = blob.read_shift(1);
+ if(fHighByte) { encoding = 'dbcs-cont'; }
+ } else if(opts.biff == 12) {
+ encoding = 'wstr';
+ }
+ if(opts.biff >= 2 && opts.biff <= 5) encoding = 'cpstr';
+ var o = cch ? blob.read_shift(cch, encoding) : "";
+ current_codepage = cp;
+ return o;
+}
+
+/* 2.5.293 XLUnicodeRichExtendedString */
+function parse_XLUnicodeRichExtendedString(blob) {
+ var cp = current_codepage;
+ current_codepage = 1200;
+ var cch = blob.read_shift(2), flags = blob.read_shift(1);
+ var /*fHighByte = flags & 0x1,*/ fExtSt = flags & 0x4, fRichSt = flags & 0x8;
+ var width = 1 + (flags & 0x1); // 0x0 -> utf8, 0x1 -> dbcs
+ var cRun = 0, cbExtRst;
+ var z = {};
+ if(fRichSt) cRun = blob.read_shift(2);
+ if(fExtSt) cbExtRst = blob.read_shift(4);
+ var encoding = width == 2 ? 'dbcs-cont' : 'sbcs-cont';
+ var msg = cch === 0 ? "" : blob.read_shift(cch, encoding);
+ if(fRichSt) blob.l += 4 * cRun; //TODO: parse this
+ if(fExtSt) blob.l += cbExtRst; //TODO: parse this
+ z.t = msg;
+ if(!fRichSt) { z.raw = "" + z.t + ""; z.r = z.t; }
+ current_codepage = cp;
+ return z;
+}
+function write_XLUnicodeRichExtendedString(xlstr) {
+ var str = (xlstr.t||""), nfmts = 1;
+
+ var hdr = new_buf(3 + (nfmts > 1 ? 2 : 0));
+ hdr.write_shift(2, str.length);
+ hdr.write_shift(1, (nfmts > 1 ? 0x08 : 0x00) | 0x01);
+ if(nfmts > 1) hdr.write_shift(2, nfmts);
+
+ var otext = new_buf(2 * str.length);
+ otext.write_shift(2 * str.length, str, 'utf16le');
+
+ var out = [hdr, otext];
+
+ return bconcat(out);
+}
+
+/* 2.5.296 XLUnicodeStringNoCch */
+function parse_XLUnicodeStringNoCch(blob, cch, opts) {
+ var retval;
+ if(opts) {
+ if(opts.biff >= 2 && opts.biff <= 5) return blob.read_shift(cch, 'cpstr');
+ if(opts.biff >= 12) return blob.read_shift(cch, 'dbcs-cont');
+ }
+ var fHighByte = blob.read_shift(1);
+ if(fHighByte===0) { retval = blob.read_shift(cch, 'sbcs-cont'); }
+ else { retval = blob.read_shift(cch, 'dbcs-cont'); }
+ return retval;
+}
+
+/* 2.5.294 XLUnicodeString */
+function parse_XLUnicodeString(blob, length, opts) {
+ var cch = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
+ if(cch === 0) { blob.l++; return ""; }
+ return parse_XLUnicodeStringNoCch(blob, cch, opts);
+}
+/* BIFF5 override */
+function parse_XLUnicodeString2(blob, length, opts) {
+ if(opts.biff > 5) return parse_XLUnicodeString(blob, length, opts);
+ var cch = blob.read_shift(1);
+ if(cch === 0) { blob.l++; return ""; }
+ return blob.read_shift(cch, (opts.biff <= 4 || !blob.lens ) ? 'cpstr' : 'sbcs-cont');
+}
+/* TODO: BIFF5 and lower, codepage awareness */
+function write_XLUnicodeString(str, opts, o) {
+ if(!o) o = new_buf(3 + 2 * str.length);
+ o.write_shift(2, str.length);
+ o.write_shift(1, 1);
+ o.write_shift(31, str, 'utf16le');
+ return o;
+}
+
+/* [MS-XLS] 2.5.61 ControlInfo */
+function parse_ControlInfo(blob) {
+ var flags = blob.read_shift(1);
+ blob.l++;
+ var accel = blob.read_shift(2);
+ blob.l += 2;
+ return [flags, accel];
+}
+
+/* [MS-OSHARED] 2.3.7.6 URLMoniker TODO: flags */
+function parse_URLMoniker(blob) {
+ var len = blob.read_shift(4), start = blob.l;
+ var extra = false;
+ if(len > 24) {
+ /* look ahead */
+ blob.l += len - 24;
+ if(blob.read_shift(16) === "795881f43b1d7f48af2c825dc4852763") extra = true;
+ blob.l = start;
+ }
+ var url = blob.read_shift((extra?len-24:len)>>1, 'utf16le').replace(chr0,"");
+ if(extra) blob.l += 24;
+ return url;
+}
+
+/* [MS-OSHARED] 2.3.7.8 FileMoniker TODO: all fields */
+function parse_FileMoniker(blob) {
+ var cAnti = blob.read_shift(2);
+ var preamble = ""; while(cAnti-- > 0) preamble += "../";
+ var ansiPath = blob.read_shift(0, 'lpstr-ansi');
+ blob.l += 2; //var endServer = blob.read_shift(2);
+ if(blob.read_shift(2) != 0xDEAD) throw new Error("Bad FileMoniker");
+ var sz = blob.read_shift(4);
+ if(sz === 0) return preamble + ansiPath.replace(/\\/g,"/");
+ var bytes = blob.read_shift(4);
+ if(blob.read_shift(2) != 3) throw new Error("Bad FileMoniker");
+ var unicodePath = blob.read_shift(bytes>>1, 'utf16le').replace(chr0,"");
+ return preamble + unicodePath;
+}
+
+/* [MS-OSHARED] 2.3.7.2 HyperlinkMoniker TODO: all the monikers */
+function parse_HyperlinkMoniker(blob, length) {
+ var clsid = blob.read_shift(16); length -= 16;
+ switch(clsid) {
+ case "e0c9ea79f9bace118c8200aa004ba90b": return parse_URLMoniker(blob, length);
+ case "0303000000000000c000000000000046": return parse_FileMoniker(blob, length);
+ default: throw new Error("Unsupported Moniker " + clsid);
+ }
+}
+
+/* [MS-OSHARED] 2.3.7.9 HyperlinkString */
+function parse_HyperlinkString(blob) {
+ var len = blob.read_shift(4);
+ var o = len > 0 ? blob.read_shift(len, 'utf16le').replace(chr0, "") : "";
+ return o;
+}
+function write_HyperlinkString(str, o) {
+ if(!o) o = new_buf(6 + str.length * 2);
+ o.write_shift(4, 1 + str.length);
+ for(var i = 0; i < str.length; ++i) o.write_shift(2, str.charCodeAt(i));
+ o.write_shift(2, 0);
+ return o;
+}
+
+/* [MS-OSHARED] 2.3.7.1 Hyperlink Object */
+function parse_Hyperlink(blob, length) {
+ var end = blob.l + length;
+ var sVer = blob.read_shift(4);
+ if(sVer !== 2) throw new Error("Unrecognized streamVersion: " + sVer);
+ var flags = blob.read_shift(2);
+ blob.l += 2;
+ var displayName, targetFrameName, moniker, oleMoniker, Loc="", guid, fileTime;
+ if(flags & 0x0010) displayName = parse_HyperlinkString(blob, end - blob.l);
+ if(flags & 0x0080) targetFrameName = parse_HyperlinkString(blob, end - blob.l);
+ if((flags & 0x0101) === 0x0101) moniker = parse_HyperlinkString(blob, end - blob.l);
+ if((flags & 0x0101) === 0x0001) oleMoniker = parse_HyperlinkMoniker(blob, end - blob.l);
+ if(flags & 0x0008) Loc = parse_HyperlinkString(blob, end - blob.l);
+ if(flags & 0x0020) guid = blob.read_shift(16);
+ if(flags & 0x0040) fileTime = parse_FILETIME(blob/*, 8*/);
+ blob.l = end;
+ var target = targetFrameName||moniker||oleMoniker||"";
+ if(target && Loc) target+="#"+Loc;
+ if(!target) target = "#" + Loc;
+ if((flags & 0x0002) && target.charAt(0) == "/" && target.charAt(1) != "/") target = "file://" + target;
+ var out = ({Target:target});
+ if(guid) out.guid = guid;
+ if(fileTime) out.time = fileTime;
+ if(displayName) out.Tooltip = displayName;
+ return out;
+}
+function write_Hyperlink(hl) {
+ var out = new_buf(512), i = 0;
+ var Target = hl.Target;
+ if(Target.slice(0,7) == "file://") Target = Target.slice(7);
+ var hashidx = Target.indexOf("#");
+ var F = hashidx > -1 ? 0x1f : 0x17;
+ switch(Target.charAt(0)) { case "#": F=0x1c; break; case ".": F&=~2; break; }
+ out.write_shift(4,2); out.write_shift(4, F);
+ var data = [8,6815827,6619237,4849780,83]; for(i = 0; i < data.length; ++i) out.write_shift(4, data[i]);
+ if(F == 0x1C) {
+ Target = Target.slice(1);
+ write_HyperlinkString(Target, out);
+ } else if(F & 0x02) {
+ data = "e0 c9 ea 79 f9 ba ce 11 8c 82 00 aa 00 4b a9 0b".split(" ");
+ for(i = 0; i < data.length; ++i) out.write_shift(1, parseInt(data[i], 16));
+ var Pretarget = hashidx > -1 ? Target.slice(0, hashidx) : Target;
+ out.write_shift(4, 2*(Pretarget.length + 1));
+ for(i = 0; i < Pretarget.length; ++i) out.write_shift(2, Pretarget.charCodeAt(i));
+ out.write_shift(2, 0);
+ if(F & 0x08) write_HyperlinkString(hashidx > -1 ? Target.slice(hashidx+1): "", out);
+ } else {
+ data = "03 03 00 00 00 00 00 00 c0 00 00 00 00 00 00 46".split(" ");
+ for(i = 0; i < data.length; ++i) out.write_shift(1, parseInt(data[i], 16));
+ var P = 0;
+ while(Target.slice(P*3,P*3+3)=="../"||Target.slice(P*3,P*3+3)=="..\\") ++P;
+ out.write_shift(2, P);
+ out.write_shift(4, Target.length - 3 * P + 1);
+ for(i = 0; i < Target.length - 3 * P; ++i) out.write_shift(1, Target.charCodeAt(i + 3 * P) & 0xFF);
+ out.write_shift(1, 0);
+ out.write_shift(2, 0xFFFF);
+ out.write_shift(2, 0xDEAD);
+ for(i = 0; i < 6; ++i) out.write_shift(4, 0);
+ }
+ return out.slice(0, out.l);
+}
+
+/* 2.5.178 LongRGBA */
+function parse_LongRGBA(blob) { var r = blob.read_shift(1), g = blob.read_shift(1), b = blob.read_shift(1), a = blob.read_shift(1); return [r,g,b,a]; }
+
+/* 2.5.177 LongRGB */
+function parse_LongRGB(blob, length) { var x = parse_LongRGBA(blob, length); x[3] = 0; return x; }
+
+
+/* [MS-XLS] 2.5.19 */
+function parse_XLSCell(blob) {
+ var rw = blob.read_shift(2); // 0-indexed
+ var col = blob.read_shift(2);
+ var ixfe = blob.read_shift(2);
+ return ({r:rw, c:col, ixfe:ixfe});
+}
+function write_XLSCell(R, C, ixfe, o) {
+ if(!o) o = new_buf(6);
+ o.write_shift(2, R);
+ o.write_shift(2, C);
+ o.write_shift(2, ixfe||0);
+ return o;
+}
+
+/* [MS-XLS] 2.5.134 */
+function parse_frtHeader(blob) {
+ var rt = blob.read_shift(2);
+ var flags = blob.read_shift(2); // TODO: parse these flags
+ blob.l += 8;
+ return {type: rt, flags: flags};
+}
+
+
+
+function parse_OptXLUnicodeString(blob, length, opts) { return length === 0 ? "" : parse_XLUnicodeString2(blob, length, opts); }
+
+/* [MS-XLS] 2.5.344 */
+function parse_XTI(blob, length, opts) {
+ var w = opts.biff > 8 ? 4 : 2;
+ var iSupBook = blob.read_shift(w), itabFirst = blob.read_shift(w,'i'), itabLast = blob.read_shift(w,'i');
+ return [iSupBook, itabFirst, itabLast];
+}
+
+/* [MS-XLS] 2.5.218 */
+function parse_RkRec(blob) {
+ var ixfe = blob.read_shift(2);
+ var RK = parse_RkNumber(blob);
+ return [ixfe, RK];
+}
+
+/* [MS-XLS] 2.5.1 */
+function parse_AddinUdf(blob, length, opts) {
+ blob.l += 4; length -= 4;
+ var l = blob.l + length;
+ var udfName = parse_ShortXLUnicodeString(blob, length, opts);
+ var cb = blob.read_shift(2);
+ l -= blob.l;
+ if(cb !== l) throw new Error("Malformed AddinUdf: padding = " + l + " != " + cb);
+ blob.l += cb;
+ return udfName;
+}
+
+/* [MS-XLS] 2.5.209 TODO: Check sizes */
+function parse_Ref8U(blob) {
+ var rwFirst = blob.read_shift(2);
+ var rwLast = blob.read_shift(2);
+ var colFirst = blob.read_shift(2);
+ var colLast = blob.read_shift(2);
+ return {s:{c:colFirst, r:rwFirst}, e:{c:colLast,r:rwLast}};
+}
+function write_Ref8U(r, o) {
+ if(!o) o = new_buf(8);
+ o.write_shift(2, r.s.r);
+ o.write_shift(2, r.e.r);
+ o.write_shift(2, r.s.c);
+ o.write_shift(2, r.e.c);
+ return o;
+}
+
+/* [MS-XLS] 2.5.211 */
+function parse_RefU(blob) {
+ var rwFirst = blob.read_shift(2);
+ var rwLast = blob.read_shift(2);
+ var colFirst = blob.read_shift(1);
+ var colLast = blob.read_shift(1);
+ return {s:{c:colFirst, r:rwFirst}, e:{c:colLast,r:rwLast}};
+}
+
+/* [MS-XLS] 2.5.207 */
+var parse_Ref = parse_RefU;
+
+/* [MS-XLS] 2.5.143 */
+function parse_FtCmo(blob) {
+ blob.l += 4;
+ var ot = blob.read_shift(2);
+ var id = blob.read_shift(2);
+ var flags = blob.read_shift(2);
+ blob.l+=12;
+ return [id, ot, flags];
+}
+
+/* [MS-XLS] 2.5.149 */
+function parse_FtNts(blob) {
+ var out = {};
+ blob.l += 4;
+ blob.l += 16; // GUID TODO
+ out.fSharedNote = blob.read_shift(2);
+ blob.l += 4;
+ return out;
+}
+
+/* [MS-XLS] 2.5.142 */
+function parse_FtCf(blob) {
+ var out = {};
+ blob.l += 4;
+ blob.cf = blob.read_shift(2);
+ return out;
+}
+
+/* [MS-XLS] 2.5.140 - 2.5.154 and friends */
+function parse_FtSkip(blob) { blob.l += 2; blob.l += blob.read_shift(2); }
+var FtTab = {
+0x00: parse_FtSkip, /* FtEnd */
+0x04: parse_FtSkip, /* FtMacro */
+0x05: parse_FtSkip, /* FtButton */
+0x06: parse_FtSkip, /* FtGmo */
+0x07: parse_FtCf, /* FtCf */
+0x08: parse_FtSkip, /* FtPioGrbit */
+0x09: parse_FtSkip, /* FtPictFmla */
+0x0A: parse_FtSkip, /* FtCbls */
+0x0B: parse_FtSkip, /* FtRbo */
+0x0C: parse_FtSkip, /* FtSbs */
+0x0D: parse_FtNts, /* FtNts */
+0x0E: parse_FtSkip, /* FtSbsFmla */
+0x0F: parse_FtSkip, /* FtGboData */
+0x10: parse_FtSkip, /* FtEdoData */
+0x11: parse_FtSkip, /* FtRboData */
+0x12: parse_FtSkip, /* FtCblsData */
+0x13: parse_FtSkip, /* FtLbsData */
+0x14: parse_FtSkip, /* FtCblsFmla */
+0x15: parse_FtCmo
+};
+function parse_FtArray(blob, length) {
+ var tgt = blob.l + length;
+ var fts = [];
+ while(blob.l < tgt) {
+ var ft = blob.read_shift(2);
+ blob.l-=2;
+ try {
+ fts.push(FtTab[ft](blob, tgt - blob.l));
+ } catch(e) { blob.l = tgt; return fts; }
+ }
+ if(blob.l != tgt) blob.l = tgt; //throw new Error("bad Object Ft-sequence");
+ return fts;
+}
+
+/* --- 2.4 Records --- */
+
+/* [MS-XLS] 2.4.21 */
+function parse_BOF(blob, length) {
+ var o = {BIFFVer:0, dt:0};
+ o.BIFFVer = blob.read_shift(2); length -= 2;
+ if(length >= 2) { o.dt = blob.read_shift(2); blob.l -= 2; }
+ switch(o.BIFFVer) {
+ case 0x0600: /* BIFF8 */
+ case 0x0500: /* BIFF5 */
+ case 0x0400: /* BIFF4 */
+ case 0x0300: /* BIFF3 */
+ case 0x0200: /* BIFF2 */
+ case 0x0002: case 0x0007: /* BIFF2 */
+ break;
+ default: if(length > 6) throw new Error("Unexpected BIFF Ver " + o.BIFFVer);
+ }
+
+ blob.read_shift(length);
+ return o;
+}
+function write_BOF(wb, t, o) {
+ var h = 0x0600, w = 16;
+ switch(o.bookType) {
+ case 'biff8': break;
+ case 'biff5': h = 0x0500; w = 8; break;
+ case 'biff4': h = 0x0004; w = 6; break;
+ case 'biff3': h = 0x0003; w = 6; break;
+ case 'biff2': h = 0x0002; w = 4; break;
+ case 'xla': break;
+ default: throw new Error("unsupported BIFF version");
+ }
+ var out = new_buf(w);
+ out.write_shift(2, h);
+ out.write_shift(2, t);
+ if(w > 4) out.write_shift(2, 0x7262);
+ if(w > 6) out.write_shift(2, 0x07CD);
+ if(w > 8) {
+ out.write_shift(2, 0xC009);
+ out.write_shift(2, 0x0001);
+ out.write_shift(2, 0x0706);
+ out.write_shift(2, 0x0000);
+ }
+ return out;
+}
+
+
+/* [MS-XLS] 2.4.146 */
+function parse_InterfaceHdr(blob, length) {
+ if(length === 0) return 0x04b0;
+ if((blob.read_shift(2))!==0x04b0){/* empty */}
+ return 0x04b0;
+}
+
+
+/* [MS-XLS] 2.4.349 */
+function parse_WriteAccess(blob, length, opts) {
+ if(opts.enc) { blob.l += length; return ""; }
+ var l = blob.l;
+ // TODO: make sure XLUnicodeString doesnt overrun
+ var UserName = parse_XLUnicodeString2(blob, 0, opts);
+ blob.read_shift(length + l - blob.l);
+ return UserName;
+}
+function write_WriteAccess(s, opts) {
+ var b8 = !opts || opts.biff == 8;
+ var o = new_buf(b8 ? 112 : 54);
+ o.write_shift(opts.biff == 8 ? 2 : 1, 7);
+ if(b8) o.write_shift(1, 0);
+ o.write_shift(4, 0x33336853);
+ o.write_shift(4, (0x00534A74 | (b8 ? 0 : 0x20000000)));
+ while(o.l < o.length) o.write_shift(1, (b8 ? 0 : 32));
+ return o;
+}
+
+/* [MS-XLS] 2.4.351 */
+function parse_WsBool(blob, length, opts) {
+ var flags = opts && opts.biff == 8 || length == 2 ? blob.read_shift(2) : (blob.l += length, 0);
+ return { fDialog: flags & 0x10, fBelow: flags & 0x40, fRight: flags & 0x80 };
+}
+
+/* [MS-XLS] 2.4.28 */
+function parse_BoundSheet8(blob, length, opts) {
+ var pos = blob.read_shift(4);
+ var hidden = blob.read_shift(1) & 0x03;
+ var dt = blob.read_shift(1);
+ switch(dt) {
+ case 0: dt = 'Worksheet'; break;
+ case 1: dt = 'Macrosheet'; break;
+ case 2: dt = 'Chartsheet'; break;
+ case 6: dt = 'VBAModule'; break;
+ }
+ var name = parse_ShortXLUnicodeString(blob, 0, opts);
+ if(name.length === 0) name = "Sheet1";
+ return { pos:pos, hs:hidden, dt:dt, name:name };
+}
+function write_BoundSheet8(data, opts) {
+ var w = (!opts || opts.biff >= 8 ? 2 : 1);
+ var o = new_buf(8 + w * data.name.length);
+ o.write_shift(4, data.pos);
+ o.write_shift(1, data.hs || 0);
+ o.write_shift(1, data.dt);
+ o.write_shift(1, data.name.length);
+ if(opts.biff >= 8) o.write_shift(1, 1);
+ o.write_shift(w * data.name.length, data.name, opts.biff < 8 ? 'sbcs' : 'utf16le');
+ var out = o.slice(0, o.l);
+ out.l = o.l; return out;
+}
+
+/* [MS-XLS] 2.4.265 TODO */
+function parse_SST(blob, length) {
+ var end = blob.l + length;
+ var cnt = blob.read_shift(4);
+ var ucnt = blob.read_shift(4);
+ var strs = ([]);
+ for(var i = 0; i != ucnt && blob.l < end; ++i) {
+ strs.push(parse_XLUnicodeRichExtendedString(blob));
+ }
+ strs.Count = cnt; strs.Unique = ucnt;
+ return strs;
+}
+function write_SST(sst, opts) {
+ var header = new_buf(8);
+ header.write_shift(4, sst.Count);
+ header.write_shift(4, sst.Unique);
+ var strs = [];
+ for(var j = 0; j < sst.length; ++j) strs[j] = write_XLUnicodeRichExtendedString(sst[j], opts);
+ var o = bconcat([header].concat(strs));
+o.parts = [header.length].concat(strs.map(function(str) { return str.length; }));
+ return o;
+}
+
+/* [MS-XLS] 2.4.107 */
+function parse_ExtSST(blob, length) {
+ var extsst = {};
+ extsst.dsst = blob.read_shift(2);
+ blob.l += length-2;
+ return extsst;
+}
+
+
+/* [MS-XLS] 2.4.221 TODO: check BIFF2-4 */
+function parse_Row(blob) {
+ var z = ({});
+ z.r = blob.read_shift(2);
+ z.c = blob.read_shift(2);
+ z.cnt = blob.read_shift(2) - z.c;
+ var miyRw = blob.read_shift(2);
+ blob.l += 4; // reserved(2), unused(2)
+ var flags = blob.read_shift(1); // various flags
+ blob.l += 3; // reserved(8), ixfe(12), flags(4)
+ if(flags & 0x07) z.level = flags & 0x07;
+ // collapsed: flags & 0x10
+ if(flags & 0x20) z.hidden = true;
+ if(flags & 0x40) z.hpt = miyRw / 20;
+ return z;
+}
+
+
+/* [MS-XLS] 2.4.125 */
+function parse_ForceFullCalculation(blob) {
+ var header = parse_frtHeader(blob);
+ if(header.type != 0x08A3) throw new Error("Invalid Future Record " + header.type);
+ var fullcalc = blob.read_shift(4);
+ return fullcalc !== 0x0;
+}
+
+
+
+
+
+/* [MS-XLS] 2.4.215 rt */
+function parse_RecalcId(blob) {
+ blob.read_shift(2);
+ return blob.read_shift(4);
+}
+
+/* [MS-XLS] 2.4.87 */
+function parse_DefaultRowHeight(blob, length, opts) {
+ var f = 0;
+ if(!(opts && opts.biff == 2)) {
+ f = blob.read_shift(2);
+ }
+ var miyRw = blob.read_shift(2);
+ if((opts && opts.biff == 2)) {
+ f = 1 - (miyRw >> 15); miyRw &= 0x7fff;
+ }
+ var fl = {Unsynced:f&1,DyZero:(f&2)>>1,ExAsc:(f&4)>>2,ExDsc:(f&8)>>3};
+ return [fl, miyRw];
+}
+
+/* [MS-XLS] 2.4.345 TODO */
+function parse_Window1(blob) {
+ var xWn = blob.read_shift(2), yWn = blob.read_shift(2), dxWn = blob.read_shift(2), dyWn = blob.read_shift(2);
+ var flags = blob.read_shift(2), iTabCur = blob.read_shift(2), iTabFirst = blob.read_shift(2);
+ var ctabSel = blob.read_shift(2), wTabRatio = blob.read_shift(2);
+ return { Pos: [xWn, yWn], Dim: [dxWn, dyWn], Flags: flags, CurTab: iTabCur,
+ FirstTab: iTabFirst, Selected: ctabSel, TabRatio: wTabRatio };
+}
+function write_Window1() {
+ var o = new_buf(18);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0x7260);
+ o.write_shift(2, 0x44c0);
+ o.write_shift(2, 0x38);
+ o.write_shift(2, 0);
+ o.write_shift(2, 0);
+ o.write_shift(2, 1);
+ o.write_shift(2, 0x01f4);
+ return o;
+}
+/* [MS-XLS] 2.4.346 TODO */
+function parse_Window2(blob, length, opts) {
+ if(opts && opts.biff >= 2 && opts.biff < 5) return {};
+ var f = blob.read_shift(2);
+ return { RTL: f & 0x40 };
+}
+function write_Window2(view) {
+ var o = new_buf(18), f = 0x6b6;
+ if(view && view.RTL) f |= 0x40;
+ o.write_shift(2, f);
+ o.write_shift(4, 0);
+ o.write_shift(4, 64);
+ o.write_shift(4, 0);
+ o.write_shift(4, 0);
+ return o;
+}
+
+/* [MS-XLS] 2.4.189 TODO */
+function parse_Pane(/*blob, length, opts*/) {
+}
+
+/* [MS-XLS] 2.4.122 TODO */
+function parse_Font(blob, length, opts) {
+ var o = {
+ dyHeight: blob.read_shift(2),
+ fl: blob.read_shift(2)
+ };
+ switch((opts && opts.biff) || 8) {
+ case 2: break;
+ case 3: case 4: blob.l += 2; break;
+ default: blob.l += 10; break;
+ }
+ o.name = parse_ShortXLUnicodeString(blob, 0, opts);
+ return o;
+}
+function write_Font(data, opts) {
+ var name = data.name || "Arial";
+ var b5 = (opts && (opts.biff == 5)), w = (b5 ? (15 + name.length) : (16 + 2 * name.length));
+ var o = new_buf(w);
+ o.write_shift(2, (data.sz || 12) * 20);
+ o.write_shift(4, 0);
+ o.write_shift(2, 400);
+ o.write_shift(4, 0);
+ o.write_shift(2, 0);
+ o.write_shift(1, name.length);
+ if(!b5) o.write_shift(1, 1);
+ o.write_shift((b5 ? 1 : 2) * name.length, name, (b5 ? "sbcs" : "utf16le"));
+ return o;
+}
+
+/* [MS-XLS] 2.4.149 */
+function parse_LabelSst(blob) {
+ var cell = parse_XLSCell(blob);
+ cell.isst = blob.read_shift(4);
+ return cell;
+}
+function write_LabelSst(R, C, v, os ) {
+ var o = new_buf(10);
+ write_XLSCell(R, C, os, o);
+ o.write_shift(4, v);
+ return o;
+}
+
+/* [MS-XLS] 2.4.148 */
+function parse_Label(blob, length, opts) {
+ if(opts.biffguess && opts.biff == 2) opts.biff = 5;
+ var target = blob.l + length;
+ var cell = parse_XLSCell(blob, 6);
+ if(opts.biff == 2) blob.l++;
+ var str = parse_XLUnicodeString(blob, target - blob.l, opts);
+ cell.val = str;
+ return cell;
+}
+function write_Label(R, C, v, os, opts) {
+ var b8 = !opts || opts.biff == 8;
+ var o = new_buf(6 + 2 + (+b8) + (1 + b8) * v.length);
+ write_XLSCell(R, C, os, o);
+ o.write_shift(2, v.length);
+ if(b8) o.write_shift(1, 1);
+ o.write_shift((1 + b8) * v.length, v, b8 ? 'utf16le' : 'sbcs');
+ return o;
+}
+
+
+/* [MS-XLS] 2.4.126 Number Formats */
+function parse_Format(blob, length, opts) {
+ var numFmtId = blob.read_shift(2);
+ var fmtstr = parse_XLUnicodeString2(blob, 0, opts);
+ return [numFmtId, fmtstr];
+}
+function write_Format(i, f, opts, o) {
+ var b5 = (opts && (opts.biff == 5));
+ if(!o) o = new_buf(b5 ? (3 + f.length) : (5 + 2 * f.length));
+ o.write_shift(2, i);
+ o.write_shift((b5 ? 1 : 2), f.length);
+ if(!b5) o.write_shift(1, 1);
+ o.write_shift((b5 ? 1 : 2) * f.length, f, (b5 ? 'sbcs' : 'utf16le'));
+ var out = (o.length > o.l) ? o.slice(0, o.l) : o;
+ if(out.l == null) out.l = out.length;
+ return out;
+}
+var parse_BIFF2Format = parse_XLUnicodeString2;
+
+/* [MS-XLS] 2.4.90 */
+function parse_Dimensions(blob, length, opts) {
+ var end = blob.l + length;
+ var w = opts.biff == 8 || !opts.biff ? 4 : 2;
+ var r = blob.read_shift(w), R = blob.read_shift(w);
+ var c = blob.read_shift(2), C = blob.read_shift(2);
+ blob.l = end;
+ return {s: {r:r, c:c}, e: {r:R, c:C}};
+}
+function write_Dimensions(range, opts) {
+ var w = opts.biff == 8 || !opts.biff ? 4 : 2;
+ var o = new_buf(2*w + 6);
+ o.write_shift(w, range.s.r);
+ o.write_shift(w, range.e.r + 1);
+ o.write_shift(2, range.s.c);
+ o.write_shift(2, range.e.c + 1);
+ o.write_shift(2, 0);
+ return o;
+}
+
+/* [MS-XLS] 2.4.220 */
+function parse_RK(blob) {
+ var rw = blob.read_shift(2), col = blob.read_shift(2);
+ var rkrec = parse_RkRec(blob);
+ return {r:rw, c:col, ixfe:rkrec[0], rknum:rkrec[1]};
+}
+
+/* [MS-XLS] 2.4.175 */
+function parse_MulRk(blob, length) {
+ var target = blob.l + length - 2;
+ var rw = blob.read_shift(2), col = blob.read_shift(2);
+ var rkrecs = [];
+ while(blob.l < target) rkrecs.push(parse_RkRec(blob));
+ if(blob.l !== target) throw new Error("MulRK read error");
+ var lastcol = blob.read_shift(2);
+ if(rkrecs.length != lastcol - col + 1) throw new Error("MulRK length mismatch");
+ return {r:rw, c:col, C:lastcol, rkrec:rkrecs};
+}
+/* [MS-XLS] 2.4.174 */
+function parse_MulBlank(blob, length) {
+ var target = blob.l + length - 2;
+ var rw = blob.read_shift(2), col = blob.read_shift(2);
+ var ixfes = [];
+ while(blob.l < target) ixfes.push(blob.read_shift(2));
+ if(blob.l !== target) throw new Error("MulBlank read error");
+ var lastcol = blob.read_shift(2);
+ if(ixfes.length != lastcol - col + 1) throw new Error("MulBlank length mismatch");
+ return {r:rw, c:col, C:lastcol, ixfe:ixfes};
+}
+
+/* [MS-XLS] 2.5.20 2.5.249 TODO: interpret values here */
+function parse_CellStyleXF(blob, length, style, opts) {
+ var o = {};
+ var a = blob.read_shift(4), b = blob.read_shift(4);
+ var c = blob.read_shift(4), d = blob.read_shift(2);
+ o.patternType = XLSFillPattern[c >> 26];
+
+ if(!opts.cellStyles) return o;
+ o.alc = a & 0x07;
+ o.fWrap = (a >> 3) & 0x01;
+ o.alcV = (a >> 4) & 0x07;
+ o.fJustLast = (a >> 7) & 0x01;
+ o.trot = (a >> 8) & 0xFF;
+ o.cIndent = (a >> 16) & 0x0F;
+ o.fShrinkToFit = (a >> 20) & 0x01;
+ o.iReadOrder = (a >> 22) & 0x02;
+ o.fAtrNum = (a >> 26) & 0x01;
+ o.fAtrFnt = (a >> 27) & 0x01;
+ o.fAtrAlc = (a >> 28) & 0x01;
+ o.fAtrBdr = (a >> 29) & 0x01;
+ o.fAtrPat = (a >> 30) & 0x01;
+ o.fAtrProt = (a >> 31) & 0x01;
+
+ o.dgLeft = b & 0x0F;
+ o.dgRight = (b >> 4) & 0x0F;
+ o.dgTop = (b >> 8) & 0x0F;
+ o.dgBottom = (b >> 12) & 0x0F;
+ o.icvLeft = (b >> 16) & 0x7F;
+ o.icvRight = (b >> 23) & 0x7F;
+ o.grbitDiag = (b >> 30) & 0x03;
+
+ o.icvTop = c & 0x7F;
+ o.icvBottom = (c >> 7) & 0x7F;
+ o.icvDiag = (c >> 14) & 0x7F;
+ o.dgDiag = (c >> 21) & 0x0F;
+
+ o.icvFore = d & 0x7F;
+ o.icvBack = (d >> 7) & 0x7F;
+ o.fsxButton = (d >> 14) & 0x01;
+ return o;
+}
+//function parse_CellXF(blob, length, opts) {return parse_CellStyleXF(blob,length,0, opts);}
+//function parse_StyleXF(blob, length, opts) {return parse_CellStyleXF(blob,length,1, opts);}
+
+/* [MS-XLS] 2.4.353 TODO: actually do this right */
+function parse_XF(blob, length, opts) {
+ var o = {};
+ o.ifnt = blob.read_shift(2); o.numFmtId = blob.read_shift(2); o.flags = blob.read_shift(2);
+ o.fStyle = (o.flags >> 2) & 0x01;
+ length -= 6;
+ o.data = parse_CellStyleXF(blob, length, o.fStyle, opts);
+ return o;
+}
+function write_XF(data, ixfeP, opts, o) {
+ var b5 = (opts && (opts.biff == 5));
+ if(!o) o = new_buf(b5 ? 16 : 20);
+ o.write_shift(2, 0);
+ if(data.style) {
+ o.write_shift(2, (data.numFmtId||0));
+ o.write_shift(2, 0xFFF4);
+ } else {
+ o.write_shift(2, (data.numFmtId||0));
+ o.write_shift(2, (ixfeP<<4));
+ }
+ var f = 0;
+ if(data.numFmtId > 0 && b5) f |= 0x0400;
+ o.write_shift(4, f);
+ o.write_shift(4, 0);
+ if(!b5) o.write_shift(4, 0);
+ o.write_shift(2, 0);
+ return o;
+}
+
+/* [MS-XLS] 2.4.134 */
+function parse_Guts(blob) {
+ blob.l += 4;
+ var out = [blob.read_shift(2), blob.read_shift(2)];
+ if(out[0] !== 0) out[0]--;
+ if(out[1] !== 0) out[1]--;
+ if(out[0] > 7 || out[1] > 7) throw new Error("Bad Gutters: " + out.join("|"));
+ return out;
+}
+function write_Guts(guts) {
+ var o = new_buf(8);
+ o.write_shift(4, 0);
+ o.write_shift(2, guts[0] ? guts[0] + 1 : 0);
+ o.write_shift(2, guts[1] ? guts[1] + 1 : 0);
+ return o;
+}
+
+/* [MS-XLS] 2.4.24 */
+function parse_BoolErr(blob, length, opts) {
+ var cell = parse_XLSCell(blob, 6);
+ if(opts.biff == 2 || length == 9) ++blob.l;
+ var val = parse_Bes(blob, 2);
+ cell.val = val;
+ cell.t = (val === true || val === false) ? 'b' : 'e';
+ return cell;
+}
+function write_BoolErr(R, C, v, os, opts, t) {
+ var o = new_buf(8);
+ write_XLSCell(R, C, os, o);
+ write_Bes(v, t, o);
+ return o;
+}
+
+/* [MS-XLS] 2.4.180 Number */
+function parse_Number(blob, length, opts) {
+ if(opts.biffguess && opts.biff == 2) opts.biff = 5;
+ var cell = parse_XLSCell(blob, 6);
+ var xnum = parse_Xnum(blob, 8);
+ cell.val = xnum;
+ return cell;
+}
+function write_Number(R, C, v, os) {
+ var o = new_buf(14);
+ write_XLSCell(R, C, os, o);
+ write_Xnum(v, o);
+ return o;
+}
+
+var parse_XLHeaderFooter = parse_OptXLUnicodeString; // TODO: parse 2.4.136
+
+/* [MS-XLS] 2.4.271 */
+function parse_SupBook(blob, length, opts) {
+ var end = blob.l + length;
+ var ctab = blob.read_shift(2);
+ var cch = blob.read_shift(2);
+ opts.sbcch = cch;
+ if(cch == 0x0401 || cch == 0x3A01) return [cch, ctab];
+ if(cch < 0x01 || cch >0xff) throw new Error("Unexpected SupBook type: "+cch);
+ var virtPath = parse_XLUnicodeStringNoCch(blob, cch);
+ /* TODO: 2.5.277 Virtual Path */
+ var rgst = [];
+ while(end > blob.l) rgst.push(parse_XLUnicodeString(blob));
+ return [cch, ctab, virtPath, rgst];
+}
+
+/* [MS-XLS] 2.4.105 TODO */
+function parse_ExternName(blob, length, opts) {
+ var flags = blob.read_shift(2);
+ var body;
+ var o = ({
+ fBuiltIn: flags & 0x01,
+ fWantAdvise: (flags >>> 1) & 0x01,
+ fWantPict: (flags >>> 2) & 0x01,
+ fOle: (flags >>> 3) & 0x01,
+ fOleLink: (flags >>> 4) & 0x01,
+ cf: (flags >>> 5) & 0x3FF,
+ fIcon: flags >>> 15 & 0x01
+ });
+ if(opts.sbcch === 0x3A01) body = parse_AddinUdf(blob, length-2, opts);
+ //else throw new Error("unsupported SupBook cch: " + opts.sbcch);
+ o.body = body || blob.read_shift(length-2);
+ if(typeof body === "string") o.Name = body;
+ return o;
+}
+
+/* [MS-XLS] 2.4.150 TODO */
+var XLSLblBuiltIn = [
+ "_xlnm.Consolidate_Area",
+ "_xlnm.Auto_Open",
+ "_xlnm.Auto_Close",
+ "_xlnm.Extract",
+ "_xlnm.Database",
+ "_xlnm.Criteria",
+ "_xlnm.Print_Area",
+ "_xlnm.Print_Titles",
+ "_xlnm.Recorder",
+ "_xlnm.Data_Form",
+ "_xlnm.Auto_Activate",
+ "_xlnm.Auto_Deactivate",
+ "_xlnm.Sheet_Title",
+ "_xlnm._FilterDatabase"
+];
+function parse_Lbl(blob, length, opts) {
+ var target = blob.l + length;
+ var flags = blob.read_shift(2);
+ var chKey = blob.read_shift(1);
+ var cch = blob.read_shift(1);
+ var cce = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
+ var itab = 0;
+ if(!opts || opts.biff >= 5) {
+ if(opts.biff != 5) blob.l += 2;
+ itab = blob.read_shift(2);
+ if(opts.biff == 5) blob.l += 2;
+ blob.l += 4;
+ }
+ var name = parse_XLUnicodeStringNoCch(blob, cch, opts);
+ if(flags & 0x20) name = XLSLblBuiltIn[name.charCodeAt(0)];
+ var npflen = target - blob.l; if(opts && opts.biff == 2) --npflen;
+ /*jshint -W018 */
+ var rgce = (target == blob.l || cce === 0 || !(npflen > 0)) ? [] : parse_NameParsedFormula(blob, npflen, opts, cce);
+ /*jshint +W018 */
+ return {
+ chKey: chKey,
+ Name: name,
+ itab: itab,
+ rgce: rgce
+ };
+}
+
+/* [MS-XLS] 2.4.106 TODO: verify filename encoding */
+function parse_ExternSheet(blob, length, opts) {
+ if(opts.biff < 8) return parse_BIFF5ExternSheet(blob, length, opts);
+ var o = [], target = blob.l + length, len = blob.read_shift(opts.biff > 8 ? 4 : 2);
+ while(len-- !== 0) o.push(parse_XTI(blob, opts.biff > 8 ? 12 : 6, opts));
+ // [iSupBook, itabFirst, itabLast];
+ if(blob.l != target) throw new Error("Bad ExternSheet: " + blob.l + " != " + target);
+ return o;
+}
+function parse_BIFF5ExternSheet(blob, length, opts) {
+ if(blob[blob.l + 1] == 0x03) blob[blob.l]++;
+ var o = parse_ShortXLUnicodeString(blob, length, opts);
+ return o.charCodeAt(0) == 0x03 ? o.slice(1) : o;
+}
+
+/* [MS-XLS] 2.4.176 TODO: check older biff */
+function parse_NameCmt(blob, length, opts) {
+ if(opts.biff < 8) { blob.l += length; return; }
+ var cchName = blob.read_shift(2);
+ var cchComment = blob.read_shift(2);
+ var name = parse_XLUnicodeStringNoCch(blob, cchName, opts);
+ var comment = parse_XLUnicodeStringNoCch(blob, cchComment, opts);
+ return [name, comment];
+}
+
+/* [MS-XLS] 2.4.260 */
+function parse_ShrFmla(blob, length, opts) {
+ var ref = parse_RefU(blob, 6);
+ blob.l++;
+ var cUse = blob.read_shift(1);
+ length -= 8;
+ return [parse_SharedParsedFormula(blob, length, opts), cUse, ref];
+}
+
+/* [MS-XLS] 2.4.4 TODO */
+function parse_Array(blob, length, opts) {
+ var ref = parse_Ref(blob, 6);
+ /* TODO: fAlwaysCalc */
+ switch(opts.biff) {
+ case 2: blob.l ++; length -= 7; break;
+ case 3: case 4: blob.l += 2; length -= 8; break;
+ default: blob.l += 6; length -= 12;
+ }
+ return [ref, parse_ArrayParsedFormula(blob, length, opts, ref)];
+}
+
+/* [MS-XLS] 2.4.173 */
+function parse_MTRSettings(blob) {
+ var fMTREnabled = blob.read_shift(4) !== 0x00;
+ var fUserSetThreadCount = blob.read_shift(4) !== 0x00;
+ var cUserThreadCount = blob.read_shift(4);
+ return [fMTREnabled, fUserSetThreadCount, cUserThreadCount];
+}
+
+/* [MS-XLS] 2.5.186 TODO: BIFF5 */
+function parse_NoteSh(blob, length, opts) {
+ if(opts.biff < 8) return;
+ var row = blob.read_shift(2), col = blob.read_shift(2);
+ var flags = blob.read_shift(2), idObj = blob.read_shift(2);
+ var stAuthor = parse_XLUnicodeString2(blob, 0, opts);
+ if(opts.biff < 8) blob.read_shift(1);
+ return [{r:row,c:col}, stAuthor, idObj, flags];
+}
+
+/* [MS-XLS] 2.4.179 */
+function parse_Note(blob, length, opts) {
+ /* TODO: Support revisions */
+ return parse_NoteSh(blob, length, opts);
+}
+
+/* [MS-XLS] 2.4.168 */
+function parse_MergeCells(blob, length) {
+ var merges = [];
+ var cmcs = blob.read_shift(2);
+ while (cmcs--) merges.push(parse_Ref8U(blob,length));
+ return merges;
+}
+function write_MergeCells(merges) {
+ var o = new_buf(2 + merges.length * 8);
+ o.write_shift(2, merges.length);
+ for(var i = 0; i < merges.length; ++i) write_Ref8U(merges[i], o);
+ return o;
+}
+
+/* [MS-XLS] 2.4.181 TODO: parse all the things! */
+function parse_Obj(blob, length, opts) {
+ if(opts && opts.biff < 8) return parse_BIFF5Obj(blob, length, opts);
+ var cmo = parse_FtCmo(blob, 22); // id, ot, flags
+ var fts = parse_FtArray(blob, length-22, cmo[1]);
+ return { cmo: cmo, ft:fts };
+}
+/* from older spec */
+var parse_BIFF5OT = {
+0x08: function(blob, length) {
+ var tgt = blob.l + length;
+ blob.l += 10; // todo
+ var cf = blob.read_shift(2);
+ blob.l += 4;
+ blob.l += 2; //var cbPictFmla = blob.read_shift(2);
+ blob.l += 2;
+ blob.l += 2; //var grbit = blob.read_shift(2);
+ blob.l += 4;
+ var cchName = blob.read_shift(1);
+ blob.l += cchName; // TODO: stName
+ blob.l = tgt; // TODO: fmla
+ return { fmt:cf };
+}
+};
+
+function parse_BIFF5Obj(blob, length, opts) {
+ blob.l += 4; //var cnt = blob.read_shift(4);
+ var ot = blob.read_shift(2);
+ var id = blob.read_shift(2);
+ var grbit = blob.read_shift(2);
+ blob.l += 2; //var colL = blob.read_shift(2);
+ blob.l += 2; //var dxL = blob.read_shift(2);
+ blob.l += 2; //var rwT = blob.read_shift(2);
+ blob.l += 2; //var dyT = blob.read_shift(2);
+ blob.l += 2; //var colR = blob.read_shift(2);
+ blob.l += 2; //var dxR = blob.read_shift(2);
+ blob.l += 2; //var rwB = blob.read_shift(2);
+ blob.l += 2; //var dyB = blob.read_shift(2);
+ blob.l += 2; //var cbMacro = blob.read_shift(2);
+ blob.l += 6;
+ length -= 36;
+ var fts = [];
+ fts.push((parse_BIFF5OT[ot]||parsenoop)(blob, length, opts));
+ return { cmo: [id, ot, grbit], ft:fts };
+}
+
+/* [MS-XLS] 2.4.329 TODO: parse properly */
+function parse_TxO(blob, length, opts) {
+ var s = blob.l;
+ var texts = "";
+try {
+ blob.l += 4;
+ var ot = (opts.lastobj||{cmo:[0,0]}).cmo[1];
+ var controlInfo; // eslint-disable-line no-unused-vars
+ if([0,5,7,11,12,14].indexOf(ot) == -1) blob.l += 6;
+ else controlInfo = parse_ControlInfo(blob, 6, opts); // eslint-disable-line no-unused-vars
+ var cchText = blob.read_shift(2);
+ /*var cbRuns = */blob.read_shift(2);
+ /*var ifntEmpty = */parseuint16(blob, 2);
+ var len = blob.read_shift(2);
+ blob.l += len;
+ //var fmla = parse_ObjFmla(blob, s + length - blob.l);
+
+ for(var i = 1; i < blob.lens.length-1; ++i) {
+ if(blob.l-s != blob.lens[i]) throw new Error("TxO: bad continue record");
+ var hdr = blob[blob.l];
+ var t = parse_XLUnicodeStringNoCch(blob, blob.lens[i+1]-blob.lens[i]-1);
+ texts += t;
+ if(texts.length >= (hdr ? cchText : 2*cchText)) break;
+ }
+ if(texts.length !== cchText && texts.length !== cchText*2) {
+ throw new Error("cchText: " + cchText + " != " + texts.length);
+ }
+
+ blob.l = s + length;
+ /* [MS-XLS] 2.5.272 TxORuns */
+// var rgTxoRuns = [];
+// for(var j = 0; j != cbRuns/8-1; ++j) blob.l += 8;
+// var cchText2 = blob.read_shift(2);
+// if(cchText2 !== cchText) throw new Error("TxOLastRun mismatch: " + cchText2 + " " + cchText);
+// blob.l += 6;
+// if(s + length != blob.l) throw new Error("TxO " + (s + length) + ", at " + blob.l);
+ return { t: texts };
+} catch(e) { blob.l = s + length; return { t: texts }; }
+}
+
+/* [MS-XLS] 2.4.140 */
+function parse_HLink(blob, length) {
+ var ref = parse_Ref8U(blob, 8);
+ blob.l += 16; /* CLSID */
+ var hlink = parse_Hyperlink(blob, length-24);
+ return [ref, hlink];
+}
+function write_HLink(hl) {
+ var O = new_buf(24);
+ var ref = decode_cell(hl[0]);
+ O.write_shift(2, ref.r); O.write_shift(2, ref.r);
+ O.write_shift(2, ref.c); O.write_shift(2, ref.c);
+ var clsid = "d0 c9 ea 79 f9 ba ce 11 8c 82 00 aa 00 4b a9 0b".split(" ");
+ for(var i = 0; i < 16; ++i) O.write_shift(1, parseInt(clsid[i], 16));
+ return bconcat([O, write_Hyperlink(hl[1])]);
+}
+
+
+/* [MS-XLS] 2.4.141 */
+function parse_HLinkTooltip(blob, length) {
+ blob.read_shift(2);
+ var ref = parse_Ref8U(blob, 8);
+ var wzTooltip = blob.read_shift((length-10)/2, 'dbcs-cont');
+ wzTooltip = wzTooltip.replace(chr0,"");
+ return [ref, wzTooltip];
+}
+function write_HLinkTooltip(hl) {
+ var TT = hl[1].Tooltip;
+ var O = new_buf(10 + 2 * (TT.length + 1));
+ O.write_shift(2, 0x0800);
+ var ref = decode_cell(hl[0]);
+ O.write_shift(2, ref.r); O.write_shift(2, ref.r);
+ O.write_shift(2, ref.c); O.write_shift(2, ref.c);
+ for(var i = 0; i < TT.length; ++i) O.write_shift(2, TT.charCodeAt(i));
+ O.write_shift(2, 0);
+ return O;
+}
+
+/* [MS-XLS] 2.4.63 */
+function parse_Country(blob) {
+ var o = [0,0], d;
+ d = blob.read_shift(2); o[0] = CountryEnum[d] || d;
+ d = blob.read_shift(2); o[1] = CountryEnum[d] || d;
+ return o;
+}
+function write_Country(o) {
+ if(!o) o = new_buf(4);
+ o.write_shift(2, 0x01);
+ o.write_shift(2, 0x01);
+ return o;
+}
+
+/* [MS-XLS] 2.4.50 ClrtClient */
+function parse_ClrtClient(blob) {
+ var ccv = blob.read_shift(2);
+ var o = [];
+ while(ccv-->0) o.push(parse_LongRGB(blob, 8));
+ return o;
+}
+
+/* [MS-XLS] 2.4.188 */
+function parse_Palette(blob) {
+ var ccv = blob.read_shift(2);
+ var o = [];
+ while(ccv-->0) o.push(parse_LongRGB(blob, 8));
+ return o;
+}
+
+/* [MS-XLS] 2.4.354 */
+function parse_XFCRC(blob) {
+ blob.l += 2;
+ var o = {cxfs:0, crc:0};
+ o.cxfs = blob.read_shift(2);
+ o.crc = blob.read_shift(4);
+ return o;
+}
+
+/* [MS-XLS] 2.4.53 TODO: parse flags */
+/* [MS-XLSB] 2.4.323 TODO: parse flags */
+function parse_ColInfo(blob, length, opts) {
+ if(!opts.cellStyles) return parsenoop(blob, length);
+ var w = opts && opts.biff >= 12 ? 4 : 2;
+ var colFirst = blob.read_shift(w);
+ var colLast = blob.read_shift(w);
+ var coldx = blob.read_shift(w);
+ var ixfe = blob.read_shift(w);
+ var flags = blob.read_shift(2);
+ if(w == 2) blob.l += 2;
+ var o = ({s:colFirst, e:colLast, w:coldx, ixfe:ixfe, flags:flags});
+ if(opts.biff >= 5 || !opts.biff) o.level = (flags >> 8) & 0x7;
+ return o;
+}
+function write_ColInfo(col, idx) {
+ var o = new_buf(12);
+ o.write_shift(2, idx);
+ o.write_shift(2, idx);
+ o.write_shift(2, col.width * 256);
+ o.write_shift(2, 0);
+ var f = 0;
+ if(col.hidden) f |= 1;
+ o.write_shift(1, f);
+ f = col.level || 0;
+ o.write_shift(1, f);
+ o.write_shift(2, 0);
+ return o;
+}
+
+/* [MS-XLS] 2.4.257 */
+function parse_Setup(blob, length) {
+ var o = {};
+ if(length < 32) return o;
+ blob.l += 16;
+ o.header = parse_Xnum(blob, 8);
+ o.footer = parse_Xnum(blob, 8);
+ blob.l += 2;
+ return o;
+}
+
+/* [MS-XLS] 2.4.261 */
+function parse_ShtProps(blob, length, opts) {
+ var def = {area:false};
+ if(opts.biff != 5) { blob.l += length; return def; }
+ var d = blob.read_shift(1); blob.l += 3;
+ if((d & 0x10)) def.area = true;
+ return def;
+}
+
+/* [MS-XLS] 2.4.241 */
+function write_RRTabId(n) {
+ var out = new_buf(2 * n);
+ for(var i = 0; i < n; ++i) out.write_shift(2, i+1);
+ return out;
+}
+
+var parse_Blank = parse_XLSCell; /* [MS-XLS] 2.4.20 Just the cell */
+var parse_Scl = parseuint16a; /* [MS-XLS] 2.4.247 num, den */
+var parse_String = parse_XLUnicodeString; /* [MS-XLS] 2.4.268 */
+
+/* --- Specific to versions before BIFF8 --- */
+function parse_ImData(blob) {
+ var cf = blob.read_shift(2);
+ var env = blob.read_shift(2);
+ var lcb = blob.read_shift(4);
+ var o = {fmt:cf, env:env, len:lcb, data:blob.slice(blob.l,blob.l+lcb)};
+ blob.l += lcb;
+ return o;
+}
+
+/* BIFF2_??? where ??? is the name from [XLS] */
+function parse_BIFF2STR(blob, length, opts) {
+ if(opts.biffguess && opts.biff == 5) opts.biff = 2;
+ var cell = parse_XLSCell(blob, 6);
+ ++blob.l;
+ var str = parse_XLUnicodeString2(blob, length-7, opts);
+ cell.t = 'str';
+ cell.val = str;
+ return cell;
+}
+
+function parse_BIFF2NUM(blob) {
+ var cell = parse_XLSCell(blob, 6);
+ ++blob.l;
+ var num = parse_Xnum(blob, 8);
+ cell.t = 'n';
+ cell.val = num;
+ return cell;
+}
+function write_BIFF2NUM(r, c, val) {
+ var out = new_buf(15);
+ write_BIFF2Cell(out, r, c);
+ out.write_shift(8, val, 'f');
+ return out;
+}
+
+function parse_BIFF2INT(blob) {
+ var cell = parse_XLSCell(blob, 6);
+ ++blob.l;
+ var num = blob.read_shift(2);
+ cell.t = 'n';
+ cell.val = num;
+ return cell;
+}
+function write_BIFF2INT(r, c, val) {
+ var out = new_buf(9);
+ write_BIFF2Cell(out, r, c);
+ out.write_shift(2, val);
+ return out;
+}
+
+function parse_BIFF2STRING(blob) {
+ var cch = blob.read_shift(1);
+ if(cch === 0) { blob.l++; return ""; }
+ return blob.read_shift(cch, 'sbcs-cont');
+}
+
+/* TODO: convert to BIFF8 font struct */
+function parse_BIFF2FONTXTRA(blob, length) {
+ blob.l += 6; // unknown
+ blob.l += 2; // font weight "bls"
+ blob.l += 1; // charset
+ blob.l += 3; // unknown
+ blob.l += 1; // font family
+ blob.l += length - 13;
+}
+
+/* TODO: parse rich text runs */
+function parse_RString(blob, length, opts) {
+ var end = blob.l + length;
+ var cell = parse_XLSCell(blob, 6);
+ var cch = blob.read_shift(2);
+ var str = parse_XLUnicodeStringNoCch(blob, cch, opts);
+ blob.l = end;
+ cell.t = 'str';
+ cell.val = str;
+ return cell;
+}
+/* from js-harb (C) 2014-present SheetJS */
+var DBF_SUPPORTED_VERSIONS = [0x02, 0x03, 0x30, 0x31, 0x83, 0x8B, 0x8C, 0xF5];
+var DBF = (function() {
+var dbf_codepage_map = {
+ /* Code Pages Supported by Visual FoxPro */
+0x01: 437, 0x02: 850,
+0x03: 1252, 0x04: 10000,
+0x64: 852, 0x65: 866,
+0x66: 865, 0x67: 861,
+0x68: 895, 0x69: 620,
+0x6A: 737, 0x6B: 857,
+0x78: 950, 0x79: 949,
+0x7A: 936, 0x7B: 932,
+0x7C: 874, 0x7D: 1255,
+0x7E: 1256, 0x96: 10007,
+0x97: 10029, 0x98: 10006,
+0xC8: 1250, 0xC9: 1251,
+0xCA: 1254, 0xCB: 1253,
+
+ /* shapefile DBF extension */
+0x00: 20127, 0x08: 865,
+0x09: 437, 0x0A: 850,
+0x0B: 437, 0x0D: 437,
+0x0E: 850, 0x0F: 437,
+0x10: 850, 0x11: 437,
+0x12: 850, 0x13: 932,
+0x14: 850, 0x15: 437,
+0x16: 850, 0x17: 865,
+0x18: 437, 0x19: 437,
+0x1A: 850, 0x1B: 437,
+0x1C: 863, 0x1D: 850,
+0x1F: 852, 0x22: 852,
+0x23: 852, 0x24: 860,
+0x25: 850, 0x26: 866,
+0x37: 850, 0x40: 852,
+0x4D: 936, 0x4E: 949,
+0x4F: 950, 0x50: 874,
+0x57: 1252, 0x58: 1252,
+0x59: 1252, 0x6C: 863,
+0x86: 737, 0x87: 852,
+0x88: 857, 0xCC: 1257,
+
+0xFF: 16969
+};
+var dbf_reverse_map = evert({
+0x01: 437, 0x02: 850,
+0x03: 1252, 0x04: 10000,
+0x64: 852, 0x65: 866,
+0x66: 865, 0x67: 861,
+0x68: 895, 0x69: 620,
+0x6A: 737, 0x6B: 857,
+0x78: 950, 0x79: 949,
+0x7A: 936, 0x7B: 932,
+0x7C: 874, 0x7D: 1255,
+0x7E: 1256, 0x96: 10007,
+0x97: 10029, 0x98: 10006,
+0xC8: 1250, 0xC9: 1251,
+0xCA: 1254, 0xCB: 1253,
+0x00: 20127
+});
+/* TODO: find an actual specification */
+function dbf_to_aoa(buf, opts) {
+ var out = [];
+ var d = (new_raw_buf(1));
+ switch(opts.type) {
+ case 'base64': d = s2a(Base64_decode(buf)); break;
+ case 'binary': d = s2a(buf); break;
+ case 'buffer':
+ case 'array': d = buf; break;
+ }
+ prep_blob(d, 0);
+
+ /* header */
+ var ft = d.read_shift(1);
+ var memo = !!(ft & 0x88);
+ var vfp = false, l7 = false;
+ switch(ft) {
+ case 0x02: break; // dBASE II
+ case 0x03: break; // dBASE III
+ case 0x30: vfp = true; memo = true; break; // VFP
+ case 0x31: vfp = true; memo = true; break; // VFP with autoincrement
+ // 0x43 dBASE IV SQL table files
+ // 0x63 dBASE IV SQL system files
+ case 0x83: break; // dBASE III with memo
+ case 0x8B: break; // dBASE IV with memo
+ case 0x8C: l7 = true; break; // dBASE Level 7 with memo
+ // case 0xCB dBASE IV SQL table files with memo
+ case 0xF5: break; // FoxPro 2.x with memo
+ // case 0xFB FoxBASE
+ default: throw new Error("DBF Unsupported Version: " + ft.toString(16));
+ }
+
+ var nrow = 0, fpos = 0x0209;
+ if(ft == 0x02) nrow = d.read_shift(2);
+ d.l += 3; // dBASE II stores DDMMYY date, others use YYMMDD
+ if(ft != 0x02) nrow = d.read_shift(4);
+ if(nrow > 1048576) nrow = 1e6;
+
+ if(ft != 0x02) fpos = d.read_shift(2); // header length
+ var rlen = d.read_shift(2); // record length
+
+ var /*flags = 0,*/ current_cp = opts.codepage || 1252;
+ if(ft != 0x02) { // 20 reserved bytes
+ d.l+=16;
+ /*flags = */d.read_shift(1);
+ //if(memo && ((flags & 0x02) === 0)) throw new Error("DBF Flags " + flags.toString(16) + " ft " + ft.toString(16));
+
+ /* codepage present in FoxPro and dBASE Level 7 */
+ if(d[d.l] !== 0) current_cp = dbf_codepage_map[d[d.l]];
+ d.l+=1;
+
+ d.l+=2;
+ }
+ if(l7) d.l += 36; // Level 7: 32 byte "Language driver name", 4 byte reserved
+
+var fields = [], field = ({});
+ var hend = Math.min(d.length, (ft == 0x02 ? 0x209 : (fpos - 10 - (vfp ? 264 : 0))));
+ var ww = l7 ? 32 : 11;
+ while(d.l < hend && d[d.l] != 0x0d) {
+ field = ({});
+ field.name = $cptable.utils.decode(current_cp, d.slice(d.l, d.l+ww)).replace(/[\u0000\r\n].*$/g,"");
+ d.l += ww;
+ field.type = String.fromCharCode(d.read_shift(1));
+ if(ft != 0x02 && !l7) field.offset = d.read_shift(4);
+ field.len = d.read_shift(1);
+ if(ft == 0x02) field.offset = d.read_shift(2);
+ field.dec = d.read_shift(1);
+ if(field.name.length) fields.push(field);
+ if(ft != 0x02) d.l += l7 ? 13 : 14;
+ switch(field.type) {
+ case 'B': // Double (VFP) / Binary (dBASE L7)
+ if((!vfp || field.len != 8) && opts.WTF) console.log('Skipping ' + field.name + ':' + field.type);
+ break;
+ case 'G': // General (FoxPro and dBASE L7)
+ case 'P': // Picture (FoxPro and dBASE L7)
+ if(opts.WTF) console.log('Skipping ' + field.name + ':' + field.type);
+ break;
+ case '+': // Autoincrement (dBASE L7 only)
+ case '0': // _NullFlags (VFP only)
+ case '@': // Timestamp (dBASE L7 only)
+ case 'C': // Character (dBASE II)
+ case 'D': // Date (dBASE III)
+ case 'F': // Float (dBASE IV)
+ case 'I': // Long (VFP and dBASE L7)
+ case 'L': // Logical (dBASE II)
+ case 'M': // Memo (dBASE III)
+ case 'N': // Number (dBASE II)
+ case 'O': // Double (dBASE L7 only)
+ case 'T': // Datetime (VFP only)
+ case 'Y': // Currency (VFP only)
+ break;
+ default: throw new Error('Unknown Field Type: ' + field.type);
+ }
+ }
+
+ if(d[d.l] !== 0x0D) d.l = fpos-1;
+ if(d.read_shift(1) !== 0x0D) throw new Error("DBF Terminator not found " + d.l + " " + d[d.l]);
+ d.l = fpos;
+
+ /* data */
+ var R = 0, C = 0;
+ out[0] = [];
+ for(C = 0; C != fields.length; ++C) out[0][C] = fields[C].name;
+ while(nrow-- > 0) {
+ if(d[d.l] === 0x2A) {
+ // TODO: record marked as deleted -- create a hidden row?
+ d.l+=rlen;
+ continue;
+ }
+ ++d.l;
+ out[++R] = []; C = 0;
+ for(C = 0; C != fields.length; ++C) {
+ var dd = d.slice(d.l, d.l+fields[C].len); d.l+=fields[C].len;
+ prep_blob(dd, 0);
+ var s = $cptable.utils.decode(current_cp, dd);
+ switch(fields[C].type) {
+ case 'C':
+ // NOTE: it is conventional to write ' / / ' for empty dates
+ if(s.trim().length) out[R][C] = s.replace(/\s+$/,"");
+ break;
+ case 'D':
+ if(s.length === 8) out[R][C] = new Date(+s.slice(0,4), +s.slice(4,6)-1, +s.slice(6,8));
+ else out[R][C] = s;
+ break;
+ case 'F': out[R][C] = parseFloat(s.trim()); break;
+ case '+': case 'I': out[R][C] = l7 ? dd.read_shift(-4, 'i') ^ 0x80000000 : dd.read_shift(4, 'i'); break;
+ case 'L': switch(s.trim().toUpperCase()) {
+ case 'Y': case 'T': out[R][C] = true; break;
+ case 'N': case 'F': out[R][C] = false; break;
+ case '': case '?': break;
+ default: throw new Error("DBF Unrecognized L:|" + s + "|");
+ } break;
+ case 'M': /* TODO: handle memo files */
+ if(!memo) throw new Error("DBF Unexpected MEMO for type " + ft.toString(16));
+ out[R][C] = "##MEMO##" + (l7 ? parseInt(s.trim(), 10): dd.read_shift(4));
+ break;
+ case 'N':
+ s = s.replace(/\u0000/g,"").trim();
+ // NOTE: dBASE II interprets " . " as 0
+ if(s && s != ".") out[R][C] = +s || 0; break;
+ case '@':
+ // NOTE: dBASE specs appear to be incorrect
+ out[R][C] = new Date(dd.read_shift(-8, 'f') - 0x388317533400);
+ break;
+ case 'T': out[R][C] = new Date((dd.read_shift(4) - 0x253D8C) * 0x5265C00 + dd.read_shift(4)); break;
+ case 'Y': out[R][C] = dd.read_shift(4,'i')/1e4 + (dd.read_shift(4, 'i')/1e4)*Math.pow(2,32); break;
+ case 'O': out[R][C] = -dd.read_shift(-8, 'f'); break;
+ case 'B': if(vfp && fields[C].len == 8) { out[R][C] = dd.read_shift(8,'f'); break; }
+ /* falls through */
+ case 'G': case 'P': dd.l += fields[C].len; break;
+ case '0':
+ if(fields[C].name === '_NullFlags') break;
+ /* falls through */
+ default: throw new Error("DBF Unsupported data type " + fields[C].type);
+ }
+ }
+ }
+ if(ft != 0x02) if(d.l < d.length && d[d.l++] != 0x1A) throw new Error("DBF EOF Marker missing " + (d.l-1) + " of " + d.length + " " + d[d.l-1].toString(16));
+ if(opts && opts.sheetRows) out = out.slice(0, opts.sheetRows);
+ opts.DBF = fields;
+ return out;
+}
+
+function dbf_to_sheet(buf, opts) {
+ var o = opts || {};
+ if(!o.dateNF) o.dateNF = "yyyymmdd";
+ var ws = aoa_to_sheet(dbf_to_aoa(buf, o), o);
+ ws["!cols"] = o.DBF.map(function(field) { return {
+ wch: field.len,
+ DBF: field
+ };});
+ delete o.DBF;
+ return ws;
+}
+
+function dbf_to_workbook(buf, opts) {
+ try { return sheet_to_workbook(dbf_to_sheet(buf, opts), opts); }
+ catch(e) { if(opts && opts.WTF) throw e; }
+ return ({SheetNames:[],Sheets:{}});
+}
+
+var _RLEN = { 'B': 8, 'C': 250, 'L': 1, 'D': 8, '?': 0, '': 0 };
+function sheet_to_dbf(ws, opts) {
+ var o = opts || {};
+ if(+o.codepage >= 0) set_cp(+o.codepage);
+ if(o.type == "string") throw new Error("Cannot write DBF to JS string");
+ var ba = buf_array();
+ var aoa = sheet_to_json(ws, {header:1, raw:true, cellDates:true});
+ var headers = aoa[0], data = aoa.slice(1), cols = ws["!cols"] || [];
+ var i = 0, j = 0, hcnt = 0, rlen = 1;
+ for(i = 0; i < headers.length; ++i) {
+ if(((cols[i]||{}).DBF||{}).name) { headers[i] = cols[i].DBF.name; ++hcnt; continue; }
+ if(headers[i] == null) continue;
+ ++hcnt;
+ if(typeof headers[i] === 'number') headers[i] = headers[i].toString(10);
+ if(typeof headers[i] !== 'string') throw new Error("DBF Invalid column name " + headers[i] + " |" + (typeof headers[i]) + "|");
+ if(headers.indexOf(headers[i]) !== i) for(j=0; j<1024;++j)
+ if(headers.indexOf(headers[i] + "_" + j) == -1) { headers[i] += "_" + j; break; }
+ }
+ var range = safe_decode_range(ws['!ref']);
+ var coltypes = [];
+ var colwidths = [];
+ var coldecimals = [];
+ for(i = 0; i <= range.e.c - range.s.c; ++i) {
+ var guess = '', _guess = '', maxlen = 0;
+ var col = [];
+ for(j=0; j < data.length; ++j) {
+ if(data[j][i] != null) col.push(data[j][i]);
+ }
+ if(col.length == 0 || headers[i] == null) { coltypes[i] = '?'; continue; }
+ for(j = 0; j < col.length; ++j) {
+ switch(typeof col[j]) {
+ /* TODO: check if L2 compat is desired */
+ case 'number': _guess = 'B'; break;
+ case 'string': _guess = 'C'; break;
+ case 'boolean': _guess = 'L'; break;
+ case 'object': _guess = col[j] instanceof Date ? 'D' : 'C'; break;
+ default: _guess = 'C';
+ }
+ maxlen = Math.max(maxlen, String(col[j]).length);
+ guess = guess && guess != _guess ? 'C' : _guess;
+ //if(guess == 'C') break;
+ }
+ if(maxlen > 250) maxlen = 250;
+ _guess = ((cols[i]||{}).DBF||{}).type;
+ /* TODO: more fine grained control over DBF type resolution */
+ if(_guess == 'C') {
+ if(cols[i].DBF.len > maxlen) maxlen = cols[i].DBF.len;
+ }
+ if(guess == 'B' && _guess == 'N') {
+ guess = 'N';
+ coldecimals[i] = cols[i].DBF.dec;
+ maxlen = cols[i].DBF.len;
+ }
+ colwidths[i] = guess == 'C' || _guess == 'N' ? maxlen : (_RLEN[guess] || 0);
+ rlen += colwidths[i];
+ coltypes[i] = guess;
+ }
+
+ var h = ba.next(32);
+ h.write_shift(4, 0x13021130);
+ h.write_shift(4, data.length);
+ h.write_shift(2, 296 + 32 * hcnt);
+ h.write_shift(2, rlen);
+ for(i=0; i < 4; ++i) h.write_shift(4, 0);
+ h.write_shift(4, 0x00000000 | ((+dbf_reverse_map[current_ansi] || 0x03)<<8));
+
+ for(i = 0, j = 0; i < headers.length; ++i) {
+ if(headers[i] == null) continue;
+ var hf = ba.next(32);
+ var _f = (headers[i].slice(-10) + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00").slice(0, 11);
+ hf.write_shift(1, _f, "sbcs");
+ hf.write_shift(1, coltypes[i] == '?' ? 'C' : coltypes[i], "sbcs");
+ hf.write_shift(4, j);
+ hf.write_shift(1, colwidths[i] || _RLEN[coltypes[i]] || 0);
+ hf.write_shift(1, coldecimals[i] || 0);
+ hf.write_shift(1, 0x02);
+ hf.write_shift(4, 0);
+ hf.write_shift(1, 0);
+ hf.write_shift(4, 0);
+ hf.write_shift(4, 0);
+ j += (colwidths[i] || _RLEN[coltypes[i]] || 0);
+ }
+
+ var hb = ba.next(264);
+ hb.write_shift(4, 0x0000000D);
+ for(i=0; i < 65;++i) hb.write_shift(4, 0x00000000);
+ for(i=0; i < data.length; ++i) {
+ var rout = ba.next(rlen);
+ rout.write_shift(1, 0);
+ for(j=0; j":190, "?":191, "{":223
+ });
+ var sylk_char_regex = new RegExp("\u001BN(" + keys(sylk_escapes).join("|").replace(/\|\|\|/, "|\\||").replace(/([?()+])/g,"\\$1") + "|\\|)", "gm");
+ var sylk_char_fn = function(_, $1){ var o = sylk_escapes[$1]; return typeof o == "number" ? _getansi(o) : o; };
+ var decode_sylk_char = function($$, $1, $2) { var newcc = (($1.charCodeAt(0) - 0x20)<<4) | ($2.charCodeAt(0) - 0x30); return newcc == 59 ? $$ : _getansi(newcc); };
+ sylk_escapes["|"] = 254;
+ /* TODO: find an actual specification */
+ function sylk_to_aoa(d, opts) {
+ switch(opts.type) {
+ case 'base64': return sylk_to_aoa_str(Base64_decode(d), opts);
+ case 'binary': return sylk_to_aoa_str(d, opts);
+ case 'buffer': return sylk_to_aoa_str(has_buf && Buffer.isBuffer(d) ? d.toString('binary') : a2s(d), opts);
+ case 'array': return sylk_to_aoa_str(cc2str(d), opts);
+ }
+ throw new Error("Unrecognized type " + opts.type);
+ }
+ function sylk_to_aoa_str(str, opts) {
+ var records = str.split(/[\n\r]+/), R = -1, C = -1, ri = 0, rj = 0, arr = [];
+ var formats = [];
+ var next_cell_format = null;
+ var sht = {}, rowinfo = [], colinfo = [], cw = [];
+ var Mval = 0, j;
+ if(+opts.codepage >= 0) set_cp(+opts.codepage);
+ for (; ri !== records.length; ++ri) {
+ Mval = 0;
+ var rstr=records[ri].trim().replace(/\x1B([\x20-\x2F])([\x30-\x3F])/g, decode_sylk_char).replace(sylk_char_regex, sylk_char_fn);
+ var record=rstr.replace(/;;/g, "\u0000").split(";").map(function(x) { return x.replace(/\u0000/g, ";"); });
+ var RT=record[0], val;
+ if(rstr.length > 0) switch(RT) {
+ case 'ID': break; /* header */
+ case 'E': break; /* EOF */
+ case 'B': break; /* dimensions */
+ case 'O': break; /* options? */
+ case 'W': break; /* window? */
+ case 'P':
+ if(record[1].charAt(0) == 'P')
+ formats.push(rstr.slice(3).replace(/;;/g, ";"));
+ break;
+ case 'C':
+ var C_seen_K = false, C_seen_X = false, C_seen_S = false, C_seen_E = false, _R = -1, _C = -1;
+ for(rj=1; rj -1 && arr[_R][_C];
+ if(!shrbase || !shrbase[1]) throw new Error("SYLK shared formula cannot find base");
+ arr[R][C][1] = shift_formula_str(shrbase[1], {r: R - _R, c: C - _C});
+ }
+ break;
+ case 'F':
+ var F_seen = 0;
+ for(rj=1; rj 0) { rowinfo[R].hpt = Mval; rowinfo[R].hpx = pt2px(Mval); }
+ else if(Mval === 0) rowinfo[R].hidden = true;
+ break;
+ default: if(opts && opts.WTF) throw new Error("SYLK bad record " + rstr);
+ }
+ if(F_seen < 1) next_cell_format = null; break;
+ default: if(opts && opts.WTF) throw new Error("SYLK bad record " + rstr);
+ }
+ }
+ if(rowinfo.length > 0) sht['!rows'] = rowinfo;
+ if(colinfo.length > 0) sht['!cols'] = colinfo;
+ if(opts && opts.sheetRows) arr = arr.slice(0, opts.sheetRows);
+ return [arr, sht];
+ }
+
+ function sylk_to_sheet(d, opts) {
+ var aoasht = sylk_to_aoa(d, opts);
+ var aoa = aoasht[0], ws = aoasht[1];
+ var o = aoa_to_sheet(aoa, opts);
+ keys(ws).forEach(function(k) { o[k] = ws[k]; });
+ return o;
+ }
+
+ function sylk_to_workbook(d, opts) { return sheet_to_workbook(sylk_to_sheet(d, opts), opts); }
+
+ function write_ws_cell_sylk(cell, ws, R, C) {
+ var o = "C;Y" + (R+1) + ";X" + (C+1) + ";K";
+ switch(cell.t) {
+ case 'n':
+ o += (cell.v||0);
+ if(cell.f && !cell.F) o += ";E" + a1_to_rc(cell.f, {r:R, c:C}); break;
+ case 'b': o += cell.v ? "TRUE" : "FALSE"; break;
+ case 'e': o += cell.w || cell.v; break;
+ case 'd': o += '"' + (cell.w || cell.v) + '"'; break;
+ case 's': o += '"' + cell.v.replace(/"/g,"").replace(/;/g, ";;") + '"'; break;
+ }
+ return o;
+ }
+
+ function write_ws_cols_sylk(out, cols) {
+ cols.forEach(function(col, i) {
+ var rec = "F;W" + (i+1) + " " + (i+1) + " ";
+ if(col.hidden) rec += "0";
+ else {
+ if(typeof col.width == 'number' && !col.wpx) col.wpx = width2px(col.width);
+ if(typeof col.wpx == 'number' && !col.wch) col.wch = px2char(col.wpx);
+ if(typeof col.wch == 'number') rec += Math.round(col.wch);
+ }
+ if(rec.charAt(rec.length - 1) != " ") out.push(rec);
+ });
+ }
+
+ function write_ws_rows_sylk(out, rows) {
+ rows.forEach(function(row, i) {
+ var rec = "F;";
+ if(row.hidden) rec += "M0;";
+ else if(row.hpt) rec += "M" + 20 * row.hpt + ";";
+ else if(row.hpx) rec += "M" + 20 * px2pt(row.hpx) + ";";
+ if(rec.length > 2) out.push(rec + "R" + (i+1));
+ });
+ }
+
+ function sheet_to_sylk(ws, opts) {
+ var preamble = ["ID;PWXL;N;E"], o = [];
+ var r = safe_decode_range(ws['!ref']), cell;
+ var dense = Array.isArray(ws);
+ var RS = "\r\n";
+
+ preamble.push("P;PGeneral");
+ preamble.push("F;P0;DG0G8;M255");
+ if(ws['!cols']) write_ws_cols_sylk(preamble, ws['!cols']);
+ if(ws['!rows']) write_ws_rows_sylk(preamble, ws['!rows']);
+
+ preamble.push("B;Y" + (r.e.r - r.s.r + 1) + ";X" + (r.e.c - r.s.c + 1) + ";D" + [r.s.c,r.s.r,r.e.c,r.e.r].join(" "));
+ for(var R = r.s.r; R <= r.e.r; ++R) {
+ for(var C = r.s.c; C <= r.e.c; ++C) {
+ var coord = encode_cell({r:R,c:C});
+ cell = dense ? (ws[R]||[])[C]: ws[coord];
+ if(!cell || (cell.v == null && (!cell.f || cell.F))) continue;
+ o.push(write_ws_cell_sylk(cell, ws, R, C, opts));
+ }
+ }
+ return preamble.join(RS) + RS + o.join(RS) + RS + "E" + RS;
+ }
+
+ return {
+ to_workbook: sylk_to_workbook,
+ to_sheet: sylk_to_sheet,
+ from_sheet: sheet_to_sylk
+ };
+})();
+
+var DIF = (function() {
+ function dif_to_aoa(d, opts) {
+ switch(opts.type) {
+ case 'base64': return dif_to_aoa_str(Base64_decode(d), opts);
+ case 'binary': return dif_to_aoa_str(d, opts);
+ case 'buffer': return dif_to_aoa_str(has_buf && Buffer.isBuffer(d) ? d.toString('binary') : a2s(d), opts);
+ case 'array': return dif_to_aoa_str(cc2str(d), opts);
+ }
+ throw new Error("Unrecognized type " + opts.type);
+ }
+ function dif_to_aoa_str(str, opts) {
+ var records = str.split('\n'), R = -1, C = -1, ri = 0, arr = [];
+ for (; ri !== records.length; ++ri) {
+ if (records[ri].trim() === 'BOT') { arr[++R] = []; C = 0; continue; }
+ if (R < 0) continue;
+ var metadata = records[ri].trim().split(",");
+ var type = metadata[0], value = metadata[1];
+ ++ri;
+ var data = records[ri] || "";
+ while(((data.match(/["]/g)||[]).length & 1) && ri < records.length - 1) data += "\n" + records[++ri];
+ data = data.trim();
+ switch (+type) {
+ case -1:
+ if (data === 'BOT') { arr[++R] = []; C = 0; continue; }
+ else if (data !== 'EOD') throw new Error("Unrecognized DIF special command " + data);
+ break;
+ case 0:
+ if(data === 'TRUE') arr[R][C] = true;
+ else if(data === 'FALSE') arr[R][C] = false;
+ else if(!isNaN(fuzzynum(value))) arr[R][C] = fuzzynum(value);
+ else if(!isNaN(fuzzydate(value).getDate())) arr[R][C] = parseDate(value);
+ else arr[R][C] = value;
+ ++C; break;
+ case 1:
+ data = data.slice(1,data.length-1);
+ data = data.replace(/""/g, '"');
+ if(DIF_XL && data && data.match(/^=".*"$/)) data = data.slice(2, -1);
+ arr[R][C++] = data !== '' ? data : null;
+ break;
+ }
+ if (data === 'EOD') break;
+ }
+ if(opts && opts.sheetRows) arr = arr.slice(0, opts.sheetRows);
+ return arr;
+ }
+
+ function dif_to_sheet(str, opts) { return aoa_to_sheet(dif_to_aoa(str, opts), opts); }
+ function dif_to_workbook(str, opts) { return sheet_to_workbook(dif_to_sheet(str, opts), opts); }
+
+ var sheet_to_dif = (function() {
+ var push_field = function pf(o, topic, v, n, s) {
+ o.push(topic);
+ o.push(v + "," + n);
+ o.push('"' + s.replace(/"/g,'""') + '"');
+ };
+ var push_value = function po(o, type, v, s) {
+ o.push(type + "," + v);
+ o.push(type == 1 ? '"' + s.replace(/"/g,'""') + '"' : s);
+ };
+ return function sheet_to_dif(ws) {
+ var o = [];
+ var r = safe_decode_range(ws['!ref']), cell;
+ var dense = Array.isArray(ws);
+ push_field(o, "TABLE", 0, 1, "sheetjs");
+ push_field(o, "VECTORS", 0, r.e.r - r.s.r + 1,"");
+ push_field(o, "TUPLES", 0, r.e.c - r.s.c + 1,"");
+ push_field(o, "DATA", 0, 0,"");
+ for(var R = r.s.r; R <= r.e.r; ++R) {
+ push_value(o, -1, 0, "BOT");
+ for(var C = r.s.c; C <= r.e.c; ++C) {
+ var coord = encode_cell({r:R,c:C});
+ cell = dense ? (ws[R]||[])[C] : ws[coord];
+ if(!cell) { push_value(o, 1, 0, ""); continue;}
+ switch(cell.t) {
+ case 'n':
+ var val = DIF_XL ? cell.w : cell.v;
+ if(!val && cell.v != null) val = cell.v;
+ if(val == null) {
+ if(DIF_XL && cell.f && !cell.F) push_value(o, 1, 0, "=" + cell.f);
+ else push_value(o, 1, 0, "");
+ }
+ else push_value(o, 0, val, "V");
+ break;
+ case 'b':
+ push_value(o, 0, cell.v ? 1 : 0, cell.v ? "TRUE" : "FALSE");
+ break;
+ case 's':
+ push_value(o, 1, 0, (!DIF_XL || isNaN(cell.v)) ? cell.v : '="' + cell.v + '"');
+ break;
+ case 'd':
+ if(!cell.w) cell.w = SSF_format(cell.z || table_fmt[14], datenum(parseDate(cell.v)));
+ if(DIF_XL) push_value(o, 0, cell.w, "V");
+ else push_value(o, 1, 0, cell.w);
+ break;
+ default: push_value(o, 1, 0, "");
+ }
+ }
+ }
+ push_value(o, -1, 0, "EOD");
+ var RS = "\r\n";
+ var oo = o.join(RS);
+ //while((oo.length & 0x7F) != 0) oo += "\0";
+ return oo;
+ };
+ })();
+ return {
+ to_workbook: dif_to_workbook,
+ to_sheet: dif_to_sheet,
+ from_sheet: sheet_to_dif
+ };
+})();
+
+var ETH = (function() {
+ function decode(s) { return s.replace(/\\b/g,"\\").replace(/\\c/g,":").replace(/\\n/g,"\n"); }
+ function encode(s) { return s.replace(/\\/g, "\\b").replace(/:/g, "\\c").replace(/\n/g,"\\n"); }
+
+ function eth_to_aoa(str, opts) {
+ var records = str.split('\n'), R = -1, C = -1, ri = 0, arr = [];
+ for (; ri !== records.length; ++ri) {
+ var record = records[ri].trim().split(":");
+ if(record[0] !== 'cell') continue;
+ var addr = decode_cell(record[1]);
+ if(arr.length <= addr.r) for(R = arr.length; R <= addr.r; ++R) if(!arr[R]) arr[R] = [];
+ R = addr.r; C = addr.c;
+ switch(record[2]) {
+ case 't': arr[R][C] = decode(record[3]); break;
+ case 'v': arr[R][C] = +record[3]; break;
+ case 'vtf': var _f = record[record.length - 1];
+ /* falls through */
+ case 'vtc':
+ switch(record[3]) {
+ case 'nl': arr[R][C] = +record[4] ? true : false; break;
+ default: arr[R][C] = +record[4]; break;
+ }
+ if(record[2] == 'vtf') arr[R][C] = [arr[R][C], _f];
+ }
+ }
+ if(opts && opts.sheetRows) arr = arr.slice(0, opts.sheetRows);
+ return arr;
+ }
+
+ function eth_to_sheet(d, opts) { return aoa_to_sheet(eth_to_aoa(d, opts), opts); }
+ function eth_to_workbook(d, opts) { return sheet_to_workbook(eth_to_sheet(d, opts), opts); }
+
+ var header = [
+ "socialcalc:version:1.5",
+ "MIME-Version: 1.0",
+ "Content-Type: multipart/mixed; boundary=SocialCalcSpreadsheetControlSave"
+ ].join("\n");
+
+ var sep = [
+ "--SocialCalcSpreadsheetControlSave",
+ "Content-type: text/plain; charset=UTF-8"
+ ].join("\n") + "\n";
+
+ /* TODO: the other parts */
+ var meta = [
+ "# SocialCalc Spreadsheet Control Save",
+ "part:sheet"
+ ].join("\n");
+
+ var end = "--SocialCalcSpreadsheetControlSave--";
+
+ function sheet_to_eth_data(ws) {
+ if(!ws || !ws['!ref']) return "";
+ var o = [], oo = [], cell, coord = "";
+ var r = decode_range(ws['!ref']);
+ var dense = Array.isArray(ws);
+ for(var R = r.s.r; R <= r.e.r; ++R) {
+ for(var C = r.s.c; C <= r.e.c; ++C) {
+ coord = encode_cell({r:R,c:C});
+ cell = dense ? (ws[R]||[])[C] : ws[coord];
+ if(!cell || cell.v == null || cell.t === 'z') continue;
+ oo = ["cell", coord, 't'];
+ switch(cell.t) {
+ case 's': case 'str': oo.push(encode(cell.v)); break;
+ case 'n':
+ if(!cell.f) { oo[2]='v'; oo[3]=cell.v; }
+ else { oo[2]='vtf'; oo[3]='n'; oo[4]=cell.v; oo[5]=encode(cell.f); }
+ break;
+ case 'b':
+ oo[2] = 'vt'+(cell.f?'f':'c'); oo[3]='nl'; oo[4]=cell.v?"1":"0";
+ oo[5] = encode(cell.f||(cell.v?'TRUE':'FALSE'));
+ break;
+ case 'd':
+ var t = datenum(parseDate(cell.v));
+ oo[2] = 'vtc'; oo[3] = 'nd'; oo[4] = ""+t;
+ oo[5] = cell.w || SSF_format(cell.z || table_fmt[14], t);
+ break;
+ case 'e': continue;
+ }
+ o.push(oo.join(":"));
+ }
+ }
+ o.push("sheet:c:" + (r.e.c-r.s.c+1) + ":r:" + (r.e.r-r.s.r+1) + ":tvf:1");
+ o.push("valueformat:1:text-wiki");
+ //o.push("copiedfrom:" + ws['!ref']); // clipboard only
+ return o.join("\n");
+ }
+
+ function sheet_to_eth(ws) {
+ return [header, sep, meta, sep, sheet_to_eth_data(ws), end].join("\n");
+ // return ["version:1.5", sheet_to_eth_data(ws)].join("\n"); // clipboard form
+ }
+
+ return {
+ to_workbook: eth_to_workbook,
+ to_sheet: eth_to_sheet,
+ from_sheet: sheet_to_eth
+ };
+})();
+
+var PRN = (function() {
+ function set_text_arr(data, arr, R, C, o) {
+ if(o.raw) arr[R][C] = data;
+ else if(data === ""){/* empty */}
+ else if(data === 'TRUE') arr[R][C] = true;
+ else if(data === 'FALSE') arr[R][C] = false;
+ else if(!isNaN(fuzzynum(data))) arr[R][C] = fuzzynum(data);
+ else if(!isNaN(fuzzydate(data).getDate())) arr[R][C] = parseDate(data);
+ else arr[R][C] = data;
+ }
+
+ function prn_to_aoa_str(f, opts) {
+ var o = opts || {};
+ var arr = ([]);
+ if(!f || f.length === 0) return arr;
+ var lines = f.split(/[\r\n]/);
+ var L = lines.length - 1;
+ while(L >= 0 && lines[L].length === 0) --L;
+ var start = 10, idx = 0;
+ var R = 0;
+ for(; R <= L; ++R) {
+ idx = lines[R].indexOf(" ");
+ if(idx == -1) idx = lines[R].length; else idx++;
+ start = Math.max(start, idx);
+ }
+ for(R = 0; R <= L; ++R) {
+ arr[R] = [];
+ /* TODO: confirm that widths are always 10 */
+ var C = 0;
+ set_text_arr(lines[R].slice(0, start).trim(), arr, R, C, o);
+ for(C = 1; C <= (lines[R].length - start)/10 + 1; ++C)
+ set_text_arr(lines[R].slice(start+(C-1)*10,start+C*10).trim(),arr,R,C,o);
+ }
+ if(o.sheetRows) arr = arr.slice(0, o.sheetRows);
+ return arr;
+ }
+
+ // List of accepted CSV separators
+ var guess_seps = {
+0x2C: ',',
+0x09: "\t",
+0x3B: ';',
+0x7C: '|'
+ };
+
+ // CSV separator weights to be used in case of equal numbers
+ var guess_sep_weights = {
+0x2C: 3,
+0x09: 2,
+0x3B: 1,
+0x7C: 0
+ };
+
+ function guess_sep(str) {
+ var cnt = {}, instr = false, end = 0, cc = 0;
+ for(;end < str.length;++end) {
+ if((cc=str.charCodeAt(end)) == 0x22) instr = !instr;
+ else if(!instr && cc in guess_seps) cnt[cc] = (cnt[cc]||0)+1;
+ }
+
+ cc = [];
+ for(end in cnt) if ( Object.prototype.hasOwnProperty.call(cnt, end) ) {
+ cc.push([ cnt[end], end ]);
+ }
+
+ if ( !cc.length ) {
+ cnt = guess_sep_weights;
+ for(end in cnt) if ( Object.prototype.hasOwnProperty.call(cnt, end) ) {
+ cc.push([ cnt[end], end ]);
+ }
+ }
+
+ cc.sort(function(a, b) { return a[0] - b[0] || guess_sep_weights[a[1]] - guess_sep_weights[b[1]]; });
+
+ return guess_seps[cc.pop()[1]] || 0x2C;
+ }
+
+ function dsv_to_sheet_str(str, opts) {
+ var o = opts || {};
+ var sep = "";
+ if(DENSE != null && o.dense == null) o.dense = DENSE;
+ var ws = o.dense ? ([]) : ({});
+ var range = ({s: {c:0, r:0}, e: {c:0, r:0}});
+
+ if(str.slice(0,4) == "sep=") {
+ // If the line ends in \r\n
+ if(str.charCodeAt(5) == 13 && str.charCodeAt(6) == 10 ) {
+ sep = str.charAt(4); str = str.slice(7);
+ }
+ // If line ends in \r OR \n
+ else if(str.charCodeAt(5) == 13 || str.charCodeAt(5) == 10 ) {
+ sep = str.charAt(4); str = str.slice(6);
+ }
+ else sep = guess_sep(str.slice(0,1024));
+ }
+ else if(o && o.FS) sep = o.FS;
+ else sep = guess_sep(str.slice(0,1024));
+ var R = 0, C = 0, v = 0;
+ var start = 0, end = 0, sepcc = sep.charCodeAt(0), instr = false, cc=0, startcc=str.charCodeAt(0);
+ str = str.replace(/\r\n/mg, "\n");
+ var _re = o.dateNF != null ? dateNF_regex(o.dateNF) : null;
+ function finish_cell() {
+ var s = str.slice(start, end);
+ var cell = ({});
+ if(s.charAt(0) == '"' && s.charAt(s.length - 1) == '"') s = s.slice(1,-1).replace(/""/g,'"');
+ if(s.length === 0) cell.t = 'z';
+ else if(o.raw) { cell.t = 's'; cell.v = s; }
+ else if(s.trim().length === 0) { cell.t = 's'; cell.v = s; }
+ else if(s.charCodeAt(0) == 0x3D) {
+ if(s.charCodeAt(1) == 0x22 && s.charCodeAt(s.length - 1) == 0x22) { cell.t = 's'; cell.v = s.slice(2,-1).replace(/""/g,'"'); }
+ else if(fuzzyfmla(s)) { cell.t = 'n'; cell.f = s.slice(1); }
+ else { cell.t = 's'; cell.v = s; } }
+ else if(s == "TRUE") { cell.t = 'b'; cell.v = true; }
+ else if(s == "FALSE") { cell.t = 'b'; cell.v = false; }
+ else if(!isNaN(v = fuzzynum(s))) { cell.t = 'n'; if(o.cellText !== false) cell.w = s; cell.v = v; }
+ else if(!isNaN(fuzzydate(s).getDate()) || _re && s.match(_re)) {
+ cell.z = o.dateNF || table_fmt[14];
+ var k = 0;
+ if(_re && s.match(_re)){ s=dateNF_fix(s, o.dateNF, (s.match(_re)||[])); k=1; }
+ if(o.cellDates) { cell.t = 'd'; cell.v = parseDate(s, k); }
+ else { cell.t = 'n'; cell.v = datenum(parseDate(s, k)); }
+ if(o.cellText !== false) cell.w = SSF_format(cell.z, cell.v instanceof Date ? datenum(cell.v):cell.v);
+ if(!o.cellNF) delete cell.z;
+ } else {
+ cell.t = 's';
+ cell.v = s;
+ }
+ if(cell.t == 'z'){}
+ else if(o.dense) { if(!ws[R]) ws[R] = []; ws[R][C] = cell; }
+ else ws[encode_cell({c:C,r:R})] = cell;
+ start = end+1; startcc = str.charCodeAt(start);
+ if(range.e.c < C) range.e.c = C;
+ if(range.e.r < R) range.e.r = R;
+ if(cc == sepcc) ++C; else { C = 0; ++R; if(o.sheetRows && o.sheetRows <= R) return true; }
+ }
+ outer: for(;end < str.length;++end) switch((cc=str.charCodeAt(end))) {
+ case 0x22: if(startcc === 0x22) instr = !instr; break;
+ case sepcc: case 0x0a: case 0x0d: if(!instr && finish_cell()) break outer; break;
+ default: break;
+ }
+ if(end - start > 0) finish_cell();
+
+ ws['!ref'] = encode_range(range);
+ return ws;
+ }
+
+ function prn_to_sheet_str(str, opts) {
+ if(!(opts && opts.PRN)) return dsv_to_sheet_str(str, opts);
+ if(opts.FS) return dsv_to_sheet_str(str, opts);
+ if(str.slice(0,4) == "sep=") return dsv_to_sheet_str(str, opts);
+ if(str.indexOf("\t") >= 0 || str.indexOf(",") >= 0 || str.indexOf(";") >= 0) return dsv_to_sheet_str(str, opts);
+ return aoa_to_sheet(prn_to_aoa_str(str, opts), opts);
+ }
+
+ function prn_to_sheet(d, opts) {
+ var str = "", bytes = opts.type == 'string' ? [0,0,0,0] : firstbyte(d, opts);
+ switch(opts.type) {
+ case 'base64': str = Base64_decode(d); break;
+ case 'binary': str = d; break;
+ case 'buffer':
+ if(opts.codepage == 65001) str = d.toString('utf8'); // TODO: test if buf
+ else if(opts.codepage && typeof $cptable !== 'undefined') str = $cptable.utils.decode(opts.codepage, d);
+ else str = has_buf && Buffer.isBuffer(d) ? d.toString('binary') : a2s(d);
+ break;
+ case 'array': str = cc2str(d); break;
+ case 'string': str = d; break;
+ default: throw new Error("Unrecognized type " + opts.type);
+ }
+ if(bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) str = utf8read(str.slice(3));
+ else if(opts.type != 'string' && opts.type != 'buffer' && opts.codepage == 65001) str = utf8read(str);
+ else if((opts.type == 'binary') && typeof $cptable !== 'undefined' && opts.codepage) str = $cptable.utils.decode(opts.codepage, $cptable.utils.encode(28591,str));
+ if(str.slice(0,19) == "socialcalc:version:") return ETH.to_sheet(opts.type == 'string' ? str : utf8read(str), opts);
+ return prn_to_sheet_str(str, opts);
+ }
+
+ function prn_to_workbook(d, opts) { return sheet_to_workbook(prn_to_sheet(d, opts), opts); }
+
+ function sheet_to_prn(ws) {
+ var o = [];
+ var r = safe_decode_range(ws['!ref']), cell;
+ var dense = Array.isArray(ws);
+ for(var R = r.s.r; R <= r.e.r; ++R) {
+ var oo = [];
+ for(var C = r.s.c; C <= r.e.c; ++C) {
+ var coord = encode_cell({r:R,c:C});
+ cell = dense ? (ws[R]||[])[C] : ws[coord];
+ if(!cell || cell.v == null) { oo.push(" "); continue; }
+ var w = (cell.w || (format_cell(cell), cell.w) || "").slice(0,10);
+ while(w.length < 10) w += " ";
+ oo.push(w + (C === 0 ? " " : ""));
+ }
+ o.push(oo.join(""));
+ }
+ return o.join("\n");
+ }
+
+ return {
+ to_workbook: prn_to_workbook,
+ to_sheet: prn_to_sheet,
+ from_sheet: sheet_to_prn
+ };
+})();
+
+/* Excel defaults to SYLK but warns if data is not valid */
+function read_wb_ID(d, opts) {
+ var o = opts || {}, OLD_WTF = !!o.WTF; o.WTF = true;
+ try {
+ var out = SYLK.to_workbook(d, o);
+ o.WTF = OLD_WTF;
+ return out;
+ } catch(e) {
+ o.WTF = OLD_WTF;
+ if(!e.message.match(/SYLK bad record ID/) && OLD_WTF) throw e;
+ return PRN.to_workbook(d, opts);
+ }
+}
+
+var WK_ = (function() {
+ function lotushopper(data, cb, opts) {
+ if(!data) return;
+ prep_blob(data, data.l || 0);
+ var Enum = opts.Enum || WK1Enum;
+ while(data.l < data.length) {
+ var RT = data.read_shift(2);
+ var R = Enum[RT] || Enum[0xFFFF];
+ var length = data.read_shift(2);
+ var tgt = data.l + length;
+ var d = R.f && R.f(data, length, opts);
+ data.l = tgt;
+ if(cb(d, R, RT)) return;
+ }
+ }
+
+ function lotus_to_workbook(d, opts) {
+ switch(opts.type) {
+ case 'base64': return lotus_to_workbook_buf(s2a(Base64_decode(d)), opts);
+ case 'binary': return lotus_to_workbook_buf(s2a(d), opts);
+ case 'buffer':
+ case 'array': return lotus_to_workbook_buf(d, opts);
+ }
+ throw "Unsupported type " + opts.type;
+ }
+
+ function lotus_to_workbook_buf(d, opts) {
+ if(!d) return d;
+ var o = opts || {};
+ if(DENSE != null && o.dense == null) o.dense = DENSE;
+ var s = ((o.dense ? [] : {})), n = "Sheet1", next_n = "", sidx = 0;
+ var sheets = {}, snames = [], realnames = [];
+
+ var refguess = {s: {r:0, c:0}, e: {r:0, c:0} };
+ var sheetRows = o.sheetRows || 0;
+
+ if(d[2] == 0x00) {
+ if(d[3] == 0x08 || d[3] == 0x09) {
+ if(d.length >= 16 && d[14] == 0x05 && d[15] === 0x6c) throw new Error("Unsupported Works 3 for Mac file");
+ }
+ }
+
+ if(d[2] == 0x02) {
+ o.Enum = WK1Enum;
+ lotushopper(d, function(val, R, RT) { switch(RT) {
+ case 0x00: /* BOF */
+ o.vers = val;
+ if(val >= 0x1000) o.qpro = true;
+ break;
+ case 0x06: refguess = val; break; /* RANGE */
+ case 0xCC: if(val) next_n = val; break; /* SHEETNAMECS */
+ case 0xDE: next_n = val; break; /* SHEETNAMELP */
+ case 0x0F: /* LABEL */
+ case 0x33: /* STRING */
+ if(!o.qpro) val[1].v = val[1].v.slice(1);
+ /* falls through */
+ case 0x0D: /* INTEGER */
+ case 0x0E: /* NUMBER */
+ case 0x10: /* FORMULA */
+ /* TODO: actual translation of the format code */
+ if(RT == 0x0E && (val[2] & 0x70) == 0x70 && (val[2] & 0x0F) > 1 && (val[2] & 0x0F) < 15) {
+ val[1].z = o.dateNF || table_fmt[14];
+ if(o.cellDates) { val[1].t = 'd'; val[1].v = numdate(val[1].v); }
+ }
+
+ if(o.qpro) {
+ if(val[3] > sidx) {
+ s["!ref"] = encode_range(refguess);
+ sheets[n] = s;
+ snames.push(n);
+ s = (o.dense ? [] : {});
+ refguess = {s: {r:0, c:0}, e: {r:0, c:0} };
+ sidx = val[3]; n = next_n || "Sheet" + (sidx + 1); next_n = "";
+ }
+ }
+
+ var tmpcell = o.dense ? (s[val[0].r]||[])[val[0].c] : s[encode_cell(val[0])];
+ if(tmpcell) {
+ tmpcell.t = val[1].t; tmpcell.v = val[1].v;
+ if(val[1].z != null) tmpcell.z = val[1].z;
+ if(val[1].f != null) tmpcell.f = val[1].f;
+ break;
+ }
+ if(o.dense) {
+ if(!s[val[0].r]) s[val[0].r] = [];
+ s[val[0].r][val[0].c] = val[1];
+ } else s[encode_cell(val[0])] = val[1];
+ break;
+ default:
+ }}, o);
+ } else if(d[2] == 0x1A || d[2] == 0x0E) {
+ o.Enum = WK3Enum;
+ if(d[2] == 0x0E) { o.qpro = true; d.l = 0; }
+ lotushopper(d, function(val, R, RT) { switch(RT) {
+ case 0xCC: n = val; break; /* SHEETNAMECS */
+ case 0x16: /* LABEL16 */
+ val[1].v = val[1].v.slice(1);
+ /* falls through */
+ case 0x17: /* NUMBER17 */
+ case 0x18: /* NUMBER18 */
+ case 0x19: /* FORMULA19 */
+ case 0x25: /* NUMBER25 */
+ case 0x27: /* NUMBER27 */
+ case 0x28: /* FORMULA28 */
+ if(val[3] > sidx) {
+ s["!ref"] = encode_range(refguess);
+ sheets[n] = s;
+ snames.push(n);
+ s = (o.dense ? [] : {});
+ refguess = {s: {r:0, c:0}, e: {r:0, c:0} };
+ sidx = val[3]; n = "Sheet" + (sidx + 1);
+ }
+ if(sheetRows > 0 && val[0].r >= sheetRows) break;
+ if(o.dense) {
+ if(!s[val[0].r]) s[val[0].r] = [];
+ s[val[0].r][val[0].c] = val[1];
+ } else s[encode_cell(val[0])] = val[1];
+ if(refguess.e.c < val[0].c) refguess.e.c = val[0].c;
+ if(refguess.e.r < val[0].r) refguess.e.r = val[0].r;
+ break;
+ case 0x1B: /* XFORMAT */
+ if(val[0x36b0]) realnames[val[0x36b0][0]] = val[0x36b0][1];
+ break;
+ case 0x0601: /* SHEETINFOQP */
+ realnames[val[0]] = val[1]; if(val[0] == sidx) n = val[1]; break;
+ default: break;
+ }}, o);
+ } else throw new Error("Unrecognized LOTUS BOF " + d[2]);
+ s["!ref"] = encode_range(refguess);
+ sheets[next_n || n] = s;
+ snames.push(next_n || n);
+ if(!realnames.length) return { SheetNames: snames, Sheets: sheets };
+ var osheets = {}, rnames = [];
+ /* TODO: verify no collisions */
+ for(var i = 0; i < realnames.length; ++i) if(sheets[snames[i]]) {
+ rnames.push(realnames[i] || snames[i]);
+ osheets[realnames[i]] = sheets[realnames[i]] || sheets[snames[i]];
+ } else {
+ rnames.push(realnames[i]);
+ osheets[realnames[i]] = ({ "!ref": "A1" });
+ }
+ return { SheetNames: rnames, Sheets: osheets };
+ }
+
+ function sheet_to_wk1(ws, opts) {
+ var o = opts || {};
+ if(+o.codepage >= 0) set_cp(+o.codepage);
+ if(o.type == "string") throw new Error("Cannot write WK1 to JS string");
+ var ba = buf_array();
+ var range = safe_decode_range(ws["!ref"]);
+ var dense = Array.isArray(ws);
+ var cols = [];
+
+ write_biff_rec(ba, 0x00, write_BOF_WK1(0x0406));
+ write_biff_rec(ba, 0x06, write_RANGE(range));
+ var max_R = Math.min(range.e.r, 8191);
+ for(var R = range.s.r; R <= max_R; ++R) {
+ var rr = encode_row(R);
+ for(var C = range.s.c; C <= range.e.c; ++C) {
+ if(R === range.s.r) cols[C] = encode_col(C);
+ var ref = cols[C] + rr;
+ var cell = dense ? (ws[R]||[])[C] : ws[ref];
+ if(!cell || cell.t == "z") continue;
+ /* TODO: formula records */
+ if(cell.t == "n") {
+ if((cell.v|0)==cell.v && cell.v >= -32768 && cell.v <= 32767) write_biff_rec(ba, 0x0d, write_INTEGER(R, C, cell.v));
+ else write_biff_rec(ba, 0x0e, write_NUMBER(R, C, cell.v));
+ } else {
+ var str = format_cell(cell);
+ write_biff_rec(ba, 0x0F, write_LABEL(R, C, str.slice(0, 239)));
+ }
+ }
+ }
+
+ write_biff_rec(ba, 0x01);
+ return ba.end();
+ }
+
+ function book_to_wk3(wb, opts) {
+ var o = opts || {};
+ if(+o.codepage >= 0) set_cp(+o.codepage);
+ if(o.type == "string") throw new Error("Cannot write WK3 to JS string");
+ var ba = buf_array();
+
+ write_biff_rec(ba, 0x00, write_BOF_WK3(wb));
+
+ for(var i = 0, cnt = 0; i < wb.SheetNames.length; ++i) if((wb.Sheets[wb.SheetNames[i]] || {})["!ref"]) write_biff_rec(ba, 0x1b, write_XFORMAT_SHEETNAME(wb.SheetNames[i], cnt++));
+
+ var wsidx = 0;
+ for(i = 0; i < wb.SheetNames.length; ++i) {
+ var ws = wb.Sheets[wb.SheetNames[i]];
+ if(!ws || !ws["!ref"]) continue;
+ var range = safe_decode_range(ws["!ref"]);
+ var dense = Array.isArray(ws);
+ var cols = [];
+ var max_R = Math.min(range.e.r, 8191);
+ for(var R = range.s.r; R <= max_R; ++R) {
+ var rr = encode_row(R);
+ for(var C = range.s.c; C <= range.e.c; ++C) {
+ if(R === range.s.r) cols[C] = encode_col(C);
+ var ref = cols[C] + rr;
+ var cell = dense ? (ws[R]||[])[C] : ws[ref];
+ if(!cell || cell.t == "z") continue;
+ /* TODO: FORMULA19 NUMBER18 records */
+ if(cell.t == "n") {
+ write_biff_rec(ba, 0x17, write_NUMBER_17(R, C, wsidx, cell.v));
+ } else {
+ var str = format_cell(cell);
+ /* TODO: max len? */
+ write_biff_rec(ba, 0x16, write_LABEL_16(R, C, wsidx, str.slice(0, 239)));
+ }
+ }
+ }
+ ++wsidx;
+ }
+
+ write_biff_rec(ba, 0x01);
+ return ba.end();
+ }
+
+
+ function write_BOF_WK1(v) {
+ var out = new_buf(2);
+ out.write_shift(2, v);
+ return out;
+ }
+
+ function write_BOF_WK3(wb) {
+ var out = new_buf(26);
+ out.write_shift(2, 0x1000);
+ out.write_shift(2, 0x0004);
+ out.write_shift(4, 0x0000);
+ var rows = 0, cols = 0, wscnt = 0;
+ for(var i = 0; i < wb.SheetNames.length; ++i) {
+ var name = wb.SheetNames[i];
+ var ws = wb.Sheets[name];
+ if(!ws || !ws["!ref"]) continue;
+ ++wscnt;
+ var range = decode_range(ws["!ref"]);
+ if(rows < range.e.r) rows = range.e.r;
+ if(cols < range.e.c) cols = range.e.c;
+ }
+ if(rows > 8191) rows = 8191;
+ out.write_shift(2, rows);
+ out.write_shift(1, wscnt);
+ out.write_shift(1, cols);
+ out.write_shift(2, 0x00);
+ out.write_shift(2, 0x00);
+ out.write_shift(1, 0x01);
+ out.write_shift(1, 0x02);
+ out.write_shift(4, 0);
+ out.write_shift(4, 0);
+ return out;
+ }
+
+ function parse_RANGE(blob, length, opts) {
+ var o = {s:{c:0,r:0},e:{c:0,r:0}};
+ if(length == 8 && opts.qpro) {
+ o.s.c = blob.read_shift(1);
+ blob.l++;
+ o.s.r = blob.read_shift(2);
+ o.e.c = blob.read_shift(1);
+ blob.l++;
+ o.e.r = blob.read_shift(2);
+ return o;
+ }
+ o.s.c = blob.read_shift(2);
+ o.s.r = blob.read_shift(2);
+ if(length == 12 && opts.qpro) blob.l += 2;
+ o.e.c = blob.read_shift(2);
+ o.e.r = blob.read_shift(2);
+ if(length == 12 && opts.qpro) blob.l += 2;
+ if(o.s.c == 0xFFFF) o.s.c = o.e.c = o.s.r = o.e.r = 0;
+ return o;
+ }
+ function write_RANGE(range) {
+ var out = new_buf(8);
+ out.write_shift(2, range.s.c);
+ out.write_shift(2, range.s.r);
+ out.write_shift(2, range.e.c);
+ out.write_shift(2, range.e.r);
+ return out;
+ }
+
+ function parse_cell(blob, length, opts) {
+ var o = [{c:0,r:0}, {t:'n',v:0}, 0, 0];
+ if(opts.qpro && opts.vers != 0x5120) {
+ o[0].c = blob.read_shift(1);
+ o[3] = blob.read_shift(1);
+ o[0].r = blob.read_shift(2);
+ blob.l+=2;
+ } else {
+ o[2] = blob.read_shift(1);
+ o[0].c = blob.read_shift(2); o[0].r = blob.read_shift(2);
+ }
+ return o;
+ }
+
+ function parse_LABEL(blob, length, opts) {
+ var tgt = blob.l + length;
+ var o = parse_cell(blob, length, opts);
+ o[1].t = 's';
+ if(opts.vers == 0x5120) {
+ blob.l++;
+ var len = blob.read_shift(1);
+ o[1].v = blob.read_shift(len, 'utf8');
+ return o;
+ }
+ if(opts.qpro) blob.l++;
+ o[1].v = blob.read_shift(tgt - blob.l, 'cstr');
+ return o;
+ }
+ function write_LABEL(R, C, s) {
+ /* TODO: encoding */
+ var o = new_buf(7 + s.length);
+ o.write_shift(1, 0xFF);
+ o.write_shift(2, C);
+ o.write_shift(2, R);
+ o.write_shift(1, 0x27); // ??
+ for(var i = 0; i < o.length; ++i) {
+ var cc = s.charCodeAt(i);
+ o.write_shift(1, cc >= 0x80 ? 0x5F : cc);
+ }
+ o.write_shift(1, 0);
+ return o;
+ }
+
+ function parse_INTEGER(blob, length, opts) {
+ var o = parse_cell(blob, length, opts);
+ o[1].v = blob.read_shift(2, 'i');
+ return o;
+ }
+ function write_INTEGER(R, C, v) {
+ var o = new_buf(7);
+ o.write_shift(1, 0xFF);
+ o.write_shift(2, C);
+ o.write_shift(2, R);
+ o.write_shift(2, v, 'i');
+ return o;
+ }
+
+ function parse_NUMBER(blob, length, opts) {
+ var o = parse_cell(blob, length, opts);
+ o[1].v = blob.read_shift(8, 'f');
+ return o;
+ }
+ function write_NUMBER(R, C, v) {
+ var o = new_buf(13);
+ o.write_shift(1, 0xFF);
+ o.write_shift(2, C);
+ o.write_shift(2, R);
+ o.write_shift(8, v, 'f');
+ return o;
+ }
+
+ function parse_FORMULA(blob, length, opts) {
+ var tgt = blob.l + length;
+ var o = parse_cell(blob, length, opts);
+ /* TODO: formula */
+ o[1].v = blob.read_shift(8, 'f');
+ if(opts.qpro) blob.l = tgt;
+ else {
+ var flen = blob.read_shift(2);
+ wk1_fmla_to_csf(blob.slice(blob.l, blob.l + flen), o);
+ blob.l += flen;
+ }
+ return o;
+ }
+
+ function wk1_parse_rc(B, V, col) {
+ var rel = V & 0x8000;
+ V &= ~0x8000;
+ V = (rel ? B : 0) + ((V >= 0x2000) ? V - 0x4000 : V);
+ return (rel ? "" : "$") + (col ? encode_col(V) : encode_row(V));
+ }
+ /* var oprec = [
+ 8, 8, 8, 8, 8, 8, 8, 8, 6, 4, 4, 5, 5, 7, 3, 3,
+ 3, 3, 3, 3, 1, 1, 2, 6, 8, 8, 8, 8, 8, 8, 8, 8
+ ]; */
+ /* TODO: flesh out */
+ var FuncTab = {
+ 0x33: ["FALSE", 0],
+ 0x34: ["TRUE", 0],
+ 0x46: ["LEN", 1],
+ 0x50: ["SUM", 69],
+ 0x51: ["AVERAGEA", 69],
+ 0x52: ["COUNTA", 69],
+ 0x53: ["MINA", 69],
+ 0x54: ["MAXA", 69],
+ 0x6F: ["T", 1]
+ };
+ var BinOpTab = [
+ "", "", "", "", "", "", "", "", // eslint-disable-line no-mixed-spaces-and-tabs
+ "", "+", "-", "*", "/", "^", "=", "<>", // eslint-disable-line no-mixed-spaces-and-tabs
+ "<=", ">=", "<", ">", "", "", "", "", // eslint-disable-line no-mixed-spaces-and-tabs
+ "&", "", "", "", "", "", "", "" // eslint-disable-line no-mixed-spaces-and-tabs
+ ];
+
+ function wk1_fmla_to_csf(blob, o) {
+ prep_blob(blob, 0);
+ var out = [], argc = 0, R = "", C = "", argL = "", argR = "";
+ while(blob.l < blob.length) {
+ var cc = blob[blob.l++];
+ switch(cc) {
+ case 0x00: out.push(blob.read_shift(8, 'f')); break;
+ case 0x01: {
+ C = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
+ R = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
+ out.push(C + R);
+ } break;
+ case 0x02: {
+ var c = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
+ var r = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
+ C = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
+ R = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
+ out.push(c + r + ":" + C + R);
+ } break;
+ case 0x03:
+ if(blob.l < blob.length) { console.error("WK1 premature formula end"); return; }
+ break;
+ case 0x04: out.push("(" + out.pop() + ")"); break;
+ case 0x05: out.push(blob.read_shift(2)); break;
+ case 0x06: {
+ /* TODO: text encoding */
+ var Z = ""; while((cc = blob[blob.l++])) Z += String.fromCharCode(cc);
+ out.push('"' + Z.replace(/"/g, '""') + '"');
+ } break;
+
+ case 0x08: out.push("-" + out.pop()); break;
+ case 0x17: out.push("+" + out.pop()); break;
+ case 0x16: out.push("NOT(" + out.pop() + ")"); break;
+
+ case 0x14: case 0x15: {
+ argR = out.pop(); argL = out.pop();
+ out.push(["AND", "OR"][cc - 0x14] + "(" + argL + "," + argR + ")");
+ } break;
+
+ default:
+ if(cc < 0x20 && BinOpTab[cc]) {
+ argR = out.pop(); argL = out.pop();
+ out.push(argL + BinOpTab[cc] + argR);
+ } else if(FuncTab[cc]) {
+ argc = FuncTab[cc][1];
+ if(argc == 69) argc = blob[blob.l++];
+ if(argc > out.length) { console.error("WK1 bad formula parse 0x" + cc.toString(16) + ":|" + out.join("|") + "|"); return; }
+ var args = out.slice(-argc);
+ out.length -= argc;
+ out.push(FuncTab[cc][0] + "(" + args.join(",") + ")");
+ }
+ else if(cc <= 0x07) return console.error("WK1 invalid opcode " + cc.toString(16));
+ else if(cc <= 0x18) return console.error("WK1 unsupported op " + cc.toString(16));
+ else if(cc <= 0x1E) return console.error("WK1 invalid opcode " + cc.toString(16));
+ else if(cc <= 0x73) return console.error("WK1 unsupported function opcode " + cc.toString(16));
+ // possible future functions ??
+ else return console.error("WK1 unrecognized opcode " + cc.toString(16));
+ }
+ }
+ if(out.length == 1) o[1].f = "" + out[0];
+ else console.error("WK1 bad formula parse |" + out.join("|") + "|");
+ }
+
+
+ function parse_cell_3(blob) {
+ var o = [{c:0,r:0}, {t:'n',v:0}, 0];
+ o[0].r = blob.read_shift(2); o[3] = blob[blob.l++]; o[0].c = blob[blob.l++];
+ return o;
+ }
+
+ function parse_LABEL_16(blob, length) {
+ var o = parse_cell_3(blob, length);
+ o[1].t = 's';
+ o[1].v = blob.read_shift(length - 4, 'cstr');
+ return o;
+ }
+ function write_LABEL_16(R, C, wsidx, s) {
+ /* TODO: encoding */
+ var o = new_buf(6 + s.length);
+ o.write_shift(2, R);
+ o.write_shift(1, wsidx);
+ o.write_shift(1, C);
+ o.write_shift(1, 0x27);
+ for(var i = 0; i < s.length; ++i) {
+ var cc = s.charCodeAt(i);
+ o.write_shift(1, cc >= 0x80 ? 0x5F : cc);
+ }
+ o.write_shift(1, 0);
+ return o;
+ }
+
+ function parse_NUMBER_18(blob, length) {
+ var o = parse_cell_3(blob, length);
+ o[1].v = blob.read_shift(2);
+ var v = o[1].v >> 1;
+ if(o[1].v & 0x1) {
+ switch(v & 0x07) {
+ case 0: v = (v >> 3) * 5000; break;
+ case 1: v = (v >> 3) * 500; break;
+ case 2: v = (v >> 3) / 20; break;
+ case 3: v = (v >> 3) / 200; break;
+ case 4: v = (v >> 3) / 2000; break;
+ case 5: v = (v >> 3) / 20000; break;
+ case 6: v = (v >> 3) / 16; break;
+ case 7: v = (v >> 3) / 64; break;
+ }
+ }
+ o[1].v = v;
+ return o;
+ }
+
+ function parse_NUMBER_17(blob, length) {
+ var o = parse_cell_3(blob, length);
+ var v1 = blob.read_shift(4);
+ var v2 = blob.read_shift(4);
+ var e = blob.read_shift(2);
+ if(e == 0xFFFF) {
+ if(v1 === 0 && v2 === 0xC0000000) { o[1].t = "e"; o[1].v = 0x0F; } // ERR -> #VALUE!
+ else if(v1 === 0 && v2 === 0xD0000000) { o[1].t = "e"; o[1].v = 0x2A; } // NA -> #N/A
+ else o[1].v = 0;
+ return o;
+ }
+ var s = e & 0x8000; e = (e&0x7FFF) - 16446;
+ o[1].v = (1 - s*2) * (v2 * Math.pow(2, e+32) + v1 * Math.pow(2, e));
+ return o;
+ }
+ function write_NUMBER_17(R, C, wsidx, v) {
+ var o = new_buf(14);
+ o.write_shift(2, R);
+ o.write_shift(1, wsidx);
+ o.write_shift(1, C);
+ if(v == 0) {
+ o.write_shift(4, 0);
+ o.write_shift(4, 0);
+ o.write_shift(2, 0xFFFF);
+ return o;
+ }
+ var s = 0, e = 0, v1 = 0, v2 = 0;
+ if(v < 0) { s = 1; v = -v; }
+ e = Math.log2(v) | 0;
+ v /= Math.pow(2, e-31);
+ v2 = (v)>>>0;
+ if((v2&0x80000000) == 0) { v/=2; ++e; v2 = v >>> 0; }
+ v -= v2;
+ v2 |= 0x80000000;
+ v2 >>>= 0;
+ v *= Math.pow(2, 32);
+ v1 = v>>>0;
+ o.write_shift(4, v1);
+ o.write_shift(4, v2);
+ e += 0x3FFF + (s ? 0x8000 : 0);
+ o.write_shift(2, e);
+ return o;
+ }
+
+ function parse_FORMULA_19(blob, length) {
+ var o = parse_NUMBER_17(blob, 14);
+ blob.l += length - 14; /* TODO: WK3 formula */
+ return o;
+ }
+
+ function parse_NUMBER_25(blob, length) {
+ var o = parse_cell_3(blob, length);
+ var v1 = blob.read_shift(4);
+ o[1].v = v1 >> 6;
+ return o;
+ }
+
+ function parse_NUMBER_27(blob, length) {
+ var o = parse_cell_3(blob, length);
+ var v1 = blob.read_shift(8,'f');
+ o[1].v = v1;
+ return o;
+ }
+
+ function parse_FORMULA_28(blob, length) {
+ var o = parse_NUMBER_27(blob, 14);
+ blob.l += length - 10; /* TODO: formula */
+ return o;
+ }
+
+ function parse_SHEETNAMECS(blob, length) {
+ return blob[blob.l + length - 1] == 0 ? blob.read_shift(length, 'cstr') : "";
+ }
+
+ function parse_SHEETNAMELP(blob, length) {
+ var len = blob[blob.l++];
+ if(len > length - 1) len = length - 1;
+ var o = ""; while(o.length < len) o += String.fromCharCode(blob[blob.l++]);
+ return o;
+ }
+
+ function parse_SHEETINFOQP(blob, length, opts) {
+ if(!opts.qpro || length < 21) return;
+ var id = blob.read_shift(1);
+ blob.l += 17;
+ blob.l += 1; //var len = blob.read_shift(1);
+ blob.l += 2;
+ var nm = blob.read_shift(length - 21, 'cstr');
+ return [id, nm];
+ }
+
+ function parse_XFORMAT(blob, length) {
+ var o = {}, tgt = blob.l + length;
+ while(blob.l < tgt) {
+ var dt = blob.read_shift(2);
+ if(dt == 0x36b0) {
+ o[dt] = [0, ""];
+ o[dt][0] = blob.read_shift(2);
+ while(blob[blob.l]) { o[dt][1] += String.fromCharCode(blob[blob.l]); blob.l++; } blob.l++;
+ }
+ // TODO: 0x3a99 ??
+ }
+ return o;
+ }
+ function write_XFORMAT_SHEETNAME(name, wsidx) {
+ var out = new_buf(5 + name.length);
+ out.write_shift(2, 0x36b0);
+ out.write_shift(2, wsidx);
+ for(var i = 0; i < name.length; ++i) {
+ var cc = name.charCodeAt(i);
+ out[out.l++] = cc > 0x7F ? 0x5F : cc;
+ }
+ out[out.l++] = 0;
+ return out;
+ }
+
+ var WK1Enum = {
+0x0000: { n:"BOF", f:parseuint16 },
+0x0001: { n:"EOF" },
+0x0002: { n:"CALCMODE" },
+0x0003: { n:"CALCORDER" },
+0x0004: { n:"SPLIT" },
+0x0005: { n:"SYNC" },
+0x0006: { n:"RANGE", f:parse_RANGE },
+0x0007: { n:"WINDOW1" },
+0x0008: { n:"COLW1" },
+0x0009: { n:"WINTWO" },
+0x000A: { n:"COLW2" },
+0x000B: { n:"NAME" },
+0x000C: { n:"BLANK" },
+0x000D: { n:"INTEGER", f:parse_INTEGER },
+0x000E: { n:"NUMBER", f:parse_NUMBER },
+0x000F: { n:"LABEL", f:parse_LABEL },
+0x0010: { n:"FORMULA", f:parse_FORMULA },
+0x0018: { n:"TABLE" },
+0x0019: { n:"ORANGE" },
+0x001A: { n:"PRANGE" },
+0x001B: { n:"SRANGE" },
+0x001C: { n:"FRANGE" },
+0x001D: { n:"KRANGE1" },
+0x0020: { n:"HRANGE" },
+0x0023: { n:"KRANGE2" },
+0x0024: { n:"PROTEC" },
+0x0025: { n:"FOOTER" },
+0x0026: { n:"HEADER" },
+0x0027: { n:"SETUP" },
+0x0028: { n:"MARGINS" },
+0x0029: { n:"LABELFMT" },
+0x002A: { n:"TITLES" },
+0x002B: { n:"SHEETJS" },
+0x002D: { n:"GRAPH" },
+0x002E: { n:"NGRAPH" },
+0x002F: { n:"CALCCOUNT" },
+0x0030: { n:"UNFORMATTED" },
+0x0031: { n:"CURSORW12" },
+0x0032: { n:"WINDOW" },
+0x0033: { n:"STRING", f:parse_LABEL },
+0x0037: { n:"PASSWORD" },
+0x0038: { n:"LOCKED" },
+0x003C: { n:"QUERY" },
+0x003D: { n:"QUERYNAME" },
+0x003E: { n:"PRINT" },
+0x003F: { n:"PRINTNAME" },
+0x0040: { n:"GRAPH2" },
+0x0041: { n:"GRAPHNAME" },
+0x0042: { n:"ZOOM" },
+0x0043: { n:"SYMSPLIT" },
+0x0044: { n:"NSROWS" },
+0x0045: { n:"NSCOLS" },
+0x0046: { n:"RULER" },
+0x0047: { n:"NNAME" },
+0x0048: { n:"ACOMM" },
+0x0049: { n:"AMACRO" },
+0x004A: { n:"PARSE" },
+0x0066: { n:"PRANGES??" },
+0x0067: { n:"RRANGES??" },
+0x0068: { n:"FNAME??" },
+0x0069: { n:"MRANGES??" },
+0x00CC: { n:"SHEETNAMECS", f:parse_SHEETNAMECS },
+0x00DE: { n:"SHEETNAMELP", f:parse_SHEETNAMELP },
+0xFFFF: { n:"" }
+ };
+
+ var WK3Enum = {
+0x0000: { n:"BOF" },
+0x0001: { n:"EOF" },
+0x0002: { n:"PASSWORD" },
+0x0003: { n:"CALCSET" },
+0x0004: { n:"WINDOWSET" },
+0x0005: { n:"SHEETCELLPTR" },
+0x0006: { n:"SHEETLAYOUT" },
+0x0007: { n:"COLUMNWIDTH" },
+0x0008: { n:"HIDDENCOLUMN" },
+0x0009: { n:"USERRANGE" },
+0x000A: { n:"SYSTEMRANGE" },
+0x000B: { n:"ZEROFORCE" },
+0x000C: { n:"SORTKEYDIR" },
+0x000D: { n:"FILESEAL" },
+0x000E: { n:"DATAFILLNUMS" },
+0x000F: { n:"PRINTMAIN" },
+0x0010: { n:"PRINTSTRING" },
+0x0011: { n:"GRAPHMAIN" },
+0x0012: { n:"GRAPHSTRING" },
+0x0013: { n:"??" },
+0x0014: { n:"ERRCELL" },
+0x0015: { n:"NACELL" },
+0x0016: { n:"LABEL16", f:parse_LABEL_16},
+0x0017: { n:"NUMBER17", f:parse_NUMBER_17 },
+0x0018: { n:"NUMBER18", f:parse_NUMBER_18 },
+0x0019: { n:"FORMULA19", f:parse_FORMULA_19},
+0x001A: { n:"FORMULA1A" },
+0x001B: { n:"XFORMAT", f:parse_XFORMAT },
+0x001C: { n:"DTLABELMISC" },
+0x001D: { n:"DTLABELCELL" },
+0x001E: { n:"GRAPHWINDOW" },
+0x001F: { n:"CPA" },
+0x0020: { n:"LPLAUTO" },
+0x0021: { n:"QUERY" },
+0x0022: { n:"HIDDENSHEET" },
+0x0023: { n:"??" },
+0x0025: { n:"NUMBER25", f:parse_NUMBER_25 },
+0x0026: { n:"??" },
+0x0027: { n:"NUMBER27", f:parse_NUMBER_27 },
+0x0028: { n:"FORMULA28", f:parse_FORMULA_28 },
+0x008E: { n:"??" },
+0x0093: { n:"??" },
+0x0096: { n:"??" },
+0x0097: { n:"??" },
+0x0098: { n:"??" },
+0x0099: { n:"??" },
+0x009A: { n:"??" },
+0x009B: { n:"??" },
+0x009C: { n:"??" },
+0x00A3: { n:"??" },
+0x00AE: { n:"??" },
+0x00AF: { n:"??" },
+0x00B0: { n:"??" },
+0x00B1: { n:"??" },
+0x00B8: { n:"??" },
+0x00B9: { n:"??" },
+0x00BA: { n:"??" },
+0x00BB: { n:"??" },
+0x00BC: { n:"??" },
+0x00C3: { n:"??" },
+0x00C9: { n:"??" },
+0x00CC: { n:"SHEETNAMECS", f:parse_SHEETNAMECS },
+0x00CD: { n:"??" },
+0x00CE: { n:"??" },
+0x00CF: { n:"??" },
+0x00D0: { n:"??" },
+0x0100: { n:"??" },
+0x0103: { n:"??" },
+0x0104: { n:"??" },
+0x0105: { n:"??" },
+0x0106: { n:"??" },
+0x0107: { n:"??" },
+0x0109: { n:"??" },
+0x010A: { n:"??" },
+0x010B: { n:"??" },
+0x010C: { n:"??" },
+0x010E: { n:"??" },
+0x010F: { n:"??" },
+0x0180: { n:"??" },
+0x0185: { n:"??" },
+0x0186: { n:"??" },
+0x0189: { n:"??" },
+0x018C: { n:"??" },
+0x0200: { n:"??" },
+0x0202: { n:"??" },
+0x0201: { n:"??" },
+0x0204: { n:"??" },
+0x0205: { n:"??" },
+0x0280: { n:"??" },
+0x0281: { n:"??" },
+0x0282: { n:"??" },
+0x0283: { n:"??" },
+0x0284: { n:"??" },
+0x0285: { n:"??" },
+0x0286: { n:"??" },
+0x0287: { n:"??" },
+0x0288: { n:"??" },
+0x0292: { n:"??" },
+0x0293: { n:"??" },
+0x0294: { n:"??" },
+0x0295: { n:"??" },
+0x0296: { n:"??" },
+0x0299: { n:"??" },
+0x029A: { n:"??" },
+0x0300: { n:"??" },
+0x0304: { n:"??" },
+0x0601: { n:"SHEETINFOQP", f:parse_SHEETINFOQP },
+0x0640: { n:"??" },
+0x0642: { n:"??" },
+0x0701: { n:"??" },
+0x0702: { n:"??" },
+0x0703: { n:"??" },
+0x0704: { n:"??" },
+0x0780: { n:"??" },
+0x0800: { n:"??" },
+0x0801: { n:"??" },
+0x0804: { n:"??" },
+0x0A80: { n:"??" },
+0x2AF6: { n:"??" },
+0x3231: { n:"??" },
+0x6E49: { n:"??" },
+0x6F44: { n:"??" },
+0xFFFF: { n:"" }
+ };
+ return {
+ sheet_to_wk1: sheet_to_wk1,
+ book_to_wk3: book_to_wk3,
+ to_workbook: lotus_to_workbook
+ };
+})();
+/* 18.4.7 rPr CT_RPrElt */
+function parse_rpr(rpr) {
+ var font = {}, m = rpr.match(tagregex), i = 0;
+ var pass = false;
+ if(m) for(;i!=m.length; ++i) {
+ var y = parsexmltag(m[i]);
+ switch(y[0].replace(/\w*:/g,"")) {
+ /* 18.8.12 condense CT_BooleanProperty */
+ /* ** not required . */
+ case '':
+ case '': font.shadow = 1; break;
+ case '': break;
+
+ /* 18.4.1 charset CT_IntProperty TODO */
+ case '':
+ case '': font.outline = 1; break;
+ case '': break;
+
+ /* 18.4.5 rFont CT_FontName */
+ case '':
+ case '"); outro.push(""); }
+
+ var align = font.valign || "";
+ if(align == "superscript" || align == "super") align = "sup";
+ else if(align == "subscript") align = "sub";
+ if(align != "") { intro.push("<" + align + ">"); outro.push(""); }
+
+ outro.push("");
+ return font;
+ }
+
+ /* 18.4.4 r CT_RElt */
+ function r_to_html(r) {
+ var terms = [[],r.v,[]];
+ if(!r.v) return "";
+
+ if(r.s) parse_rpr2(r.s, terms[0], terms[2]);
+
+ return terms[0].join("") + terms[1].replace(nlregex,'
') + terms[2].join("");
+ }
+
+ return function parse_rs(rs) {
+ return rs.map(r_to_html).join("");
+ };
+})();
+
+/* 18.4.8 si CT_Rst */
+var sitregex = /<(?:\w+:)?t[^>]*>([^<]*)<\/(?:\w+:)?t>/g, sirregex = /<(?:\w+:)?r>/;
+var sirphregex = /<(?:\w+:)?rPh.*?>([\s\S]*?)<\/(?:\w+:)?rPh>/g;
+function parse_si(x, opts) {
+ var html = opts ? opts.cellHTML : true;
+ var z = {};
+ if(!x) return { t: "" };
+ //var y;
+ /* 18.4.12 t ST_Xstring (Plaintext String) */
+ // TODO: is whitespace actually valid here?
+ if(x.match(/^\s*<(?:\w+:)?t[^>]*>/)) {
+ z.t = unescapexml(utf8read(x.slice(x.indexOf(">")+1).split(/<\/(?:\w+:)?t>/)[0]||""));
+ z.r = utf8read(x);
+ if(html) z.h = escapehtml(z.t);
+ }
+ /* 18.4.4 r CT_RElt (Rich Text Run) */
+ else if((/*y = */x.match(sirregex))) {
+ z.r = utf8read(x);
+ z.t = unescapexml(utf8read((x.replace(sirphregex, '').match(sitregex)||[]).join("").replace(tagregex,"")));
+ if(html) z.h = rs_to_html(parse_rs(z.r));
+ }
+ /* 18.4.3 phoneticPr CT_PhoneticPr (TODO: needed for Asian support) */
+ /* 18.4.6 rPh CT_PhoneticRun (TODO: needed for Asian support) */
+ return z;
+}
+
+/* 18.4 Shared String Table */
+var sstr0 = /<(?:\w+:)?sst([^>]*)>([\s\S]*)<\/(?:\w+:)?sst>/;
+var sstr1 = /<(?:\w+:)?(?:si|sstItem)>/g;
+var sstr2 = /<\/(?:\w+:)?(?:si|sstItem)>/;
+function parse_sst_xml(data, opts) {
+ var s = ([]), ss = "";
+ if(!data) return s;
+ /* 18.4.9 sst CT_Sst */
+ var sst = data.match(sstr0);
+ if(sst) {
+ ss = sst[2].replace(sstr1,"").split(sstr2);
+ for(var i = 0; i != ss.length; ++i) {
+ var o = parse_si(ss[i].trim(), opts);
+ if(o != null) s[s.length] = o;
+ }
+ sst = parsexmltag(sst[1]); s.Count = sst.count; s.Unique = sst.uniqueCount;
+ }
+ return s;
+}
+
+var straywsregex = /^\s|\s$|[\t\n\r]/;
+function write_sst_xml(sst, opts) {
+ if(!opts.bookSST) return "";
+ var o = [XML_HEADER];
+ o[o.length] = (writextag('sst', null, {
+ xmlns: XMLNS_main[0],
+ count: sst.Count,
+ uniqueCount: sst.Unique
+ }));
+ for(var i = 0; i != sst.length; ++i) { if(sst[i] == null) continue;
+ var s = sst[i];
+ var sitag = "";
+ if(s.r) sitag += s.r;
+ else {
+ sitag += "";
+ }
+ sitag += "";
+ o[o.length] = (sitag);
+ }
+ if(o.length>2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* [MS-XLSB] 2.4.221 BrtBeginSst */
+function parse_BrtBeginSst(data) {
+ return [data.read_shift(4), data.read_shift(4)];
+}
+
+/* [MS-XLSB] 2.1.7.45 Shared Strings */
+function parse_sst_bin(data, opts) {
+ var s = ([]);
+ var pass = false;
+ recordhopper(data, function hopper_sst(val, R, RT) {
+ switch(RT) {
+ case 0x009F: /* BrtBeginSst */
+ s.Count = val[0]; s.Unique = val[1]; break;
+ case 0x0013: /* BrtSSTItem */
+ s.push(val); break;
+ case 0x00A0: /* BrtEndSst */
+ return true;
+
+ case 0x0023: /* BrtFRTBegin */
+ pass = true; break;
+ case 0x0024: /* BrtFRTEnd */
+ pass = false; break;
+
+ default:
+ if(R.T){}
+ if(!pass || opts.WTF) throw new Error("Unexpected record 0x" + RT.toString(16));
+ }
+ });
+ return s;
+}
+
+function write_BrtBeginSst(sst, o) {
+ if(!o) o = new_buf(8);
+ o.write_shift(4, sst.Count);
+ o.write_shift(4, sst.Unique);
+ return o;
+}
+
+var write_BrtSSTItem = write_RichStr;
+
+function write_sst_bin(sst) {
+ var ba = buf_array();
+ write_record(ba, 0x009F /* BrtBeginSst */, write_BrtBeginSst(sst));
+ for(var i = 0; i < sst.length; ++i) write_record(ba, 0x0013 /* BrtSSTItem */, write_BrtSSTItem(sst[i]));
+ /* FRTSST */
+ write_record(ba, 0x00A0 /* BrtEndSst */);
+ return ba.end();
+}
+function _JS2ANSI(str) {
+ if(typeof $cptable !== 'undefined') return $cptable.utils.encode(current_ansi, str);
+ var o = [], oo = str.split("");
+ for(var i = 0; i < oo.length; ++i) o[i] = oo[i].charCodeAt(0);
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.4 Version */
+function parse_CRYPTOVersion(blob, length) {
+ var o = {};
+ o.Major = blob.read_shift(2);
+ o.Minor = blob.read_shift(2);
+if(length >= 4) blob.l += length - 4;
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.5 DataSpaceVersionInfo */
+function parse_DataSpaceVersionInfo(blob) {
+ var o = {};
+ o.id = blob.read_shift(0, 'lpp4');
+ o.R = parse_CRYPTOVersion(blob, 4);
+ o.U = parse_CRYPTOVersion(blob, 4);
+ o.W = parse_CRYPTOVersion(blob, 4);
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.6.1 DataSpaceMapEntry Structure */
+function parse_DataSpaceMapEntry(blob) {
+ var len = blob.read_shift(4);
+ var end = blob.l + len - 4;
+ var o = {};
+ var cnt = blob.read_shift(4);
+ var comps = [];
+ /* [MS-OFFCRYPTO] 2.1.6.2 DataSpaceReferenceComponent Structure */
+ while(cnt-- > 0) comps.push({ t: blob.read_shift(4), v: blob.read_shift(0, 'lpp4') });
+ o.name = blob.read_shift(0, 'lpp4');
+ o.comps = comps;
+ if(blob.l != end) throw new Error("Bad DataSpaceMapEntry: " + blob.l + " != " + end);
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.6 DataSpaceMap */
+function parse_DataSpaceMap(blob) {
+ var o = [];
+ blob.l += 4; // must be 0x8
+ var cnt = blob.read_shift(4);
+ while(cnt-- > 0) o.push(parse_DataSpaceMapEntry(blob));
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.7 DataSpaceDefinition */
+function parse_DataSpaceDefinition(blob) {
+ var o = [];
+ blob.l += 4; // must be 0x8
+ var cnt = blob.read_shift(4);
+ while(cnt-- > 0) o.push(blob.read_shift(0, 'lpp4'));
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.1.8 DataSpaceDefinition */
+function parse_TransformInfoHeader(blob) {
+ var o = {};
+ /*var len = */blob.read_shift(4);
+ blob.l += 4; // must be 0x1
+ o.id = blob.read_shift(0, 'lpp4');
+ o.name = blob.read_shift(0, 'lpp4');
+ o.R = parse_CRYPTOVersion(blob, 4);
+ o.U = parse_CRYPTOVersion(blob, 4);
+ o.W = parse_CRYPTOVersion(blob, 4);
+ return o;
+}
+
+function parse_Primary(blob) {
+ /* [MS-OFFCRYPTO] 2.2.6 IRMDSTransformInfo */
+ var hdr = parse_TransformInfoHeader(blob);
+ /* [MS-OFFCRYPTO] 2.1.9 EncryptionTransformInfo */
+ hdr.ename = blob.read_shift(0, '8lpp4');
+ hdr.blksz = blob.read_shift(4);
+ hdr.cmode = blob.read_shift(4);
+ if(blob.read_shift(4) != 0x04) throw new Error("Bad !Primary record");
+ return hdr;
+}
+
+/* [MS-OFFCRYPTO] 2.3.2 Encryption Header */
+function parse_EncryptionHeader(blob, length) {
+ var tgt = blob.l + length;
+ var o = {};
+ o.Flags = (blob.read_shift(4) & 0x3F);
+ blob.l += 4;
+ o.AlgID = blob.read_shift(4);
+ var valid = false;
+ switch(o.AlgID) {
+ case 0x660E: case 0x660F: case 0x6610: valid = (o.Flags == 0x24); break;
+ case 0x6801: valid = (o.Flags == 0x04); break;
+ case 0: valid = (o.Flags == 0x10 || o.Flags == 0x04 || o.Flags == 0x24); break;
+ default: throw 'Unrecognized encryption algorithm: ' + o.AlgID;
+ }
+ if(!valid) throw new Error("Encryption Flags/AlgID mismatch");
+ o.AlgIDHash = blob.read_shift(4);
+ o.KeySize = blob.read_shift(4);
+ o.ProviderType = blob.read_shift(4);
+ blob.l += 8;
+ o.CSPName = blob.read_shift((tgt-blob.l)>>1, 'utf16le');
+ blob.l = tgt;
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.3.3 Encryption Verifier */
+function parse_EncryptionVerifier(blob, length) {
+ var o = {}, tgt = blob.l + length;
+ blob.l += 4; // SaltSize must be 0x10
+ o.Salt = blob.slice(blob.l, blob.l+16); blob.l += 16;
+ o.Verifier = blob.slice(blob.l, blob.l+16); blob.l += 16;
+ /*var sz = */blob.read_shift(4);
+ o.VerifierHash = blob.slice(blob.l, tgt); blob.l = tgt;
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.3.4.* EncryptionInfo Stream */
+function parse_EncryptionInfo(blob) {
+ var vers = parse_CRYPTOVersion(blob);
+ switch(vers.Minor) {
+ case 0x02: return [vers.Minor, parse_EncInfoStd(blob, vers)];
+ case 0x03: return [vers.Minor, parse_EncInfoExt(blob, vers)];
+ case 0x04: return [vers.Minor, parse_EncInfoAgl(blob, vers)];
+ }
+ throw new Error("ECMA-376 Encrypted file unrecognized Version: " + vers.Minor);
+}
+
+/* [MS-OFFCRYPTO] 2.3.4.5 EncryptionInfo Stream (Standard Encryption) */
+function parse_EncInfoStd(blob) {
+ var flags = blob.read_shift(4);
+ if((flags & 0x3F) != 0x24) throw new Error("EncryptionInfo mismatch");
+ var sz = blob.read_shift(4);
+ //var tgt = blob.l + sz;
+ var hdr = parse_EncryptionHeader(blob, sz);
+ var verifier = parse_EncryptionVerifier(blob, blob.length - blob.l);
+ return { t:"Std", h:hdr, v:verifier };
+}
+/* [MS-OFFCRYPTO] 2.3.4.6 EncryptionInfo Stream (Extensible Encryption) */
+function parse_EncInfoExt() { throw new Error("File is password-protected: ECMA-376 Extensible"); }
+/* [MS-OFFCRYPTO] 2.3.4.10 EncryptionInfo Stream (Agile Encryption) */
+function parse_EncInfoAgl(blob) {
+ var KeyData = ["saltSize","blockSize","keyBits","hashSize","cipherAlgorithm","cipherChaining","hashAlgorithm","saltValue"];
+ blob.l+=4;
+ var xml = blob.read_shift(blob.length - blob.l, 'utf8');
+ var o = {};
+ xml.replace(tagregex, function xml_agile(x) {
+ var y = parsexmltag(x);
+ switch(strip_ns(y[0])) {
+ case '': break;
+ case '': case '': break;
+
+ case '': break;
+ case ' 4 || vers.Major < 2) throw new Error('unrecognized major version code: ' + vers.Major);
+ o.Flags = blob.read_shift(4); length -= 4;
+ var sz = blob.read_shift(4); length -= 4;
+ o.EncryptionHeader = parse_EncryptionHeader(blob, sz); length -= sz;
+ o.EncryptionVerifier = parse_EncryptionVerifier(blob, length);
+ return o;
+}
+/* [MS-OFFCRYPTO] 2.3.6.1 RC4 Encryption Header */
+function parse_RC4Header(blob) {
+ var o = {};
+ var vers = o.EncryptionVersionInfo = parse_CRYPTOVersion(blob, 4);
+ if(vers.Major != 1 || vers.Minor != 1) throw 'unrecognized version code ' + vers.Major + ' : ' + vers.Minor;
+ o.Salt = blob.read_shift(16);
+ o.EncryptedVerifier = blob.read_shift(16);
+ o.EncryptedVerifierHash = blob.read_shift(16);
+ return o;
+}
+
+/* [MS-OFFCRYPTO] 2.3.7.1 Binary Document Password Verifier Derivation */
+function crypto_CreatePasswordVerifier_Method1(Password) {
+ var Verifier = 0x0000, PasswordArray;
+ var PasswordDecoded = _JS2ANSI(Password);
+ var len = PasswordDecoded.length + 1, i, PasswordByte;
+ var Intermediate1, Intermediate2, Intermediate3;
+ PasswordArray = new_raw_buf(len);
+ PasswordArray[0] = PasswordDecoded.length;
+ for(i = 1; i != len; ++i) PasswordArray[i] = PasswordDecoded[i-1];
+ for(i = len-1; i >= 0; --i) {
+ PasswordByte = PasswordArray[i];
+ Intermediate1 = ((Verifier & 0x4000) === 0x0000) ? 0 : 1;
+ Intermediate2 = (Verifier << 1) & 0x7FFF;
+ Intermediate3 = Intermediate1 | Intermediate2;
+ Verifier = Intermediate3 ^ PasswordByte;
+ }
+ return Verifier ^ 0xCE4B;
+}
+
+/* [MS-OFFCRYPTO] 2.3.7.2 Binary Document XOR Array Initialization */
+var crypto_CreateXorArray_Method1 = (function() {
+ var PadArray = [0xBB, 0xFF, 0xFF, 0xBA, 0xFF, 0xFF, 0xB9, 0x80, 0x00, 0xBE, 0x0F, 0x00, 0xBF, 0x0F, 0x00];
+ var InitialCode = [0xE1F0, 0x1D0F, 0xCC9C, 0x84C0, 0x110C, 0x0E10, 0xF1CE, 0x313E, 0x1872, 0xE139, 0xD40F, 0x84F9, 0x280C, 0xA96A, 0x4EC3];
+ var XorMatrix = [0xAEFC, 0x4DD9, 0x9BB2, 0x2745, 0x4E8A, 0x9D14, 0x2A09, 0x7B61, 0xF6C2, 0xFDA5, 0xEB6B, 0xC6F7, 0x9DCF, 0x2BBF, 0x4563, 0x8AC6, 0x05AD, 0x0B5A, 0x16B4, 0x2D68, 0x5AD0, 0x0375, 0x06EA, 0x0DD4, 0x1BA8, 0x3750, 0x6EA0, 0xDD40, 0xD849, 0xA0B3, 0x5147, 0xA28E, 0x553D, 0xAA7A, 0x44D5, 0x6F45, 0xDE8A, 0xAD35, 0x4A4B, 0x9496, 0x390D, 0x721A, 0xEB23, 0xC667, 0x9CEF, 0x29FF, 0x53FE, 0xA7FC, 0x5FD9, 0x47D3, 0x8FA6, 0x0F6D, 0x1EDA, 0x3DB4, 0x7B68, 0xF6D0, 0xB861, 0x60E3, 0xC1C6, 0x93AD, 0x377B, 0x6EF6, 0xDDEC, 0x45A0, 0x8B40, 0x06A1, 0x0D42, 0x1A84, 0x3508, 0x6A10, 0xAA51, 0x4483, 0x8906, 0x022D, 0x045A, 0x08B4, 0x1168, 0x76B4, 0xED68, 0xCAF1, 0x85C3, 0x1BA7, 0x374E, 0x6E9C, 0x3730, 0x6E60, 0xDCC0, 0xA9A1, 0x4363, 0x86C6, 0x1DAD, 0x3331, 0x6662, 0xCCC4, 0x89A9, 0x0373, 0x06E6, 0x0DCC, 0x1021, 0x2042, 0x4084, 0x8108, 0x1231, 0x2462, 0x48C4];
+ var Ror = function(Byte) { return ((Byte/2) | (Byte*128)) & 0xFF; };
+ var XorRor = function(byte1, byte2) { return Ror(byte1 ^ byte2); };
+ var CreateXorKey_Method1 = function(Password) {
+ var XorKey = InitialCode[Password.length - 1];
+ var CurrentElement = 0x68;
+ for(var i = Password.length-1; i >= 0; --i) {
+ var Char = Password[i];
+ for(var j = 0; j != 7; ++j) {
+ if(Char & 0x40) XorKey ^= XorMatrix[CurrentElement];
+ Char *= 2; --CurrentElement;
+ }
+ }
+ return XorKey;
+ };
+ return function(password) {
+ var Password = _JS2ANSI(password);
+ var XorKey = CreateXorKey_Method1(Password);
+ var Index = Password.length;
+ var ObfuscationArray = new_raw_buf(16);
+ for(var i = 0; i != 16; ++i) ObfuscationArray[i] = 0x00;
+ var Temp, PasswordLastChar, PadIndex;
+ if((Index & 1) === 1) {
+ Temp = XorKey >> 8;
+ ObfuscationArray[Index] = XorRor(PadArray[0], Temp);
+ --Index;
+ Temp = XorKey & 0xFF;
+ PasswordLastChar = Password[Password.length - 1];
+ ObfuscationArray[Index] = XorRor(PasswordLastChar, Temp);
+ }
+ while(Index > 0) {
+ --Index;
+ Temp = XorKey >> 8;
+ ObfuscationArray[Index] = XorRor(Password[Index], Temp);
+ --Index;
+ Temp = XorKey & 0xFF;
+ ObfuscationArray[Index] = XorRor(Password[Index], Temp);
+ }
+ Index = 15;
+ PadIndex = 15 - Password.length;
+ while(PadIndex > 0) {
+ Temp = XorKey >> 8;
+ ObfuscationArray[Index] = XorRor(PadArray[PadIndex], Temp);
+ --Index;
+ --PadIndex;
+ Temp = XorKey & 0xFF;
+ ObfuscationArray[Index] = XorRor(Password[Index], Temp);
+ --Index;
+ --PadIndex;
+ }
+ return ObfuscationArray;
+ };
+})();
+
+/* [MS-OFFCRYPTO] 2.3.7.3 Binary Document XOR Data Transformation Method 1 */
+var crypto_DecryptData_Method1 = function(password, Data, XorArrayIndex, XorArray, O) {
+ /* If XorArray is set, use it; if O is not set, make changes in-place */
+ if(!O) O = Data;
+ if(!XorArray) XorArray = crypto_CreateXorArray_Method1(password);
+ var Index, Value;
+ for(Index = 0; Index != Data.length; ++Index) {
+ Value = Data[Index];
+ Value ^= XorArray[XorArrayIndex];
+ Value = ((Value>>5) | (Value<<3)) & 0xFF;
+ O[Index] = Value;
+ ++XorArrayIndex;
+ }
+ return [O, XorArrayIndex, XorArray];
+};
+
+var crypto_MakeXorDecryptor = function(password) {
+ var XorArrayIndex = 0, XorArray = crypto_CreateXorArray_Method1(password);
+ return function(Data) {
+ var O = crypto_DecryptData_Method1("", Data, XorArrayIndex, XorArray);
+ XorArrayIndex = O[1];
+ return O[0];
+ };
+};
+
+/* 2.5.343 */
+function parse_XORObfuscation(blob, length, opts, out) {
+ var o = ({ key: parseuint16(blob), verificationBytes: parseuint16(blob) });
+ if(opts.password) o.verifier = crypto_CreatePasswordVerifier_Method1(opts.password);
+ out.valid = o.verificationBytes === o.verifier;
+ if(out.valid) out.insitu = crypto_MakeXorDecryptor(opts.password);
+ return o;
+}
+
+/* 2.4.117 */
+function parse_FilePassHeader(blob, length, oo) {
+ var o = oo || {}; o.Info = blob.read_shift(2); blob.l -= 2;
+ if(o.Info === 1) o.Data = parse_RC4Header(blob, length);
+ else o.Data = parse_RC4CryptoHeader(blob, length);
+ return o;
+}
+function parse_FilePass(blob, length, opts) {
+ var o = ({ Type: opts.biff >= 8 ? blob.read_shift(2) : 0 }); /* wEncryptionType */
+ if(o.Type) parse_FilePassHeader(blob, length-2, o);
+ else parse_XORObfuscation(blob, opts.biff >= 8 ? length : length - 2, opts, o);
+ return o;
+}
+
+
+var RTF = (function() {
+ function rtf_to_sheet(d, opts) {
+ switch(opts.type) {
+ case 'base64': return rtf_to_sheet_str(Base64_decode(d), opts);
+ case 'binary': return rtf_to_sheet_str(d, opts);
+ case 'buffer': return rtf_to_sheet_str(has_buf && Buffer.isBuffer(d) ? d.toString('binary') : a2s(d), opts);
+ case 'array': return rtf_to_sheet_str(cc2str(d), opts);
+ }
+ throw new Error("Unrecognized type " + opts.type);
+ }
+
+ /* TODO: this is a stub */
+ function rtf_to_sheet_str(str, opts) {
+ var o = opts || {};
+ var ws = o.dense ? ([]) : ({});
+
+ var rows = str.match(/\\trowd.*?\\row\b/g);
+ if(!rows.length) throw new Error("RTF missing table");
+ var range = ({s: {c:0, r:0}, e: {c:0, r:rows.length - 1}});
+ rows.forEach(function(rowtf, R) {
+ if(Array.isArray(ws)) ws[R] = [];
+ var rtfre = /\\\w+\b/g;
+ var last_index = 0;
+ var res;
+ var C = -1;
+ while((res = rtfre.exec(rowtf))) {
+ switch(res[0]) {
+ case "\\cell":
+ var data = rowtf.slice(last_index, rtfre.lastIndex - res[0].length);
+ if(data[0] == " ") data = data.slice(1);
+ ++C;
+ if(data.length) {
+ // TODO: value parsing, including codepage adjustments
+ var cell = {v: data, t:"s"};
+ if(Array.isArray(ws)) ws[R][C] = cell;
+ else ws[encode_cell({r:R, c:C})] = cell;
+ }
+ break;
+ }
+ last_index = rtfre.lastIndex;
+ }
+ if(C > range.e.c) range.e.c = C;
+ });
+ ws['!ref'] = encode_range(range);
+ return ws;
+ }
+
+ function rtf_to_workbook(d, opts) { return sheet_to_workbook(rtf_to_sheet(d, opts), opts); }
+
+ /* TODO: this is a stub */
+ function sheet_to_rtf(ws) {
+ var o = ["{\\rtf1\\ansi"];
+ var r = safe_decode_range(ws['!ref']), cell;
+ var dense = Array.isArray(ws);
+ for(var R = r.s.r; R <= r.e.r; ++R) {
+ o.push("\\trowd\\trautofit1");
+ for(var C = r.s.c; C <= r.e.c; ++C) o.push("\\cellx" + (C+1));
+ o.push("\\pard\\intbl");
+ for(C = r.s.c; C <= r.e.c; ++C) {
+ var coord = encode_cell({r:R,c:C});
+ cell = dense ? (ws[R]||[])[C]: ws[coord];
+ if(!cell || cell.v == null && (!cell.f || cell.F)) continue;
+ o.push(" " + (cell.w || (format_cell(cell), cell.w)));
+ o.push("\\cell");
+ }
+ o.push("\\pard\\intbl\\row");
+ }
+ return o.join("") + "}";
+ }
+
+ return {
+ to_workbook: rtf_to_workbook,
+ to_sheet: rtf_to_sheet,
+ from_sheet: sheet_to_rtf
+ };
+})();
+function hex2RGB(h) {
+ var o = h.slice(h[0]==="#"?1:0).slice(0,6);
+ return [parseInt(o.slice(0,2),16),parseInt(o.slice(2,4),16),parseInt(o.slice(4,6),16)];
+}
+function rgb2Hex(rgb) {
+ for(var i=0,o=1; i!=3; ++i) o = o*256 + (rgb[i]>255?255:rgb[i]<0?0:rgb[i]);
+ return o.toString(16).toUpperCase().slice(1);
+}
+
+function rgb2HSL(rgb) {
+ var R = rgb[0]/255, G = rgb[1]/255, B=rgb[2]/255;
+ var M = Math.max(R, G, B), m = Math.min(R, G, B), C = M - m;
+ if(C === 0) return [0, 0, R];
+
+ var H6 = 0, S = 0, L2 = (M + m);
+ S = C / (L2 > 1 ? 2 - L2 : L2);
+ switch(M){
+ case R: H6 = ((G - B) / C + 6)%6; break;
+ case G: H6 = ((B - R) / C + 2); break;
+ case B: H6 = ((R - G) / C + 4); break;
+ }
+ return [H6 / 6, S, L2 / 2];
+}
+
+function hsl2RGB(hsl){
+ var H = hsl[0], S = hsl[1], L = hsl[2];
+ var C = S * 2 * (L < 0.5 ? L : 1 - L), m = L - C/2;
+ var rgb = [m,m,m], h6 = 6*H;
+
+ var X;
+ if(S !== 0) switch(h6|0) {
+ case 0: case 6: X = C * h6; rgb[0] += C; rgb[1] += X; break;
+ case 1: X = C * (2 - h6); rgb[0] += X; rgb[1] += C; break;
+ case 2: X = C * (h6 - 2); rgb[1] += C; rgb[2] += X; break;
+ case 3: X = C * (4 - h6); rgb[1] += X; rgb[2] += C; break;
+ case 4: X = C * (h6 - 4); rgb[2] += C; rgb[0] += X; break;
+ case 5: X = C * (6 - h6); rgb[2] += X; rgb[0] += C; break;
+ }
+ for(var i = 0; i != 3; ++i) rgb[i] = Math.round(rgb[i]*255);
+ return rgb;
+}
+
+/* 18.8.3 bgColor tint algorithm */
+function rgb_tint(hex, tint) {
+ if(tint === 0) return hex;
+ var hsl = rgb2HSL(hex2RGB(hex));
+ if (tint < 0) hsl[2] = hsl[2] * (1 + tint);
+ else hsl[2] = 1 - (1 - hsl[2]) * (1 - tint);
+ return rgb2Hex(hsl2RGB(hsl));
+}
+
+/* 18.3.1.13 width calculations */
+/* [MS-OI29500] 2.1.595 Column Width & Formatting */
+var DEF_MDW = 6, MAX_MDW = 15, MIN_MDW = 1, MDW = DEF_MDW;
+function width2px(width) { return Math.floor(( width + (Math.round(128/MDW))/256 )* MDW ); }
+function px2char(px) { return (Math.floor((px - 5)/MDW * 100 + 0.5))/100; }
+function char2width(chr) { return (Math.round((chr * MDW + 5)/MDW*256))/256; }
+//function px2char_(px) { return (((px - 5)/MDW * 100 + 0.5))/100; }
+//function char2width_(chr) { return (((chr * MDW + 5)/MDW*256))/256; }
+function cycle_width(collw) { return char2width(px2char(width2px(collw))); }
+/* XLSX/XLSB/XLS specify width in units of MDW */
+function find_mdw_colw(collw) {
+ var delta = Math.abs(collw - cycle_width(collw)), _MDW = MDW;
+ if(delta > 0.005) for(MDW=MIN_MDW; MDW 0.5) guess--;
+ if(Math.abs(guess) < delta) { delta = Math.abs(guess); _MDW = MDW; }
+ }
+ MDW = _MDW;
+}*/
+
+function process_col(coll) {
+ if(coll.width) {
+ coll.wpx = width2px(coll.width);
+ coll.wch = px2char(coll.wpx);
+ coll.MDW = MDW;
+ } else if(coll.wpx) {
+ coll.wch = px2char(coll.wpx);
+ coll.width = char2width(coll.wch);
+ coll.MDW = MDW;
+ } else if(typeof coll.wch == 'number') {
+ coll.width = char2width(coll.wch);
+ coll.wpx = width2px(coll.width);
+ coll.MDW = MDW;
+ }
+ if(coll.customWidth) delete coll.customWidth;
+}
+
+var DEF_PPI = 96, PPI = DEF_PPI;
+function px2pt(px) { return px * 96 / PPI; }
+function pt2px(pt) { return pt * PPI / 96; }
+
+/* [MS-EXSPXML3] 2.4.54 ST_enmPattern */
+var XLMLPatternTypeMap = {
+ "None": "none",
+ "Solid": "solid",
+ "Gray50": "mediumGray",
+ "Gray75": "darkGray",
+ "Gray25": "lightGray",
+ "HorzStripe": "darkHorizontal",
+ "VertStripe": "darkVertical",
+ "ReverseDiagStripe": "darkDown",
+ "DiagStripe": "darkUp",
+ "DiagCross": "darkGrid",
+ "ThickDiagCross": "darkTrellis",
+ "ThinHorzStripe": "lightHorizontal",
+ "ThinVertStripe": "lightVertical",
+ "ThinReverseDiagStripe": "lightDown",
+ "ThinHorzCross": "lightGrid"
+};
+
+/* 18.8.5 borders CT_Borders */
+function parse_borders(t, styles, themes, opts) {
+ styles.Borders = [];
+ var border = {};
+ var pass = false;
+ (t[0].match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ switch(strip_ns(y[0])) {
+ case '': case '': break;
+
+ /* 18.8.4 border CT_Border */
+ case '': case '':
+ border = {};
+ if(y.diagonalUp) border.diagonalUp = parsexmlbool(y.diagonalUp);
+ if(y.diagonalDown) border.diagonalDown = parsexmlbool(y.diagonalDown);
+ styles.Borders.push(border);
+ break;
+ case '': break;
+
+ /* note: not in spec, appears to be CT_BorderPr */
+ case '': break;
+ case '': break;
+ case '': break;
+
+ /* note: not in spec, appears to be CT_BorderPr */
+ case '': break;
+ case '': break;
+ case '': break;
+
+ /* 18.8.43 top CT_BorderPr */
+ case '': break;
+ case '': break;
+ case '': break;
+
+ /* 18.8.6 bottom CT_BorderPr */
+ case '': break;
+ case '': break;
+ case '': break;
+
+ /* 18.8.13 diagonal CT_BorderPr */
+ case '': case '': break;
+ case '': break;
+
+ /* 18.8.25 horizontal CT_BorderPr */
+ case '': case '': break;
+ case '': break;
+
+ /* 18.8.44 vertical CT_BorderPr */
+ case '': case '': break;
+ case '': break;
+
+ /* 18.8.37 start CT_BorderPr */
+ case '': case '': break;
+ case '': break;
+
+ /* 18.8.16 end CT_BorderPr */
+ case '': case '': break;
+ case '': break;
+
+ /* 18.8.? color CT_Color */
+ case '':
+ break;
+ case '': case '': break;
+
+ /* 18.2.10 extLst CT_ExtensionList ? */
+ case '': case '': break;
+ case '': pass = false; break;
+ default: if(opts && opts.WTF) {
+ if(!pass) throw new Error('unrecognized ' + y[0] + ' in borders');
+ }
+ }
+ });
+}
+
+/* 18.8.21 fills CT_Fills */
+function parse_fills(t, styles, themes, opts) {
+ styles.Fills = [];
+ var fill = {};
+ var pass = false;
+ (t[0].match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ switch(strip_ns(y[0])) {
+ case '': case '': break;
+
+ /* 18.8.20 fill CT_Fill */
+ case '': case '':
+ fill = {}; styles.Fills.push(fill); break;
+ case '': break;
+
+ /* 18.8.24 gradientFill CT_GradientFill */
+ case '': break;
+ case '': styles.Fills.push(fill); fill = {}; break;
+
+ /* 18.8.32 patternFill CT_PatternFill */
+ case '':
+ if(y.patternType) fill.patternType = y.patternType;
+ break;
+ case '': case '': break;
+
+ /* 18.8.3 bgColor CT_Color */
+ case '': case '': break;
+
+ /* 18.8.19 fgColor CT_Color */
+ case '': case '': break;
+
+ /* 18.8.38 stop CT_GradientStop */
+ case '': break;
+ case '': break;
+
+ /* 18.8.? color CT_Color */
+ case '': break;
+ case '': break;
+
+ /* 18.2.10 extLst CT_ExtensionList ? */
+ case '': case '': break;
+ case '': pass = false; break;
+ default: if(opts && opts.WTF) {
+ if(!pass) throw new Error('unrecognized ' + y[0] + ' in fills');
+ }
+ }
+ });
+}
+
+/* 18.8.23 fonts CT_Fonts */
+function parse_fonts(t, styles, themes, opts) {
+ styles.Fonts = [];
+ var font = {};
+ var pass = false;
+ (t[0].match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ switch(strip_ns(y[0])) {
+ case '': case '': break;
+
+ /* 18.8.22 font CT_Font */
+ case '': break;
+ case '': case '':
+ styles.Fonts.push(font);
+ font = {};
+ break;
+
+ /* 18.8.29 name CT_FontName */
+ case '': case '': break;
+
+ /* 18.8.2 b CT_BooleanProperty */
+ case '': font.bold = 1; break;
+
+ /* 18.8.26 i CT_BooleanProperty */
+ case '': font.italic = 1; break;
+
+ /* 18.4.13 u CT_UnderlineProperty */
+ case '': font.underline = 1; break;
+
+ /* 18.4.10 strike CT_BooleanProperty */
+ case '': font.strike = 1; break;
+
+ /* 18.4.2 outline CT_BooleanProperty */
+ case '': font.outline = 1; break;
+
+ /* 18.8.36 shadow CT_BooleanProperty */
+ case '': font.shadow = 1; break;
+
+ /* 18.8.12 condense CT_BooleanProperty */
+ case '': font.condense = 1; break;
+
+ /* 18.8.17 extend CT_BooleanProperty */
+ case '': font.extend = 1; break;
+
+ /* 18.4.11 sz CT_FontSize */
+ case '': case '': break;
+
+ /* 18.4.14 vertAlign CT_VerticalAlignFontProperty */
+ case '': case '': break;
+
+ /* 18.8.18 family CT_FontFamily */
+ case '': case '': break;
+
+ /* 18.8.35 scheme CT_FontScheme */
+ case '': case '': break;
+
+ /* 18.4.1 charset CT_IntProperty */
+ case '': case '': break;
+
+ /* note: sometimes mc:AlternateContent appears bare */
+ case '': pass = false; break;
+
+ /* 18.2.10 extLst CT_ExtensionList ? */
+ case '': case '': break;
+ case '': pass = false; break;
+ default: if(opts && opts.WTF) {
+ if(!pass) throw new Error('unrecognized ' + y[0] + ' in fonts');
+ }
+ }
+ });
+}
+
+/* 18.8.31 numFmts CT_NumFmts */
+function parse_numFmts(t, styles, opts) {
+ styles.NumberFmt = [];
+ var k/*Array*/ = (keys(table_fmt));
+ for(var i=0; i < k.length; ++i) styles.NumberFmt[k[i]] = table_fmt[k[i]];
+ var m = t[0].match(tagregex);
+ if(!m) return;
+ for(i=0; i < m.length; ++i) {
+ var y = parsexmltag(m[i]);
+ switch(strip_ns(y[0])) {
+ case '': case '': case '': break;
+ case '0) {
+ if(j > 0x188) {
+ for(j = 0x188; j > 0x3c; --j) if(styles.NumberFmt[j] == null) break;
+ styles.NumberFmt[j] = f;
+ }
+ SSF_load(f,j);
+ }
+ } break;
+ case '': break;
+ default: if(opts.WTF) throw new Error('unrecognized ' + y[0] + ' in numFmts');
+ }
+ }
+}
+
+function write_numFmts(NF) {
+ var o = [""];
+ [[5,8],[23,26],[41,44],[/*63*/50,/*66],[164,*/392]].forEach(function(r) {
+ for(var i = r[0]; i <= r[1]; ++i) if(NF[i] != null) o[o.length] = (writextag('numFmt',null,{numFmtId:i,formatCode:escapexml(NF[i])}));
+ });
+ if(o.length === 1) return "";
+ o[o.length] = ("");
+ o[0] = writextag('numFmts', null, { count:o.length-2 }).replace("/>", ">");
+ return o.join("");
+}
+
+/* 18.8.10 cellXfs CT_CellXfs */
+var cellXF_uint = [ "numFmtId", "fillId", "fontId", "borderId", "xfId" ];
+var cellXF_bool = [ "applyAlignment", "applyBorder", "applyFill", "applyFont", "applyNumberFormat", "applyProtection", "pivotButton", "quotePrefix" ];
+function parse_cellXfs(t, styles, opts) {
+ styles.CellXf = [];
+ var xf;
+ var pass = false;
+ (t[0].match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x), i = 0;
+ switch(strip_ns(y[0])) {
+ case '': case '': case '': break;
+
+ /* 18.8.45 xf CT_Xf */
+ case '':
+ xf = y;
+ delete xf[0];
+ for(i = 0; i < cellXF_uint.length; ++i) if(xf[cellXF_uint[i]])
+ xf[cellXF_uint[i]] = parseInt(xf[cellXF_uint[i]], 10);
+ for(i = 0; i < cellXF_bool.length; ++i) if(xf[cellXF_bool[i]])
+ xf[cellXF_bool[i]] = parsexmlbool(xf[cellXF_bool[i]]);
+ if(styles.NumberFmt && xf.numFmtId > 0x188) {
+ for(i = 0x188; i > 0x3c; --i) if(styles.NumberFmt[xf.numFmtId] == styles.NumberFmt[i]) { xf.numFmtId = i; break; }
+ }
+ styles.CellXf.push(xf); break;
+ case '': break;
+
+ /* 18.8.1 alignment CT_CellAlignment */
+ case '':
+ var alignment = {};
+ if(y.vertical) alignment.vertical = y.vertical;
+ if(y.horizontal) alignment.horizontal = y.horizontal;
+ if(y.textRotation != null) alignment.textRotation = y.textRotation;
+ if(y.indent) alignment.indent = y.indent;
+ if(y.wrapText) alignment.wrapText = parsexmlbool(y.wrapText);
+ xf.alignment = alignment;
+ break;
+ case '': break;
+
+ /* 18.8.33 protection CT_CellProtection */
+ case '': case '': break;
+
+ /* note: sometimes mc:AlternateContent appears bare */
+ case '': pass = false; break;
+
+ /* 18.2.10 extLst CT_ExtensionList ? */
+ case '': case '': break;
+ case '': pass = false; break;
+ default: if(opts && opts.WTF) {
+ if(!pass) throw new Error('unrecognized ' + y[0] + ' in cellXfs');
+ }
+ }
+ });
+}
+
+function write_cellXfs(cellXfs) {
+ var o = [];
+ o[o.length] = (writextag('cellXfs',null));
+ cellXfs.forEach(function(c) {
+ o[o.length] = (writextag('xf', null, c));
+ });
+ o[o.length] = ("");
+ if(o.length === 2) return "";
+ o[0] = writextag('cellXfs',null, {count:o.length-2}).replace("/>",">");
+ return o.join("");
+}
+
+/* 18.8 Styles CT_Stylesheet*/
+var parse_sty_xml= (function make_pstyx() {
+var numFmtRegex = /<(?:\w+:)?numFmts([^>]*)>[\S\s]*?<\/(?:\w+:)?numFmts>/;
+var cellXfRegex = /<(?:\w+:)?cellXfs([^>]*)>[\S\s]*?<\/(?:\w+:)?cellXfs>/;
+var fillsRegex = /<(?:\w+:)?fills([^>]*)>[\S\s]*?<\/(?:\w+:)?fills>/;
+var fontsRegex = /<(?:\w+:)?fonts([^>]*)>[\S\s]*?<\/(?:\w+:)?fonts>/;
+var bordersRegex = /<(?:\w+:)?borders([^>]*)>[\S\s]*?<\/(?:\w+:)?borders>/;
+
+return function parse_sty_xml(data, themes, opts) {
+ var styles = {};
+ if(!data) return styles;
+ data = data.replace(//mg,"").replace(//gm,"");
+ /* 18.8.39 styleSheet CT_Stylesheet */
+ var t;
+
+ /* 18.8.31 numFmts CT_NumFmts ? */
+ if((t=data.match(numFmtRegex))) parse_numFmts(t, styles, opts);
+
+ /* 18.8.23 fonts CT_Fonts ? */
+ if((t=data.match(fontsRegex))) parse_fonts(t, styles, themes, opts);
+
+ /* 18.8.21 fills CT_Fills ? */
+ if((t=data.match(fillsRegex))) parse_fills(t, styles, themes, opts);
+
+ /* 18.8.5 borders CT_Borders ? */
+ if((t=data.match(bordersRegex))) parse_borders(t, styles, themes, opts);
+
+ /* 18.8.9 cellStyleXfs CT_CellStyleXfs ? */
+ /* 18.8.8 cellStyles CT_CellStyles ? */
+
+ /* 18.8.10 cellXfs CT_CellXfs ? */
+ if((t=data.match(cellXfRegex))) parse_cellXfs(t, styles, opts);
+
+ /* 18.8.15 dxfs CT_Dxfs ? */
+ /* 18.8.42 tableStyles CT_TableStyles ? */
+ /* 18.8.11 colors CT_Colors ? */
+ /* 18.2.10 extLst CT_ExtensionList ? */
+
+ return styles;
+};
+})();
+
+function write_sty_xml(wb, opts) {
+ var o = [XML_HEADER, writextag('styleSheet', null, {
+ 'xmlns': XMLNS_main[0],
+ 'xmlns:vt': XMLNS.vt
+ })], w;
+ if(wb.SSF && (w = write_numFmts(wb.SSF)) != null) o[o.length] = w;
+ o[o.length] = ('');
+ o[o.length] = ('');
+ o[o.length] = ('');
+ o[o.length] = ('');
+ if((w = write_cellXfs(opts.cellXfs))) o[o.length] = (w);
+ o[o.length] = ('');
+ o[o.length] = ('');
+ o[o.length] = ('');
+
+ if(o.length>2){ o[o.length] = (''); o[1]=o[1].replace("/>",">"); }
+ return o.join("");
+}
+/* [MS-XLSB] 2.4.657 BrtFmt */
+function parse_BrtFmt(data, length) {
+ var numFmtId = data.read_shift(2);
+ var stFmtCode = parse_XLWideString(data,length-2);
+ return [numFmtId, stFmtCode];
+}
+function write_BrtFmt(i, f, o) {
+ if(!o) o = new_buf(6 + 4 * f.length);
+ o.write_shift(2, i);
+ write_XLWideString(f, o);
+ var out = (o.length > o.l) ? o.slice(0, o.l) : o;
+ if(o.l == null) o.l = o.length;
+ return out;
+}
+
+/* [MS-XLSB] 2.4.659 BrtFont TODO */
+function parse_BrtFont(data, length, opts) {
+ var out = ({});
+
+ out.sz = data.read_shift(2) / 20;
+
+ var grbit = parse_FontFlags(data, 2, opts);
+ if(grbit.fItalic) out.italic = 1;
+ if(grbit.fCondense) out.condense = 1;
+ if(grbit.fExtend) out.extend = 1;
+ if(grbit.fShadow) out.shadow = 1;
+ if(grbit.fOutline) out.outline = 1;
+ if(grbit.fStrikeout) out.strike = 1;
+
+ var bls = data.read_shift(2);
+ if(bls === 0x02BC) out.bold = 1;
+
+ switch(data.read_shift(2)) {
+ /* case 0: out.vertAlign = "baseline"; break; */
+ case 1: out.vertAlign = "superscript"; break;
+ case 2: out.vertAlign = "subscript"; break;
+ }
+
+ var underline = data.read_shift(1);
+ if(underline != 0) out.underline = underline;
+
+ var family = data.read_shift(1);
+ if(family > 0) out.family = family;
+
+ var bCharSet = data.read_shift(1);
+ if(bCharSet > 0) out.charset = bCharSet;
+
+ data.l++;
+ out.color = parse_BrtColor(data, 8);
+
+ switch(data.read_shift(1)) {
+ /* case 0: out.scheme = "none": break; */
+ case 1: out.scheme = "major"; break;
+ case 2: out.scheme = "minor"; break;
+ }
+
+ out.name = parse_XLWideString(data, length - 21);
+
+ return out;
+}
+function write_BrtFont(font, o) {
+ if(!o) o = new_buf(25+4*32);
+ o.write_shift(2, font.sz * 20);
+ write_FontFlags(font, o);
+ o.write_shift(2, font.bold ? 0x02BC : 0x0190);
+ var sss = 0;
+ if(font.vertAlign == "superscript") sss = 1;
+ else if(font.vertAlign == "subscript") sss = 2;
+ o.write_shift(2, sss);
+ o.write_shift(1, font.underline || 0);
+ o.write_shift(1, font.family || 0);
+ o.write_shift(1, font.charset || 0);
+ o.write_shift(1, 0);
+ write_BrtColor(font.color, o);
+ var scheme = 0;
+ if(font.scheme == "major") scheme = 1;
+ if(font.scheme == "minor") scheme = 2;
+ o.write_shift(1, scheme);
+ write_XLWideString(font.name, o);
+ return o.length > o.l ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.4.650 BrtFill */
+var XLSBFillPTNames = [
+ "none",
+ "solid",
+ "mediumGray",
+ "darkGray",
+ "lightGray",
+ "darkHorizontal",
+ "darkVertical",
+ "darkDown",
+ "darkUp",
+ "darkGrid",
+ "darkTrellis",
+ "lightHorizontal",
+ "lightVertical",
+ "lightDown",
+ "lightUp",
+ "lightGrid",
+ "lightTrellis",
+ "gray125",
+ "gray0625"
+];
+var rev_XLSBFillPTNames;
+/* TODO: gradient fill representation */
+var parse_BrtFill = parsenoop;
+function write_BrtFill(fill, o) {
+ if(!o) o = new_buf(4*3 + 8*7 + 16*1);
+ if(!rev_XLSBFillPTNames) rev_XLSBFillPTNames = (evert(XLSBFillPTNames));
+ var fls = rev_XLSBFillPTNames[fill.patternType];
+ if(fls == null) fls = 0x28;
+ o.write_shift(4, fls);
+ var j = 0;
+ if(fls != 0x28) {
+ /* TODO: custom FG Color */
+ write_BrtColor({auto:1}, o);
+ /* TODO: custom BG Color */
+ write_BrtColor({auto:1}, o);
+
+ for(; j < 12; ++j) o.write_shift(4, 0);
+ } else {
+ for(; j < 4; ++j) o.write_shift(4, 0);
+
+ for(; j < 12; ++j) o.write_shift(4, 0); /* TODO */
+ /* iGradientType */
+ /* xnumDegree */
+ /* xnumFillToLeft */
+ /* xnumFillToRight */
+ /* xnumFillToTop */
+ /* xnumFillToBottom */
+ /* cNumStop */
+ /* xfillGradientStop */
+ }
+ return o.length > o.l ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.4.824 BrtXF */
+function parse_BrtXF(data, length) {
+ var tgt = data.l + length;
+ var ixfeParent = data.read_shift(2);
+ var ifmt = data.read_shift(2);
+ data.l = tgt;
+ return {ixfe:ixfeParent, numFmtId:ifmt };
+}
+function write_BrtXF(data, ixfeP, o) {
+ if(!o) o = new_buf(16);
+ o.write_shift(2, ixfeP||0);
+ o.write_shift(2, data.numFmtId||0);
+ o.write_shift(2, 0); /* iFont */
+ o.write_shift(2, 0); /* iFill */
+ o.write_shift(2, 0); /* ixBorder */
+ o.write_shift(1, 0); /* trot */
+ o.write_shift(1, 0); /* indent */
+ var flow = 0;
+ o.write_shift(1, flow); /* flags */
+ o.write_shift(1, 0); /* flags */
+ o.write_shift(1, 0); /* xfGrbitAtr */
+ o.write_shift(1, 0);
+ return o;
+}
+
+/* [MS-XLSB] 2.5.4 Blxf TODO */
+function write_Blxf(data, o) {
+ if(!o) o = new_buf(10);
+ o.write_shift(1, 0); /* dg */
+ o.write_shift(1, 0);
+ o.write_shift(4, 0); /* color */
+ o.write_shift(4, 0); /* color */
+ return o;
+}
+/* [MS-XLSB] 2.4.302 BrtBorder TODO */
+var parse_BrtBorder = parsenoop;
+function write_BrtBorder(border, o) {
+ if(!o) o = new_buf(51);
+ o.write_shift(1, 0); /* diagonal */
+ write_Blxf(null, o); /* top */
+ write_Blxf(null, o); /* bottom */
+ write_Blxf(null, o); /* left */
+ write_Blxf(null, o); /* right */
+ write_Blxf(null, o); /* diag */
+ return o.length > o.l ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.4.763 BrtStyle TODO */
+function write_BrtStyle(style, o) {
+ if(!o) o = new_buf(12+4*10);
+ o.write_shift(4, style.xfId);
+ o.write_shift(2, 1);
+ o.write_shift(1, +style.builtinId);
+ o.write_shift(1, 0); /* iLevel */
+ write_XLNullableWideString(style.name || "", o);
+ return o.length > o.l ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.4.272 BrtBeginTableStyles */
+function write_BrtBeginTableStyles(cnt, defTableStyle, defPivotStyle) {
+ var o = new_buf(4+256*2*4);
+ o.write_shift(4, cnt);
+ write_XLNullableWideString(defTableStyle, o);
+ write_XLNullableWideString(defPivotStyle, o);
+ return o.length > o.l ? o.slice(0, o.l) : o;
+}
+
+/* [MS-XLSB] 2.1.7.50 Styles */
+function parse_sty_bin(data, themes, opts) {
+ var styles = {};
+ styles.NumberFmt = ([]);
+ for(var y in table_fmt) styles.NumberFmt[y] = table_fmt[y];
+
+ styles.CellXf = [];
+ styles.Fonts = [];
+ var state = [];
+ var pass = false;
+ recordhopper(data, function hopper_sty(val, R, RT) {
+ switch(RT) {
+ case 0x002C: /* BrtFmt */
+ styles.NumberFmt[val[0]] = val[1]; SSF_load(val[1], val[0]);
+ break;
+ case 0x002B: /* BrtFont */
+ styles.Fonts.push(val);
+ if(val.color.theme != null && themes && themes.themeElements && themes.themeElements.clrScheme) {
+ val.color.rgb = rgb_tint(themes.themeElements.clrScheme[val.color.theme].rgb, val.color.tint || 0);
+ }
+ break;
+ case 0x0401: /* BrtKnownFonts */ break;
+ case 0x002D: /* BrtFill */
+ break;
+ case 0x002E: /* BrtBorder */
+ break;
+ case 0x002F: /* BrtXF */
+ if(state[state.length - 1] == 0x0269 /* BrtBeginCellXFs */) {
+ styles.CellXf.push(val);
+ }
+ break;
+ case 0x0030: /* BrtStyle */
+ case 0x01FB: /* BrtDXF */
+ case 0x023C: /* BrtMRUColor */
+ case 0x01DB: /* BrtIndexedColor */
+ break;
+
+ case 0x0493: /* BrtDXF14 */
+ case 0x0836: /* BrtDXF15 */
+ case 0x046A: /* BrtSlicerStyleElement */
+ case 0x0200: /* BrtTableStyleElement */
+ case 0x082F: /* BrtTimelineStyleElement */
+ case 0x0C00: /* BrtUid */
+ break;
+
+ case 0x0023: /* BrtFRTBegin */
+ pass = true; break;
+ case 0x0024: /* BrtFRTEnd */
+ pass = false; break;
+ case 0x0025: /* BrtACBegin */
+ state.push(RT); pass = true; break;
+ case 0x0026: /* BrtACEnd */
+ state.pop(); pass = false; break;
+
+ default:
+ if(R.T > 0) state.push(RT);
+ else if(R.T < 0) state.pop();
+ else if(!pass || (opts.WTF && state[state.length-1] != 0x0025 /* BrtACBegin */)) throw new Error("Unexpected record 0x" + RT.toString(16));
+ }
+ });
+ return styles;
+}
+
+function write_FMTS_bin(ba, NF) {
+ if(!NF) return;
+ var cnt = 0;
+ [[5,8],[23,26],[41,44],[/*63*/50,/*66],[164,*/392]].forEach(function(r) {
+for(var i = r[0]; i <= r[1]; ++i) if(NF[i] != null) ++cnt;
+ });
+
+ if(cnt == 0) return;
+ write_record(ba, 0x0267 /* BrtBeginFmts */, write_UInt32LE(cnt));
+ [[5,8],[23,26],[41,44],[/*63*/50,/*66],[164,*/392]].forEach(function(r) {
+for(var i = r[0]; i <= r[1]; ++i) if(NF[i] != null) write_record(ba, 0x002C /* BrtFmt */, write_BrtFmt(i, NF[i]));
+ });
+ write_record(ba, 0x0268 /* BrtEndFmts */);
+}
+
+function write_FONTS_bin(ba) {
+ var cnt = 1;
+
+ if(cnt == 0) return;
+ write_record(ba, 0x0263 /* BrtBeginFonts */, write_UInt32LE(cnt));
+ write_record(ba, 0x002B /* BrtFont */, write_BrtFont({
+ sz:12,
+ color: {theme:1},
+ name: "Calibri",
+ family: 2,
+ scheme: "minor"
+ }));
+ /* 1*65491BrtFont [ACFONTS] */
+ write_record(ba, 0x0264 /* BrtEndFonts */);
+}
+
+function write_FILLS_bin(ba) {
+ var cnt = 2;
+
+ if(cnt == 0) return;
+ write_record(ba, 0x025B /* BrtBeginFills */, write_UInt32LE(cnt));
+ write_record(ba, 0x002D /* BrtFill */, write_BrtFill({patternType:"none"}));
+ write_record(ba, 0x002D /* BrtFill */, write_BrtFill({patternType:"gray125"}));
+ /* 1*65431BrtFill */
+ write_record(ba, 0x025C /* BrtEndFills */);
+}
+
+function write_BORDERS_bin(ba) {
+ var cnt = 1;
+
+ if(cnt == 0) return;
+ write_record(ba, 0x0265 /* BrtBeginBorders */, write_UInt32LE(cnt));
+ write_record(ba, 0x002E /* BrtBorder */, write_BrtBorder({}));
+ /* 1*65430BrtBorder */
+ write_record(ba, 0x0266 /* BrtEndBorders */);
+}
+
+function write_CELLSTYLEXFS_bin(ba) {
+ var cnt = 1;
+ write_record(ba, 0x0272 /* BrtBeginCellStyleXFs */, write_UInt32LE(cnt));
+ write_record(ba, 0x002F /* BrtXF */, write_BrtXF({
+ numFmtId: 0,
+ fontId: 0,
+ fillId: 0,
+ borderId: 0
+ }, 0xFFFF));
+ /* 1*65430(BrtXF *FRT) */
+ write_record(ba, 0x0273 /* BrtEndCellStyleXFs */);
+}
+
+function write_CELLXFS_bin(ba, data) {
+ write_record(ba, 0x0269 /* BrtBeginCellXFs */, write_UInt32LE(data.length));
+ data.forEach(function(c) { write_record(ba, 0x002F /* BrtXF */, write_BrtXF(c,0)); });
+ /* 1*65430(BrtXF *FRT) */
+ write_record(ba, 0x026A /* BrtEndCellXFs */);
+}
+
+function write_STYLES_bin(ba) {
+ var cnt = 1;
+
+ write_record(ba, 0x026B /* BrtBeginStyles */, write_UInt32LE(cnt));
+ write_record(ba, 0x0030 /* BrtStyle */, write_BrtStyle({
+ xfId:0,
+ builtinId:0,
+ name:"Normal"
+ }));
+ /* 1*65430(BrtStyle *FRT) */
+ write_record(ba, 0x026C /* BrtEndStyles */);
+}
+
+function write_DXFS_bin(ba) {
+ var cnt = 0;
+
+ write_record(ba, 0x01F9 /* BrtBeginDXFs */, write_UInt32LE(cnt));
+ /* *2147483647(BrtDXF *FRT) */
+ write_record(ba, 0x01FA /* BrtEndDXFs */);
+}
+
+function write_TABLESTYLES_bin(ba) {
+ var cnt = 0;
+
+ write_record(ba, 0x01FC /* BrtBeginTableStyles */, write_BrtBeginTableStyles(cnt, "TableStyleMedium9", "PivotStyleMedium4"));
+ /* *TABLESTYLE */
+ write_record(ba, 0x01FD /* BrtEndTableStyles */);
+}
+
+function write_COLORPALETTE_bin() {
+ return;
+ /* BrtBeginColorPalette [INDEXEDCOLORS] [MRUCOLORS] BrtEndColorPalette */
+}
+
+/* [MS-XLSB] 2.1.7.50 Styles */
+function write_sty_bin(wb, opts) {
+ var ba = buf_array();
+ write_record(ba, 0x0116 /* BrtBeginStyleSheet */);
+ write_FMTS_bin(ba, wb.SSF);
+ write_FONTS_bin(ba, wb);
+ write_FILLS_bin(ba, wb);
+ write_BORDERS_bin(ba, wb);
+ write_CELLSTYLEXFS_bin(ba, wb);
+ write_CELLXFS_bin(ba, opts.cellXfs);
+ write_STYLES_bin(ba, wb);
+ write_DXFS_bin(ba, wb);
+ write_TABLESTYLES_bin(ba, wb);
+ write_COLORPALETTE_bin(ba, wb);
+ /* FRTSTYLESHEET*/
+ write_record(ba, 0x0117 /* BrtEndStyleSheet */);
+ return ba.end();
+}
+/* Even though theme layout is dk1 lt1 dk2 lt2, true order is lt1 dk1 lt2 dk2 */
+var XLSXThemeClrScheme = [
+ '', '', '', '',
+ '', '', '',
+ '', '', '',
+ '', ''
+];
+/* 20.1.6.2 clrScheme CT_ColorScheme */
+function parse_clrScheme(t, themes, opts) {
+ themes.themeElements.clrScheme = [];
+ var color = {};
+ (t[0].match(tagregex)||[]).forEach(function(x) {
+ var y = parsexmltag(x);
+ switch(y[0]) {
+ /* 20.1.6.2 clrScheme (Color Scheme) CT_ColorScheme */
+ case '': break;
+
+ /* 20.1.2.3.32 srgbClr CT_SRgbColor */
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ case '': case '':
+ if (y[0].charAt(1) === '/') {
+ themes.themeElements.clrScheme[XLSXThemeClrScheme.indexOf(y[0])] = color;
+ color = {};
+ } else {
+ color.name = y[0].slice(3, y[0].length - 1);
+ }
+ break;
+
+ default: if(opts && opts.WTF) throw new Error('Unrecognized ' + y[0] + ' in clrScheme');
+ }
+ });
+}
+
+/* 20.1.4.1.18 fontScheme CT_FontScheme */
+function parse_fontScheme() { }
+
+/* 20.1.4.1.15 fmtScheme CT_StyleMatrix */
+function parse_fmtScheme() { }
+
+var clrsregex = /]*)>[\s\S]*<\/a:clrScheme>/;
+var fntsregex = /]*)>[\s\S]*<\/a:fontScheme>/;
+var fmtsregex = /]*)>[\s\S]*<\/a:fmtScheme>/;
+
+/* 20.1.6.10 themeElements CT_BaseStyles */
+function parse_themeElements(data, themes, opts) {
+ themes.themeElements = {};
+
+ var t;
+
+ [
+ /* clrScheme CT_ColorScheme */
+ ['clrScheme', clrsregex, parse_clrScheme],
+ /* fontScheme CT_FontScheme */
+ ['fontScheme', fntsregex, parse_fontScheme],
+ /* fmtScheme CT_StyleMatrix */
+ ['fmtScheme', fmtsregex, parse_fmtScheme]
+ ].forEach(function(m) {
+ if(!(t=data.match(m[1]))) throw new Error(m[0] + ' not found in themeElements');
+ m[2](t, themes, opts);
+ });
+}
+
+var themeltregex = /]*)>[\s\S]*<\/a:themeElements>/;
+
+/* 14.2.7 Theme Part */
+function parse_theme_xml(data, opts) {
+ /* 20.1.6.9 theme CT_OfficeStyleSheet */
+ if(!data || data.length === 0) data = write_theme();
+
+ var t;
+ var themes = {};
+
+ /* themeElements CT_BaseStyles */
+ if(!(t=data.match(themeltregex))) throw new Error('themeElements not found in theme');
+ parse_themeElements(t[0], themes, opts);
+ themes.raw = data;
+ return themes;
+}
+
+function write_theme(Themes, opts) {
+ if(opts && opts.themeXLSX) return opts.themeXLSX;
+ if(Themes && typeof Themes.raw == "string") return Themes.raw;
+ var o = [XML_HEADER];
+ o[o.length] = '';
+ o[o.length] = '';
+
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ o[o.length] = '';
+ return o.join("");
+}
+/* [MS-XLS] 2.4.326 TODO: payload is a zip file */
+function parse_Theme(blob, length, opts) {
+ var end = blob.l + length;
+ var dwThemeVersion = blob.read_shift(4);
+ if(dwThemeVersion === 124226) return;
+ if(!opts.cellStyles) { blob.l = end; return; }
+ var data = blob.slice(blob.l);
+ blob.l = end;
+ var zip; try { zip = zip_read(data, {type: "array"}); } catch(e) { return; }
+ var themeXML = getzipstr(zip, "theme/theme/theme1.xml", true);
+ if(!themeXML) return;
+ return parse_theme_xml(themeXML, opts);
+}
+
+/* 2.5.49 */
+function parse_ColorTheme(blob) { return blob.read_shift(4); }
+
+/* 2.5.155 */
+function parse_FullColorExt(blob) {
+ var o = {};
+ o.xclrType = blob.read_shift(2);
+ o.nTintShade = blob.read_shift(2);
+ switch(o.xclrType) {
+ case 0: blob.l += 4; break;
+ case 1: o.xclrValue = parse_IcvXF(blob, 4); break;
+ case 2: o.xclrValue = parse_LongRGBA(blob, 4); break;
+ case 3: o.xclrValue = parse_ColorTheme(blob, 4); break;
+ case 4: blob.l += 4; break;
+ }
+ blob.l += 8;
+ return o;
+}
+
+/* 2.5.164 TODO: read 7 bits*/
+function parse_IcvXF(blob, length) {
+ return parsenoop(blob, length);
+}
+
+/* 2.5.280 */
+function parse_XFExtGradient(blob, length) {
+ return parsenoop(blob, length);
+}
+
+/* [MS-XLS] 2.5.108 */
+function parse_ExtProp(blob) {
+ var extType = blob.read_shift(2);
+ var cb = blob.read_shift(2) - 4;
+ var o = [extType];
+ switch(extType) {
+ case 0x04: case 0x05: case 0x07: case 0x08:
+ case 0x09: case 0x0A: case 0x0B: case 0x0D:
+ o[1] = parse_FullColorExt(blob, cb); break;
+ case 0x06: o[1] = parse_XFExtGradient(blob, cb); break;
+ case 0x0E: case 0x0F: o[1] = blob.read_shift(cb === 1 ? 1 : 2); break;
+ default: throw new Error("Unrecognized ExtProp type: " + extType + " " + cb);
+ }
+ return o;
+}
+
+/* 2.4.355 */
+function parse_XFExt(blob, length) {
+ var end = blob.l + length;
+ blob.l += 2;
+ var ixfe = blob.read_shift(2);
+ blob.l += 2;
+ var cexts = blob.read_shift(2);
+ var ext = [];
+ while(cexts-- > 0) ext.push(parse_ExtProp(blob, end-blob.l));
+ return {ixfe:ixfe, ext:ext};
+}
+
+/* xf is an XF, see parse_XFExt for xfext */
+function update_xfext(xf, xfext) {
+ xfext.forEach(function(xfe) {
+ switch(xfe[0]) { /* 2.5.108 extPropData */
+ case 0x04: break; /* foreground color */
+ case 0x05: break; /* background color */
+ case 0x06: break; /* gradient fill */
+ case 0x07: break; /* top cell border color */
+ case 0x08: break; /* bottom cell border color */
+ case 0x09: break; /* left cell border color */
+ case 0x0a: break; /* right cell border color */
+ case 0x0b: break; /* diagonal cell border color */
+ case 0x0d: /* text color */
+ break;
+ case 0x0e: break; /* font scheme */
+ case 0x0f: break; /* indentation level */
+ }
+ });
+}
+
+function parse_BrtMdtinfo(data, length) {
+ return {
+ flags: data.read_shift(4),
+ version: data.read_shift(4),
+ name: parse_XLWideString(data, length - 8)
+ };
+}
+function write_BrtMdtinfo(data) {
+ var o = new_buf(12 + 2 * data.name.length);
+ o.write_shift(4, data.flags);
+ o.write_shift(4, data.version);
+ write_XLWideString(data.name, o);
+ return o.slice(0, o.l);
+}
+function parse_BrtMdb(data) {
+ var out = [];
+ var cnt = data.read_shift(4);
+ while (cnt-- > 0)
+ out.push([data.read_shift(4), data.read_shift(4)]);
+ return out;
+}
+function write_BrtMdb(mdb) {
+ var o = new_buf(4 + 8 * mdb.length);
+ o.write_shift(4, mdb.length);
+ for (var i = 0; i < mdb.length; ++i) {
+ o.write_shift(4, mdb[i][0]);
+ o.write_shift(4, mdb[i][1]);
+ }
+ return o;
+}
+function write_BrtBeginEsfmd(cnt, name) {
+ var o = new_buf(8 + 2 * name.length);
+ o.write_shift(4, cnt);
+ write_XLWideString(name, o);
+ return o.slice(0, o.l);
+}
+function parse_BrtBeginEsmdb(data) {
+ data.l += 4;
+ return data.read_shift(4) != 0;
+}
+function write_BrtBeginEsmdb(cnt, cm) {
+ var o = new_buf(8);
+ o.write_shift(4, cnt);
+ o.write_shift(4, cm ? 1 : 0);
+ return o;
+}
+function parse_xlmeta_bin(data, name, _opts) {
+ var out = { Types: [], Cell: [], Value: [] };
+ var opts = _opts || {};
+ var state = [];
+ var pass = false;
+ var metatype = 2;
+ recordhopper(data, function(val, R, RT) {
+ switch (RT) {
+ case 335:
+ out.Types.push({ name: val.name });
+ break;
+ case 51:
+ val.forEach(function(r) {
+ if (metatype == 1)
+ out.Cell.push({ type: out.Types[r[0] - 1].name, index: r[1] });
+ else if (metatype == 0)
+ out.Value.push({ type: out.Types[r[0] - 1].name, index: r[1] });
+ });
+ break;
+ case 337:
+ metatype = val ? 1 : 0;
+ break;
+ case 338:
+ metatype = 2;
+ break;
+ case 35:
+ state.push(RT);
+ pass = true;
+ break;
+ case 36:
+ state.pop();
+ pass = false;
+ break;
+ default:
+ if (R.T) {
+ } else if (!pass || opts.WTF && state[state.length - 1] != 35)
+ throw new Error("Unexpected record 0x" + RT.toString(16));
+ }
+ });
+ return out;
+}
+function write_xlmeta_bin() {
+ var ba = buf_array();
+ write_record(ba, 332);
+ write_record(ba, 334, write_UInt32LE(1));
+ write_record(ba, 335, write_BrtMdtinfo({
+ name: "XLDAPR",
+ version: 12e4,
+ flags: 3496657072
+ }));
+ write_record(ba, 336);
+ write_record(ba, 339, write_BrtBeginEsfmd(1, "XLDAPR"));
+ write_record(ba, 52);
+ write_record(ba, 35, write_UInt32LE(514));
+ write_record(ba, 4096, write_UInt32LE(0));
+ write_record(ba, 4097, writeuint16(1));
+ write_record(ba, 36);
+ write_record(ba, 53);
+ write_record(ba, 340);
+ write_record(ba, 337, write_BrtBeginEsmdb(1, true));
+ write_record(ba, 51, write_BrtMdb([[1, 0]]));
+ write_record(ba, 338);
+ write_record(ba, 333);
+ return ba.end();
+}
+function parse_xlmeta_xml(data, name, opts) {
+ var out = { Types: [], Cell: [], Value: [] };
+ if (!data)
+ return out;
+ var pass = false;
+ var metatype = 2;
+ var lastmeta;
+ data.replace(tagregex, function(x) {
+ var y = parsexmltag(x);
+ switch (strip_ns(y[0])) {
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ break;
+ case "":
+ metatype = 2;
+ break;
+ case "":
+ metatype = 2;
+ break;
+ case "":
+ case "":
+ case "":
+ break;
+ case "":
+ pass = false;
+ break;
+ case "\n |