@lyit/exceljs 4.4.1

package/dist/es5/xlsx/xlsx.js

@@ -0,0 +1,1109 @@
+"use strict";
+
+const fs = require('fs');
+const JSZip = require('jszip');
+const {
+  PassThrough
+} = require('readable-stream');
+const ZipStream = require('../utils/zip-stream');
+const StreamBuf = require('../utils/stream-buf');
+const utils = require('../utils/utils');
+const XmlStream = require('../utils/xml-stream');
+const {
+  bufferToString
+} = require('../utils/browser-buffer-decode');
+const StylesXform = require('./xform/style/styles-xform');
+const CoreXform = require('./xform/core/core-xform');
+const SharedStringsXform = require('./xform/strings/shared-strings-xform');
+const RelationshipsXform = require('./xform/core/relationships-xform');
+const ContentTypesXform = require('./xform/core/content-types-xform');
+const AppXform = require('./xform/core/app-xform');
+const WorkbookXform = require('./xform/book/workbook-xform');
+const WorksheetXform = require('./xform/sheet/worksheet-xform');
+const DrawingXform = require('./xform/drawing/drawing-xform');
+const TableXform = require('./xform/table/table-xform');
+const PivotCacheRecordsXform = require('./xform/pivot-table/pivot-cache-records-xform');
+const PivotCacheDefinitionXform = require('./xform/pivot-table/pivot-cache-definition-xform');
+const PivotTableXform = require('./xform/pivot-table/pivot-table-xform');
+const CommentsXform = require('./xform/comment/comments-xform');
+const VmlNotesXform = require('./xform/comment/vml-notes-xform');
+const CtrlPropXform = require('./xform/drawing/ctrl-prop-xform');
+const theme1Xml = require('./xml/theme1');
+const RelType = require('./rel-type');
+function fsReadFileAsync(filename, options) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(filename, options, (error, data) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(data);
+      }
+    });
+  });
+}
+class XLSX {
+  constructor(workbook) {
+    this.workbook = workbook;
+  }
+
+  // ===============================================================================
+  // Workbook
+  // =========================================================================
+  // Read
+
+  async readFile(filename, options) {
+    if (!(await utils.fs.exists(filename))) {
+      throw new Error(`File not found: ${filename}`);
+    }
+    const stream = fs.createReadStream(filename);
+    try {
+      const workbook = await this.read(stream, options);
+      stream.close();
+      return workbook;
+    } catch (error) {
+      stream.close();
+      throw error;
+    }
+  }
+  parseRels(stream) {
+    const xform = new RelationshipsXform();
+    return xform.parseStream(stream);
+  }
+  parseWorkbook(stream) {
+    const xform = new WorkbookXform();
+    return xform.parseStream(stream);
+  }
+  parseSharedStrings(stream) {
+    const xform = new SharedStringsXform();
+    return xform.parseStream(stream);
+  }
+  reconcile(model, options) {
+    const workbookXform = new WorkbookXform();
+    const worksheetXform = new WorksheetXform(options);
+    const drawingXform = new DrawingXform();
+    const tableXform = new TableXform();
+    workbookXform.reconcile(model);
+
+    // reconcile drawings with their rels
+    const drawingOptions = {
+      media: model.media,
+      mediaIndex: model.mediaIndex
+    };
+    Object.keys(model.drawings).forEach(name => {
+      const drawing = model.drawings[name];
+      const drawingRel = model.drawingRels[name];
+      if (drawingRel) {
+        drawingOptions.rels = drawingRel.reduce((o, rel) => {
+          o[rel.Id] = rel;
+          return o;
+        }, {});
+        (drawing.anchors || []).forEach(anchor => {
+          const hyperlinks = anchor.picture && anchor.picture.hyperlinks;
+          if (hyperlinks && drawingOptions.rels[hyperlinks.rId]) {
+            hyperlinks.hyperlink = drawingOptions.rels[hyperlinks.rId].Target;
+            delete hyperlinks.rId;
+          }
+        });
+        drawingXform.reconcile(drawing, drawingOptions);
+      }
+    });
+
+    // reconcile tables with the default styles
+    const tableOptions = {
+      styles: model.styles
+    };
+    Object.values(model.tables).forEach(table => {
+      tableXform.reconcile(table, tableOptions);
+    });
+    const sheetOptions = {
+      styles: model.styles,
+      sharedStrings: model.sharedStrings,
+      media: model.media,
+      mediaIndex: model.mediaIndex,
+      date1904: model.properties && model.properties.date1904,
+      drawings: model.drawings,
+      comments: model.comments,
+      tables: model.tables,
+      vmlDrawings: model.vmlDrawings,
+      preservedPivotTablesXml: model.preservedPivotTablesXml,
+      preservedPivotTablesRels: model.preservedPivotTablesRels,
+      preservedDrawingsXml: model.preservedDrawingsXml,
+      preservedDrawingsRels: model.preservedDrawingsRels
+    };
+    model.worksheets.forEach(worksheet => {
+      worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
+      worksheetXform.reconcile(worksheet, sheetOptions);
+    });
+
+    // Collect preserved pivot tables for write
+    model.preservedPivotTables = {
+      pivotTables: model.preservedPivotTablesXml,
+      pivotCacheDefinitions: model.preservedPivotCacheDefinitionsXml,
+      pivotCacheRecords: model.preservedPivotCacheRecordsXml
+    };
+
+    // Extract cache IDs from preserved pivot tables and create pivot cache entries
+    // These will be used by workbook-xform to write the <pivotCaches> section
+    const preservedCaches = [];
+    const cacheIdToFilename = {}; // Map cacheId to actual filename
+
+    // First, build a map of cacheId to definition filename by checking the pivot table rels
+    model.worksheets.forEach(worksheet => {
+      if (worksheet.pivotTables && worksheet.pivotTables.length > 0) {
+        worksheet.pivotTables.forEach(pivotTable => {
+          if (pivotTable.xml && pivotTable.rels) {
+            // Extract cacheId from the pivot table XML
+            const cacheIdMatch = pivotTable.xml.match(/cacheId="(\d+)"/);
+            if (cacheIdMatch) {
+              const cacheId = cacheIdMatch[1];
+              // Find the pivot cache definition relationship
+              // pivotTable.rels should have a relationship to the cache definition
+              const cacheDefRel = pivotTable.rels.find(rel => rel.Type === RelType.PivotCacheDefinition);
+              if (cacheDefRel) {
+                // Extract filename from Target like "../pivotCache/pivotCacheDefinition1.xml"
+                const targetMatch = cacheDefRel.Target.match(/pivotCacheDefinition\d+\.xml/);
+                if (targetMatch) {
+                  cacheIdToFilename[cacheId] = targetMatch[0];
+                }
+              }
+            }
+          }
+        });
+      }
+    });
+
+    // Now create the preserved cache entries with correct filenames
+    Object.keys(cacheIdToFilename).forEach(cacheId => {
+      preservedCaches.push({
+        cacheId,
+        definitionFilename: cacheIdToFilename[cacheId],
+        isPreserved: true
+      });
+    });
+    model.preservedPivotCaches = preservedCaches;
+
+    // delete unnecessary parts
+    delete model.worksheetHash;
+    delete model.worksheetRels;
+    delete model.globalRels;
+    delete model.sharedStrings;
+    delete model.workbookRels;
+    delete model.sheetDefs;
+    delete model.styles;
+    delete model.mediaIndex;
+    delete model.drawings;
+    delete model.drawingRels;
+    delete model.vmlDrawings;
+    delete model.preservedPivotTablesRels;
+    delete model.preservedPivotCacheDefinitionsRels;
+    // Keep the XML dictionaries through preservedPivotTables
+  }
+  async _processWorksheetEntry(stream, model, sheetNo, options, path) {
+    const xform = new WorksheetXform(options);
+    const worksheet = await xform.parseStream(stream);
+    worksheet.sheetNo = sheetNo;
+    model.worksheetHash[path] = worksheet;
+    model.worksheets.push(worksheet);
+  }
+  async _processCommentEntry(stream, model, name) {
+    const xform = new CommentsXform();
+    const comments = await xform.parseStream(stream);
+    model.comments[`../${name}.xml`] = comments;
+  }
+  async _processTableEntry(stream, model, name) {
+    const xform = new TableXform();
+    const table = await xform.parseStream(stream);
+    model.tables[`../tables/${name}.xml`] = table;
+  }
+  async _processWorksheetRelsEntry(stream, model, sheetNo) {
+    const xform = new RelationshipsXform();
+    const relationships = await xform.parseStream(stream);
+    model.worksheetRels[sheetNo] = relationships;
+  }
+  async _processMediaEntry(entry, model, filename) {
+    const lastDot = filename.lastIndexOf('.');
+    // if we can't determine extension, ignore it
+    if (lastDot >= 1) {
+      const extension = filename.substr(lastDot + 1);
+      const name = filename.substr(0, lastDot);
+      await new Promise((resolve, reject) => {
+        const streamBuf = new StreamBuf();
+        streamBuf.on('finish', () => {
+          model.mediaIndex[filename] = model.media.length;
+          model.mediaIndex[name] = model.media.length;
+          const medium = {
+            type: 'image',
+            name,
+            extension,
+            buffer: streamBuf.toBuffer()
+          };
+          model.media.push(medium);
+          resolve();
+        });
+        entry.on('error', error => {
+          reject(error);
+        });
+        entry.pipe(streamBuf);
+      });
+    }
+  }
+  async _processDrawingEntry(entry, model, name) {
+    // Check if drawing contains chart references
+    const xml = await entry.async('string');
+    const hasChart = xml.includes('drawingml/2006/chart');
+    if (hasChart) {
+      // Preserve as raw XML if it contains charts
+      model.preservedDrawingsXml[name] = xml;
+    } else {
+      // Parse normally for images and other content
+      // Re-create a stream from the XML we already read using StreamBuf
+      const stream = new StreamBuf();
+      stream.write(xml);
+      stream.end();
+      const xform = new DrawingXform();
+      const drawing = await xform.parseStream(stream);
+      model.drawings[name] = drawing;
+    }
+  }
+  async _processDrawingRelsEntry(entry, model, name) {
+    const xform = new RelationshipsXform();
+    const relationships = await xform.parseStream(entry);
+    model.drawingRels[name] = relationships;
+
+    // Also preserve raw relationships for preserved drawings
+    if (model.preservedDrawingsXml[name]) {
+      model.preservedDrawingsRels[name] = relationships;
+    }
+  }
+  async _processVmlDrawingEntry(entry, model, name) {
+    const xform = new VmlNotesXform();
+    const vmlDrawing = await xform.parseStream(entry);
+    model.vmlDrawings[`../drawings/${name}.vml`] = vmlDrawing;
+  }
+  async _processPivotTableEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedPivotTablesXml[name] = xml;
+  }
+  async _processPivotTableRelsEntry(stream, model, name) {
+    const xform = new RelationshipsXform();
+    const relationships = await xform.parseStream(stream);
+    model.preservedPivotTablesRels[name] = relationships;
+  }
+  async _processPivotCacheDefinitionEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedPivotCacheDefinitionsXml[name] = xml;
+  }
+  async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
+    const xform = new RelationshipsXform();
+    const relationships = await xform.parseStream(stream);
+    model.preservedPivotCacheDefinitionsRels[name] = relationships;
+  }
+  async _processPivotCacheRecordsEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedPivotCacheRecordsXml[name] = xml;
+  }
+  async _processChartEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedChartsXml[name] = xml;
+  }
+  async _processChartRelsEntry(stream, model, name) {
+    const xform = new RelationshipsXform();
+    const relationships = await xform.parseStream(stream);
+    model.preservedChartsRels[name] = relationships;
+  }
+  async _processChartStyleEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedChartStylesXml[name] = xml;
+  }
+  async _processChartColorsEntry(zipEntry, model, name) {
+    // Read XML directly from zip entry
+    const xml = await zipEntry.async('string');
+    model.preservedChartColorsXml[name] = xml;
+  }
+  async _processThemeEntry(entry, model, name) {
+    await new Promise((resolve, reject) => {
+      // TODO: stream entry into buffer and store the xml in the model.themes[]
+      const stream = new StreamBuf();
+      entry.on('error', reject);
+      stream.on('error', reject);
+      stream.on('finish', () => {
+        model.themes[name] = stream.read().toString();
+        resolve();
+      });
+      entry.pipe(stream);
+    });
+  }
+
+  /**
+   * @deprecated since version 4.0. You should use `#read` instead. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md
+   */
+  createInputStream() {
+    throw new Error('`XLSX#createInputStream` is deprecated. You should use `XLSX#read` instead. This method will be removed in version 5.0. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md');
+  }
+  async read(stream, options) {
+    // TODO: Remove once node v8 is deprecated
+    // Detect and upgrade old streams
+    if (!stream[Symbol.asyncIterator] && stream.pipe) {
+      stream = stream.pipe(new PassThrough());
+    }
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+    return this.load(Buffer.concat(chunks), options);
+  }
+  async load(data, options) {
+    let buffer;
+    if (options && options.base64) {
+      buffer = Buffer.from(data.toString(), 'base64');
+    } else {
+      buffer = data;
+    }
+    const model = {
+      worksheets: [],
+      worksheetHash: {},
+      worksheetRels: [],
+      themes: {},
+      media: [],
+      mediaIndex: {},
+      drawings: {},
+      drawingRels: {},
+      comments: {},
+      tables: {},
+      vmlDrawings: {},
+      pivotTables: [],
+      // Keep as array for programmatic pivots
+      preservedPivotTablesXml: {},
+      preservedPivotTablesRels: {},
+      preservedPivotCacheDefinitionsXml: {},
+      preservedPivotCacheDefinitionsRels: {},
+      preservedPivotCacheRecordsXml: {},
+      preservedChartsXml: {},
+      preservedChartsRels: {},
+      preservedChartStylesXml: {},
+      preservedChartColorsXml: {},
+      preservedDrawingsXml: {},
+      preservedDrawingsRels: {}
+    };
+    const zip = await JSZip.loadAsync(buffer);
+    for (const entry of Object.values(zip.files)) {
+      /* eslint-disable no-await-in-loop */
+      if (!entry.dir) {
+        let entryName = entry.name;
+        if (entryName[0] === '/') {
+          entryName = entryName.substr(1);
+        }
+        let stream;
+        if (entryName.match(/xl\/media\//) ||
+        // themes are not parsed as stream
+        entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/)) {
+          stream = new PassThrough();
+          stream.write(await entry.async('nodebuffer'));
+        } else {
+          // use object mode to avoid buffer-string convention
+          stream = new PassThrough({
+            writableObjectMode: true,
+            readableObjectMode: true
+          });
+          let content;
+          // https://www.npmjs.com/package/process
+          if (process.browser) {
+            // running in browser, use TextDecoder if possible
+            content = bufferToString(await entry.async('nodebuffer'));
+          } else {
+            // running in node.js
+            content = await entry.async('string');
+          }
+          const chunkSize = 16 * 1024;
+          for (let i = 0; i < content.length; i += chunkSize) {
+            stream.write(content.substring(i, i + chunkSize));
+          }
+        }
+        stream.end();
+        switch (entryName) {
+          case '_rels/.rels':
+            model.globalRels = await this.parseRels(stream);
+            break;
+          case 'xl/workbook.xml':
+            {
+              const workbook = await this.parseWorkbook(stream);
+              if (workbook) {
+                model.sheets = workbook.sheets;
+                model.definedNames = workbook.definedNames;
+                model.views = workbook.views;
+                model.properties = workbook.properties;
+                model.calcProperties = workbook.calcProperties;
+              }
+              break;
+            }
+          case 'xl/_rels/workbook.xml.rels':
+            model.workbookRels = await this.parseRels(stream);
+            break;
+          case 'xl/sharedStrings.xml':
+            model.sharedStrings = new SharedStringsXform();
+            await model.sharedStrings.parseStream(stream);
+            break;
+          case 'xl/styles.xml':
+            model.styles = new StylesXform();
+            await model.styles.parseStream(stream);
+            break;
+          case 'docProps/app.xml':
+            {
+              const appXform = new AppXform();
+              const appProperties = await appXform.parseStream(stream);
+              if (appProperties) {
+                model.company = appProperties.company;
+                model.manager = appProperties.manager;
+              }
+              break;
+            }
+          case 'docProps/core.xml':
+            {
+              const coreXform = new CoreXform();
+              const coreProperties = await coreXform.parseStream(stream);
+              if (coreProperties) {
+                Object.assign(model, coreProperties);
+              }
+              break;
+            }
+          default:
+            {
+              let match = entryName.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
+              if (match) {
+                await this._processWorksheetEntry(stream, model, match[1], options, entryName);
+                break;
+              }
+              match = entryName.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/);
+              if (match) {
+                await this._processWorksheetRelsEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/);
+              if (match) {
+                await this._processThemeEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/media\/([a-zA-Z0-9]+[.][a-zA-Z0-9]{3,4})$/);
+              if (match) {
+                await this._processMediaEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/drawings\/([a-zA-Z0-9]+)[.]xml/);
+              if (match) {
+                await this._processDrawingEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/(comments\d+)[.]xml/);
+              if (match) {
+                await this._processCommentEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/tables\/(table\d+)[.]xml/);
+              if (match) {
+                await this._processTableEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/drawings\/_rels\/([a-zA-Z0-9]+)[.]xml[.]rels/);
+              if (match) {
+                await this._processDrawingRelsEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/drawings\/(vmlDrawing\d+)[.]vml/);
+              if (match) {
+                await this._processVmlDrawingEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
+              if (match) {
+                await this._processPivotTableEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
+              if (match) {
+                await this._processPivotTableRelsEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
+              if (match) {
+                await this._processPivotCacheDefinitionEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
+              if (match) {
+                await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
+              if (match) {
+                await this._processPivotCacheRecordsEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/charts\/(chart\d+)[.]xml/);
+              if (match) {
+                await this._processChartEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/charts\/_rels\/(chart\d+)[.]xml[.]rels/);
+              if (match) {
+                await this._processChartRelsEntry(stream, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/charts\/(style\d+)[.]xml/);
+              if (match) {
+                await this._processChartStyleEntry(entry, model, match[1]);
+                break;
+              }
+              match = entryName.match(/xl\/charts\/(colors\d+)[.]xml/);
+              if (match) {
+                await this._processChartColorsEntry(entry, model, match[1]);
+                break;
+              }
+            }
+        }
+      }
+    }
+    this.reconcile(model, options);
+
+    // apply model
+    this.workbook.model = model;
+    return this.workbook;
+  }
+
+  // =========================================================================
+  // Write
+
+  async addMedia(zip, model) {
+    await Promise.all(model.media.map(async medium => {
+      if (medium.type === 'image') {
+        const filename = `xl/media/${medium.name}.${medium.extension}`;
+        if (medium.filename) {
+          const data = await fsReadFileAsync(medium.filename);
+          return zip.append(data, {
+            name: filename
+          });
+        }
+        if (medium.buffer) {
+          return zip.append(medium.buffer, {
+            name: filename
+          });
+        }
+        if (medium.base64) {
+          const dataimg64 = medium.base64;
+          const content = dataimg64.substring(dataimg64.indexOf(',') + 1);
+          return zip.append(content, {
+            name: filename,
+            base64: true
+          });
+        }
+      }
+      throw new Error('Unsupported media');
+    }));
+  }
+  addDrawings(zip, model) {
+    const drawingXform = new DrawingXform();
+    const relsXform = new RelationshipsXform();
+
+    // First add preserved drawings (with charts)
+    if (model.preservedDrawingsXml) {
+      Object.keys(model.preservedDrawingsXml).forEach(name => {
+        zip.append(model.preservedDrawingsXml[name], {
+          name: `xl/drawings/${name}.xml`
+        });
+      });
+    }
+    if (model.preservedDrawingsRels) {
+      Object.keys(model.preservedDrawingsRels).forEach(name => {
+        const xml = relsXform.toXml(model.preservedDrawingsRels[name]);
+        zip.append(xml, {
+          name: `xl/drawings/_rels/${name}.xml.rels`
+        });
+      });
+    }
+
+    // Then add programmatic drawings
+    model.worksheets.forEach(worksheet => {
+      const {
+        drawing,
+        preservedDrawing
+      } = worksheet;
+      // Skip if this is a preserved drawing (already written above)
+      if (drawing && !preservedDrawing) {
+        drawingXform.prepare(drawing, {});
+        let xml = drawingXform.toXml(drawing);
+        zip.append(xml, {
+          name: `xl/drawings/${drawing.name}.xml`
+        });
+        xml = relsXform.toXml(drawing.rels);
+        zip.append(xml, {
+          name: `xl/drawings/_rels/${drawing.name}.xml.rels`
+        });
+      }
+    });
+  }
+  addTables(zip, model) {
+    const tableXform = new TableXform();
+    model.worksheets.forEach(worksheet => {
+      const {
+        tables
+      } = worksheet;
+      tables.forEach(table => {
+        tableXform.prepare(table, {});
+        const tableXml = tableXform.toXml(table);
+        zip.append(tableXml, {
+          name: `xl/tables/${table.target}`
+        });
+      });
+    });
+  }
+  addCtrlProps(zip, model) {
+    if (!model.formControlRefs || !model.formControlRefs.length) return;
+    const ctrlPropXform = new CtrlPropXform();
+    model.formControlRefs.forEach(ref => {
+      const ctrlPropXml = ctrlPropXform.toXml(ref.model);
+      zip.append(ctrlPropXml, {
+        name: `xl/ctrlProps/ctrlProp${ref.id}.xml`
+      });
+    });
+  }
+  addPivotTables(zip, model) {
+    const hasProgrammaticPivots = model.pivotTables && model.pivotTables.length > 0;
+    const hasPreservedPivots = model.preservedPivotTables && Object.keys(model.preservedPivotTables.pivotTables || {}).length > 0;
+    if (!hasProgrammaticPivots && !hasPreservedPivots) return;
+    const pivotCacheRecordsXform = new PivotCacheRecordsXform();
+    const pivotCacheDefinitionXform = new PivotCacheDefinitionXform();
+    const pivotTableXform = new PivotTableXform();
+    const relsXform = new RelationshipsXform();
+
+    // First, write preserved pivot tables (from round-trip)
+    if (hasPreservedPivots) {
+      const preserved = model.preservedPivotTables;
+
+      // Write pivot tables
+      Object.keys(preserved.pivotTables).forEach(name => {
+        zip.append(preserved.pivotTables[name], {
+          name: `xl/pivotTables/${name}.xml`
+        });
+      });
+
+      // Write pivot cache definitions
+      Object.keys(preserved.pivotCacheDefinitions).forEach(name => {
+        zip.append(preserved.pivotCacheDefinitions[name], {
+          name: `xl/pivotCache/${name}.xml`
+        });
+      });
+
+      // Write pivot cache records
+      Object.keys(preserved.pivotCacheRecords).forEach(name => {
+        zip.append(preserved.pivotCacheRecords[name], {
+          name: `xl/pivotCache/${name}.xml`
+        });
+      });
+
+      // Write rels for pivot tables
+      Object.keys(preserved.pivotTables).forEach(name => {
+        const tableNum = name.match(/\d+/)[0];
+        const xml = relsXform.toXml([{
+          Id: 'rId1',
+          Type: XLSX.RelType.PivotCacheDefinition,
+          Target: `../pivotCache/pivotCacheDefinition${tableNum}.xml`
+        }]);
+        zip.append(xml, {
+          name: `xl/pivotTables/_rels/${name}.xml.rels`
+        });
+      });
+
+      // Write rels for pivot cache definitions
+      Object.keys(preserved.pivotCacheDefinitions).forEach(name => {
+        const tableNum = name.match(/\d+/)[0];
+        const xml = relsXform.toXml([{
+          Id: 'rId1',
+          Type: XLSX.RelType.PivotCacheRecords,
+          Target: `pivotCacheRecords${tableNum}.xml`
+        }]);
+        zip.append(xml, {
+          name: `xl/pivotCache/_rels/${name}.xml.rels`
+        });
+      });
+    }
+
+    // Then, process programmatic pivot tables
+    if (!hasProgrammaticPivots) return;
+
+    // Process each pivot table
+    model.pivotTables.forEach((pivotTable, index) => {
+      const tableNum = index + 1;
+
+      // pivot cache records
+      // --------------------------------------------------
+      // copy of the source data.
+      //
+      // Note: cells in the columns of the source data which are part
+      // of the "rows" or "columns" of the pivot table configuration are
+      // replaced by references to their __cache field__ identifiers.
+      // See "pivot cache definition" below.
+
+      let xml = pivotCacheRecordsXform.toXml(pivotTable);
+      zip.append(xml, {
+        name: `xl/pivotCache/pivotCacheRecords${tableNum}.xml`
+      });
+
+      // pivot cache definition
+      // --------------------------------------------------
+      // cache source (source data):
+      //    ref="A1:E7" on sheet="Sheet1"
+      // cache fields:
+      //    - 0: "A" (a1, a2, a3)
+      //    - 1: "B" (b1, b2)
+      //    - ...
+
+      xml = pivotCacheDefinitionXform.toXml(pivotTable);
+      zip.append(xml, {
+        name: `xl/pivotCache/pivotCacheDefinition${tableNum}.xml`
+      });
+      xml = relsXform.toXml([{
+        Id: 'rId1',
+        Type: XLSX.RelType.PivotCacheRecords,
+        Target: `pivotCacheRecords${tableNum}.xml`
+      }]);
+      zip.append(xml, {
+        name: `xl/pivotCache/_rels/pivotCacheDefinition${tableNum}.xml.rels`
+      });
+
+      // pivot tables (on destination worksheet)
+      // --------------------------------------------------
+      // location: ref="A3:E15"
+      // pivotFields
+      // rowFields and rowItems
+      // colFields and colItems
+      // dataFields
+      // pivotTableStyleInfo
+
+      xml = pivotTableXform.toXml(pivotTable);
+      zip.append(xml, {
+        name: `xl/pivotTables/pivotTable${tableNum}.xml`
+      });
+      xml = relsXform.toXml([{
+        Id: 'rId1',
+        Type: XLSX.RelType.PivotCacheDefinition,
+        Target: `../pivotCache/pivotCacheDefinition${tableNum}.xml`
+      }]);
+      zip.append(xml, {
+        name: `xl/pivotTables/_rels/pivotTable${tableNum}.xml.rels`
+      });
+    });
+  }
+  addCharts(zip, model) {
+    const hasPreservedCharts = model.preservedChartsXml && Object.keys(model.preservedChartsXml).length > 0;
+    if (!hasPreservedCharts) return;
+    const relsXform = new RelationshipsXform();
+
+    // Write chart XML files
+    Object.keys(model.preservedChartsXml).forEach(name => {
+      zip.append(model.preservedChartsXml[name], {
+        name: `xl/charts/${name}.xml`
+      });
+    });
+
+    // Write chart relationship files
+    Object.keys(model.preservedChartsRels || {}).forEach(name => {
+      const xml = relsXform.toXml(model.preservedChartsRels[name]);
+      zip.append(xml, {
+        name: `xl/charts/_rels/${name}.xml.rels`
+      });
+    });
+
+    // Write chart style files
+    Object.keys(model.preservedChartStylesXml || {}).forEach(name => {
+      zip.append(model.preservedChartStylesXml[name], {
+        name: `xl/charts/${name}.xml`
+      });
+    });
+
+    // Write chart colors files
+    Object.keys(model.preservedChartColorsXml || {}).forEach(name => {
+      zip.append(model.preservedChartColorsXml[name], {
+        name: `xl/charts/${name}.xml`
+      });
+    });
+  }
+  async addContentTypes(zip, model) {
+    const xform = new ContentTypesXform();
+    const xml = xform.toXml(model);
+    zip.append(xml, {
+      name: '[Content_Types].xml'
+    });
+  }
+  async addApp(zip, model) {
+    const xform = new AppXform();
+    const xml = xform.toXml(model);
+    zip.append(xml, {
+      name: 'docProps/app.xml'
+    });
+  }
+  async addCore(zip, model) {
+    const coreXform = new CoreXform();
+    zip.append(coreXform.toXml(model), {
+      name: 'docProps/core.xml'
+    });
+  }
+  async addThemes(zip, model) {
+    const themes = model.themes || {
+      theme1: theme1Xml
+    };
+    Object.keys(themes).forEach(name => {
+      const xml = themes[name];
+      const path = `xl/theme/${name}.xml`;
+      zip.append(xml, {
+        name: path
+      });
+    });
+  }
+  async addOfficeRels(zip) {
+    const xform = new RelationshipsXform();
+    const xml = xform.toXml([{
+      Id: 'rId1',
+      Type: XLSX.RelType.OfficeDocument,
+      Target: 'xl/workbook.xml'
+    }, {
+      Id: 'rId2',
+      Type: XLSX.RelType.CoreProperties,
+      Target: 'docProps/core.xml'
+    }, {
+      Id: 'rId3',
+      Type: XLSX.RelType.ExtenderProperties,
+      Target: 'docProps/app.xml'
+    }]);
+    zip.append(xml, {
+      name: '_rels/.rels'
+    });
+  }
+  async addWorkbookRels(zip, model) {
+    let count = 1;
+    const relationships = [{
+      Id: `rId${count++}`,
+      Type: XLSX.RelType.Styles,
+      Target: 'styles.xml'
+    }, {
+      Id: `rId${count++}`,
+      Type: XLSX.RelType.Theme,
+      Target: 'theme/theme1.xml'
+    }];
+    if (model.sharedStrings.count) {
+      relationships.push({
+        Id: `rId${count++}`,
+        Type: XLSX.RelType.SharedStrings,
+        Target: 'sharedStrings.xml'
+      });
+    }
+    // Add relationships for programmatic pivot tables
+    if ((model.pivotTables || []).length) {
+      model.pivotTables.forEach((pivotTable, index) => {
+        const tableNum = index + 1;
+        pivotTable.rId = `rId${count++}`;
+        relationships.push({
+          Id: pivotTable.rId,
+          Type: XLSX.RelType.PivotCacheDefinition,
+          Target: `pivotCache/pivotCacheDefinition${tableNum}.xml`
+        });
+      });
+    }
+
+    // Add relationships for preserved pivot tables (from round-trip)
+    if (model.preservedPivotCaches && model.preservedPivotCaches.length) {
+      model.preservedPivotCaches.forEach(cache => {
+        cache.rId = `rId${count++}`;
+        relationships.push({
+          Id: cache.rId,
+          Type: XLSX.RelType.PivotCacheDefinition,
+          Target: `pivotCache/${cache.definitionFilename}`
+        });
+      });
+    }
+    model.worksheets.forEach(worksheet => {
+      worksheet.rId = `rId${count++}`;
+      relationships.push({
+        Id: worksheet.rId,
+        Type: XLSX.RelType.Worksheet,
+        Target: `worksheets/sheet${worksheet.id}.xml`
+      });
+    });
+    const xform = new RelationshipsXform();
+    const xml = xform.toXml(relationships);
+    zip.append(xml, {
+      name: 'xl/_rels/workbook.xml.rels'
+    });
+  }
+  async addSharedStrings(zip, model) {
+    if (model.sharedStrings && model.sharedStrings.count) {
+      zip.append(model.sharedStrings.xml, {
+        name: 'xl/sharedStrings.xml'
+      });
+    }
+  }
+  async addStyles(zip, model) {
+    const {
+      xml
+    } = model.styles;
+    if (xml) {
+      zip.append(xml, {
+        name: 'xl/styles.xml'
+      });
+    }
+  }
+  async addWorkbook(zip, model) {
+    const xform = new WorkbookXform();
+    zip.append(xform.toXml(model), {
+      name: 'xl/workbook.xml'
+    });
+  }
+  async addWorksheets(zip, model) {
+    // preparation phase
+    const worksheetXform = new WorksheetXform();
+    const relationshipsXform = new RelationshipsXform();
+    const commentsXform = new CommentsXform();
+    const vmlNotesXform = new VmlNotesXform();
+
+    // write sheets
+    model.worksheets.forEach(worksheet => {
+      let xmlStream = new XmlStream();
+      worksheetXform.render(xmlStream, worksheet);
+      zip.append(xmlStream.xml, {
+        name: `xl/worksheets/sheet${worksheet.id}.xml`
+      });
+      if (worksheet.rels && worksheet.rels.length) {
+        xmlStream = new XmlStream();
+        relationshipsXform.render(xmlStream, worksheet.rels);
+        zip.append(xmlStream.xml, {
+          name: `xl/worksheets/_rels/sheet${worksheet.id}.xml.rels`
+        });
+      }
+      if (worksheet.comments.length > 0) {
+        xmlStream = new XmlStream();
+        commentsXform.render(xmlStream, worksheet);
+        zip.append(xmlStream.xml, {
+          name: `xl/comments${worksheet.id}.xml`
+        });
+        xmlStream = new XmlStream();
+        vmlNotesXform.render(xmlStream, worksheet);
+        zip.append(xmlStream.xml, {
+          name: `xl/drawings/vmlDrawing${worksheet.id}.vml`
+        });
+      } else if (worksheet.formControls && worksheet.formControls.length > 0) {
+        // VML file for form controls (no comments)
+        xmlStream = new XmlStream();
+        vmlNotesXform.render(xmlStream, worksheet);
+        zip.append(xmlStream.xml, {
+          name: `xl/drawings/vmlDrawing${worksheet.id}.vml`
+        });
+      }
+    });
+  }
+  _finalize(zip) {
+    return new Promise((resolve, reject) => {
+      zip.on('finish', () => {
+        resolve(this);
+      });
+      zip.on('error', reject);
+      zip.finalize();
+    });
+  }
+  prepareModel(model, options) {
+    // ensure following properties have sane values
+    model.creator = model.creator || 'ExcelJS';
+    model.lastModifiedBy = model.lastModifiedBy || 'ExcelJS';
+    model.created = model.created || new Date();
+    model.modified = model.modified || new Date();
+    model.useSharedStrings = options.useSharedStrings !== undefined ? options.useSharedStrings : true;
+    model.useStyles = options.useStyles !== undefined ? options.useStyles : true;
+
+    // Manage the shared strings
+    model.sharedStrings = new SharedStringsXform();
+
+    // add a style manager to handle cell formats, fonts, etc.
+    model.styles = model.useStyles ? new StylesXform(true) : new StylesXform.Mock();
+
+    // prepare all of the things before the render
+    const workbookXform = new WorkbookXform();
+    const worksheetXform = new WorksheetXform();
+    workbookXform.prepare(model);
+    const worksheetOptions = {
+      sharedStrings: model.sharedStrings,
+      styles: model.styles,
+      date1904: model.properties.date1904,
+      drawingsCount: 0,
+      media: model.media
+    };
+    worksheetOptions.drawings = model.drawings = [];
+    worksheetOptions.commentRefs = model.commentRefs = [];
+    worksheetOptions.formControlRefs = model.formControlRefs = [];
+    let tableCount = 0;
+    model.tables = [];
+    model.worksheets.forEach(worksheet => {
+      // assign unique filenames to tables
+      worksheet.tables.forEach(table => {
+        tableCount++;
+        table.target = `table${tableCount}.xml`;
+        table.id = tableCount;
+        model.tables.push(table);
+      });
+      worksheetXform.prepare(worksheet, worksheetOptions);
+    });
+
+    // TODO: workbook drawing list
+  }
+  async write(stream, options) {
+    options = options || {};
+    const {
+      model
+    } = this.workbook;
+    const zip = new ZipStream.ZipWriter(options.zip);
+    zip.pipe(stream);
+    this.prepareModel(model, options);
+
+    // render
+    await this.addContentTypes(zip, model);
+    await this.addOfficeRels(zip, model);
+    await this.addWorkbookRels(zip, model);
+    await this.addWorksheets(zip, model);
+    await this.addSharedStrings(zip, model); // always after worksheets
+    await this.addDrawings(zip, model);
+    await this.addTables(zip, model);
+    await this.addCtrlProps(zip, model);
+    await this.addPivotTables(zip, model);
+    await this.addCharts(zip, model);
+    await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
+    await this.addMedia(zip, model);
+    await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
+    await this.addWorkbook(zip, model);
+    return this._finalize(zip);
+  }
+  writeFile(filename, options) {
+    const stream = fs.createWriteStream(filename);
+    return new Promise((resolve, reject) => {
+      stream.on('finish', () => {
+        resolve();
+      });
+      stream.on('error', error => {
+        reject(error);
+      });
+      this.write(stream, options).then(() => {
+        stream.end();
+      }).catch(err => {
+        reject(err);
+      });
+    });
+  }
+  async writeBuffer(options) {
+    const stream = new StreamBuf();
+    await this.write(stream, options);
+    return stream.read();
+  }
+}
+XLSX.RelType = require('./rel-type');
+module.exports = XLSX;
+//# sourceMappingURL=xlsx.js.map