@alienkarma/exceljs 4.4.0-fork.12 → 4.4.0-fork.13

package/lib/utils/encryptor.js

@@ -1,55 +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;
+'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

@@ -1,48 +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);
-  });
-}
+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

@@ -1,30 +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 = [];
-  }
-};
+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 = [];
+  }
+};

package/lib/utils/shared-formula.js

@@ -1,44 +1,44 @@
-const colCache = require('./col-cache');
-
-// const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
-const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
-const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
-
-function slideFormula(formula, fromCell, toCell) {
-  const offset = colCache.decode(fromCell);
-  const to = colCache.decode(toCell);
-  return formula.replace(
-    replacementCandidateRx,
-    (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
-      if (trailingParen) {
-        return refMatch;
-      }
-      const match = CRrx.exec(addrPart);
-      if (match) {
-        const colDollar = match[1];
-        const colStr = match[2].toUpperCase();
-        const rowDollar = match[3];
-        const rowStr = match[4];
-        if (colStr.length > 3 || (colStr.length === 3 && colStr > 'XFD')) {
-          // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
-          return refMatch;
-        }
-        let col = colCache.l2n(colStr);
-        let row = parseInt(rowStr, 10);
-        if (!colDollar) {
-          col += to.col - offset.col;
-        }
-        if (!rowDollar) {
-          row += to.row - offset.row;
-        }
-        const res = (sheet || '') + (colDollar || '') + colCache.n2l(col) + (rowDollar || '') + row;
-        return res;
-      }
-      return refMatch;
-    }
-  );
-}
-
-module.exports = {
-  slideFormula,
-};
+const colCache = require('./col-cache');
+
+// const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
+const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
+const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
+
+function slideFormula(formula, fromCell, toCell) {
+  const offset = colCache.decode(fromCell);
+  const to = colCache.decode(toCell);
+  return formula.replace(
+    replacementCandidateRx,
+    (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
+      if (trailingParen) {
+        return refMatch;
+      }
+      const match = CRrx.exec(addrPart);
+      if (match) {
+        const colDollar = match[1];
+        const colStr = match[2].toUpperCase();
+        const rowDollar = match[3];
+        const rowStr = match[4];
+        if (colStr.length > 3 || (colStr.length === 3 && colStr > 'XFD')) {
+          // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
+          return refMatch;
+        }
+        let col = colCache.l2n(colStr);
+        let row = parseInt(rowStr, 10);
+        if (!colDollar) {
+          col += to.col - offset.col;
+        }
+        if (!rowDollar) {
+          row += to.row - offset.row;
+        }
+        const res = (sheet || '') + (colDollar || '') + colCache.n2l(col) + (rowDollar || '') + row;
+        return res;
+      }
+      return refMatch;
+    }
+  );
+}
+
+module.exports = {
+  slideFormula,
+};

package/lib/utils/shared-strings.js

@@ -1,35 +1,35 @@
-class SharedStrings {
-  constructor() {
-    this._values = [];
-    this._totalRefs = 0;
-    this._hash = Object.create(null);
-  }
-
-  get count() {
-    return this._values.length;
-  }
-
-  get values() {
-    return this._values;
-  }
-
-  get totalRefs() {
-    return this._totalRefs;
-  }
-
-  getString(index) {
-    return this._values[index];
-  }
-
-  add(value) {
-    let index = this._hash[value];
-    if (index === undefined) {
-      index = this._hash[value] = this._values.length;
-      this._values.push(value);
-    }
-    this._totalRefs++;
-    return index;
-  }
-}
-
-module.exports = SharedStrings;
+class SharedStrings {
+  constructor() {
+    this._values = [];
+    this._totalRefs = 0;
+    this._hash = Object.create(null);
+  }
+
+  get count() {
+    return this._values.length;
+  }
+
+  get values() {
+    return this._values;
+  }
+
+  get totalRefs() {
+    return this._totalRefs;
+  }
+
+  getString(index) {
+    return this._values[index];
+  }
+
+  add(value) {
+    let index = this._hash[value];
+    if (index === undefined) {
+      index = this._hash[value] = this._values.length;
+      this._values.push(value);
+    }
+    this._totalRefs++;
+    return index;
+  }
+}
+
+module.exports = SharedStrings;

