zmdms-webui 1.9.5 → 1.9.6

package/dist/es/node_modules/exceljs/lib/utils/shared-formula.js

@@ -1,48 +0,0 @@
-import { c as colCache_1 } from './col-cache.js';
-
-const colCache = colCache_1;
-
-// 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;
-    }
-  );
-}
-
-var sharedFormula = {
-  slideFormula,
-};
-
-export { sharedFormula as s };

package/dist/es/node_modules/exceljs/lib/utils/shared-strings.js

@@ -1,37 +0,0 @@
-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;
-  }
-}
-
-var sharedStrings = SharedStrings;
-
-export { sharedStrings as s };

package/dist/es/node_modules/exceljs/lib/utils/stream-buf.js

@@ -1,371 +0,0 @@
-import { r as readableExports } from '../../node_modules/readable-stream/readable.js';
-import { u as utils_1 } from './utils.js';
-import { s as stringBuf } from './string-buf.js';
-
-/* eslint-disable max-classes-per-file */
-
-const Stream = readableExports;
-
-const utils = utils_1;
-const StringBuf = stringBuf;
-
-// =============================================================================
-// data chunks - encapsulating incoming data
-class StringChunk {
-  constructor(data, encoding) {
-    this._data = data;
-    this._encoding = encoding;
-  }
-
-  get length() {
-    return this.toBuffer().length;
-  }
-
-  // copy to target buffer
-  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);
-    }
-    return this._buffer;
-  }
-}
-
-class StringBufChunk {
-  constructor(data) {
-    this._data = data;
-  }
-
-  get length() {
-    return this._data.length;
-  }
-
-  // copy to target buffer
-  copy(target, targetOffset, offset, length) {
-    // 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;
-  }
-
-  // copy to target buffer
-  copy(target, targetOffset, offset, length) {
-    this._data.copy(target, targetOffset, offset, length);
-  }
-
-  toBuffer() {
-    return this._data;
-  }
-}
-
-// =============================================================================
-// ReadWriteBuf - a single buffer supporting simple read-write
-class ReadWriteBuf {
-  constructor(size) {
-    this.size = size;
-    // the buffer
-    this.buffer = Buffer.alloc(size);
-    // read index
-    this.iRead = 0;
-    // 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
-    if (size === 0) {
-      // 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();
-      this.iRead = this.iWrite;
-      return buf;
-    }
-
-    // otherwise return a chunk
-    buf = Buffer.alloc(size);
-    this.buffer.copy(buf, 0, this.iRead, size);
-    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
-    const size = Math.min(length, this.size - this.iWrite);
-    chunk.copy(this.buffer, this.iWrite, offset, offset + size);
-    this.iWrite += size;
-    return size;
-  }
-}
-
-// =============================================================================
-// StreamBuf - a multi-purpose read-write stream
-//  As MemBuf - write as much data as you like. Then call toBuffer() to consolidate
-//  As StreamHub - pipe to multiple writables
-//  As readable stream - feed data into the writable part and have some other code read from it.
-
-// Note: Not sure why but StreamBuf does not like JS "class" sugar. It fails the
-// integration tests
-const StreamBuf = function(options) {
-  options = options || {};
-  this.bufSize = options.bufSize || 1024 * 1024;
-  this.buffers = [];
-
-  // 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;
-
-  // where in the current readable buffer we've read up to
-  this.outPos = 0;
-
-  // consuming pipe streams go here
-  this.pipes = [];
-
-  // controls emit('data')
-  this.paused = false;
-
-  this.encoding = null;
-};
-
-utils.inherits(StreamBuf, Stream.Duplex, {
-  toBuffer() {
-    switch (this.buffers.length) {
-      case 0:
-        return null;
-      case 1:
-        return this.buffers[0].toBuffer();
-      default:
-        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
-  // pipe(src) - pipe() has been called on readable
-  // unpipe(src) - unpipe() has been called on readable
-  // error - duh
-
-  _getWritableBuffer() {
-    if (this.buffers.length) {
-      const last = this.buffers[this.buffers.length - 1];
-      if (!last.full) {
-        return last;
-      }
-    }
-    const buf = new ReadWriteBuf(this.bufSize);
-    this.buffers.push(buf);
-    return buf;
-  },
-
-  async _pipe(chunk) {
-    const write = function(pipe) {
-      return new Promise(resolve => {
-        pipe.write(chunk.toBuffer(), () => {
-          resolve();
-        });
-      });
-    };
-    await Promise.all(this.pipes.map(write));
-  },
-  _writeToBuffers(chunk) {
-    let inPos = 0;
-    const inLen = chunk.length;
-    while (inPos < inLen) {
-      // find writable buffer
-      const buffer = this._getWritableBuffer();
-
-      // write some data
-      inPos += buffer.write(chunk, inPos, inLen - inPos);
-    }
-  },
-  async write(data, encoding, callback) {
-    if (encoding instanceof Function) {
-      callback = encoding;
-      encoding = 'utf8';
-    }
-    callback = callback || utils.nop;
-
-    // encapsulate data into a chunk
-    let chunk;
-    if (data instanceof StringBuf) {
-      chunk = new StringBufChunk(data);
-    } else if (data instanceof Buffer) {
-      chunk = new BufferChunk(data);
-    } else if (typeof data === 'string' || data instanceof String || data instanceof ArrayBuffer) {
-      chunk = new StringChunk(data, encoding);
-    } else {
-      throw new Error('Chunk must be one of type String, Buffer or StringBuf.');
-    }
-
-    // now, do something with the chunk
-    if (this.pipes.length) {
-      if (this.batch) {
-        this._writeToBuffers(chunk);
-        while (!this.corked && this.buffers.length > 1) {
-          this._pipe(this.buffers.shift());
-        }
-      } else if (!this.corked) {
-        await this._pipe(chunk);
-        callback();
-      } else {
-        this._writeToBuffers(chunk);
-        process.nextTick(callback);
-      }
-    } else {
-      if (!this.paused) {
-        this.emit('data', chunk.toBuffer());
-      }
-
-      this._writeToBuffers(chunk);
-      this.emit('readable');
-    }
-
-    return true;
-  },
-  cork() {
-    this.corked = true;
-  },
-  _flush(/* destination */) {
-    // if we have comsumers...
-    if (this.pipes.length) {
-      // and there's stuff not written
-      while (this.buffers.length) {
-        this._pipe(this.buffers.shift());
-      }
-    }
-  },
-  uncork() {
-    this.corked = false;
-    this._flush();
-  },
-  end(chunk, encoding, callback) {
-    const writeComplete = error => {
-      if (error) {
-        callback(error);
-      } else {
-        this._flush();
-        this.pipes.forEach(pipe => {
-          pipe.end();
-        });
-        this.emit('finish');
-      }
-    };
-    if (chunk) {
-      this.write(chunk, encoding, writeComplete);
-    } else {
-      writeComplete();
-    }
-  },
-
-  // 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) {
-    let buffers;
-    // read min(buffer, size || infinity)
-    if (size) {
-      buffers = [];
-      while (size && this.buffers.length && !this.buffers[0].eod) {
-        const first = this.buffers[0];
-        const buffer = first.read(size);
-        size -= buffer.length;
-        buffers.push(buffer);
-        if (first.eod && first.full) {
-          this.buffers.shift();
-        }
-      }
-      return Buffer.concat(buffers);
-    }
-
-    buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
-    this.buffers = [];
-    return Buffer.concat(buffers);
-  },
-  setEncoding(encoding) {
-    // causes stream.read or stream.on('data) to return strings of encoding instead of Buffer objects
-    this.encoding = encoding;
-  },
-  pause() {
-    this.paused = true;
-  },
-  resume() {
-    this.paused = false;
-  },
-  isPaused() {
-    return !!this.paused;
-  },
-  pipe(destination) {
-    // add destination to pipe list & write current buffer
-    this.pipes.push(destination);
-    if (!this.paused && this.buffers.length) {
-      this.end();
-    }
-  },
-  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');
-  },
-});
-
-var streamBuf = StreamBuf;
-
-export { streamBuf as s };

package/dist/es/node_modules/exceljs/lib/utils/string-buf.js

@@ -1,84 +0,0 @@
-// 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';
-
-    // where in the buffer we are at
-    this._inPos = 0;
-
-    // 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) {
-      this._buffer = Buffer.alloc(this.length);
-      this._buf.copy(this._buffer, 0, 0, this.length);
-    }
-    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) {
-      size *= 2;
-    }
-    const buf = Buffer.alloc(size);
-    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
-    while (inPos >= this._buf.length - 4) {
-      this._grow(this._inPos + text.length);
-
-      // 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);
-      }
-      // eslint-disable-next-line no-underscore-dangle
-      inBuf._buf.copy(this._buf, this._inPos, 0, inBuf.length);
-      this._inPos += inBuf.length;
-    }
-  }
-}
-
-var stringBuf = StringBuf;
-
-export { stringBuf as s };