@zergai/ztc 0.2.5-dev.36050816660 → 0.2.6-dev.36101352252

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/cell-matrix.js

@@ -1,26 +1,30 @@
-"use strict";
-
 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++) {
@@ -32,25 +36,31 @@ class CellMatrix {
       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
-    });
+    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) {
@@ -62,6 +72,7 @@ class CellMatrix {
     }
     delete row[address.col];
   }
+
   forEachInSheet(sheetName, callback) {
     const sheet = this.sheets[sheetName];
     if (sheet) {
@@ -76,11 +87,13 @@ class CellMatrix {
       });
     }
   }
+
   forEach(callback) {
     _.each(this.sheets, (sheet, sheetName) => {
       this.forEachInSheet(sheetName, callback);
     });
   }
+
   map(callback) {
     const results = [];
     this.forEach(cell => {
@@ -88,40 +101,42 @@ class CellMatrix {
     });
     return results;
   }
+
   findSheet(address, create) {
     const name = address.sheetName;
     if (this.sheets[name]) {
       return this.sheets[name];
     }
     if (create) {
-      return this.sheets[name] = [];
+      return (this.sheets[name] = []);
     }
     return undefined;
   }
+
   findSheetRow(sheet, address, create) {
-    const {
-      row
-    } = address;
+    const {row} = address;
     if (sheet && sheet[row]) {
       return sheet[row];
     }
     if (create) {
-      return sheet[row] = [];
+      return (sheet[row] = []);
     }
     return undefined;
   }
+
   findRowCell(row, address, create) {
-    const {
-      col
-    } = address;
+    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 (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) {
@@ -132,6 +147,7 @@ class CellMatrix {
       sheet.splice(start, numDelete, ...inserts);
     }
   }
+
   spliceColumns(sheetName, start, numDelete, numInsert) {
     const sheet = this.sheets[sheetName];
     if (sheet) {
@@ -145,5 +161,5 @@ class CellMatrix {
     }
   }
 }
+
 module.exports = CellMatrix;
-//# sourceMappingURL=cell-matrix.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/col-cache.js

@@ -1,10 +1,35 @@
-"use strict";
-
 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'],
+  _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: [],
@@ -38,7 +63,7 @@ const colCache = {
     }
     if (this._l2nFill < 2 && level >= 2) {
       n = 27;
-      while (n <= 26 + 26 * 26) {
+      while (n <= 26 + (26 * 26)) {
         v = n - (26 + 1);
         l1 = v % 26;
         l2 = Math.floor(v / 26);
@@ -50,9 +75,9 @@ const colCache = {
       this._l2nFill = 2;
     }
     if (this._l2nFill < 3 && level >= 3) {
-      n = 26 + 26 * 26 + 1;
+      n = 26 + (26 * 26) + 1;
       while (n <= 16384) {
-        v = n - (26 * 26 + 26 + 1);
+        v = n - ((26 * 26) + 26 + 1);
         l1 = v % 26;
         l2 = Math.floor(v / 26) % 26;
         l3 = Math.floor(v / (26 * 26));
@@ -82,9 +107,11 @@ const colCache = {
     }
     return this._n2l[n];
   },
+
   // =========================================================================
   // Address processing
   _hash: {},
+
   // check if value looks like an address
   validateAddress(value) {
     if (!addressRegex.test(value)) {
@@ -92,6 +119,7 @@ const colCache = {
     }
     return true;
   },
+
   // convert address string into structure
   decodeAddress(value) {
     const addr = value.length < 5 && this._hash[value];
@@ -113,14 +141,14 @@ const colCache = {
         hasCol = true;
         col += value[i];
         // colNumber starts from 1
-        colNumber = colNumber * 26 + char - 64;
+        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;
+        rowNumber = (rowNumber * 10) + char - 48;
       } else if (hasRow && hasCol && char !== 36) {
         // 36 = '$'.charCodeAt(0)
         break;
@@ -137,11 +165,12 @@ const colCache = {
 
     // in case $row$col
     value = col + row;
+
     const address = {
       address: value,
       col: colNumber,
       row: rowNumber,
-      $col$row: `$${col}$${row}`
+      $col$row: `$${col}$${row}`,
     };
 
     // mem fix - cache only the tl 100x100 square
@@ -149,8 +178,10 @@ const colCache = {
       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) {
@@ -159,6 +190,7 @@ const colCache = {
     }
     return this.decodeAddress(r);
   },
+
   // convert [address], [tl:br] into address structures
   decode(value) {
     const parts = value.split(':');
@@ -169,7 +201,7 @@ const colCache = {
         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)
+        right: Math.max(tl.col, br.col),
       };
       // reconstruct tl, br and dimensions
       result.tl = this.n2l(result.left) + result.top;
@@ -179,9 +211,11 @@ const colCache = {
     }
     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
 
@@ -193,66 +227,61 @@ const colCache = {
       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
-        },
+        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
+          sheetName,
         },
-        dimensions: `${tl}:${br}`
+        dimensions: `${tl}:${br}`,
       };
     }
     if (reference.startsWith('#')) {
-      return sheetName ? {
-        sheetName,
-        error: reference
-      } : {
-        error: reference
-      };
+      return sheetName ? {sheetName, error: reference} : {error: reference};
     }
+
     const address = this.decodeAddress(reference);
-    return sheetName ? {
-      sheetName,
-      ...address
-    } : address;
+    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])}`;
+        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 [left, top, , right, bottom] = range;
     const [col, row] = address;
     return col >= left && col <= right && row >= top && row <= bottom;
-  }
+  },
 };
+
 module.exports = colCache;
-//# sourceMappingURL=col-cache.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/copy-style.js

@@ -1,25 +1,23 @@
-"use strict";
-
 const oneDepthCopy = (obj, nestKeys) => ({
   ...obj,
   ...nestKeys.reduce((memo, key) => {
-    if (obj[key]) memo[key] = {
-      ...obj[key]
-    };
+    if (obj[key]) memo[key] = {...obj[key]};
     return memo;
-  }, {})
+  }, {}),
 });
-const setIfExists = function (src, dst, key) {
-  let nestKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+
+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
-  };
+
+  const copied = {...style};
+
   setIfExists(style, copied, 'font', ['color']);
   setIfExists(style, copied, 'alignment');
   setIfExists(style, copied, 'protection');
@@ -31,13 +29,15 @@ const copyStyle = style => {
     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;
-//# sourceMappingURL=copy-style.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/encryptor.js

@@ -1,17 +1,15 @@
 '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) {
+  hash(algorithm, ...buffers) {
     const hash = crypto.createHash(algorithm);
-    for (var _len = arguments.length, buffers = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      buffers[_key - 1] = arguments[_key];
-    }
     hash.update(Buffer.concat(buffers));
     return hash.digest();
   },
@@ -52,7 +50,6 @@ const Encryptor = {
    */
   randomBytes(size) {
     return crypto.randomBytes(size);
-  }
+  },
 };
 module.exports = Encryptor;
-//# sourceMappingURL=encryptor.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/iterate-stream.js

@@ -1,20 +1,22 @@
-"use strict";
-
 module.exports = async function* iterateStream(stream) {
   const contents = [];
   stream.on('data', data => contents.push(data));
+
   let resolveStreamEndedPromise;
-  const streamEndedPromise = new Promise(resolve => resolveStreamEndedPromise = resolve);
+  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();
@@ -29,6 +31,7 @@ module.exports = async function* iterateStream(stream) {
   }
   resolveStreamEndedPromise();
 };
+
 function once(eventEmitter, type) {
   // TODO: Use require('events').once when node v10 is dropped
   return new Promise(resolve => {
@@ -43,4 +46,3 @@ function once(eventEmitter, type) {
     eventEmitter.addListener(type, handler);
   });
 }
-//# sourceMappingURL=iterate-stream.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/parse-sax.js

@@ -1,14 +1,7 @@
-"use strict";
+const {SaxesParser} = require('saxes');
+const {PassThrough} = require('readable-stream');
+const {bufferToString} = require('./browser-buffer-decode');
 
-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
@@ -21,18 +14,9 @@ module.exports = async function* (iterable) {
     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
-  }));
+  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,
@@ -44,4 +28,3 @@ module.exports = async function* (iterable) {
     events = [];
   }
 };
-//# sourceMappingURL=parse-sax.js.map

package/packages/exceljs/lib/utils/shared-formula.js

@@ -0,0 +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,
+};

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/shared-strings.js

@@ -1,23 +1,26 @@
-"use strict";
-
 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) {
@@ -28,5 +31,5 @@ class SharedStrings {
     return index;
   }
 }
+
 module.exports = SharedStrings;
-//# sourceMappingURL=shared-strings.js.map