zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/exceljs/lib/utils/under-dash.js

@@ -0,0 +1,186 @@
+const {toString} = Object.prototype;
+const escapeHtmlRegex = /["&<>]/;
+const _ = {
+  each: function each(obj, cb) {
+    if (obj) {
+      if (Array.isArray(obj)) {
+        obj.forEach(cb);
+      } else {
+        Object.keys(obj).forEach(key => {
+          cb(obj[key], key);
+        });
+      }
+    }
+  },
+
+  some: function some(obj, cb) {
+    if (obj) {
+      if (Array.isArray(obj)) {
+        return obj.some(cb);
+      }
+      return Object.keys(obj).some(key => cb(obj[key], key));
+    }
+    return false;
+  },
+
+  every: function every(obj, cb) {
+    if (obj) {
+      if (Array.isArray(obj)) {
+        return obj.every(cb);
+      }
+      return Object.keys(obj).every(key => cb(obj[key], key));
+    }
+    return true;
+  },
+
+  map: function map(obj, cb) {
+    if (obj) {
+      if (Array.isArray(obj)) {
+        return obj.map(cb);
+      }
+      return Object.keys(obj).map(key => cb(obj[key], key));
+    }
+    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;
+    }
+    switch (typeof a) {
+      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 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;
+    let i = regexResult.index;
+    for (; i < html.length; i++) {
+      switch (html.charAt(i)) {
+        case '"':
+          escape = '&quot;';
+          break;
+        case '&':
+          escape = '&amp;';
+          break;
+        case '\'':
+          escape = '&apos;';
+          break;
+        case '<':
+          escape = '&lt;';
+          break;
+        case '>':
+          escape = '&gt;';
+          break;
+        default:
+          continue;
+      }
+      if (lastIndex !== i) result += html.substring(lastIndex, i);
+      lastIndex = i + 1;
+      result += escape;
+    }
+    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;
+    // eslint-disable-next-line one-var
+    let src, clone, copyIsArray;
+
+    function assignValue(val, key) {
+      src = target[key];
+      copyIsArray = Array.isArray(val);
+      if (_.isObject(val) || copyIsArray) {
+        if (copyIsArray) {
+          copyIsArray = false;
+          clone = src && Array.isArray(src) ? src : [];
+        } else {
+          clone = src && _.isObject(src) ? src : {};
+        }
+        target[key] = _.deepMerge(clone, val);
+      } else if (!_.isUndefined(val)) {
+        target[key] = val;
+      }
+    }
+
+    for (let i = 0; i < length; i++) {
+      _.each(arguments[i], assignValue);
+    }
+    return target;
+  },
+};
+
+var underDash = _;
+
+export { underDash as u };

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

@@ -0,0 +1,177 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+import require$$0 from 'fs';
+
+const fs = require$$0;
+
+// useful stuff
+const inherits = function(cls, superCtor, statics, prototype) {
+  // eslint-disable-next-line no-underscore-dangle
+  cls.super_ = superCtor;
+
+  if (!prototype) {
+    prototype = statics;
+    statics = null;
+  }
+
+  if (statics) {
+    Object.keys(statics).forEach(i => {
+      Object.defineProperty(cls, i, Object.getOwnPropertyDescriptor(statics, i));
+    });
+  }
+
+  const properties = {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    },
+  };
+  if (prototype) {
+    Object.keys(prototype).forEach(i => {
+      properties[i] = Object.getOwnPropertyDescriptor(prototype, i);
+    });
+  }
+
+  cls.prototype = Object.create(superCtor.prototype, properties);
+};
+
+// eslint-disable-next-line no-control-regex
+const xmlDecodeRegex = /[<>&'"\x7F\x00-\x08\x0B-\x0C\x0E-\x1F]/;
+const utils = {
+  nop() {},
+  promiseImmediate(value) {
+    return new Promise(resolve => {
+      if (commonjsGlobal.setImmediate) {
+        setImmediate(() => {
+          resolve(value);
+        });
+      } else {
+        // poorman's setImmediate - must wait at least 1ms
+        setTimeout(() => {
+          resolve(value);
+        }, 1);
+      }
+    });
+  },
+  inherits,
+  dateToExcel(d, date1904) {
+    return 25569 + ( d.getTime() / (24 * 3600 * 1000) ) - (date1904 ? 1462 : 0);
+  },
+  excelToDate(v, date1904) {
+    const millisecondSinceEpoch = Math.round((v - 25569 + (date1904 ? 1462 : 0)) * 24 * 3600 * 1000);
+    return new Date(millisecondSinceEpoch);
+  },
+  parsePath(filepath) {
+    const last = filepath.lastIndexOf('/');
+    return {
+      path: filepath.substring(0, last),
+      name: filepath.substring(last + 1),
+    };
+  },
+  getRelsPath(filepath) {
+    const path = utils.parsePath(filepath);
+    return `${path.path}/_rels/${path.name}.rels`;
+  },
+  xmlEncode(text) {
+    const regexResult = xmlDecodeRegex.exec(text);
+    if (!regexResult) return text;
+
+    let result = '';
+    let escape = '';
+    let lastIndex = 0;
+    let i = regexResult.index;
+    for (; i < text.length; i++) {
+      const charCode = text.charCodeAt(i);
+      switch (charCode) {
+        case 34: // "
+          escape = '&quot;';
+          break;
+        case 38: // &
+          escape = '&amp;';
+          break;
+        case 39: // '
+          escape = '&apos;';
+          break;
+        case 60: // <
+          escape = '&lt;';
+          break;
+        case 62: // >
+          escape = '&gt;';
+          break;
+        case 127:
+          escape = '';
+          break;
+        default: {
+          if (charCode <= 31 && (charCode <= 8 || (charCode >= 11 && charCode !== 13))) {
+            escape = '';
+            break;
+          }
+          continue;
+        }
+      }
+      if (lastIndex !== i) result += text.substring(lastIndex, i);
+      lastIndex = i + 1;
+      if (escape) result += escape;
+    }
+    if (lastIndex !== i) return result + text.substring(lastIndex, i);
+    return result;
+  },
+  xmlDecode(text) {
+    return text.replace(/&([a-z]*);/g, c => {
+      switch (c) {
+        case '&lt;':
+          return '<';
+        case '&gt;':
+          return '>';
+        case '&amp;':
+          return '&';
+        case '&apos;':
+          return '\'';
+        case '&quot;':
+          return '"';
+        default:
+          return c;
+      }
+    });
+  },
+  validInt(value) {
+    const i = parseInt(value, 10);
+    return !Number.isNaN(i) ? i : 0;
+  },
+
+  isDateFmt(fmt) {
+    if (!fmt) {
+      return false;
+    }
+
+    // must remove all chars inside quotes and []
+    fmt = fmt.replace(/\[[^\]]*]/g, '');
+    fmt = fmt.replace(/"[^"]*"/g, '');
+    // then check for date formatting chars
+    const result = fmt.match(/[ymdhMsb]+/) !== null;
+    return result;
+  },
+
+  fs: {
+    exists(path) {
+      return new Promise(resolve => {
+        fs.access(path, fs.constants.F_OK, err => {
+          resolve(!err);
+        });
+      });
+    },
+  },
+
+  toIsoDateString(dt) {
+    return dt.toIsoString().subsstr(0, 10);
+  },
+
+  parseBoolean(value) {
+    return value === true || value === 'true' || value === 1 || value === '1';
+  },
+};
+
+var utils_1 = utils;
+
+export { utils_1 as u };

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

