zmdms-webui 1.9.4 → 1.9.6

package/dist/es/node_modules/exceljs/lib/utils/browser-buffer-decode.js

@@ -1,18 +0,0 @@
-import { __exports as browserBufferDecode } from '../../../../_virtual/browser-buffer-decode.js';
-
-// 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();
-}
-
-browserBufferDecode.bufferToString = bufferToString;
-
-export { browserBufferDecode as default };

package/dist/es/node_modules/exceljs/lib/utils/browser-buffer-encode.js

@@ -1,20 +0,0 @@
-import { __exports as browserBufferEncode } from '../../../../_virtual/browser-buffer-encode.js';
-import require$$0 from 'buffer';
-
-// eslint-disable-next-line node/no-unsupported-features/node-builtins
-const textEncoder = typeof TextEncoder === 'undefined' ? null : new TextEncoder('utf-8');
-const {Buffer} = require$$0;
-
-function stringToBuffer(str) {
-  if (typeof str !== 'string') {
-    return str;
-  }
-  if (textEncoder) {
-    return Buffer.from(textEncoder.encode(str).buffer);
-  }
-  return Buffer.from(str);
-}
-
-browserBufferEncode.stringToBuffer = stringToBuffer;
-
-export { browserBufferEncode as default };

package/dist/es/node_modules/exceljs/lib/utils/cell-matrix.js

@@ -1,170 +0,0 @@
-import { u as underDash } from './under-dash.js';
-import { c as colCache_1 } from './col-cache.js';
-
-const _ = underDash;
-const colCache = colCache_1;
-
-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);
-      });
-    }
-  }
-}
-
-var cellMatrix = CellMatrix;
-
-export { cellMatrix as c };

package/dist/es/node_modules/exceljs/lib/utils/col-cache.js

@@ -1,289 +0,0 @@
-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;
-  },
-};
-
-var colCache_1 = colCache;
-
-export { colCache_1 as c };

package/dist/es/node_modules/exceljs/lib/utils/copy-style.js

@@ -1,47 +0,0 @@
-import { __exports as copyStyle$1 } from '../../../../_virtual/copy-style.js';
-
-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;
-};
-
-copyStyle$1.copyStyle = copyStyle;
-
-export { copyStyle$1 as default };

package/dist/es/node_modules/exceljs/lib/utils/encryptor.js

@@ -1,57 +0,0 @@
-import require$$0 from 'crypto';
-
-const crypto = require$$0;
-
-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);
-  },
-};
-var encryptor = Encryptor;
-
-export { encryptor as e };

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

@@ -1,50 +0,0 @@
-var iterateStream = 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);
-  });
-}
-
-export { iterateStream as i };

package/dist/es/node_modules/exceljs/lib/utils/parse-sax.js

@@ -1,38 +0,0 @@
-import '../../../saxes/saxes.js';
-import { r as readableExports } from '../../node_modules/readable-stream/readable.js';
-import './browser-buffer-decode.js';
-import { __exports as saxes } from '../../../../_virtual/saxes.js';
-import { __exports as browserBufferDecode } from '../../../../_virtual/browser-buffer-decode.js';
-
-const {SaxesParser} = saxes;
-const {PassThrough} = readableExports;
-const {bufferToString} = browserBufferDecode;
-
-var parseSax = 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 = [];
-  }
-};
-
-export { parseSax as p };