@alienkarma/exceljs 4.4.0-fork.1

package/lib/utils/auto-drain.js

@@ -0,0 +1,15 @@
+const {EventEmitter} = require('events');
+
+// =============================================================================
+// AutoDrain - kind of /dev/null
+class AutoDrain extends EventEmitter {
+  write(chunk) {
+    this.emit('data', chunk);
+  }
+
+  end() {
+    this.emit('end');
+  }
+}
+
+module.exports = AutoDrain;

package/lib/utils/browser-buffer-decode.js

@@ -0,0 +1,14 @@
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const textDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8');
+
+function bufferToString(chunk) {
+  if (typeof chunk === 'string') {
+    return chunk;
+  }
+  if (textDecoder) {
+    return textDecoder.decode(chunk);
+  }
+  return chunk.toString();
+}
+
+exports.bufferToString = bufferToString;

package/lib/utils/browser-buffer-encode.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const textEncoder = typeof TextEncoder === 'undefined' ? null : new TextEncoder('utf-8');
+const {Buffer} = require('buffer');
+
+function stringToBuffer(str) {
+  if (typeof str !== 'string') {
+    return str;
+  }
+  if (textEncoder) {
+    return Buffer.from(textEncoder.encode(str).buffer);
+  }
+  return Buffer.from(str);
+}
+
+exports.stringToBuffer = stringToBuffer;

package/lib/utils/cell-matrix.js

@@ -0,0 +1,165 @@
+const _ = require('./under-dash');
+const colCache = require('./col-cache');
+
+class CellMatrix {
+  constructor(template) {
+    this.template = template;
+    this.sheets = {};
+  }
+
+  addCell(addressStr) {
+    this.addCellEx(colCache.decodeEx(addressStr));
+  }
+
+  getCell(addressStr) {
+    return this.findCellEx(colCache.decodeEx(addressStr), true);
+  }
+
+  findCell(addressStr) {
+    return this.findCellEx(colCache.decodeEx(addressStr), false);
+  }
+
+  findCellAt(sheetName, rowNumber, colNumber) {
+    const sheet = this.sheets[sheetName];
+    const row = sheet && sheet[rowNumber];
+    return row && row[colNumber];
+  }
+
+  addCellEx(address) {
+    if (address.top) {
+      for (let row = address.top; row <= address.bottom; row++) {
+        for (let col = address.left; col <= address.right; col++) {
+          this.getCellAt(address.sheetName, row, col);
+        }
+      }
+    } else {
+      this.findCellEx(address, true);
+    }
+  }
+
+  getCellEx(address) {
+    return this.findCellEx(address, true);
+  }
+
+  findCellEx(address, create) {
+    const sheet = this.findSheet(address, create);
+    const row = this.findSheetRow(sheet, address, create);
+    return this.findRowCell(row, address, create);
+  }
+
+  getCellAt(sheetName, rowNumber, colNumber) {
+    const sheet = this.sheets[sheetName] || (this.sheets[sheetName] = []);
+    const row = sheet[rowNumber] || (sheet[rowNumber] = []);
+    const cell =
+      row[colNumber] ||
+      (row[colNumber] = {
+        sheetName,
+        address: colCache.n2l(colNumber) + rowNumber,
+        row: rowNumber,
+        col: colNumber,
+      });
+    return cell;
+  }
+
+  removeCellEx(address) {
+    const sheet = this.findSheet(address);
+    if (!sheet) {
+      return;
+    }
+    const row = this.findSheetRow(sheet, address);
+    if (!row) {
+      return;
+    }
+    delete row[address.col];
+  }
+
+  forEachInSheet(sheetName, callback) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      sheet.forEach((row, rowNumber) => {
+        if (row) {
+          row.forEach((cell, colNumber) => {
+            if (cell) {
+              callback(cell, rowNumber, colNumber);
+            }
+          });
+        }
+      });
+    }
+  }
+
+  forEach(callback) {
+    _.each(this.sheets, (sheet, sheetName) => {
+      this.forEachInSheet(sheetName, callback);
+    });
+  }
+
+  map(callback) {
+    const results = [];
+    this.forEach(cell => {
+      results.push(callback(cell));
+    });
+    return results;
+  }
+
+  findSheet(address, create) {
+    const name = address.sheetName;
+    if (this.sheets[name]) {
+      return this.sheets[name];
+    }
+    if (create) {
+      return (this.sheets[name] = []);
+    }
+    return undefined;
+  }
+
+  findSheetRow(sheet, address, create) {
+    const {row} = address;
+    if (sheet && sheet[row]) {
+      return sheet[row];
+    }
+    if (create) {
+      return (sheet[row] = []);
+    }
+    return undefined;
+  }
+
+  findRowCell(row, address, create) {
+    const {col} = address;
+    if (row && row[col]) {
+      return row[col];
+    }
+    if (create) {
+      return (row[col] = this.template
+        ? Object.assign(address, JSON.parse(JSON.stringify(this.template)))
+        : address);
+    }
+    return undefined;
+  }
+
+  spliceRows(sheetName, start, numDelete, numInsert) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      const inserts = [];
+      for (let i = 0; i < numInsert; i++) {
+        inserts.push([]);
+      }
+      sheet.splice(start, numDelete, ...inserts);
+    }
+  }
+
+  spliceColumns(sheetName, start, numDelete, numInsert) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      const inserts = [];
+      for (let i = 0; i < numInsert; i++) {
+        inserts.push(null);
+      }
+      _.each(sheet, row => {
+        row.splice(start, numDelete, ...inserts);
+      });
+    }
+  }
+}
+
+module.exports = CellMatrix;