@@ -0,0 +1,174 @@
+import { u as underDash } from './under-dash.js';
+import { u as utils_1 } from './utils.js';
+
+const _ = underDash;
+
+const utils = utils_1;
+
+// constants
+const OPEN_ANGLE = '<';
+const CLOSE_ANGLE = '>';
+const OPEN_ANGLE_SLASH = '</';
+const CLOSE_SLASH_ANGLE = '/>';
+
+function pushAttribute(xml, name, value) {
+  xml.push(` ${name}="${utils.xmlEncode(value.toString())}"`);
+}
+function pushAttributes(xml, attributes) {
+  if (attributes) {
+    const tmp = [];
+    _.each(attributes, (value, name) => {
+      if (value !== undefined) {
+        pushAttribute(tmp, name, value);
+      }
+    });
+    xml.push(tmp.join(""));
+  }
+}
+
+class XmlStream {
+  constructor() {
+    this._xml = [];
+    this._stack = [];
+    this._rollbacks = [];
+  }
+
+  get tos() {
+    return this._stack.length ? this._stack[this._stack.length - 1] : undefined;
+  }
+
+  get cursor() {
+    // handy way to track whether anything has been added
+    return this._xml.length;
+  }
+
+  openXml(docAttributes) {
+    const xml = this._xml;
+    // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    xml.push('<?xml');
+    pushAttributes(xml, docAttributes);
+    xml.push('?>\n');
+  }
+
+  openNode(name, attributes) {
+    const parent = this.tos;
+    const xml = this._xml;
+    if (parent && this.open) {
+      xml.push(CLOSE_ANGLE);
+    }
+
+    this._stack.push(name);
+
+    // start streaming node
+    xml.push(OPEN_ANGLE);
+    xml.push(name);
+    pushAttributes(xml, attributes);
+    this.leaf = true;
+    this.open = true;
+  }
+
+  addAttribute(name, value) {
+    if (!this.open) {
+      throw new Error('Cannot write attributes to node if it is not open');
+    }
+    if (value !== undefined) {
+      pushAttribute(this._xml, name, value);
+    }
+  }
+
+  addAttributes(attrs) {
+    if (!this.open) {
+      throw new Error('Cannot write attributes to node if it is not open');
+    }
+    pushAttributes(this._xml, attrs);
+  }
+
+  writeText(text) {
+    const xml = this._xml;
+    if (this.open) {
+      xml.push(CLOSE_ANGLE);
+      this.open = false;
+    }
+    this.leaf = false;
+    xml.push(utils.xmlEncode(text.toString()));
+  }
+
+  writeXml(xml) {
+    if (this.open) {
+      this._xml.push(CLOSE_ANGLE);
+      this.open = false;
+    }
+    this.leaf = false;
+    this._xml.push(xml);
+  }
+
+  closeNode() {
+    const node = this._stack.pop();
+    const xml = this._xml;
+    if (this.leaf) {
+      xml.push(CLOSE_SLASH_ANGLE);
+    } else {
+      xml.push(OPEN_ANGLE_SLASH);
+      xml.push(node);
+      xml.push(CLOSE_ANGLE);
+    }
+    this.open = false;
+    this.leaf = false;
+  }
+
+  leafNode(name, attributes, text) {
+    this.openNode(name, attributes);
+    if (text !== undefined) {
+      // zeros need to be written
+      this.writeText(text);
+    }
+    this.closeNode();
+  }
+
+  closeAll() {
+    while (this._stack.length) {
+      this.closeNode();
+    }
+  }
+
+  addRollback() {
+    this._rollbacks.push({
+      xml: this._xml.length,
+      stack: this._stack.length,
+      leaf: this.leaf,
+      open: this.open,
+    });
+    return this.cursor;
+  }
+
+  commit() {
+    this._rollbacks.pop();
+  }
+
+  rollback() {
+    const r = this._rollbacks.pop();
+    if (this._xml.length > r.xml) {
+      this._xml.splice(r.xml, this._xml.length - r.xml);
+    }
+    if (this._stack.length > r.stack) {
+      this._stack.splice(r.stack, this._stack.length - r.stack);
+    }
+    this.leaf = r.leaf;
+    this.open = r.open;
+  }
+
+  get xml() {
+    this.closeAll();
+    return this._xml.join('');
+  }
+}
+
+XmlStream.StdDocAttributes = {
+  version: '1.0',
+  encoding: 'UTF-8',
+  standalone: 'yes',
+};
+
+var xmlStream = XmlStream;
+
+export { xmlStream as x };

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