package/lib/utils/stream-base64.js

@@ -1,72 +1,72 @@
-const Stream = require('readable-stream');
-
-// =============================================================================
-// StreamBase64 - A utility to convert to/from base64 stream
-// Note: does not buffer data, must be piped
-class StreamBase64 extends Stream.Duplex {
-  constructor() {
-    super();
-
-    // consuming pipe streams go here
-    this.pipes = [];
-  }
-
-  // writable
-  // event drain - if write returns false (which it won't), indicates when safe to write again.
-  // finish - end() has been called
-  // pipe(src) - pipe() has been called on readable
-  // unpipe(src) - unpipe() has been called on readable
-  // error - duh
-
-  write(/* data, encoding */) {
-    return true;
-  }
-
-  cork() {}
-
-  uncork() {}
-
-  end(/* chunk, encoding, callback */) {}
-
-  // readable
-  // event readable - some data is now available
-  // event data - switch to flowing mode - feeds chunks to handler
-  // event end - no more data
-  // event close - optional, indicates upstream close
-  // event error - duh
-  read(/* size */) {}
-
-  setEncoding(encoding) {
-    // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
-    this.encoding = encoding;
-  }
-
-  pause() {}
-
-  resume() {}
-
-  isPaused() {}
-
-  pipe(destination) {
-    // add destination to pipe list & write current buffer
-    this.pipes.push(destination);
-  }
-
-  unpipe(destination) {
-    // remove destination from pipe list
-    this.pipes = this.pipes.filter(pipe => pipe !== destination);
-  }
-
-  unshift(/* chunk */) {
-    // some numpty has read some data that's not for them and they want to put it back!
-    // Might implement this some day
-    throw new Error('Not Implemented');
-  }
-
-  wrap(/* stream */) {
-    // not implemented
-    throw new Error('Not Implemented');
-  }
-}
-
-module.exports = StreamBase64;
+const Stream = require('readable-stream');
+
+// =============================================================================
+// StreamBase64 - A utility to convert to/from base64 stream
+// Note: does not buffer data, must be piped
+class StreamBase64 extends Stream.Duplex {
+  constructor() {
+    super();
+
+    // consuming pipe streams go here
+    this.pipes = [];
+  }
+
+  // writable
+  // event drain - if write returns false (which it won't), indicates when safe to write again.
+  // finish - end() has been called
+  // pipe(src) - pipe() has been called on readable
+  // unpipe(src) - unpipe() has been called on readable
+  // error - duh
+
+  write(/* data, encoding */) {
+    return true;
+  }
+
+  cork() {}
+
+  uncork() {}
+
+  end(/* chunk, encoding, callback */) {}
+
+  // readable
+  // event readable - some data is now available
+  // event data - switch to flowing mode - feeds chunks to handler
+  // event end - no more data
+  // event close - optional, indicates upstream close
+  // event error - duh
+  read(/* size */) {}
+
+  setEncoding(encoding) {
+    // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
+    this.encoding = encoding;
+  }
+
+  pause() {}
+
+  resume() {}
+
+  isPaused() {}
+
+  pipe(destination) {
+    // add destination to pipe list & write current buffer
+    this.pipes.push(destination);
+  }
+
+  unpipe(destination) {
+    // remove destination from pipe list
+    this.pipes = this.pipes.filter(pipe => pipe !== destination);
+  }
+
+  unshift(/* chunk */) {
+    // some numpty has read some data that's not for them and they want to put it back!
+    // Might implement this some day
+    throw new Error('Not Implemented');
+  }
+
+  wrap(/* stream */) {
+    // not implemented
+    throw new Error('Not Implemented');
+  }
+}
+
+module.exports = StreamBase64;