package/lib/utils/col-cache.js

@@ -0,0 +1,287 @@
+const addressRegex = /^[A-Z]+\d+$/;
+// =========================================================================
+// Column Letter to Number conversion
+const colCache = {
+  _dictionary: [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+  ],
+  _l2nFill: 0,
+  _l2n: {},
+  _n2l: [],
+  _level(n) {
+    if (n <= 26) {
+      return 1;
+    }
+    if (n <= 26 * 26) {
+      return 2;
+    }
+    return 3;
+  },
+  _fill(level) {
+    let c;
+    let v;
+    let l1;
+    let l2;
+    let l3;
+    let n = 1;
+    if (level >= 4) {
+      throw new Error('Out of bounds. Excel supports columns from 1 to 16384');
+    }
+    if (this._l2nFill < 1 && level >= 1) {
+      while (n <= 26) {
+        c = this._dictionary[n - 1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 1;
+    }
+    if (this._l2nFill < 2 && level >= 2) {
+      n = 27;
+      while (n <= 26 + (26 * 26)) {
+        v = n - (26 + 1);
+        l1 = v % 26;
+        l2 = Math.floor(v / 26);
+        c = this._dictionary[l2] + this._dictionary[l1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 2;
+    }
+    if (this._l2nFill < 3 && level >= 3) {
+      n = 26 + (26 * 26) + 1;
+      while (n <= 16384) {
+        v = n - ((26 * 26) + 26 + 1);
+        l1 = v % 26;
+        l2 = Math.floor(v / 26) % 26;
+        l3 = Math.floor(v / (26 * 26));
+        c = this._dictionary[l3] + this._dictionary[l2] + this._dictionary[l1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 3;
+    }
+  },
+  l2n(l) {
+    if (!this._l2n[l]) {
+      this._fill(l.length);
+    }
+    if (!this._l2n[l]) {
+      throw new Error(`Out of bounds. Invalid column letter: ${l}`);
+    }
+    return this._l2n[l];
+  },
+  n2l(n) {
+    if (n < 1 || n > 16384) {
+      throw new Error(`${n} is out of bounds. Excel supports columns from 1 to 16384`);
+    }
+    if (!this._n2l[n]) {
+      this._fill(this._level(n));
+    }
+    return this._n2l[n];
+  },
+
+  // =========================================================================
+  // Address processing
+  _hash: {},
+
+  // check if value looks like an address
+  validateAddress(value) {
+    if (!addressRegex.test(value)) {
+      throw new Error(`Invalid Address: ${value}`);
+    }
+    return true;
+  },
+
+  // convert address string into structure
+  decodeAddress(value) {
+    const addr = value.length < 5 && this._hash[value];
+    if (addr) {
+      return addr;
+    }
+    let hasCol = false;
+    let col = '';
+    let colNumber = 0;
+    let hasRow = false;
+    let row = '';
+    let rowNumber = 0;
+    for (let i = 0, char; i < value.length; i++) {
+      char = value.charCodeAt(i);
+      // col should before row
+      if (!hasRow && char >= 65 && char <= 90) {
+        // 65 = 'A'.charCodeAt(0)
+        // 90 = 'Z'.charCodeAt(0)
+        hasCol = true;
+        col += value[i];
+        // colNumber starts from 1
+        colNumber = (colNumber * 26) + char - 64;
+      } else if (char >= 48 && char <= 57) {
+        // 48 = '0'.charCodeAt(0)
+        // 57 = '9'.charCodeAt(0)
+        hasRow = true;
+        row += value[i];
+        // rowNumber starts from 0
+        rowNumber = (rowNumber * 10) + char - 48;
+      } else if (hasRow && hasCol && char !== 36) {
+        // 36 = '$'.charCodeAt(0)
+        break;
+      }
+    }
+    if (!hasCol) {
+      colNumber = undefined;
+    } else if (colNumber > 16384) {
+      throw new Error(`Out of bounds. Invalid column letter: ${col}`);
+    }
+    if (!hasRow) {
+      rowNumber = undefined;
+    }
+
+    // in case $row$col
+    value = col + row;
+
+    const address = {
+      address: value,
+      col: colNumber,
+      row: rowNumber,
+      $col$row: `$${col}$${row}`,
+    };
+
+    // mem fix - cache only the tl 100x100 square
+    if (colNumber <= 100 && rowNumber <= 100) {
+      this._hash[value] = address;
+      this._hash[address.$col$row] = address;
+    }
+
+    return address;
+  },
+
+  // convert r,c into structure (if only 1 arg, assume r is address string)
+  getAddress(r, c) {
+    if (c) {
+      const address = this.n2l(c) + r;
+      return this.decodeAddress(address);
+    }
+    return this.decodeAddress(r);
+  },
+
+  // convert [address], [tl:br] into address structures
+  decode(value) {
+    const parts = value.split(':');
+    if (parts.length === 2) {
+      const tl = this.decodeAddress(parts[0]);
+      const br = this.decodeAddress(parts[1]);
+      const result = {
+        top: Math.min(tl.row, br.row),
+        left: Math.min(tl.col, br.col),
+        bottom: Math.max(tl.row, br.row),
+        right: Math.max(tl.col, br.col),
+      };
+      // reconstruct tl, br and dimensions
+      result.tl = this.n2l(result.left) + result.top;
+      result.br = this.n2l(result.right) + result.bottom;
+      result.dimensions = `${result.tl}:${result.br}`;
+      return result;
+    }
+    return this.decodeAddress(value);
+  },
+
+  // convert [sheetName!][$]col[$]row[[$]col[$]row] into address or range structures
+  decodeEx(value) {
+    const groups = value.match(/(?:(?:(?:'((?:[^']|'')*)')|([^'^ !]*))!)?(.*)/);
+
+    const sheetName = groups[1] || groups[2]; // Qouted and unqouted groups
+    const reference = groups[3]; // Remaining address
+
+    const parts = reference.split(':');
+    if (parts.length > 1) {
+      let tl = this.decodeAddress(parts[0]);
+      let br = this.decodeAddress(parts[1]);
+      const top = Math.min(tl.row, br.row);
+      const left = Math.min(tl.col, br.col);
+      const bottom = Math.max(tl.row, br.row);
+      const right = Math.max(tl.col, br.col);
+
+      tl = this.n2l(left) + top;
+      br = this.n2l(right) + bottom;
+
+      return {
+        top,
+        left,
+        bottom,
+        right,
+        sheetName,
+        tl: {address: tl, col: left, row: top, $col$row: `$${this.n2l(left)}$${top}`, sheetName},
+        br: {
+          address: br,
+          col: right,
+          row: bottom,
+          $col$row: `$${this.n2l(right)}$${bottom}`,
+          sheetName,
+        },
+        dimensions: `${tl}:${br}`,
+      };
+    }
+    if (reference.startsWith('#')) {
+      return sheetName ? {sheetName, error: reference} : {error: reference};
+    }
+
+    const address = this.decodeAddress(reference);
+    return sheetName ? {sheetName, ...address} : address;
+  },
+
+  // convert row,col into address string
+  encodeAddress(row, col) {
+    return colCache.n2l(col) + row;
+  },
+
+  // convert row,col into string address or t,l,b,r into range
+  encode() {
+    switch (arguments.length) {
+      case 2:
+        return colCache.encodeAddress(arguments[0], arguments[1]);
+      case 4:
+        return `${colCache.encodeAddress(arguments[0], arguments[1])}:${colCache.encodeAddress(
+          arguments[2],
+          arguments[3]
+        )}`;
+      default:
+        throw new Error('Can only encode with 2 or 4 arguments');
+    }
+  },
+
+  // return true if address is contained within range
+  inRange(range, address) {
+    const [left, top, , right, bottom] = range;
+    const [col, row] = address;
+    return col >= left && col <= right && row >= top && row <= bottom;
+  },
+};
+
+module.exports = colCache;

package/lib/utils/copy-style.js

@@ -0,0 +1,43 @@
+const oneDepthCopy = (obj, nestKeys) => ({
+  ...obj,
+  ...nestKeys.reduce((memo, key) => {
+    if (obj[key]) memo[key] = {...obj[key]};
+    return memo;
+  }, {}),
+});
+
+const setIfExists = (src, dst, key, nestKeys = []) => {
+  if (src[key]) dst[key] = oneDepthCopy(src[key], nestKeys);
+};
+
+const isEmptyObj = obj => Object.keys(obj).length === 0;
+
+const copyStyle = style => {
+  if (!style) return style;
+  if (isEmptyObj(style)) return {};
+
+  const copied = {...style};
+
+  setIfExists(style, copied, 'font', ['color']);
+  setIfExists(style, copied, 'alignment');
+  setIfExists(style, copied, 'protection');
+  if (style.border) {
+    setIfExists(style, copied, 'border');
+    setIfExists(style.border, copied.border, 'top', ['color']);
+    setIfExists(style.border, copied.border, 'left', ['color']);
+    setIfExists(style.border, copied.border, 'bottom', ['color']);
+    setIfExists(style.border, copied.border, 'right', ['color']);
+    setIfExists(style.border, copied.border, 'diagonal', ['color']);
+  }
+
+  if (style.fill) {
+    setIfExists(style, copied, 'fill', ['fgColor', 'bgColor', 'center']);
+    if (style.fill.stops) {
+      copied.fill.stops = style.fill.stops.map(s => oneDepthCopy(s, ['color']));
+    }
+  }
+
+  return copied;
+};
+
+exports.copyStyle = copyStyle;

package/lib/utils/encryptor.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const Encryptor = {
+  /**
+   * Calculate a hash of the concatenated buffers with the given algorithm.
+   * @param {string} algorithm - The hash algorithm.
+   * @returns {Buffer} The hash
+   */
+  hash(algorithm, ...buffers) {
+    const hash = crypto.createHash(algorithm);
+    hash.update(Buffer.concat(buffers));
+    return hash.digest();
+  },
+  /**
+   * Convert a password into an encryption key
+   * @param {string} password - The password
+   * @param {string} hashAlgorithm - The hash algoritm
+   * @param {string} saltValue - The salt value
+   * @param {number} spinCount - The spin count
+   * @param {number} keyBits - The length of the key in bits
+   * @param {Buffer} blockKey - The block key
+   * @returns {Buffer} The encryption key
+   */
+  convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+    hashAlgorithm = hashAlgorithm.toLowerCase();
+    const hashes = crypto.getHashes();
+    if (hashes.indexOf(hashAlgorithm) < 0) {
+      throw new Error(`Hash algorithm '${hashAlgorithm}' not supported!`);
+    }
+
+    // Password must be in unicode buffer
+    const passwordBuffer = Buffer.from(password, 'utf16le');
+    // Generate the initial hash
+    let key = this.hash(hashAlgorithm, Buffer.from(saltValue, 'base64'), passwordBuffer);
+    // Now regenerate until spin count
+    for (let i = 0; i < spinCount; i++) {
+      const iterator = Buffer.alloc(4);
+      // this is the 'special' element of Excel password hashing
+      // that stops us from using crypto.pbkdf2()
+      iterator.writeUInt32LE(i, 0);
+      key = this.hash(hashAlgorithm, key, iterator);
+    }
+    return key.toString('base64');
+  },
+  /**
+   * Generates cryptographically strong pseudo-random data.
+   * @param size The size argument is a number indicating the number of bytes to generate.
+   */
+  randomBytes(size) {
+    return crypto.randomBytes(size);
+  },
+};
+module.exports = Encryptor;

package/lib/utils/iterate-stream.js

@@ -0,0 +1,48 @@
+module.exports = async function* iterateStream(stream) {
+  const contents = [];
+  stream.on('data', data => contents.push(data));
+
+  let resolveStreamEndedPromise;
+  const streamEndedPromise = new Promise(resolve => (resolveStreamEndedPromise = resolve));
+
+  let ended = false;
+  stream.on('end', () => {
+    ended = true;
+    resolveStreamEndedPromise();
+  });
+
+  let error = false;
+  stream.on('error', err => {
+    error = err;
+    resolveStreamEndedPromise();
+  });
+
+  while (!ended || contents.length > 0) {
+    if (contents.length === 0) {
+      stream.resume();
+      // eslint-disable-next-line no-await-in-loop
+      await Promise.race([once(stream, 'data'), streamEndedPromise]);
+    } else {
+      stream.pause();
+      const data = contents.shift();
+      yield data;
+    }
+    if (error) throw error;
+  }
+  resolveStreamEndedPromise();
+};
+
+function once(eventEmitter, type) {
+  // TODO: Use require('events').once when node v10 is dropped
+  return new Promise(resolve => {
+    let fired = false;
+    const handler = () => {
+      if (!fired) {
+        fired = true;
+        eventEmitter.removeListener(type, handler);
+        resolve();
+      }
+    };
+    eventEmitter.addListener(type, handler);
+  });
+}

package/lib/utils/parse-sax.js

@@ -0,0 +1,30 @@
+const {SaxesParser} = require('saxes');
+const {PassThrough} = require('readable-stream');
+const {bufferToString} = require('./browser-buffer-decode');
+
+module.exports = async function* (iterable) {
+  // TODO: Remove once node v8 is deprecated
+  // Detect and upgrade old streams
+  if (iterable.pipe && !iterable[Symbol.asyncIterator]) {
+    iterable = iterable.pipe(new PassThrough());
+  }
+  const saxesParser = new SaxesParser();
+  let error;
+  saxesParser.on('error', err => {
+    error = err;
+  });
+  let events = [];
+  saxesParser.on('opentag', value => events.push({eventType: 'opentag', value}));
+  saxesParser.on('text', value => events.push({eventType: 'text', value}));
+  saxesParser.on('closetag', value => events.push({eventType: 'closetag', value}));
+  for await (const chunk of iterable) {
+    saxesParser.write(bufferToString(chunk));
+    // saxesParser.write and saxesParser.on() are synchronous,
+    // so we can only reach the below line once all events have been emitted
+    if (error) throw error;
+    // As a performance optimization, we gather all events instead of passing
+    // them one by one, which would cause each event to go through the event queue
+    yield events;
+    events = [];
+  }
+};