@@ -0,0 +1,95 @@
+import require$$0 from 'events';
+import { l as lib } from '../../../jszip/lib/index.js';
+import { s as streamBuf } from './stream-buf.js';
+import './browser-buffer-encode.js';
+import { __exports as browserBufferEncode } from '../../../../_virtual/browser-buffer-encode.js';
+
+const events = require$$0;
+const JSZip = lib;
+
+const StreamBuf = streamBuf;
+const {stringToBuffer} = browserBufferEncode;
+
+// =============================================================================
+// The ZipWriter class
+// Packs streamed data into an output zip stream
+class ZipWriter extends events.EventEmitter {
+  constructor(options) {
+    super();
+    this.options = Object.assign(
+      {
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+      },
+      options
+    );
+
+    this.zip = new JSZip();
+    this.stream = new StreamBuf();
+  }
+
+  append(data, options) {
+    if (options.hasOwnProperty('base64') && options.base64) {
+      this.zip.file(options.name, data, {base64: true});
+    } else {
+      // https://www.npmjs.com/package/process
+      if (process.browser && typeof data === 'string') {
+        // use TextEncoder in browser
+        data = stringToBuffer(data);
+      }
+      this.zip.file(options.name, data);
+    }
+  }
+
+  async finalize() {
+    const content = await this.zip.generateAsync(this.options);
+    this.stream.end(content);
+    this.emit('finish');
+  }
+
+  // ==========================================================================
+  // Stream.Readable interface
+  read(size) {
+    return this.stream.read(size);
+  }
+
+  setEncoding(encoding) {
+    return this.stream.setEncoding(encoding);
+  }
+
+  pause() {
+    return this.stream.pause();
+  }
+
+  resume() {
+    return this.stream.resume();
+  }
+
+  isPaused() {
+    return this.stream.isPaused();
+  }
+
+  pipe(destination, options) {
+    return this.stream.pipe(destination, options);
+  }
+
+  unpipe(destination) {
+    return this.stream.unpipe(destination);
+  }
+
+  unshift(chunk) {
+    return this.stream.unshift(chunk);
+  }
+
+  wrap(stream) {
+    return this.stream.wrap(stream);
+  }
+}
+
+// =============================================================================
+
+var zipStream = {
+  ZipWriter,
+};
+
+export { zipStream as z };