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

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

@@ -1,5 +1,3 @@
-"use strict";
-
 const Stream = require('readable-stream');
 
 // =============================================================================
@@ -20,13 +18,15 @@ class StreamBase64 extends Stream.Duplex {
   // unpipe(src) - unpipe() has been called on readable
   // error - duh
 
-  write( /* data, encoding */
-  ) {
+  write(/* data, encoding */) {
     return true;
   }
+
   cork() {}
+
   uncork() {}
-  end( /* chunk, encoding, callback */) {}
+
+  end(/* chunk, encoding, callback */) {}
 
   // readable
   // event readable - some data is now available
@@ -34,33 +34,39 @@ class StreamBase64 extends Stream.Duplex {
   // event end - no more data
   // event close - optional, indicates upstream close
   // event error - duh
-  read( /* size */) {}
+  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 */
-  ) {
+
+  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 */
-  ) {
+
+  wrap(/* stream */) {
     // not implemented
     throw new Error('Not Implemented');
   }
 }
+
 module.exports = StreamBase64;
-//# sourceMappingURL=stream-base64.js.map

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

@@ -1,7 +1,6 @@
-"use strict";
-
 /* eslint-disable max-classes-per-file */
 const Stream = require('readable-stream');
+
 const utils = require('./utils');
 const StringBuf = require('./string-buf');
 
@@ -12,6 +11,7 @@ class StringChunk {
     this._data = data;
     this._encoding = encoding;
   }
+
   get length() {
     return this.toBuffer().length;
   }
@@ -20,6 +20,7 @@ class StringChunk {
   copy(target, targetOffset, offset, length) {
     return this.toBuffer().copy(target, targetOffset, offset, length);
   }
+
   toBuffer() {
     if (!this._buffer) {
       this._buffer = Buffer.from(this._data, this._encoding);
@@ -27,10 +28,12 @@ class StringChunk {
     return this._buffer;
   }
 }
+
 class StringBufChunk {
   constructor(data) {
     this._data = data;
   }
+
   get length() {
     return this._data.length;
   }
@@ -40,14 +43,17 @@ class StringBufChunk {
     // eslint-disable-next-line no-underscore-dangle
     return this._data._buf.copy(target, targetOffset, offset, length);
   }
+
   toBuffer() {
     return this._data.toBuffer();
   }
 }
+
 class BufferChunk {
   constructor(data) {
     this._data = data;
   }
+
   get length() {
     return this._data.length;
   }
@@ -56,6 +62,7 @@ class BufferChunk {
   copy(target, targetOffset, offset, length) {
     this._data.copy(target, targetOffset, offset, length);
   }
+
   toBuffer() {
     return this._data;
   }
@@ -73,23 +80,29 @@ class ReadWriteBuf {
     // write index
     this.iWrite = 0;
   }
+
   toBuffer() {
     if (this.iRead === 0 && this.iWrite === this.size) {
       return this.buffer;
     }
+
     const buf = Buffer.alloc(this.iWrite - this.iRead);
     this.buffer.copy(buf, 0, this.iRead, this.iWrite);
     return buf;
   }
+
   get length() {
     return this.iWrite - this.iRead;
   }
+
   get eod() {
     return this.iRead === this.iWrite;
   }
+
   get full() {
     return this.iWrite === this.size;
   }
+
   read(size) {
     let buf;
     // read size bytes from buffer and return buffer
@@ -97,6 +110,7 @@ class ReadWriteBuf {
       // special case - return null if no data requested
       return null;
     }
+
     if (size === undefined || size >= this.length) {
       // if no size specified or size is at least what we have then return all of the bytes
       buf = this.toBuffer();
@@ -110,6 +124,7 @@ class ReadWriteBuf {
     this.iRead += size;
     return buf;
   }
+
   write(chunk, offset, length) {
     // write as many bytes from data from optional source offset
     // and return number of bytes written
@@ -128,7 +143,7 @@ class ReadWriteBuf {
 
 // Note: Not sure why but StreamBuf does not like JS "class" sugar. It fails the
 // integration tests
-const StreamBuf = function (options) {
+const StreamBuf = function(options) {
   options = options || {};
   this.bufSize = options.bufSize || 1024 * 1024;
   this.buffers = [];
@@ -136,6 +151,7 @@ const StreamBuf = function (options) {
   // batch mode fills a buffer completely before passing the data on
   // to pipes or 'readable' event listeners
   this.batch = options.batch || false;
+
   this.corked = false;
   // where in the current writable buffer we're up to
   this.inPos = 0;
@@ -148,8 +164,10 @@ const StreamBuf = function (options) {
 
   // controls emit('data')
   this.paused = false;
+
   this.encoding = null;
 };
+
 utils.inherits(StreamBuf, Stream.Duplex, {
   toBuffer() {
     switch (this.buffers.length) {
@@ -161,6 +179,7 @@ utils.inherits(StreamBuf, Stream.Duplex, {
         return Buffer.concat(this.buffers.map(rwBuf => rwBuf.toBuffer()));
     }
   },
+
   // writable
   // event drain - if write returns false (which it won't), indicates when safe to write again.
   // finish - end() has been called
@@ -179,8 +198,9 @@ utils.inherits(StreamBuf, Stream.Duplex, {
     this.buffers.push(buf);
     return buf;
   },
+
   async _pipe(chunk) {
-    const write = function (pipe) {
+    const write = function(pipe) {
       return new Promise(resolve => {
         pipe.write(chunk.toBuffer(), () => {
           resolve();
@@ -237,16 +257,17 @@ utils.inherits(StreamBuf, Stream.Duplex, {
       if (!this.paused) {
         this.emit('data', chunk.toBuffer());
       }
+
       this._writeToBuffers(chunk);
       this.emit('readable');
     }
+
     return true;
   },
   cork() {
     this.corked = true;
   },
-  _flush( /* destination */
-  ) {
+  _flush(/* destination */) {
     // if we have comsumers...
     if (this.pipes.length) {
       // and there's stuff not written
@@ -277,6 +298,7 @@ utils.inherits(StreamBuf, Stream.Duplex, {
       writeComplete();
     }
   },
+
   // readable
   // event readable - some data is now available
   // event data - switch to flowing mode - feeds chunks to handler
@@ -299,6 +321,7 @@ utils.inherits(StreamBuf, Stream.Duplex, {
       }
       return Buffer.concat(buffers);
     }
+
     buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
     this.buffers = [];
     return Buffer.concat(buffers);
@@ -327,17 +350,15 @@ utils.inherits(StreamBuf, Stream.Duplex, {
     // remove destination from pipe list
     this.pipes = this.pipes.filter(pipe => pipe !== destination);
   },
-  unshift( /* chunk */
-  ) {
+  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 */
-  ) {
+  wrap(/* stream */) {
     // not implemented
     throw new Error('Not Implemented');
-  }
+  },
 });
+
 module.exports = StreamBuf;
-//# sourceMappingURL=stream-buf.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/string-buf.js

@@ -1,11 +1,9 @@
-"use strict";
-
 // StringBuf - a way to keep string memory operations to a minimum
 // while building the strings for the xml files
 class StringBuf {
   constructor(options) {
-    this._buf = Buffer.alloc(options && options.size || 16384);
-    this._encoding = options && options.encoding || 'utf8';
+    this._buf = Buffer.alloc((options && options.size) || 16384);
+    this._encoding = (options && options.encoding) || 'utf8';
 
     // where in the buffer we are at
     this._inPos = 0;
@@ -13,15 +11,19 @@ class StringBuf {
     // for use by toBuffer()
     this._buffer = undefined;
   }
+
   get length() {
     return this._inPos;
   }
+
   get capacity() {
     return this._buf.length;
   }
+
   get buffer() {
     return this._buf;
   }
+
   toBuffer() {
     // return the current data as a single enclosing buffer
     if (!this._buffer) {
@@ -30,11 +32,13 @@ class StringBuf {
     }
     return this._buffer;
   }
+
   reset(position) {
     position = position || 0;
     this._buffer = undefined;
     this._inPos = position;
   }
+
   _grow(min) {
     let size = this._buf.length * 2;
     while (size < min) {
@@ -44,8 +48,10 @@ class StringBuf {
     this._buf.copy(buf, 0);
     this._buf = buf;
   }
+
   addText(text) {
     this._buffer = undefined;
+
     let inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
 
     // if we've hit (or nearing capacity), grow the buf
@@ -55,11 +61,14 @@ class StringBuf {
       // keep trying to write until we've completely written the text
       inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
     }
+
     this._inPos = inPos;
   }
+
   addStringBuf(inBuf) {
     if (inBuf.length) {
       this._buffer = undefined;
+
       if (this.length + inBuf.length > this.capacity) {
         this._grow(this.length + inBuf.length);
       }
@@ -69,5 +78,5 @@ class StringBuf {
     }
   }
 }
+
 module.exports = StringBuf;
-//# sourceMappingURL=string-buf.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/string-builder.js

@@ -1,17 +1,18 @@
-"use strict";
-
 // StringBuilder - a way to keep string memory operations to a minimum
 // while building the strings for the xml files
 class StringBuilder {
   constructor() {
     this.reset();
   }
+
   get length() {
     return this._buf.length;
   }
+
   toString() {
     return this._buf.join('');
   }
+
   reset(position) {
     if (position) {
       while (this._buf.length > position) {
@@ -21,12 +22,14 @@ class StringBuilder {
       this._buf = [];
     }
   }
+
   addText(text) {
     this._buf.push(text);
   }
+
   addStringBuf(inBuf) {
     this._buf.push(inBuf.toString());
   }
 }
+
 module.exports = StringBuilder;
-//# sourceMappingURL=string-builder.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/stuttered-pipe.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const events = require('events');
 
 // =============================================================================
@@ -7,14 +5,18 @@ const events = require('events');
 class StutteredPipe extends events.EventEmitter {
   constructor(readable, writable, options) {
     super();
+
     options = options || {};
+
     this.readable = readable;
     this.writable = writable;
     this.bufSize = options.bufSize || 16384;
     this.autoPause = options.autoPause || false;
+
     this.paused = false;
     this.eod = false;
     this.scheduled = null;
+
     readable.on('end', () => {
       this.eod = true;
       writable.end();
@@ -29,9 +31,11 @@ class StutteredPipe extends events.EventEmitter {
     });
     this._schedule();
   }
+
   pause() {
     this.paused = true;
   }
+
   resume() {
     if (!this.eod) {
       if (this.scheduled !== null) {
@@ -40,6 +44,7 @@ class StutteredPipe extends events.EventEmitter {
       this._schedule();
     }
   }
+
   _schedule() {
     this.scheduled = setImmediate(() => {
       this.scheduled = null;
@@ -47,6 +52,7 @@ class StutteredPipe extends events.EventEmitter {
         const data = this.readable.read(this.bufSize);
         if (data && data.length) {
           this.writable.write(data);
+
           if (!this.paused && !this.autoPause) {
             this._schedule();
           }
@@ -57,5 +63,5 @@ class StutteredPipe extends events.EventEmitter {
     });
   }
 }
+
 module.exports = StutteredPipe;
-//# sourceMappingURL=stuttered-pipe.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/typed-stack.js

@@ -1,17 +1,18 @@
-"use strict";
-
 class TypedStack {
   constructor(type) {
     this._type = type;
     this._stack = [];
   }
+
   get size() {
     return this._stack.length;
   }
+
   pop() {
     const tos = this._stack.pop();
     return tos || new this._type();
   }
+
   push(instance) {
     if (!(instance instanceof this._type)) {
       throw new Error('Invalid type pushed to TypedStack');
@@ -19,5 +20,5 @@ class TypedStack {
     this._stack.push(instance);
   }
 }
+
 module.exports = TypedStack;
-//# sourceMappingURL=typed-stack.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/utils/under-dash.js

@@ -1,8 +1,4 @@
-"use strict";
-
-const {
-  toString
-} = Object.prototype;
+const {toString} = Object.prototype;
 const escapeHtmlRegex = /["&<>]/;
 const _ = {
   each: function each(obj, cb) {
@@ -16,6 +12,7 @@ const _ = {
       }
     }
   },
+
   some: function some(obj, cb) {
     if (obj) {
       if (Array.isArray(obj)) {
@@ -25,6 +22,7 @@ const _ = {
     }
     return false;
   },
+
   every: function every(obj, cb) {
     if (obj) {
       if (Array.isArray(obj)) {
@@ -34,6 +32,7 @@ const _ = {
     }
     return true;
   },
+
   map: function map(obj, cb) {
     if (obj) {
       if (Array.isArray(obj)) {
@@ -43,18 +42,21 @@ const _ = {
     }
     return [];
   },
+
   keyBy(a, p) {
     return a.reduce((o, v) => {
       o[v[p]] = v;
       return o;
     }, {});
   },
+
   isEqual: function isEqual(a, b) {
     const aType = typeof a;
     const bType = typeof b;
     const aArray = Array.isArray(a);
     const bArray = Array.isArray(b);
     let keys;
+
     if (aType !== bType) {
       return false;
     }
@@ -62,38 +64,48 @@ const _ = {
       case 'object':
         if (aArray || bArray) {
           if (aArray && bArray) {
-            return a.length === b.length && a.every((aValue, index) => {
-              const bValue = b[index];
-              return _.isEqual(aValue, bValue);
-            });
+            return (
+              a.length === b.length &&
+              a.every((aValue, index) => {
+                const bValue = b[index];
+                return _.isEqual(aValue, bValue);
+              })
+            );
           }
           return false;
         }
+
         if (a === null || b === null) {
           return a === b;
         }
 
         // Compare object keys and values
         keys = Object.keys(a);
+
         if (Object.keys(b).length !== keys.length) {
           return false;
         }
+
         for (const key of keys) {
           if (!b.hasOwnProperty(key)) {
             return false;
           }
         }
+
         return _.every(a, (aValue, key) => {
           const bValue = b[key];
           return _.isEqual(aValue, bValue);
         });
+
       default:
         return a === b;
     }
   },
+
   escapeHtml(html) {
     const regexResult = escapeHtmlRegex.exec(html);
     if (!regexResult) return html;
+
     let result = '';
     let escape = '';
     let lastIndex = 0;
@@ -125,24 +137,27 @@ const _ = {
     if (lastIndex !== i) return result + html.substring(lastIndex, i);
     return result;
   },
+
   strcmp(a, b) {
     if (a < b) return -1;
     if (a > b) return 1;
     return 0;
   },
+
   isUndefined(val) {
     return toString.call(val) === '[object Undefined]';
   },
+
   isObject(val) {
     return toString.call(val) === '[object Object]';
   },
+
   deepMerge() {
     const target = arguments[0] || {};
-    const {
-      length
-    } = arguments;
+    const {length} = arguments;
     // eslint-disable-next-line one-var
     let src, clone, copyIsArray;
+
     function assignValue(val, key) {
       src = target[key];
       copyIsArray = Array.isArray(val);
@@ -158,11 +173,12 @@ const _ = {
         target[key] = val;
       }
     }
+
     for (let i = 0; i < length; i++) {
       _.each(arguments[i], assignValue);
     }
     return target;
-  }
+  },
 };
+
 module.exports = _;
-//# sourceMappingURL=under-dash.js.map